Análisis de errores en agentes IA

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre análisis de errores en agentes IA

• Errores comunes en agentes IA y cómo identificarlos.
• Cómo configurar tracing, debugging y logging para agentes.
• Cómo analizar y resolver errores de forma sistemática.
• Ejemplos prácticos de bucles infinitos, alucinaciones y fallos de herramientas.
• Mejores prácticas para agentes confiables.

Introducción: análisis de errores en agentes IA explicado

Los agentes IA son complejos: invocan modelos, ejecutan herramientas, toman decisiones. Cuando algo falla, el agente puede quedar atrapado en bucles infinitos, invocar herramientas incorrectas, alucinar o bloquearse. El análisis de errores es la disciplina que permite reconocer, comprender y corregir estas fallas.

Este artículo está dirigido a desarrolladores que construyen y depuran agentes IA. Deberías entender qué son los agentes IA y cómo ejecutarlos localmente con Ollama. Los fundamentos de la programación en Python los encontrarás en IRC-Coding.de.

¿Por qué necesito análisis de errores?

Imagina que tu agente debe clasificar correos electrónicos pero no hace nada. ¿Por qué? ¿No respondió el modelo? ¿Falló la herramienta? ¿Está el agente atrapado en un bucle? Sin análisis de errores, adivinas en la oscuridad. Con análisis de errores, ves cada paso, cada decisión, cada fallo e intervenes de forma precisa.

Análisis de errores en agentes IA en pocas palabras

El análisis de errores es la investigación sistemática de fallos en agentes. Utilizas tracing (cada paso se registra), logging (los eventos se protocolizan) y debugging (investigación dirigida) para encontrar la causa y resolverla.

La idea central es simple: sin tracing no hay debugging, sin debugging no hay confiabilidad.

Para quién es este artículo

• Desarrolladores que construyen y depuran agentes IA.
• Administradores de sistemas que mantienen agentes en producción.
• Equipos que mejoran la calidad de agentes de forma sistemática.
• Investigadores que estudian el comportamiento de agentes.

Se requieren conocimientos previos en Python, agentes IA y Ollama.

Términos importantes

• Tracing - Registro de cada paso del agente. Útil para: trazabilidad.
• Protocolo de eventos - Logs estructurados. Útil para: base del análisis.
• Debugging - Búsqueda sistemática de errores. Útil para: encontrar causas.
• Bucle infinito - El agente repite pasos sin avanzar. Útil para: error frecuente.
• Alucinación - El modelo inventa hechos. Útil para: error frecuente.
• Fallo de herramienta - La invocación de herramienta falla. Útil para: error frecuente.
• Agentes IA - Lo que se depura. Útil para: objeto de estudio.
• Ollama - Servidor de modelos local. Útil para: backend cuyo error se analiza.
• Function Calling - Uso de herramientas. Útil para: fuente frecuente de errores.

Errores comunes en agentes IA

1. Bucles infinitos

El agente repite pasos sin avanzar.

Síntomas: el agente se ejecuta mucho tiempo, se repiten las mismas invocaciones de herramientas, no hay respuesta final.

Causas:

• El modelo no puede resolver la tarea e intenta una y otra vez.
• La herramienta devuelve resultados inesperados que el modelo no entiende.
• No hay límite de pasos.

Solución: implementa un límite de pasos.

MAX_STEPS = 20
step = 0
while step < MAX_STEPS:
    step += 1
    # Agenten-Schritt
    if is_done(result):
        break
else:
    log_error("endless_loop", f"Agent hat {MAX_STEPS} Schritte überschritten")

2. Alucinaciones

El modelo inventa hechos que no están en las fuentes.

Síntomas: la respuesta contiene hechos no verificados, las citas son incorrectas.

Causas:

• El modelo no tiene suficiente contexto.
• El modelo es propenso a alucinaciones (depende del modelo).
• No hay validación de resultados.

Solución: valida hechos y solicita fuentes.

Consulta Flujos de investigación para estrategias contra alucinaciones.

3. Fallos de herramientas

Las invocaciones de herramientas fallan.

