Implementação de RAG

Domine a Geração Aumentada por Recuperação (RAG) para construir aplicações de LLM que fornecem respostas precisas e fundamentadas usando fontes de conhecimento externas.

Quando Usar Esta Habilidade

• Construir sistemas de Perguntas e Respostas sobre documentos proprietários
• Criar chatbots com informações atuais e factuais
• Implementar busca semântica com consultas em linguagem natural
• Reduzir alucinações com respostas fundamentadas
• Permitir que LLMs acessem conhecimento específico de domínio
• Construir assistentes de documentação
• Criar ferramentas de pesquisa com citação de fontes

Componentes Principais

1. Bancos de Dados Vetoriais

Propósito: Armazenar e recuperar embeddings de documentos de forma eficiente

Opções:

• Pinecone: Gerenciado, escalável, serverless
• Weaviate: Código aberto, busca híbrida, GraphQL
• Milvus: Alto desempenho, on-premise
• Chroma: Leve, fácil de usar, desenvolvimento local
• Qdrant: Rápido, busca filtrada, baseado em Rust
• pgvector: Extensão do PostgreSQL, integração SQL

2. Embeddings

Propósito: Converter texto em vetores numéricos para busca de similaridade

Modelos (2026):

3. Estratégias de Recuperação

Abordagens:

• Recuperação Densa: Similaridade semântica via embeddings
• Recuperação Esparsa: Correspondência de palavras-chave (BM25, TF-IDF)
• Busca Híbrida: Combina densa + esparsa com fusão ponderada
• Multi-Query: Gera múltiplas variações de consulta
• HyDE: Gera documentos hipotéticos para melhor recuperação

4. Reclassificação (Reranking)

Propósito: Melhorar a qualidade da recuperação reordenando os resultados

Métodos:

• Cross-Encoders: Reclassificação baseada em BERT (ms-marco-MiniLM)
• Cohere Rerank: Reclassificação baseada em API
• Maximal Marginal Relevance (MMR): Diversidade + relevância
• Baseado em LLM: Usa LLM para pontuar a relevância

Início Rápido com LangGraph

from langgraph.graph import StateGraph, START, END
from langchain_anthropic import ChatAnthropic
from langchain_voyageai import VoyageAIEmbeddings
from langchain_pinecone import PineconeVectorStore
from langchain_core.documents import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_text_splitters import RecursiveCharacterTextSplitter
from typing import TypedDict, Annotated

class RAGState(TypedDict):
    question: str
    context: list[Document]
    answer: str

# Initialize components
llm = ChatAnthropic(model="claude-sonnet-5")
embeddings = VoyageAIEmbeddings(model="voyage-3-large")
vectorstore = PineconeVectorStore(index_name="docs", embedding=embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# RAG prompt
rag_prompt = ChatPromptTemplate.from_template(
    """Answer based on the context below. If you cannot answer, say so.

    Context:
    {context}

    Question: {question}

    Answer:"""
)

async def retrieve(state: RAGState) -> RAGState:
    """Retrieve relevant documents."""
    docs = await retriever.ainvoke(state["question"])
    return {"context": docs}

async def generate(state: RAGState) -> RAGState:
    """Generate answer from context."""
    context_text = "\n\n".join(doc.page_content for doc in state["context"])
    messages = rag_prompt.format_messages(
        context=context_text,
        question=state["question"]
    )
    response = await llm.ainvoke(messages)
    return {"answer": response.content}

# Build RAG graph
builder = StateGraph(RAGState)
builder.add_node("retrieve", retrieve)
builder.add_node("generate", generate)
builder.add_edge(START, "retrieve")
builder.add_edge("retrieve", "generate")
builder.add_edge("generate", END)

rag_chain = builder.compile()

# Use
result = await rag_chain.ainvoke({"question": "What are the main features?"})
print(result["answer"])

Padrões detalhados e exemplos práticos

A documentação detalhada dos padrões está em references/details.md. Leia este arquivo quando o nível de navegação acima for insuficiente.