Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Recuperação e Geração

Aula 13 de 18 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Do Vetor à Resposta
  2. Construção do Prompt RAG
  3. Geração da Resposta
  4. Encapsulamento do Fluxo numa Classe
  5. Três Variantes de Prompt por Caso de Uso
  6. Pontos-chave

Do Vetor à Resposta

Já sabe como indexar documentos e recuperar os mais próximos de uma pergunta. Falta apenas um passo: transformar uma lista de fragmentos numa resposta legível. Isto implica injetar o contexto recuperado num prompt para que o LLM formule uma resposta baseada nos seus dados e não nas memórias do seu treino. São necessárias apenas algumas linhas de código, mas fazem uma diferença decisiva na qualidade. Um contexto bem apresentado e uma instrução clara são tão importantes quanto a precisão da recuperação.

Construção do Prompt RAG

A estrutura do prompt é simples, mas cada escolha tem consequências. Numere os fragmentos e anote-os com a sua origem para que o modelo possa citar com precisão. Separe-os com um delimitador visível, ---, para que o modelo não funde dois documentos contraditórios numa única afirmação. O mais importante: a instrução deve restringir explicitamente a resposta ao contexto fornecido e permitir que o modelo diga que não sabe. Sem essa permissão, um LLM questionado sobre informação em falta preencherá a lacuna com o que parecer plausível. Esse é exatamente o mecanismo da alucinação.

def build_rag_prompt(question, retrieved_chunks):
    """Constrói o prompt RAG com o contexto recuperado."""
    # Formatar o contexto
    context_parts = []
    for i, chunk in enumerate(retrieved_chunks):
        source = chunk.get("source", "fonte desconhecida")
        context_parts.append(f"[Documento {i+1} - {source}]\n{chunk['text']}")

    context = "\n\n---\n\n".join(context_parts)

    prompt = f"""Você é um assistente especialista. Responda à pergunta usando
APENAS o contexto fornecido abaixo. Se a informação não estiver no
contexto, diga-o claramente.

## Contexto

{context}

## Pergunta

{question}

## Resposta"""

    return prompt

Geração da Resposta

A chamada de geração é direta: uma mensagem de sistema que reitera o papel e uma mensagem de utilizador que transporta o prompt montado. Preste atenção ao parâmetro temperature, definido aqui como 0.1. Na escrita criativa, quer variedade; no RAG, quer o oposto. Quer que o modelo se mantenha o mais próximo possível do que o contexto diz e quer que duas execuções sobre a mesma pergunta produzam a mesma resposta. Uma temperatura elevada levaria o modelo a reformular, extrapolar e afastar-se da fonte.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
    """Gera uma resposta RAG com o Mistral."""
    prompt = build_rag_prompt(question, retrieved_chunks)

    response = client.chat.complete(
        model=model,
        messages=[
            {
                "role": "system",
                "content": "Você é um assistente preciso que responde com base no contexto fornecido."
            },
            {
                "role": "user",
                "content": prompt,
            }
        ],
        temperature=0.1,  # Temperatura baixa para respostas factuais
    )

    return response.choices[0].message.content

# Exemplo
question = "Quais são os principais passos do RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)

Encapsulamento do Fluxo numa Classe

Funções dispersas funcionam para exploração, não para entrega. A classe RAGPipeline agrupa o estado — os fragmentos, a matriz de embeddings e o índice FAISS construído uma única vez na instanciação — e três operações: retrieve codifica a pergunta e consulta o índice, generate monta o prompt e chama o modelo, e ask encadeia as duas. Note o que ask devolve: não uma cadeia de caracteres, mas um dicionário contendo a resposta, a lista de fontes e o número de fragmentos utilizados. Esta rastreabilidade é o que separa um assistente auditável de uma caixa negra. No dia em que um utilizador contestar uma resposta, saberá em que passagens ela se baseou.

import numpy as np
import faiss
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

