Ancorar respostas nas fontes e reduzir alucinações
Nesta página
O problema das alucinações em produção
Uma alucinação é uma resposta factualmente incorreta apresentada com a confiança de uma resposta correta. É exatamente essa confiança que a torna perigosa. Um chatbot de suporte que inventa um procedimento envia os utilizadores para um beco sem saída; um assistente jurídico que cita um estatuto inexistente expõe o seu cliente a riscos; uma ferramenta médica que recomenda a dosagem errada causa danos reais. Em todos os três casos, nada no formato da resposta sinaliza o problema.
A ancoragem (grounding) aborda este risco ao constranger o modelo a basear as suas respostas exclusivamente em fontes verificadas. Combinada com o sistema de citações abordado nas lições anteriores, cria uma rede de segurança em várias camadas: o prompt define o comportamento esperado, a análise de citações permite a verificação e o pipeline decide como lidar com as respostas que falham na verificação.
O prompt do sistema: a sua primeira linha de defesa
Um prompt vago produz uma ancoragem vaga. Deve enunciara as regras como uma especificação: defina o âmbito das fontes, forneça a frase exata a utilizar quando a informação estiver em falta, proíba o preenchimento de lacunas com conhecimento geral, exija citações para cada afirmação e especifique como lidar com contradições entre fontes.
system_prompt = """
You are a specialized documentation assistant.
ABSOLUTE RULES:
1. Answer ONLY using the sources provided via references.
2. If the information is not in the sources, respond:
"This information is not available in the provided sources."
3. NEVER supplement with your general knowledge.
4. Cite every claim with the corresponding reference.
5. If two sources contradict each other, mention both versions.
"""
Este prompt não garante zero alucinações, e deve ser claro sobre isto com as suas partes interessadas: reduz significativamente a sua frequência. Os modelos Mistral, treinados para ancoragem, seguem estas instruções com uma elevada taxa de conformidade. No entanto, uma taxa elevada não é uma taxa de 100%, razão pela qual os passos seguintes são necessários.
Verificar a ancoragem após a geração
A função validate_grounding transforma uma intuição — «esta resposta parece baseada em fontes?» — numa métrica. Itera sobre os blocos da resposta, somando o comprimento do texto de um lado e contando citações e fontes distintas do outro. Deriva então uma densidade expressa em citações por mil caracteres. Uma resposta de 2.000 caracteres com apenas uma referência torna-se imediatamente suspeita, enquanto um revisor humano poderia tê-la ignorado.
from mistralai.client.models import TextChunk, ReferenceChunk
def validate_grounding(response, min_citations=1):
"""Verifies that the response is grounded in sources."""
content = response.choices[0].message.content
text_length = 0
citation_count = 0
cited_refs = set()
for chunk in content:
if isinstance(chunk, TextChunk):
text_length += len(chunk.text)
elif isinstance(chunk, ReferenceChunk):
citation_count += 1
cited_refs.update(chunk.reference_ids)
# Checks
checks = {
"has_citations": citation_count >= min_citations,
"citation_count": citation_count,
"unique_sources": len(cited_refs),
"text_length": text_length,
"citations_per_1000_chars": round(
citation_count / max(text_length / 1000, 1), 1
)
}
checks["is_grounded"] = checks["has_citations"]
return checks
result = validate_grounding(final_response, min_citations=2)
if not result["is_grounded"]:
print("ALERT: Response potentially ungrounded!")
print(f" Citations found: {result['citation_count']}")
Identificar afirmações fora do âmbito
Contar citações não indica se o texto entre elas permanece fiel às fontes. A função detect_ungrounded_claims aborda este ponto cego com uma heurística lexical simples: divide a resposta em frases, compara palavras com mais de cinco caracteres em cada frase com os excertos concatenados e sinaliza qualquer frase onde menos de 30% das palavras-chave apareçam nas fontes. Para um assistente de documentação, as frases que sobem ao topo da lista de suspeitas são tipicamente o preenchimento de «conhecimento geral» adicionado pelo modelo.
def detect_ungrounded_claims(response_text, source_snippets):
"""Detects sentences that do not match any snippet."""
import re
# Split response into sentences
sentences = re.split(r'[.!?]+', response_text)
sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
# Concatenate all snippets into a single text
all_sources = " ".join(source_snippets).lower()
suspicious = []
for sentence in sentences:
# Extract significant keywords (> 5 chars)
keywords = [
w.lower() for w in sentence.split()
if len(w) > 5
]
# Check coverage
matches = sum(1 for kw in keywords if kw in all_sources)
coverage = matches / max(len(keywords), 1)
if coverage < 0.3: # Less than 30% of keywords found
suspicious.append({
"sentence": sentence,
"coverage": round(coverage, 2)
})
return suspicious
Montar um pipeline de confiança
Em produção, estas verificações não são apenas scripts de análise: tornam-se um portão que a resposta deve atravessar antes de chegar ao utilizador. A classe GroundedRAG implementa este portão. Gera a resposta citada, valida-a e, no modo estrito, rejeita liminarmente respostas com ancoragem insuficiente, devolvendo um estado explícito em vez de texto duvidoso. A pontuação de confiança agrega três sinais — presença de citações, diversidade de fontes e densidade — para que a sua interface possa exibir um nível de fiabilidade ou encaminhar casos de baixa confiança para revisão humana.
class GroundedRAG:
"""RAG pipeline with grounding and validation."""
def __init__(self, client, model="mistral-large-latest"):
self.client = client
self.model = model
def query(self, question, references, strict=True):
"""Executes a RAG query with grounding validation."""
# 1. Generate response with citations
response = self._generate_with_citations(
question, references
)
# 2. Validate grounding
grounding = validate_grounding(response, min_citations=1)
# 3. In strict mode, reject ungrounded responses
if strict and not grounding["is_grounded"]:
return {
"status": "rejected",
"reason": "Response insufficiently grounded in sources",
"grounding_score": grounding
}
# 4. Return validated response
return {
"status": "ok",
"response": response,
"grounding_score": grounding,
"confidence": self._compute_confidence(grounding)
}
def _compute_confidence(self, grounding):
"""Calculates a confidence score based on grounding."""
score = 0.0
if grounding["has_citations"]:
score += 0.4
if grounding["unique_sources"] >= 2:
score += 0.3
if grounding["citations_per_1000_chars"] >= 1.0:
score += 0.3
return round(score, 2)
Monitorizar a ancoragem ao longo do tempo
Um pipeline ancorado no primeiro dia de produção pode degradar-se com o tempo porque a base de documentação envelhece, porque um prompt foi ajustado ou porque o tráfego muda para tópicos mal cobertos. As cinco métricas abaixo calculam-se diretamente a partir dos resultados de validate_grounding e merecem um painel de controlo permanente: é a sua deriva, mais do que o seu valor absoluto, que o alerta.
| Métrica | O que mede |
|---|---|
| Taxa de citação | Percentagem de respostas contendo pelo menos uma citação |
| Densidade de citação | Número médio de citações por 1.000 caracteres |
| Diversidade de fontes | Número médio de fontes distintas por resposta |
| Taxa de rejeição | Percentagem de respostas rejeitadas por ancoragem insuficiente |
| Pontuação média de confiança | Evolução da pontuação de confiança ao longo do tempo |
Pontos-chave
- A ancoragem constrange o modelo a responder apenas com base em fontes verificadas
- Um prompt de sistema estrito é a primeira linha de defesa contra alucinações
- A validação pós-geração verifica programaticamente a ancoragem de cada resposta
- Combine estas estratégias num pipeline de confiança multinível
- Monitore continuamente as métricas de ancoragem para detetar degradação