Part 7: Real-World Applications and Use Cases

← Part 6: Performance Optimization | Back to Series Overview

The RAG Chatbot That Saved Our Support Team

We had a problem: Support engineers spending 60% of their time answering repetitive questions from our documentation.

Traditional FAQ bots failed because:

• Questions weren't phrased exactly like documentation

• Users asked compound questions ("How do I deploy AND monitor my app?")

• Context was spread across multiple docs

• Keyword search missed semantically relevant articles

I built a RAG (Retrieval-Augmented Generation) chatbot with pgvector + OpenAI:

1. User asks question

2. Vector search finds relevant docs

3. LLM generates answer using retrieved context

4. Response includes source citations

Results after 3 months:

• Support ticket volume: -48%

• First response time: 4.2 hours → 0.3 seconds

• Customer satisfaction: 73% → 94%

• Support team freed up to work on complex issues

This article shows you how to build real-world applications with vector databases.

Application 1: RAG Chatbot for Documentation

Architecture

/**
 * RAG Pipeline:
 * 1. Embed user question
 * 2. Find relevant documentation chunks (vector search)
 * 3. Pass chunks as context to LLM
 * 4. Generate answer with sources
 */

interface ChatMessage {
  role: 'user' | 'assistant' | 'system';
  content: string;
}

interface RAGResponse {
  answer: string;
  sources: Array<{ title: string; url: string; similarity: number }>;
  confidence: number;
}

export class RAGChatbotService {
  /**
   * Answer question using RAG
   */
  static async askQuestion(question: string): Promise<RAGResponse> {
    // 1. Find relevant documentation
    const relevantDocs = await this.retrieveRelevantDocs(question);
    
    if (relevantDocs.length === 0) {
      return {
        answer: "I couldn't find relevant information to answer your question. Please try rephrasing or contact support.",
        sources: [],
        confidence: 0,
      };
    }
    
    // 2. Build context from retrieved docs
    const context = this.buildContext(relevantDocs);
    
    // 3. Generate answer using LLM
    const answer = await this.generateAnswer(question, context);
    
    // 4. Extract sources
    const sources = relevantDocs.map(doc => ({
      title: doc.title,
      url: doc.url,
      similarity: doc.similarity,
    }));
    
    // 5. Calculate confidence
    const confidence = this.calculateConfidence(relevantDocs);
    
    return { answer, sources, confidence };
  }
  
  /**
   * Retrieve relevant documentation chunks
   */
  private static async retrieveRelevantDocs(
    question: string,
    limit: number = 5
  ) {
    const questionEmbedding = await EmbeddingService.getEmbedding(question);
    
    const docs = await prisma.$queryRaw<Array<{
      id: number;
      title: string;
      content: string;
      url: string;
      similarity: number;
    }>>`
      SELECT 
        id, title, content, url,
        1 - (embedding <=> ${questionEmbedding}::vector) as similarity
      FROM documentation_chunks
      WHERE 1 - (embedding <=> ${questionEmbedding}::vector) > 0.7
      ORDER BY embedding <=> ${questionEmbedding}::vector
      LIMIT ${limit}
    `;
    
    return docs;
  }
  
  /**
   * Build context string from docs
   */
  private static buildContext(docs: Array<{ title: string; content: string }>): string {
    return docs
      .map((doc, i) => `[Document ${i + 1}: ${doc.title}]\n${doc.content}`)
      .join('\n\n---\n\n');
  }
  
  /**
   * Generate answer using LLM
   */
  private static async generateAnswer(
    question: string,
    context: string
  ): Promise<string> {
    const messages: ChatMessage[] = [
      {
        role: 'system',
        content: `You are a helpful documentation assistant. Answer questions based ONLY on the provided documentation context. If the answer isn't in the context, say so. Always cite which document you're referencing.`,
      },
      {
        role: 'user',
        content: `Context:\n${context}\n\nQuestion: ${question}\n\nAnswer:`,
      },
    ];
    
    const response = await openai.chat.completions.create({
      model: 'gpt-4-turbo',
      messages,
      temperature: 0.3, // Lower = more deterministic
      max_tokens: 500,
    });
    
    return response.choices[0].message.content || 'No answer generated.';
  }
  
  /**
   * Calculate confidence score
   */
  private static calculateConfidence(docs: Array<{ similarity: number }>): number {
    if (docs.length === 0) return 0;
    
    // Average similarity of top 3 docs
    const topDocs = docs.slice(0, 3);
    const avgSimilarity = topDocs.reduce((sum, d) => sum + d.similarity, 0) / topDocs.length;
    
    return Math.round(avgSimilarity * 100);
  }
}

Chat API Endpoint

