Sistemas multiagente con Claude Opus 4 para tareas complejas

La era de la solución "con una sola instrucción" está llegando a su fin. A medida que pasamos de simples chatbots a sistemas autónomos capaces de ejecutar flujos de trabajo empresariales complejos (como la diligencia debida automatizada, la migración de código heredado o el análisis dinámico del mercado), la limitación no reside en el conocimiento del modelo, sino en su arquitectura.

Para resolver problemas complejos y ambiguos que requieren múltiples pasos, debemos avanzar hacia los Sistemas de Agentes (MAS). En estas arquitecturas, un "Orchestrador" altamente inteligente descompone los objetivos de alto nivel en tareas más pequeñas y las delega a agentes especializados.. En estas arquitecturas, un "Orchestrador" altamente inteligente descompone los objetivos de alto nivel en tareas más pequeñas y las delega a agentes especializados.

Actualmente,Claude 3 Opus se encuentra como la mejor opción para este puesto de "Orchestrator" debido a su superior capacidad de razonamiento, su capacidad para recordar contextos extensos y su habilidad para seguir instrucciones complejas de "chain-of-thought" sin generar información errónea. Si bien la industria espera la llegada de modelos de próxima generación (a menudo especulados como "Claude 4"), los patrones arquitectónicos que construimos hoy con Opus son la base para esas futuras capacidades.

En este artículo, construiremos un sistema robusto de múltiples agentes utilizando Python y la API de Anthropic, diseñado para directores de tecnología (CTOs) e ingenieros senior que estén listos para pasar de la fase de prueba a la implementación real.

La Arquitectura: El patrón "Supervisor" de "nodo central y periférico"

Para tareas complejas, una estructura plana donde los agentes se comunican entre sí a menudo conduce a bucles infinitos y a la pérdida de estado. En cambio, utilizamos un patrón de "Centro y Periféricos (Supervisor).Modelo centralizado (Supervisor)).

• El Cerebro (Supervisor): Impulsado por Claude 3 Opus. Contiene el "Estado Global" y el "Plan". No ejecuta herramientas (como la extracción de datos o la escritura en bases de datos) directamente, a menos que sea estrictamente necesario. Su función es pensar, analizar y dirigir.
• Los Trabajadores (Sub-Agentes): Impulsados por modelos más rápidos y económicos como Claude 3.5 Sonnet o Haiku. Estos agentes poseen "Herramientas" (funciones) específicas y son de corto alcance: solo se preocupan por su tarea específica (por ejemplo, "Extraer esta URL" o "Ejecutar esta consulta SQL").
• Estado Compartido: Un objeto JSON o Pydantic persistente que rastrea el historial de acciones, resultados y el plan actual.

Implementación técnica

Crearemos un sistema en el que un "Orchestrador" (Opus) gestione un flujo de trabajo de investigación. Delegará tareas a un "Agente de Búsqueda" y a un "Agente de Escritura".

1. Requisitos y configuración

Nos basamos en el SDK nativoanthropic y enpydantic para la validación estricta de tipos, lo cual es indispensable para la ingeniería de productos en producciónProduct Engineering.

pip install anthropic pydantic

2. Definir el estado y las herramientas

Primero, definimos la estructura de nuestros mensajes y las herramientas que nuestros agentes pueden utilizar.

import os
import json
from typing import List, Dict, Any, Optional
from pydantic import BaseModel, Field
from anthropic import Anthropic

# Initialize Client
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

# Define a tool for our workers
def web_search_tool(query: str):
    # In production, replace with SerpAPI or similar
    return f"Simulated search results for: {query}"

TOOLS_DEFINITION = [
    {
        "name": "web_search",
        "description": "Searches the web for information.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "The search query"}
            },
            "required": ["query"]
        }
    }
]

3. El Opus Orchestrator (El "cerebro")

El desafío de ingeniería fundamental es el "System Prompt". Debemos obligar a Claude 3 Opus a actuar estrictamente como un gerente, no como un empleado. Utilizamos la etiquetación XML (que Claude prefiere) para definir límites claros.

ORCHESTRATOR_SYSTEM_PROMPT = """
You are the Chief Orchestrator of a research team.
Your Goal: Answer the user's complex question by delegating tasks to your workers.

You have access to the following workers:
1. 'researcher': Can search the internet.
2. 'writer': Can compile information into a summary.

Instructions:
1. Analyze the user's request.
2. Break it down into step-by-step sub-tasks.
3. Output a JSON object with the key "next_action" and "payload".
   - If you need information, route to 'researcher'.
   - If you have enough info, route to 'writer'.
   - If the task is done, output "FINISH".

Do not perform the search yourself. DELEGATE.
"""

