Deten las Hallucinations en Agentes de IA: 4 Tecnicas Esenciales

4 tecnicas para detener las hallucinations en AI agents: Graph-RAG para recuperacion precisa de datos, seleccion semantica de tools para elegir la herramienta correcta, guardrails neurosimbolicos para aplicar reglas de negocio, y validacion multi-agent para deteccion de errores.

Objetivos de Aprendizaje

• Como Graph-RAG previene hallucinations estadisticas con datos estructurados
• Por que la seleccion semantica de tools mejora la precision y reduce costos de tokens
• Como los guardrails neurosimbolicos con Strands Agents bloquean operaciones invalidas
• Como la validacion multi-agent detecta hallucinations antes de que lleguen a los usuarios

Esta demo utiliza Strands Agents. Patrones similares pueden aplicarse en LangGraph, AutoGen u otros frameworks de agents.

Repositorio y Prerequisitos

Clonar:

git clone https://github.com/aws-samples/sample-why-agents-fail
cd stop-ai-agent-hallucinations

Requisitos:

• Python 3.9+
• Acceso a un LLM (Amazon Bedrock, OpenAI, Anthropic u Ollama)
• Credenciales de AWS configuradas (si se usa Bedrock)
• Comprension basica de AI agents y tool calling
• Bibliotecas clave: Strands Agents, Neo4j, FAISS, SentenceTransformers

Tecnica 1: Graph-RAG para Recuperacion Precisa de Datos

Problema: El RAG tradicional recupera fragmentos de texto en lugar de ejecutar calculos, lo que produce tres tipos de hallucination:

1. Estadisticas fabricadas a partir de agregaciones adivinadas
2. Recuperacion incompleta cuando los datos estan dispersos
3. Fabricacion fuera de dominio cuando no existen datos relevantes

Solucion: Los knowledge graphs proporcionan datos estructurados y verificables, donde las agregaciones son calculadas por la base de datos en lugar de ser adivinadas por los LLMs.

Codigo de Comparacion

from strands import Agent, tool

# RAG Agent — vector similarity search
@tool
def search_faqs(query: str) -> str:
    """Search hotel FAQs using vector similarity."""
    query_embedding = embed_model.encode([query])
    distances, indices = index.search(query_embedding.astype('float32'), 3)
    return "\n".join([documents[idx]['text'][:500] for idx in indices[0]])

# Graph-RAG Agent — Cypher queries on knowledge graph
@tool
def query_knowledge_graph(cypher_query: str) -> str:
    """Execute a Cypher query against the hotel knowledge graph.
    Node labels: Hotel, Room, Amenity, Policy, Service
    Relationships: (Hotel)-[:HAS_ROOM]->(Room), (Hotel)-[:OFFERS_AMENITY]->(Amenity)
    """
    with driver.session() as session:
        result = session.run(cypher_query)
        records = list(result)
        if not records:
            return "No results found."
        return f"Found {len(records)} results:\n" + "\n".join(str(dict(r.items())) for r in records[:15])

rag_agent = Agent(tools=[search_faqs], model=model)
graph_agent = Agent(tools=[query_knowledge_graph], model=model)

Resultados de la Demo

Tipo de Consulta	RAG	Graph-RAG
Agregacion: “Calificacion promedio en Paris?”	Calcula solo con 2 documentos	AVG() nativo sobre todos
Conteo: “Hoteles con piscina?"	"No tengo los datos”	Preciso: 133
Multi-hop: “Tipos de habitacion del mejor hotel?”	No puede recorrer relaciones	Recorrido Hotel - Room
Fuera de dominio: “Hoteles en la Antartida”	Fabrica respuestas	Honesto: “No hay hoteles”

Hallazgo Clave: Graph-RAG reduce las hallucinations porque devuelve resultados vacios en lugar de respuestas fabricadas cuando los datos no estan disponibles.

---

Tecnica 2: Seleccion Semantica de Tools para Elegir la Herramienta Correcta

Problema: “Las hallucinations en tool-calling aumentan con la cantidad de tools.” Cuando los agents tienen muchas tools similares, exhiben errores de seleccion de funcion, errores de idoneidad, errores de parametros, errores de completitud y comportamiento de evasion de tools.

Problema Dual:

• Riesgo de hallucination: Mas tools = mas selecciones inapropiadas
• Desperdicio de tokens: 31 tools = 4,500 tokens por consulta

Solucion: Filtrado Semantico de Tools

Filtra las tools antes de que el agent las vea usando similitud vectorial.

from sentence_transformers import SentenceTransformer
import faiss

# Build index once
model = SentenceTransformer('all-MiniLM-L6-v2')
tool_embeddings = model.encode([tool.description for tool in ALL_TOOLS])
index = faiss.IndexFlatL2(384)
index.add(tool_embeddings)

# Filter per query
query_embedding = model.encode([query])
distances, indices = index.search(query_embedding, k=3)
relevant_tools = [ALL_TOOLS[i] for i in indices[0]]

Intercambio Dinamico de Tools con Strands Agents

from strands import Agent

# Create agent once
agent = Agent(tools=[...], model=model)