// POST /api/chat
app.post('/api/chat', async (req: Request, res: Response) => {
  const { question } = req.body;
  
  if (!question || question.length < 3) {
    return res.status(400).json({ error: 'Question required' });
  }
  
  const result = await RAGChatbotService.askQuestion(question);
  
  res.json({
    success: true,
    answer: result.answer,
    sources: result.sources,
    confidence: result.confidence,
  });
});

Frontend Integration

// Example client code
async function askDocumentation(question: string) {
  const response = await fetch('/api/chat', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ question }),
  });
  
  const data = await response.json();
  
  displayAnswer(data.answer);
  displaySources(data.sources);
  displayConfidence(data.confidence);
}

// Usage
await askDocumentation("How do I deploy my app to Kubernetes?");

Application 2: Semantic Product Recommendations

export class ProductRecommendationService {
  /**
   * Get product recommendations based on viewing history
   */
  static async getRecommendations(
    userId: string,
    limit: number = 6
  ): Promise<Product[]> {
    // 1. Get user's recent view history
    const viewedProducts = await prisma.productView.findMany({
      where: { userId },
      orderBy: { viewedAt: 'desc' },
      take: 10,
      include: { product: true },
    });
    
    if (viewedProducts.length === 0) {
      return this.getPopularProducts(limit);
    }
    
    // 2. Get embeddings of viewed products
    const viewedEmbeddings = viewedProducts
      .map(v => v.product.embedding)
      .filter(e => e !== null) as number[][];
    
    // 3. Create user preference vector (average of viewed products)
    const userVector = this.averageVectors(viewedEmbeddings);
    
    // 4. Find similar products
    const viewedIds = viewedProducts.map(v => v.productId);
    
    const recommendations = await prisma.$queryRaw<Product[]>`
      SELECT 
        id, name, description, price, image_url,
        1 - (embedding <=> ${userVector}::vector) as similarity
      FROM products
      WHERE id != ALL(${viewedIds}::int[])
        AND in_stock = true
        AND embedding IS NOT NULL
      ORDER BY embedding <=> ${userVector}::vector
      LIMIT ${limit}
    `;
    
    return recommendations;
  }
  
  /**
   * Get similar products to a specific product
   */
  static async getSimilarProducts(
    productId: number,
    limit: number = 6
  ): Promise<Product[]> {
    const product = await prisma.product.findUnique({
      where: { id: productId },
    });
    
    if (!product || !product.embedding) {
      return [];
    }
    
    const similar = await prisma.$queryRaw<Product[]>`
      SELECT 
        id, name, description, price, image_url,
        1 - (embedding <=> ${product.embedding}::vector) as similarity
      FROM products
      WHERE id != ${productId}
        AND category = ${product.category}
        AND in_stock = true
        AND embedding IS NOT NULL
      ORDER BY embedding <=> ${product.embedding}::vector
      LIMIT ${limit}
    `;
    
    return similar;
  }
  
  /**
   * Complement recommendations (complete the outfit/setup)
   */
  static async getComplementaryProducts(
    productId: number,
    limit: number = 4
  ): Promise<Product[]> {
    const product = await prisma.product.findUnique({
      where: { id: productId },
      include: { complementaryCategories: true },
    });
    
    if (!product || !product.embedding) {
      return [];
    }
    
    // Find products in complementary categories
    const complementary = await prisma.$queryRaw<Product[]>`
      SELECT 
        id, name, description, price, image_url,
        1 - (embedding <=> ${product.embedding}::vector) as similarity
      FROM products
      WHERE category = ANY(${product.complementaryCategories}::text[])
        AND in_stock = true
        AND embedding IS NOT NULL
      ORDER BY embedding <=> ${product.embedding}::vector
      LIMIT ${limit}
    `;
    
    return complementary;
  }
  
  private static averageVectors(vectors: number[][]): number[] {
    if (vectors.length === 0) return [];
    
    const dimensions = vectors[0].length;
    const avgVector = new Array(dimensions).fill(0);
    
    for (const vector of vectors) {
      for (let i = 0; i < dimensions; i++) {
        avgVector[i] += vector[i];
      }
    }
    
    return avgVector.map(v => v / vectors.length);
  }
  
  private static async getPopularProducts(limit: number): Promise<Product[]> {
    return await prisma.product.findMany({
      where: { inStock: true },
      orderBy: { salesCount: 'desc' },
      take: limit,
    });
  }
}

Application 3: Duplicate Detection