class RAGPipeline:
    """Pipeline RAG completo com Mistral e FAISS."""

    def __init__(self, chunks, embeddings):
        self.chunks = chunks
        self.embeddings = embeddings.astype(np.float32)

        # Criar o índice FAISS
        dimension = embeddings.shape[1]
        self.index = faiss.IndexFlatL2(dimension)
        self.index.add(self.embeddings)

    def retrieve(self, question, k=3):
        """Passo 1: recuperar fragmentos relevantes."""
        response = client.embeddings.create(
            model="mistral-embed",
            inputs=[question],
        )
        query_vector = np.array(
            [response.data[0].embedding], dtype=np.float32
        )

        distances, indices = self.index.search(query_vector, k)

        results = []
        for dist, idx in zip(distances[0], indices[0]):
            if idx >= 0:
                results.append({
                    "text": self.chunks[idx]["text"],
                    "source": self.chunks[idx].get("source", ""),
                    "distance": float(dist),
                })
        return results

    def generate(self, question, context_chunks):
        """Passo 2: gerar a resposta com contexto."""
        prompt = build_rag_prompt(question, context_chunks)

        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.1,
        )
        return response.choices[0].message.content

    def ask(self, question, k=3):
        """Pipeline completo: pergunta -> resposta com fontes."""
        # Recuperação
        context = self.retrieve(question, k=k)

        # Geração
        answer = self.generate(question, context)

        return {
            "question": question,
            "answer": answer,
            "sources": [c["source"] for c in context],
            "n_chunks_used": len(context),
        }

# Utilização
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Como funciona a indexação no FAISS?")

print(f"Pergunta: {result['question']}")
print(f"Resposta: {result['answer']}")
print(f"Fontes: {result['sources']}")

Três Variantes de Prompt por Caso de Uso

Pode especializar o prompt base dependendo do que espera do assistente. Se os seus utilizadores devem verificar cada afirmação, peça explicitamente citações entre parênteses retos. O modelo anexará então cada frase a um documento numerado. Se a resposta alimentar uma interface ou um relatório, um formato estruturado impõe secções estáveis: uma resposta concisa, detalhes, fontes e um nível de confiança que reflete quão bem o contexto cobre a pergunta. A terceira variante desempenha um papel diferente: ensina o modelo a decompor a incerteza, distinguindo o que pode afirmar, o que falta e onde procurar a seguir. Isto produz frequentemente os assistentes mais úteis na prática, porque «falta-me X» vale mais do que uma resposta confiante mas errada.

# 1. Prompt com instrução de citação
prompt_cite = """Responda citando os documentos fonte entre parênteses retos.
Exemplo: "O RAG melhora a precisão [Documento 1]."

Contexto: {context}
Pergunta: {question}"""

# 2. Prompt com formato estruturado
prompt_structured = """Responda no seguinte formato:

**Resposta**: [a sua resposta concisa]
**Detalhes**: [explicação detalhada]
**Fontes**: [lista de documentos utilizados]
**Confiança**: [alta/média/baixa com base na cobertura do contexto]

Contexto: {context}
Pergunta: {question}"""

# 3. Prompt com gestão de informação em falta
prompt_honest = """Se o contexto não contiver informação suficiente para
responder completamente, declare claramente:
- O que pode afirmar com certeza
- O que falta no contexto
- Sugestões para obter a informação em falta

Contexto: {context}
Pergunta: {question}"""

Quanto aos parâmetros da chamada, três definições governam o comportamento do RAG. Uma temperatura baixa fixa a produção factual, max_tokens impede respostas que derivem para ensaios e um top_p conservador restringe o vocabulário amostrado às continuações mais prováveis.

# Para RAG, utilize uma temperatura baixa
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,   # Factual, baixa criatividade
    max_tokens=1024,    # Limitar o comprimento da resposta
    top_p=0.95,         # Amostragem de núcleo conservadora
)

Pontos-chave

  • O prompt RAG injeta o contexto recuperado antes da pergunta
  • Utilize uma temperatura baixa (0.1–0.3) para respostas factuais
  • Peça ao modelo para citar as fontes para garantir a rastreabilidade
  • A classe RAGPipeline encapsula todo o fluxo: recuperar, gerar, perguntar
  • Trate os casos em que o contexto não contém informação suficiente