Como implementar RAG com Llama 2 local: reduzindo alucinações sem depender de APIs externas

O problema: LLM sozinho é mentiroso

Um modelo de linguagem grande (LLM) é basicamente um preditor de próxima palavra muito sofisticado. Ele não consulta banco de dados, não acessa documentos, não valida informação. Se você pergunta algo fora do seu conhecimento de treinamento, ele inventa. Designers chamam isso de alucinação. Você chama de frustração.

Eu já me queimei fazendo um chatbot só com GPT-3.5 pura, sem contexto. O usuário perguntava sobre processos internos da empresa e levava uma resposta confiante e completamente errada. A solução existe faz tempo: RAG, ou Retrieval-Augmented Generation.

RAG é simples na essência: antes de pedir para o modelo gerar uma resposta, você busca documentos relevantes do seu próprio banco de dados e passa eles junto com a pergunta. Assim o modelo trabalha com fatos verificados, não com alucinação. E a melhor parte? Você pode rodar tudo localmente com Llama 2, sem pagar nada a API externa.

Por que Llama 2 local muda o jogo

Llama 2 é o modelo open source da Meta. Rode na sua máquina, controle total, sem limite de chamadas, sem fila, sem surpresa na fatura. Uma RTX 3060 (aquela placa de garimpagem) aguenta bem. Uma RTX 4090 roda que é uma beleza.

A diferença em custo é brutal. OpenAI cobra por token. Millhão de tokens sai caro. Llama 2 roda local: custo é só a eletricidade e a GPU que você já pagou.

Tem uma desvantagem: qualidade não é a mesma. Llama 2 é bom, mas GPT-4 é melhor. Só que para RAG, essa diferença diminui muito. O modelo não precisa ser perfeito em raciocínio — ele tem os fatos na mão.

Arquitetura prática de RAG

RAG tem três componentes principais:

• Indexação: você pega seus documentos, divide em pedaços, converte cada um em números (embeddings), guarda num banco que permite busca por similaridade.
• Retrieval: quando chega uma pergunta, você converte ela em embedding também e busca os K documentos mais parecidos.
• Generation: você passa a pergunta + os documentos relevantes para o LLM gerar resposta baseado nesses fatos.

Na prática eu uso assim:

Pergunta do usuário
        ↓
Converter em embedding (usando sentence-transformers)
        ↓
Buscar em banco vetorial (Chroma ou Weaviate)
        ↓
Reparir os top-5 documentos
        ↓
Montar prompt: "Responda baseado nisto: [documentos]\n\nPergunta: [pergunta]"
        ↓
Passar para Llama 2 local
        ↓
Retornar resposta com fonte

Tudo rodando na sua máquina, sem internet (a não ser para baixar o modelo na primeira vez).

Implementação step-by-step

1. Instale as dependências

Precisa de Python 3.9+. Comece assim:

pip install llama-cpp-python sentence-transformers chroma-db

llama-cpp-python roda Llama 2 em CPU/GPU. sentence-transformers gera embeddings. chroma-db é banco vetorial simples e rápido.

2. Baixe o modelo

Llama 2 vem em versões quantizadas para caber em GPU modesta. Eu uso a versão Q4 (4-bit quantization). Pega em huggingface.co:

from huggingface_hub import hf_hub_download

model_path = hf_hub_download(
    repo_id="TheBloke/Llama-2-7B-Chat-GGML",
    filename="llama-2-7b-chat.ggmlv3.q4_K_M.bin"
)

Primeira vez vai baixar ~5GB. Fica local depois.

3. Carregue documentos e crie índice

from sentence_transformers import SentenceTransformer
import chromadb

# Seu banco de docs (arquivo de texto, PDF, whatever)
docs = [
    "Política de RH: férias são 30 dias úteis",
    "Sistema de pontuação: cada bug é 5 pontos",
    "Benefício: vale refeição cobre até R$ 50"
]

# Embedding model
embed_model = SentenceTransformer('distiluse-base-multilingual-cased-v2')

# Chroma: banco vetorial
client = chromadb.Client()
collection = client.create_collection(name="docs")

# Indexa
for i, doc in enumerate(docs):
    embedding = embed_model.encode(doc).tolist()
    collection.add(
        ids=[f"doc_{i}"],
        embeddings=[embedding],
        documents=[doc]
    )

Pronto. Seus documentos estão indexados.

4. Retrieval + Generation

from llama_cpp import Llama

# Carrega modelo
llm = Llama(
    model_path=model_path,
    n_gpu_layers=32,  # quanto mais, melhor (se sua GPU aguenta)
    n_ctx=2048
)

# Pergunta do usuário
query = "Qual é a política de férias?"

# Busca docs relevantes
query_embedding = embed_model.encode(query).tolist()
results = collection.query(
    query_embeddings=[query_embedding],
    n_results=3
)

# Monta contexto
context = "\n".join(results["documents"][0])

# Prompt final
prompt = f"""Use o contexto abaixo para responder.
Contexto:
{context}

Pergunta: {query}
Resposta:"""

# Gera resposta
response = llm(prompt, max_tokens=256, temperature=0.1)
print(response["choices"][0]["text"])

Rode isso e você vai ter uma resposta baseada nos seus documentos, não em alucinação.

Dicas para produção

Chunking inteligente — não jogue documentos inteiros no índice. Divida em pedaços de 200-500 tokens. Um PDF grande vira 50+ chunks. Assim a busca traz exatamente o trecho relevante, não informação no meio de ruído.

Temperatura baixa — na geração, use temperature=0.1 ou até 0. Você quer respostas determinísticas baseadas nos fatos, não criativa.

Validação de relevância — nem sempre a busca traz docs bons. Coloque um limiar: se o score de similaridade for menor que 0.6, avise ao usuário que você não tem documentos sobre isso. Melhor ser honesto do que inventar.

Logs de retrieval — salve qual documento foi usado para gerar cada resposta. Quando o usuário disser que a resposta está errada, você vê exatamente qual doc mentiu.

Problemas reais que você vai encarar

Performance fica lenta? Llama 2 7B em GPU aguenta umas 5-10 respostas por minuto. Se precisa mais, ou suba para uma GPU melhor ou use um modelo menor (3B, 2B).

Documentos muito técnicos? Sentence-transformers padrão falha com jargão específico. Teste treinar um modelo de embedding só com seus documentos. Fine-tune de embedding é mais rápido que fine-tune de LLM.

Muitos documentos? Chroma em arquivo local fica lento com mais de 100k chunks. Migre para Weaviate ou Pinecone. Lógica é a mesma, só muda a performance.

Alucinação ainda acontece? Pode ser chunk ruim no retrieval ou modelo fraco. Teste aumentar n_results (buscar mais documentos) e colocar um prefixo no prompt: "Responda APENAS baseado no contexto fornecido. Se não souber, diga que não sabe."

Próximos passos

Comece pequeno: 5 documentos, teste na sua máquina, veja se funciona. Depois escala — mais docs, melhor modelo de embedding, banco vetorial produção. RAG é simples, mas os detalhinhos fazem diferença.

Se quiser mais controle ainda, estude fine-tuning de Llama 2. Mas pra maioria dos casos, RAG local já resolve: menos alucinação, dados privados, custo zero.