export class DuplicateDetectionService {
  /**
   * Find duplicate support tickets
   */
  static async findDuplicateTickets(
    ticketId: number,
    similarityThreshold: number = 0.85
  ): Promise<Array<{ id: number; subject: string; similarity: number }>> {
    const ticket = await prisma.supportTicket.findUnique({
      where: { id: ticketId },
    });
    
    if (!ticket || !ticket.embedding) {
      return [];
    }
    
    const duplicates = await prisma.$queryRaw`
      SELECT 
        id,
        subject,
        1 - (embedding <=> ${ticket.embedding}::vector) as similarity
      FROM support_tickets
      WHERE id != ${ticketId}
        AND status IN ('open', 'in_progress')
        AND 1 - (embedding <=> ${ticket.embedding}::vector) > ${similarityThreshold}
      ORDER BY embedding <=> ${ticket.embedding}::vector
      LIMIT 10
    `;
    
    return duplicates;
  }
  
  /**
   * Check if new ticket is duplicate before creation
   */
  static async checkForDuplicates(subject: string, description: string) {
    const text = `${subject}\n${description}`;
    const embedding = await EmbeddingService.getEmbedding(text);
    
    const potentialDuplicates = await prisma.$queryRaw`
      SELECT 
        id,
        subject,
        created_at,
        1 - (embedding <=> ${embedding}::vector) as similarity
      FROM support_tickets
      WHERE status IN ('open', 'in_progress')
        AND 1 - (embedding <=> ${embedding}::vector) > 0.8
      ORDER BY embedding <=> ${embedding}::vector
      LIMIT 5
    `;
    
    return potentialDuplicates;
  }
  
  /**
   * Automatic ticket routing based on similar resolved tickets
   */
  static async suggestTicketAssignment(ticketId: number) {
    const ticket = await prisma.supportTicket.findUnique({
      where: { id: ticketId },
    });
    
    if (!ticket || !ticket.embedding) {
      return null;
    }
    
    // Find similar resolved tickets
    const similar = await prisma.$queryRaw<Array<{
      assignee: string;
      count: number;
    }>>`
      SELECT 
        assignee,
        COUNT(*) as count
      FROM support_tickets
      WHERE status = 'resolved'
        AND 1 - (embedding <=> ${ticket.embedding}::vector) > 0.75
      GROUP BY assignee
      ORDER BY count DESC
      LIMIT 1
    `;
    
    return similar[0]?.assignee || null;
  }
}

Application 4: Semantic Code Search

export class CodeSearchService {
  /**
   * Search codebase semantically
   */
  static async searchCode(
    query: string,
    language?: string,
    limit: number = 10
  ) {
    const queryEmbedding = await EmbeddingService.getEmbedding(query);
    
    const languageFilter = language ? `AND language = '${language}'` : '';
    
    const results = await prisma.$queryRaw`
      SELECT 
        file_path,
        function_name,
        code_snippet,
        language,
        1 - (embedding <=> ${queryEmbedding}::vector) as similarity
      FROM code_snippets
      WHERE embedding IS NOT NULL
        ${languageFilter}
      ORDER BY embedding <=> ${queryEmbedding}::vector
      LIMIT ${limit}
    `;
    
    return results;
  }
  
  /**
   * Find code examples similar to user's code
   */
  static async findSimilarCode(code: string, language: string) {
    const codeEmbedding = await EmbeddingService.getEmbedding(code);
    
    const similar = await prisma.$queryRaw`
      SELECT 
        file_path,
        function_name,
        code_snippet,
        repository_url,
        1 - (embedding <=> ${codeEmbedding}::vector) as similarity
      FROM code_snippets
      WHERE language = ${language}
        AND 1 - (embedding <=> ${codeEmbedding}::vector) > 0.7
      ORDER BY embedding <=> ${codeEmbedding}::vector
      LIMIT 5
    `;
    
    return similar;
  }
}

Application 5: Content Moderation

export class ContentModerationService {
  private static readonly TOXIC_EXAMPLES = [
    "I hate you",
    "You're stupid",
    "This is garbage",
    // ... more examples
  ];
  
  /**
   * Check if content is toxic using vector similarity
   */
  static async checkToxicity(content: string): Promise<{
    isToxic: boolean;
    confidence: number;
    category?: string;
  }> {
    const contentEmbedding = await EmbeddingService.getEmbedding(content);
    
    // Compare with known toxic content
    const similar = await prisma.$queryRaw<Array<{
      content: string;
      category: string;
      similarity: number;
    }>>`
      SELECT 
        content,
        category,
        1 - (embedding <=> ${contentEmbedding}::vector) as similarity
      FROM toxic_content_examples
      ORDER BY embedding <=> ${contentEmbedding}::vector
      LIMIT 1
    `;
    
    if (similar.length === 0) {
      return { isToxic: false, confidence: 0 };
    }
    
    const topMatch = similar[0];
    const isToxic = topMatch.similarity > 0.75;
    
    return {
      isToxic,
      confidence: topMatch.similarity,
      category: isToxic ? topMatch.category : undefined,
    };
  }
}