Síntomas: la herramienta devuelve un error, el agente no lo entiende, se bloquea.

Causas:

• La herramienta no es accesible (red, servicio caído).
• Parámetros incorrectos (el modelo envió parámetros equivocados).
• Problema de permisos (la herramienta no se puede ejecutar).

Solución: manejo de errores en el agente.

def call_tool_safe(tool_name, parameters):
    try:
        result = execute_tool(tool_name, parameters)
        return {"success": True, "result": result}
    except NetworkError as e:
        return {"success": False, "error": "tool_unreachable", "message": str(e)}
    except InvalidParameters as e:
        return {"success": False, "error": "invalid_parameters", "message": str(e)}
    except PermissionError as e:
        return {"success": False, "error": "permission_denied", "message": str(e)}

4. Longitud de contexto excedida

El contexto se vuelve demasiado largo, el modelo no puede responder.

Síntomas: la respuesta del modelo se corta, error de límite de contexto.

Causas:

• Demasiados mensajes en el historial.
• Resultados de herramientas largos.
• Sin función de resumen.

Solución: utiliza memory con resumen.

def manage_context(messages, max_tokens=4000):
    total = sum(len(m["content"]) for m in messages)
    if total > max_tokens:
        # Zusammenfassen
        summary = call_ollama([
            {"role": "system", "content": "Fasse zusammen."},
            {"role": "user", "content": str(messages[:5])}
        ])
        messages = [messages[0], {"role": "system", "content": f"Zusammenfassung: {summary}"}] + messages[-3:]
    return messages

5. Modelo no accesible

Ollama o la API en la nube no está accesible.

Síntomas: timeout, error de conexión, el agente se bloquea.

Causas:

• Ollama no está en ejecución.
• Problema de red.
• API en la nube caída.

Solución: lógica de reintentos y fallback.

import time

def call_model_retry(messages, max_retries=3, delay=1):
    for attempt in range(max_retries):
        try:
            return call_ollama(messages)
        except (ConnectionError, TimeoutError) as e:
            if attempt < max_retries - 1:
                time.sleep(delay * (attempt + 1))
            else:
                log_error("model_unreachable", str(e))
                raise

Implementar tracing

from datetime import datetime
import json

class AgentTracer:
    def __init__(self, trace_file="agent_trace.json"):
        self.trace_file = trace_file
        self.steps = []

    def trace_step(self, step_type, data):
        step = {
            "timestamp": datetime.now().isoformat(),
            "step_type": step_type,
            "data": data
        }
        self.steps.append(step)
        with open(self.trace_file, "a") as f:
            f.write(json.dumps(step) + "\n")

    def trace_model_call(self, model, messages, response, duration_ms):
        self.trace_step("model_call", {
            "model": model,
            "input_messages": len(messages),
            "response_length": len(response),
            "duration_ms": duration_ms
        })

    def trace_tool_call(self, tool, parameters, result, duration_ms):
        self.trace_step("tool_call", {
            "tool": tool,
            "parameters": parameters,
            "result_status": result.get("status", "unknown"),
            "duration_ms": duration_ms
        })

    def trace_decision(self, decision, reasoning):
        self.trace_step("decision", {
            "decision": decision,
            "reasoning": reasoning
        })

    def trace_error(self, error_type, message, context):
        self.trace_step("error", {
            "error_type": error_type,
            "message": message,
            "context": context
        })

Agente con Tracing

class TraceableAgent:
    def __init__(self, model="llama3.1"):
        self.model = model
        self.tracer = AgentTracer()

    def run(self, task):
        self.tracer.trace_step("start", {"task": task})
        step = 0

        while step < 20:
            step += 1
            self.tracer.trace_step("step", {"step_number": step})

            # Llamar al modelo
            start = time.time()
            try:
                response = call_ollama([
                    {"role": "user", "content": task}
                ])
                duration = (time.time() - start) * 1000
                self.tracer.trace_model_call(self.model, [task], response, duration)
            except Exception as e:
                self.tracer.trace_error("model_error", str(e), {"step": step})
                raise

            # ¿Llamada a herramienta?
            if has_tool_call(response):
                tool_name, params = extract_tool_call(response)
                start = time.time()
                try:
                    result = execute_tool(tool_name, params)
                    duration = (time.time() - start) * 1000
                    self.tracer.trace_tool_call(tool_name, params, result, duration)
                except Exception as e:
                    self.tracer.trace_error("tool_error", str(e), {"tool": tool_name})
                    result = {"success": False, "error": str(e)}

            # ¿Terminado?
            if is_done(response):
                self.tracer.trace_step("done", {"result": response})
                return response

        self.tracer.trace_error("max_steps", "Máximo número de pasos excedido", {"steps": step})