def get_orchestrator_decision(messages: List[Dict]) -> Dict:
    """
    Asks Claude 3 Opus to decide the next step.
    """
    response = client.messages.create(
        model="claude-3-opus-20240229", # Using Opus for high-level reasoning
        max_tokens=1024,
        system=ORCHESTRATOR_SYSTEM_PROMPT,
        messages=messages
    )
    
    # In a real app, use robust JSON parsing/validation here
    try:
        decision = json.loads(response.content[0].text)
        return decision
    except json.JSONDecodeError:
        # Fallback logic or retry mechanism
        return {"next_action": "ERROR", "payload": "Failed to parse JSON"}

4. Los Agentes para Trabajadores (La Capa de Ejecución)

Para los trabajadores, no necesitamos el alto costo de razonamiento de Opus. Podemos utilizarClaude 3.5 Sonnet, que es más rápido y muy capaz de ejecutar herramientas.

def run_worker_agent(agent_name: str, task_description: str) -> str:
    """
    Executes a specific task using a sub-agent (Sonnet).
    """
    if agent_name == "researcher":
        # This agent is 'bound' to the web_search tool
        response = client.messages.create(
            model="claude-3-5-sonnet-20240620",
            max_tokens=1024,
            tools=TOOLS_DEFINITION,
            system=f"You are a specialist {agent_name}. Perform the requested task using your tools.",
            messages=[{"role": "user", "content": task_description}]
        )
        
        # specific logic to handle tool use response
        if response.stop_reason == "tool_use":
            tool_use = next(block for block in response.content if block.type == "tool_use")
            # Execute the function (simulated)
            result = web_search_tool(tool_use.input["query"])
            return f"Search Result: {result}"
            
    elif agent_name == "writer":
        # Pure generation task
        response = client.messages.create(
            model="claude-3-5-sonnet-20240620",
            max_tokens=1024,
            system="You are a technical writer. Summarize the provided context.",
            messages=[{"role": "user", "content": task_description}]
        )
        return response.content[0].text
        
    return "Unknown Agent"

5. El ciclo de ejecución (El "tiempo de ejecución")

Finalmente, necesitamos un bucle para mantener el ciclo de vida de la solicitud. Esto permite que el sistema sea "con estado" a lo largo del tiempo, lo cual es un requisito para Flujos de Trabajo de IA Inteligente.

def run_multi_agent_system(user_query: str):
    conversation_history = [{"role": "user", "content": user_query}]
    
    print(f"Starting Task: {user_query}")
    
    while True:
        # 1. Orchestrator decides
        decision = get_orchestrator_decision(conversation_history)
        action = decision.get("next_action")
        payload = decision.get("payload")
        
        print(f"Orchestrator Decision: {action}")
        
        if action == "FINISH":
            print("Final Answer:", payload)
            break
            
        if action == "ERROR":
            print("Orchestration Error")
            break
            
        # 2. Worker executes
        worker_result = run_worker_agent(action, payload)
        
        # 3. Update State (Context)
        # We append the result back to the history so Opus knows what happened
        conversation_history.append({
            "role": "assistant", 
            "content": f"Delegated to {action}. Result: {worker_result}"
        })

Consideraciones Avanzadas para Directores de Tecnología (CTOs)

Manejo de cambios en el estado y el contexto

En producción, no puedes simplemente añadir mensajes indefinidamente; la ventana de contexto (incluso los 200k tokens de Opus) se llenará, aumentando la latencia y el coste.

Recuperación de errores y autocrrectura

Los agentes fallan. Un rastreador web podría devolver un error 403; una consulta a la base de datos podría generar un error de sintaxis.

Costo frente a precisión

El patrón "Orchestrator" te permite optimizar los costos. Pagas solo por la inteligencia de Opus para la planificación de alto nivel (rutas), mientras que el 90% del volumen de tokens (lectura de documentos, extracción de datos, resumen) es gestionado por los modelos más económicos, Sonnet o Haiku.

Conclusión

Construir sistemas multiagentes ya no se trata solo de la ingeniería de prompts; es una disciplina de arquitectura de software. Requiere una gestión robusta del estado, definiciones claras de la interfaz y una combinación estratégica de modelos.

Mientras esperamos el lanzamiento de modelos como Claude 4, los patrones establecidos aquí: Orquestación, Delegación y Autocorrectiva, son de futuro. Permiten que incorpores "cerebros" más potentes a medida que estén disponibles, sin tener que reescribir toda tu infraestructura.Claude 4, los patrones establecidos aquí (Orquestación, Delegación y Autocorrectiva) son duraderos. Les permiten incorporar "cerebros" más potentes a medida que estén disponibles, sin necesidad de modificar toda su infraestructura.

Si su organización busca ampliar sus capacidades de ingeniería para desarrollar estosAgentes de IA personalizados o soluciones deIngeniería de Productos complejas, colaborar con un equipo especializado puede acelerar su plan de desarrollo. 4Geeks Teams ofrece el talento de ingeniería senior a demanda necesario para convertir estos conceptos arquitectónicos en software de generación de ingresos.

Preguntas frecuentes