Complete Real-World Example: Job Matching Platform

interface JobPosting {
  id: number;
  title: string;
  description: string;
  requirements: string[];
  location: string;
  salary: { min: number; max: number };
  embedding?: number[];
}

interface Candidate {
  id: number;
  resume: string;
  skills: string[];
  experience: string;
  embedding?: number[];
}

export class JobMatchingService {
  /**
   * Match candidates to jobs
   */
  static async matchCandidateToJobs(
    candidateId: number,
    limit: number = 10
  ): Promise<Array<JobPosting & { matchScore: number }>> {
    const candidate = await prisma.candidate.findUnique({
      where: { id: candidateId },
    });
    
    if (!candidate || !candidate.embedding) {
      throw new Error('Candidate not found or missing embedding');
    }
    
    const matches = await prisma.$queryRaw<Array<JobPosting & { matchScore: number }>>`
      SELECT 
        id,
        title,
        description,
        requirements,
        location,
        salary,
        (
          (1 - (embedding <=> ${candidate.embedding}::vector)) * 0.7 +
          (CASE 
            WHEN location = ${candidate.preferredLocation} THEN 0.2 
            ELSE 0 
          END) +
          (CASE 
            WHEN salary->>'max' >= ${candidate.minSalary}::text THEN 0.1 
            ELSE 0 
          END)
        ) as match_score
      FROM job_postings
      WHERE status = 'open'
        AND embedding IS NOT NULL
      ORDER BY match_score DESC
      LIMIT ${limit}
    `;
    
    return matches;
  }
  
  /**
   * Find best candidates for a job
   */
  static async matchJobToCandidates(
    jobId: number,
    limit: number = 20
  ): Promise<Array<Candidate & { matchScore: number }>> {
    const job = await prisma.jobPosting.findUnique({
      where: { id: jobId },
    });
    
    if (!job || !job.embedding) {
      throw new Error('Job not found or missing embedding');
    }
    
    const matches = await prisma.$queryRaw<Array<Candidate & { matchScore: number }>>`
      SELECT 
        id,
        name,
        resume,
        skills,
        experience,
        1 - (embedding <=> ${job.embedding}::vector) as match_score
      FROM candidates
      WHERE is_active = true
        AND embedding IS NOT NULL
      ORDER BY embedding <=> ${job.embedding}::vector
      LIMIT ${limit}
    `;
    
    return matches;
  }
}

Key Takeaways

When Vector Search Excels

✅ Semantic search - Understanding meaning beyond keywords ✅ Recommendations - Finding similar items ✅ RAG applications - Retrieving relevant context for LLMs ✅ Duplicate detection - Finding semantically similar content ✅ Content discovery - Exploring related content ✅ Personalization - Matching user preferences

When to Use Hybrid Approaches

🔄 E-commerce - Vector similarity + price/category filters 🔄 Job matching - Semantic matching + location/salary requirements 🔄 Content moderation - Vector similarity + rule-based filters 🔄 Support tickets - Semantic search + priority/status filters

Production Lessons Learned

1. Start simple - Pure vector search first, add complexity as needed

2. Cache everything - Embeddings, query results, common queries

3. Monitor performance - Track query latency, embedding costs

4. Version embeddings - Support model migrations

5. Have fallbacks - Keyword search when vector search fails

6. Test with real users - A/B test vector vs traditional search

What You've Learned in This Series

Throughout this Vector Database 101 series, you've learned:

✅ Part 1: What vector databases are and why they matter ✅ Part 2: How embeddings work and similarity metrics ✅ Part 3: Setting up PostgreSQL with pgvector ✅ Part 4: Building production TypeScript applications ✅ Part 5: Advanced queries and hybrid search ✅ Part 6: Performance optimization and monitoring ✅ Part 7: Real-world applications (RAG, recommendations, search)

Next Steps

Keep building:

1. Implement semantic search in your application

2. Add vector embeddings to existing features

3. Experiment with different embedding models

4. Monitor and optimize query performance

5. Share your results with the community

Resources:

• pgvector GitHub: https://github.com/pgvector/pgvector

• OpenAI Embeddings: https://platform.openai.com/docs/guides/embeddings

• Prisma ORM: https://www.prisma.io/docs

Final Thoughts

Vector databases aren't replacing traditional databases—they're augmenting them. The best applications combine:

• Exact filters (traditional SQL) for constraints

• Semantic search (vectors) for understanding meaning

• Business logic for context-aware results

You don't need a specialized vector database to get started. PostgreSQL + pgvector is production-ready, cost-effective, and powerful enough for most applications.

Start building today. The technology is mature, the tools are accessible, and the use cases are endless.

---

← Part 6: Performance Optimization | Back to Series Overview