# Swap tools per query without losing conversation history
for query in conversation:
    relevant_tools = search_tools(query, top_k=3)
    agent.tool_registry.registry.clear()
    for tool in relevant_tools:
        agent.tool_registry.register_tool(tool)

    response = agent(query)  # agent.messages preserved

Resultados en 29 Consultas de Viaje

Las pruebas muestran mejoras significativas:

• 86.4% de reduccion en errores de seleccion de tools
• 89% de reduccion en costos de tokens
• Precision mantenida con menos tools visibles

---

Tecnica 3: Guardrails Neurosimbolicos para AI Agents

Problema: Investigaciones demuestran que los agents generan hallucinations cuando las reglas de negocio se expresan unicamente en prompts de lenguaje natural. El prompt engineering no puede aplicar restricciones porque los prompts son sugerencias, no reglas ejecutables.

Solucion: Usar hooks de Strands Agents para interceptar llamadas a tools antes de su ejecucion y aplicar reglas simbolicas a nivel del framework.

Implementacion

from strands import Agent, tool
from strands.hooks import HookProvider, HookRegistry, BeforeToolCallEvent

# Define symbolic rules
BOOKING_RULES = [
    Rule(
        name="max_guests",
        condition=lambda ctx: ctx.get("guests", 1) <= 10,
        message="Maximum 10 guests per booking"
    ),
]

# Create validation hook
class NeurosymbolicHook(HookProvider):
    def register_hooks(self, registry: HookRegistry) -> None:
        registry.add_callback(BeforeToolCallEvent, self.validate)

    def validate(self, event: BeforeToolCallEvent) -> None:
        ctx = {"guests": event.tool_use["input"].get("guests", 1)}
        passed, violations = validate(BOOKING_RULES, ctx)

        if not passed:
            event.cancel_tool = f"BLOCKED: {', '.join(violations)}"

# Clean tool (no validation logic)
@tool
def book_hotel(hotel: str, guests: int = 1) -> str:
    """Book a hotel room."""
    return f"SUCCESS: Booked {hotel} for {guests} guests"

# Attach hook to agent
hook = NeurosymbolicHook()
agent = Agent(tools=[book_hotel], hooks=[hook])

# Test
query = "Book hotel for 15 guests"
result = agent(query)  # Hook blocks before tool executes

Efectividad

Escenario	Prompt Engineering	Neurosimbolico con Hooks
Parametros Invalidos	Acepta	Bloquea
Prerequisitos Faltantes	A veces detecta	Siempre bloquea
Evasion de Reglas	Posible	Imposible

---

Tecnica 4: Validacion Multi-Agent para Deteccion de Errores

Problema: Los agents individuales operan en aislamiento. Cuando generan hallucinations, no existe un mecanismo para detectar errores antes de que lleguen a los usuarios.

Solucion: Multiples agents especializados se validan mutuamente mediante debate estructurado, utilizando Strands Swarm para transferencias autonomas con contexto compartido.

Implementacion

from strands import Agent
from strands.multiagent import Swarm

# Define specialized agents
executor = Agent(
    name="executor",
    tools=ALL_TOOLS,
    system_prompt="Execute requests, then hand off to validator"
)

validator = Agent(
    name="validator",
    system_prompt="Check for hallucinations. Say VALID or HALLUCINATION"
)

critic = Agent(
    name="critic",
    system_prompt="Final review. Say APPROVED or REJECTED"
)

# Create swarm - agents hand off autonomously
swarm = Swarm(
    [executor, validator, critic],
    entry_point=executor,
    max_handoffs=5
)

result = swarm("Book grand_hotel for John")

Comparacion de Rendimiento

Enfoque	Deteccion de Hallucinations	Precision	Latencia
Agent Individual	Ninguna	Fabrica	Rapido
Multi-Agent	Detecta errores	Valida	Mas lento

---

Combinando Tecnicas para Produccion

Estas tecnicas se complementan entre si:

1. Graph-RAG asegura la precision de los datos
2. Seleccion semantica de tools reduce errores de tools y costos de tokens
3. Reglas neurosimbolicas aplican restricciones de negocio
4. Validacion multi-agent detecta las hallucinations restantes

---

Conclusiones Clave

1. Las hallucinations son inevitables — enfocate en deteccion y mitigacion, no en eliminacion
2. Graph-RAG para precision cuando necesitas calculos exactos o relaciones
3. Filtrado semantico esencial con mas de 10 tools similares
4. Las reglas simbolicas aplican cumplimiento de negocio donde el prompt engineering falla
5. La validacion multi-agent detecta errores que los agents individuales no captan
6. Strands Agents permite despliegues en produccion con tools dinamicas y soporte nativo multi-agent

---

Referencias

• MetaRAG: Metamorphic Testing for Hallucination Detection
• Internal Representations as Indicators of Hallucinations in Agent Tool Selection
• Teaming LLMs to Detect and Mitigate Hallucinations
• RAG-KG-IL: Multi-Agent Hybrid Framework
• Strands Agents Documentation

---

Gracias!

🇻🇪🇨🇱 Dev.to Linkedin GitHub Twitter Instagram Youtube Linktr