RAG Architecture Patterns

import { PineconeClient } from '@pinecone-database/pinecone';
import { OpenAIEmbeddings } from 'langchain/embeddings/openai';
import { OpenAI } from 'langchain/llms/openai';

const pinecone = new PineconeClient();
await pinecone.init({
  apiKey: process.env.PINECONE_API_KEY!,
  environment: process.env.PINECONE_ENVIRONMENT!,
});

const embeddings = new OpenAIEmbeddings();

async function simpleRAG(question: string) {
  // 1. Embed the query
  const queryEmbedding = await embeddings.embedQuery(question);

  // 2. Search vectors
  const index = pinecone.Index('docs');
  const searchResults = await index.query({
    vector: queryEmbedding,
    topK: 3,
    includeMetadata: true,
  });

  // 3. Build context
  const context = searchResults.matches
    .map((m) => m.metadata.text)
    .join('\n\n');

  // 4. Generate answer
  const llm = new OpenAI({ temperature: 0 });
  const prompt = `Context: ${context}\n\nQuestion: ${question}\n\nAnswer:`;
  
  return await llm.call(prompt);
}

import { Pinecone } from '@pinecone-database/pinecone';
import Anthropic from '@anthropic-ai/sdk';
import Cohere from 'cohere-ai';

const pinecone = new Pinecone();
const anthropic = new Anthropic();
const cohere = new Cohere();

async function advancedRAG(question: string) {
  // 1. Query expansion
  const expandedQueries = await expandQuery(question);
  
  // 2. Hybrid search (vector + keyword)
  const vectorResults = await Promise.all(
    expandedQueries.map(q => vectorSearch(q))
  );
  const keywordResults = await keywordSearch(question);
  const combined = mergeResults(vectorResults.flat(), keywordResults);
  
  // 3. Rerank with Cohere
  const reranked = await cohere.rerank({
    query: question,
    documents: combined.map(r => r.text),
    topN: 5,
    model: 'rerank-english-v3.0',
  });
  
  // 4. Build context from top results
  const context = reranked.results
    .map(r => combined[r.index].text)
    .join('\n\n---\n\n');
  
  // 5. Generate with Claude
  const message = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1024,
    messages: [{
      role: 'user',
      content: `Context:\n${context}\n\nQuestion: ${question}\n\nAnswer based on the context above. Cite sources.`
    }]
  });
  
  return message.content[0].text;
}

async function expandQuery(query: string): Promise<string[]> {
  const response = await anthropic.messages.create({
    model: 'claude-3-haiku-20240307',
    max_tokens: 200,
    messages: [{
      role: 'user',
      content: `Generate 3 alternative phrasings of: "${query}"`
    }]
  });
  // Parse and return variants
  return parseVariants(response.content[0].text);
}

interface Chunk {
  text: string;
  metadata: {
    source: string;
    page?: number;
    chunkIndex: number;
    totalChunks: number;
  };
}

function chunkDocument(
  text: string,
  chunkSize: number = 1000,
  overlapSize: number = 200,
  source: string
): Chunk[] {
  const chunks: Chunk[] = [];
  let start = 0;
  let chunkIndex = 0;

  while (start < text.length) {
    // Extract chunk
    const end = Math.min(start + chunkSize, text.length);
    let chunkText = text.slice(start, end);

    // Try to end at sentence boundary
    if (end < text.length) {
      const lastPeriod = chunkText.lastIndexOf('.');
      if (lastPeriod > chunkSize * 0.7) {
        chunkText = chunkText.slice(0, lastPeriod + 1);
      }
    }

    chunks.push({
      text: chunkText.trim(),
      metadata: {
        source,
        chunkIndex,
        totalChunks: 0, // Will update later
      },
    });

    // Move start position (with overlap)
    start += chunkText.length - overlapSize;
    chunkIndex++;
  }

  // Update total chunks
  chunks.forEach(chunk => {
    chunk.metadata.totalChunks = chunks.length;
  });

  return chunks;
}

// Usage
const document = await loadDocument('policy.pdf');
const chunks = chunkDocument(document.text, 1000, 200, 'policy.pdf');
await embedAndStore(chunks);

import { OpenAI } from 'openai';
import { PineconeClient } from '@pinecone-database/pinecone';

const openai = new OpenAI();
const pinecone = new PineconeClient();

async function hydeSearch(question: string) {
  // 1. Generate hypothetical answer
  const hypotheticalDoc = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [{
      role: 'user',
      content: `Write a detailed answer to: ${question}`
    }],
    temperature: 0.7,
    max_tokens: 300,
  });

  const hydeText = hypotheticalDoc.choices[0].message.content;

  // 2. Embed the hypothetical answer
  const embedding = await openai.embeddings.create({
    model: 'text-embedding-3-large',
    input: hydeText,
  });

  // 3. Search with hypothetical embedding
  const index = pinecone.Index('documents');
  const results = await index.query({
    vector: embedding.data[0].embedding,
    topK: 5,
    includeMetadata: true,
  });

  // 4. Return actual documents
  return results.matches.map(m => ({
    text: m.metadata.text,
    score: m.score,
    source: m.metadata.source,
  }));
}

// HyDE works because the hypothetical answer is more similar
// to actual documents than the question itself
const results = await hydeSearch("How does photosynthesis work?");