Analizar el trace

# Todos los errores
jq 'select(.step_type == "error")' agent_trace.json

# Todas las llamadas a herramientas
jq 'select(.step_type == "tool_call")' agent_trace.json

# Llamadas a herramientas que fallaron
jq 'select(.step_type == "tool_call" and .data.result_status == "failed")' agent_trace.json

# Llamadas al modelo lentas
jq 'select(.step_type == "model_call" and .data.duration_ms > 5000)' agent_trace.json

Ejemplo práctico 1: Depurar bucles infinitos

# El trace muestra: el agente llama 20 veces la misma herramienta
# Análisis: la herramienta devuelve un resultado inesperado, el modelo no lo entiende

# Solución: mejor descripción de errores para el modelo
def call_tool_with_explanation(tool_name, parameters):
    result = execute_tool(tool_name, parameters)
    if not result["success"]:
        # Descripción de error clara para el modelo
        result["explanation"] = f"La herramienta {tool_name} falló: {result['error']}. Intenta otro método."
    return result

Ejemplo práctico 2: Depurar alucinaciones

# El trace muestra: el modelo genera hechos sin fuentes
# Análisis: el modelo no tiene suficiente contexto

# Solución: exigir fuentes
system_prompt = """
Eres un agente de investigación.
Todo hecho debe tener una fuente.
Si no tienes una fuente, di "No lo sé".
No inventes hechos.
"""

Ejemplo práctico 3: Depurar errores de herramientas

# El trace muestra: la llamada a la herramienta falla con "connection refused"
# Análisis: Ollama no se está ejecutando

# Solución: verificación de salud antes de iniciar el agente
def check_ollama_health():
    try:
        requests.get("http://localhost:11434/api/tags", timeout=5)
        return True
    except:
        return False

if not check_ollama_health():
    print("Ollama no está ejecutándose. Iniciando Ollama.")
    subprocess.Popen(["ollama", "serve"])
    time.sleep(5)

Escollos típicos

• Sin Tracing: sin un registro de eventos, no puedes saber qué sucedió.
• Sin manejo de errores: si una herramienta falla, el agente se detiene.
• Sin límite de pasos: el agente puede quedarse atrapado en bucles infinitos.
• Sin gestión de contexto: el contexto crece, el modelo no puede responder.
• Sin lógica de reintentos: un error de red temporal detiene el agente.
• Trace demasiado grande: demasiados detalles hacen el registro confuso. Usa niveles de log.

Enlaces relacionados

• Fundamentos de agentes de IA - Qué son los agentes de IA.
• Registro de eventos - Conceptos básicos de logging.
• Control de costos - Monitorear gastos.
• Flujos de investigación - Contra alucinaciones.
• Agentes de IA con Ollama - Ejecutar agentes localmente.
• Function Calling - Uso de herramientas.
• Solución de problemas de Ollama - Depurar Ollama.

Puntos clave:

• Errores comunes: bucles infinitos, alucinaciones, errores de herramientas, longitud de contexto.
• El Tracing registra cada paso para trazabilidad.
• El manejo de errores captura fallos de herramientas sin detener el agente.
• El límite de pasos previene bucles infinitos.
• La lógica de reintentos y fallbacks mejoran confiabilidad.

FAQ

Fuentes y referencias

• LangSmith - Tracing para LangChain.
• Langfuse - Tracing de código abierto.
• Ollama - Servidor de modelos local.
• Protokollierung - Fundamentos de logging.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert