1.9 — Memória Privada para LLMs: Recuperação Aumentada por Geração (RAG & Embeddings)

FASE DE INDEXAÇÃO (roda uma vez, offline):

                                          

  Documentos brutos                       

  (PDFs, Markdown, DB)                    

       ↓                                  

  Chunking                                

  (dividir em pedaços de ~500 tokens)     

       ↓                                  

  Geração de embeddings                   

  (API de embedding → vetor float[])      

       ↓                                  

  Armazenamento no vector store           

  (pgvector, Pinecone, Qdrant, Chroma)    



FASE DE CONSULTA (roda a cada pergunta):



  Pergunta do usuário                     

       ↓                                  

  Embedding da pergunta                   

       ↓                                  

  Busca por similaridade no vector store  

  (top-K mais similares)                  

       ↓                                  

  Construção do prompt com contexto       

  (pergunta + documentos encontrados)     

       ↓                                  

  LLM gera resposta fundamentada          

"O MCP foi criado pela Anthropic"        → [0.23, -0.87, ..., 0.14]  (1536 dims)

"Model Context Protocol da Anthropic"    → [0.21, -0.85, ..., 0.12]  (1536 dims)

"Receita de bolo de chocolate"           → [-0.45, 0.23, ..., -0.78] (1536 dims)



Distância cosseno:

  MCP ↔ MCP_alternativo: 0.97  (muito similar ✓)

  MCP ↔ receita: 0.08          (muito diferente ✓)

def chunkar_fixo(texto, tamanho=500, overlap=50):

    palavras = texto.split()

    chunks = []

    for i in range(0, len(palavras), tamanho - overlap):

        chunk = ' '.join(palavras[i:i + tamanho])

        chunks.append(chunk)

    return chunks

def chunkar_semantico(texto):

    # Divide por parágrafos (linhas em branco)

    paragrafos = [p.strip() for p in texto.split('\n\n') if p.strip()]

    # Agrupa parágrafos pequenos, divide parágrafos grandes

    return [p for p in paragrafos if len(p) > 50]

Documento: "Como configurar autenticação JWT. [Seção 1] Gerar chave privada... [Seção 2] Configurar middleware..."



Indexação: 

  chunk1 = "Gerar chave privada com openssl genrsa -out private.key 2048"

  chunk2 = "Configurar middleware com jwt.verify(token, publicKey)"



Busca por "como verificar JWT":

  → Encontra chunk2 (alta similaridade)

  

Retorno para o LLM:

  → Retorna o documento pai completo (toda a seção de JWT)

  → Mais contexto = resposta melhor

Para 1M de documentos:

  1M × similaridade_cosseno → ordena → retorna top-K

  Tempo: O(n) linear — pode ser lento

HNSW (Hierarchical Navigable Small World):

  Pré-computa um grafo de "vizinhança" entre vetores

  Busca navega o grafo em vez de comparar todos

  Tempo: O(log n) — muito mais rápido

  Trade-off: ~5% de resultados podem não ser os exatos mais similares

# Teste manual: a resposta pode ser derivada dos documentos?

documentos = recuperar(pergunta)

resposta = llm.gerar(pergunta, documentos)



# Se a resposta menciona informação que NÃO está em nenhum documento recuperado

# → alucinação de RAG (o modelo "completou" com conhecimento próprio)

# Top-3 recuperados para "O que é pgvector?"

doc1: "pgvector é uma extensão do PostgreSQL..." → ✓ relevante

doc2: "RAG combina busca semântica com geração..." → parcialmente relevante

doc3: "Prompt caching reduz custos..." → ✗ irrelevante



# Precision@3 = 2/3 = 67% — pode melhorar

# Pergunta: "Qual a diferença entre RAG e fine-tuning?"

# Resposta: "RAG foi proposto em 2020..." (menciona data mas não responde)

# → Baixa answer relevance

Fase 1 (rápida): embedding search recupera top-50 candidatos

Fase 2 (precisa): cross-encoder reranker analisa a query junto com cada candidato

                  → retorna top-3 mais relevantes



Cross-encoder: modelo que recebe [query, documento] e retorna score de relevância

  → Mais lento (O(k) vs O(1) do embedding search)

  → Muito mais preciso (considera interação direta entre query e documento)

def hyde_search(query, vector_store):

    # 1. LLM gera documento hipotético que responderia a query

    doc_hipotetico = llm.gerar(f"Escreva um parágrafo respondendo: {query}")

    

    # 2. Usa embedding do documento hipotético (não da query!) para buscar

    embedding_hipotetico = embedder.embed(doc_hipotetico)

    documentos = vector_store.buscar(embedding_hipotetico, top_k=5)

    

    # 3. Usa documentos reais encontrados para gerar resposta final

    return llm.gerar(query, documentos)

const Anthropic = require('@anthropic-ai/sdk')

const client = new Anthropic.default()



// Embedding simplificado baseado em palavras-chave

// NOTA: Em produção, use API real de embeddings (voyage-3, ada-002)

// A diferença de qualidade é enorme — esse é apenas para fins didáticos

function gerarEmbeddingSimples(texto) {

  const palavrasChave = {

    mcp: 1, anthropic: 1, protocol: 1,

    rag: 2, retrieval: 2, busca: 2,

    embedding: 3, vetor: 3, similaridade: 3,

    transformer: 4, attention: 4, token: 4,

    finetuning: 5, treinamento: 5, modelo: 5,

  }

  

  const textoNorm = texto.toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '')

  const vetor = new Array(5).fill(0)

  

  for (const [palavra, categoria] of Object.entries(palavrasChave)) {

    if (textoNorm.includes(palavra)) {

      vetor[categoria - 1] += 1  // incrementa a dimensão da categoria

    }

  }

  

  return vetor

}



function similCosseno(a, b) {

  // Produto escalar usando reduce — mais conciso que loop explícito

  const dot = a.reduce((sum, ai, i) => sum + ai * b[i], 0)

  // sqrt da soma dos quadrados = norma L2

  const normA = Math.sqrt(a.reduce((sum, ai) => sum + ai * ai, 0))

  const normB = Math.sqrt(b.reduce((sum, bi) => sum + bi * bi, 0))

  // Proteção contra divisão por zero (vetor nulo = documento sem palavras conhecidas)

  return normA === 0 || normB === 0 ? 0 : dot / (normA * normB)

}



class VectorStore {

  constructor() {

    this.indices = []  // [{ id, texto, embedding }]

  }



  indexar(documentos) {

    // Para cada documento, geramos e armazenamos seu embedding

    // Em produção: batch requests de embedding para economizar custo

    this.indices = documentos.map((doc) => ({

      id: doc.id,

      texto: doc.texto,

      embedding: gerarEmbeddingSimples(doc.texto),  // em produção: await embedder.embed(doc.texto)

    }))

    console.log(`  Indexados ${this.indices.length} documentos`)

  }



  buscar(query, topK = 3) {

    // Geramos embedding da query com o MESMO modelo dos documentos

    // Usar modelos diferentes quebraria a comparação (espaços vetoriais diferentes)

    const embeddingQuery = gerarEmbeddingSimples(query)

    

    // Calculamos similaridade com todos os documentos indexados

    const resultados = this.indices.map((doc) => ({

      ...doc,

      similaridade: similCosseno(embeddingQuery, doc.embedding),

    }))

    

    // Ordenamos do mais para o menos similar e retornamos os top-K

    return resultados

      .sort((a, b) => b.similaridade - a.similaridade)

      .slice(0, topK)

  }

}

async function gerarResposta(pergunta, documentosContexto) {

  // Formata os documentos como contexto numerado

  // Numeração permite que a resposta cite fontes: "De acordo com o documento 2..."

  const contexto = documentosContexto

    .map((doc) => `[Documento ${doc.id}]: ${doc.texto}`)

    .join('\n\n')

  

  const prompt = `Com base nos documentos a seguir, responda à pergunta.

Cite os números dos documentos usados na resposta.

Se a resposta não estiver nos documentos, diga "Essa informação não está na base de conhecimento."



${contexto}



Pergunta: ${pergunta}



Resposta:`



  const resposta = await client.messages.create({

    model: 'claude-haiku-4-5-20251001',

    max_tokens: 300,

    messages: [{ role: 'user', content: prompt }],

  })

  

  return resposta.content[0].text

}



// Uso completo:

const store = new VectorStore()

store.indexar(documentos)



const pergunta = 'Qual a diferença entre RAG e fine-tuning?'

const docsRelevantes = store.buscar(pergunta, 3)

const resposta = await gerarResposta(pergunta, docsRelevantes)

console.log(resposta)

// "De acordo com os documentos 2 e 5, RAG usa recuperação em tempo de inferência

//  enquanto fine-tuning adapta os pesos do modelo durante treinamento..."

Documentos recuperados:

  0.82 - "RAG combina busca semântica com geração..."

  0.71 - "Fine-tuning adapta um modelo pré-treinado..."

  0.45 - "Embeddings são representações vetoriais..."



Resposta:

De acordo com os documentos 2 e 5, RAG usa recuperação de contexto em tempo de

inferência — busca documentos relevantes e os inclui no prompt — enquanto fine-tuning

adapta os pesos do próprio modelo durante treinamento com exemplos rotulados.

RAG é mais fácil de atualizar (re-indexar documentos), enquanto fine-tuning congela

o conhecimento no modelo e exige re-treinamento para atualizar.

this.indices.push({

  id: doc.id,

  texto: doc.texto,

  embedding: gerarEmbeddingSimples(doc.texto)

})