AI Search Examples

A product search engine that understands natural language queries ('comfortable shoes for standing all day') and matches against product descriptions, reviews, and attributes using semantic embeddings rather than keyword matching.

// Semantic product search
async function semanticProductSearch(query, filters) {
  const queryEmbedding = await embed(query);

  const results = await vectorStore.search(queryEmbedding, {
    topK: 50,
    filter: {
      inStock: true,
      ...filters,
    },
  });

  // Re-rank with business logic
  const reranked = results.map(r => ({
    ...r,
    finalScore: r.similarityScore * 0.6 + r.popularityScore * 0.2 + r.marginScore * 0.1 + r.freshnessScore * 0.1,
  })).sort((a, b) => b.finalScore - a.finalScore);

  return reranked.slice(0, 20);
}

A unified search across company documentation (Confluence, SharePoint, Slack, Google Drive) that respects document permissions, ranks results by relevance and recency, and provides AI-generated answer snippets.

// Enterprise knowledge search
async function enterpriseSearch(query, user) {
  const permissions = await getPermissions(user);

  // Search across all sources with access control
  const [confluenceResults, slackResults, driveResults] = await Promise.all([
    searchConfluence(query, permissions.confluence),
    searchSlack(query, permissions.slackChannels),
    searchDrive(query, permissions.driveAccess),
  ]);

  const allResults = [...confluenceResults, ...slackResults, ...driveResults];

  // Generate AI answer snippet
  const topResults = rerank(allResults, query).slice(0, 5);
  const answerSnippet = await llm.chat({
    messages: [{
      role: "system",
      content: "Generate a concise answer based on these search results. Cite which source each piece of information comes from."
    }, { role: "user", content: `Query: ${query}\nResults: ${JSON.stringify(topResults)}` }]
  });

  return { answer: answerSnippet, results: topResults };
}

A search experience where users can refine results through conversation. 'Find project management tools' followed by 'that integrate with Slack' followed by 'under £20 per month'. Each turn narrows and refines the search.

// Conversational search
async function conversationalSearch(message, conversationState) {
  // Understand the refinement
  const intent = await llm.chat({
    messages: [{
      role: "system",
      content: "Given the conversation, extract the cumulative search criteria as structured filters."
    }, ...conversationState.messages, { role: "user", content: message }]
  });

  // Merge with existing filters
  const filters = { ...conversationState.filters, ...intent.newFilters };

  const results = await search(intent.query, filters);

  return {
    results,
    filters,
    clarification: results.length > 20 ? "Would you like to narrow this down further?" : null,
  };
}

An image-based search where users upload a photo and find visually similar products. Uses CLIP embeddings to map images and text into the same space, enabling both image-to-image and text-to-image search.

// Visual similarity search
async function visualSearch(image) {
  const imageEmbedding = await clipEmbed(image);

  const similar = await vectorStore.search(imageEmbedding, {
    topK: 20,
    index: "product-images",
  });

  // Group by product to avoid showing multiple angles of same item
  const unique = deduplicateByProduct(similar);

  return unique.map(r => ({
    product: r.product,
    similarity: r.score,
    image: r.thumbnailUrl,
    price: r.price,
  }));
}

A search system that handles misspellings, synonyms, and ambiguous queries gracefully. Uses an LLM to understand query intent, correct spelling, expand abbreviations, and generate multiple search interpretations.

// Query understanding pipeline
async function understandQuery(rawQuery) {
  const understood = await llm.chat({
    messages: [{
      role: "system",
      content: `Analyse this search query. Return JSON:
      { correctedQuery, intent, synonymExpansions, filters, isAmbiguous, interpretations }`
    }, { role: "user", content: rawQuery }]
  });

  if (understood.isAmbiguous) {
    return {
      searchQueries: understood.interpretations.map(i => i.query),
      clarificationPrompt: "Did you mean: " + understood.interpretations.map(i => i.description).join(" or "),
    };
  }

  return { searchQueries: [understood.correctedQuery, ...understood.synonymExpansions] };
}