Examples

Practical examples to help you get the most out of the Nosible API.

Basic Search Examples

Simple Fast Search

The most basic use case - quick search results:

import {NosibleClient} from "nosible";

const client = new NosibleClient();

const results = await client.fastSearch({
  question: "What is Nosible?",
  nResults: 10,
});

console.log(`Found ${results.length} results`);

Processing Search Results

Iterate through and display formatted results:

const fastRes = await client.fastSearch({
  question: "AI startups in 2025",
  nResults: 20,
});

fastRes.results.forEach((result, index) => {
  console.log(`\n${index + 1}. ${result.title}`);
  console.log(`   Published: ${result.published}`);
  console.log(`   URL: ${result.url}`);
  console.log(
    `   Relevance: ${(result.semantics.similarity * 100).toFixed(1)}%`
  );
  console.log(`   Preview: ${result.best_chunk.substring(0, 150)}...`);
});

Filtering High-Quality Results

Filter results by similarity score:

const fastRes = await client.fastSearch({
  question: "Machine learning applications",
  nResults: 50,
});

// Only keep highly relevant results (similarity > 0.92)
const highQualityResults = fastRes.results.filter(
  (result) => result.semantics.similarity > 0.92
);

console.log(`Found ${highQualityResults.length} high-quality results`);

Advanced Examples

Sorting by Recency

Find the most recent articles:

const fastRes = await client.fastSearch({
  question: "Latest developments in quantum computing",
  nResults: 50,
});

const results = fastRes.results;

// Sort by publication date (newest first)
const sortedResults = [...results].sort(
  (a, b) => new Date(b.published).getTime() - new Date(a.published).getTime()
);

console.log("Most recent articles:");
sortedResults.slice(0, 5).forEach((result) => {
  console.log(`- (${result.published}) ${result.title}`);
});

Bulk Data Export

Save search results to a file:

const fastResults = await client.fastSearch({
  question: "Climate tech innovations",
  nResults: 50,
});

// Use built-in export methods
await fastResults.writeToCsv("search-results.csv");
await fastResults.writeToJson("search-results.json");
await fastResults.writeToNdjson("search-results.ndjson");
await fastResults.writeToParquet("search-results.parquet");
await fastResults.writeToIpc("search-results.ipc");

console.log("Results saved");

Building a Research Dashboard

Create a simple analytics dashboard:

import {AnalyzeBy} from "nosible";
interface SearchAnalytics {
  totalResults: number;
  avgSimilarity: number;
  maxSimilarity: number;
  minSimilarity: number;
  topSources: {[domain: string]: number};
}

async function analyzeSearch(question: string): Promise<SearchAnalytics> {
  const results = await client.fastSearch({
    question,
    nResults: 50,
  });

  // Similarity stats via built-in analyzer
  const {
    mean: avgSimilarity,
    max: maxSimilarity,
    min: minSimilarity,
  } = results.analyze(AnalyzeBy.similarity);

  // Top sources via built-in analyzer
  const topSources = results.analyze(AnalyzeBy.netloc);

  return {
    totalResults: results.results.length,
    avgSimilarity,
    maxSimilarity,
    minSimilarity,
    topSources,
  };
}

// Usage
const analytics = await analyzeSearch("Artificial intelligence trends");
console.log("Search Analytics:", analytics);

Real-World Use Cases

Market Research

Gather competitive intelligence:

async function marketResearch(company: string) {
  const [fundingResults, productResults, competitorResults] = await Promise.all(
    [
      client.fastSearch({
        question: `${company} funding and investments`,
        nResults: 20,
      }),
      client.fastSearch({
        question: `${company} product launches`,
        nResults: 20,
      }),
      client.fastSearch({
        question: `${company} competitors`,
        nResults: 20,
      }),
    ]
  );

  return {
    funding: fundingResults,
    products: productResults,
    competitors: competitorResults,
  };
}

const research = await marketResearch("Apple");
console.log(`Found ${research.funding.results.length} funding articles`);

Content Curation

Build a content aggregator:

async function curateDailyNews(topics: string[]) {
  // Build a SearchSet for all topics
  const searches = topics.map(
    (topic) =>
      new Search({
        question: `${topic} latest news`,
        nResults: 10,
        publishStart: new Date("2025-10-01"),
      })
  );
  const searchSet = new SearchSet(searches);

  // Execute searches in parallel using fastSearches
  const resultSets = await client.fastSearches(searchSet);

  // Combine and deduplicate
  const seen = new Set<string>();
  const curated = resultSets
    .flatMap((rs) => rs.results)
    .filter((result) => {
      if (seen.has(result.url)) return false;
      seen.add(result.url);
      return true;
    })
    .sort((a, b) => b.semantics.similarity - a.semantics.similarity);

  return curated.slice(0, 50); // Top 50 articles
}

const topics = ["AI", "Climate Tech", "FinTech"];
const news = await curateDailyNews(topics);
news.map((n) => {
  console.log("Title: " + n.title);
  console.log("URL: " + n.url + "\n");
});

Trend Analysis

Use the built-in topic trend feature:

// Use the built-in topicTrend method
const trends = await client.topicTrend("artificial intelligence");

console.log(`Topic: ${trends.data.query.query}`);
// trends.data.response is an object with dates as keys and popularity as values
Object.entries(trends.data.response).forEach(([date, popularity]) => {
  console.log(`${date}: ${popularity}`);
});

Performance Tips

Parallel Requests

Execute multiple searches concurrently:

const queries = ["AI in healthcare", "AI in finance", "AI in education"];

const fastSearches = await client.fastSearches({
  questions: queries,
  nResults: 10,
});

fastSearches.forEach((resultSet, i) => {
  console.log(`${queries[i]}: ${resultSet.length} results`);
});

Error Handling Patterns

Next Steps

• Review the API Reference for detailed method signatures
• Explore type definitions for full TypeScript support
• Check out our GitHub repository for more examples