LemonData logoLemonData

Configuración

Idioma
Blog

Construyendo Agentes de IA con Múltiples Modelos: Una Guía Práctica de Arquitectura

L
LemonData
·26 de febrero de 2026·15 vistas
#agentes de IA#multimodelo#arquitectura#tutorial#LangChain
Construyendo Agentes de IA con Múltiples Modelos: Una Guía Práctica de Arquitectura

Construyendo Agentes de IA con Múltiples Modelos: Una Guía Práctica de Arquitectura

La mayoría de los agentes de IA usan un solo modelo para todo. El paso de planificación, las llamadas a herramientas, la resumición, la recuperación de errores. Esto funciona para demos. En producción, es un desperdicio.

Un paso de planificación que requiere razonamiento profundo no necesita el mismo modelo que un paso de extracción de JSON. Una tarea de generación de código tiene requisitos diferentes a una tarea de clasificación. Usar Claude Opus 4.6 ($25/1M tokens de salida) para formatear una cadena de fecha es como contratar a un arquitecto senior para pintar una pared.

Aquí te mostramos cómo construir agentes que dirigen cada paso al modelo óptimo.

La Arquitectura del Agente Multi-Modelo

Solicitud del Usuario
    │
    ▼
┌─────────────┐
│   Router     │  ← Clasifica la complejidad de la tarea
│  (modelo rápido)│
└──────┬──────┘
       │
   ┌───┴───┐
   ▼       ▼
┌──────┐ ┌──────┐
│Simple│ │Complejo│
│Modelo│ │Modelo  │
└──┬───┘ └──┬───┘
   │        │
   ▼        ▼
┌─────────────┐
│  Agregador  │  ← Combina resultados
│  (modelo rápido)│
└─────────────┘

Tres componentes:

  1. Un router que clasifica las tareas entrantes según su complejidad
  2. Un conjunto de modelos asignados a diferentes tipos de tareas
  3. Un agregador que combina resultados cuando es necesario

Implementación con OpenAI SDK

Usando una sola clave API a través de un agregador, puedes acceder a todos los modelos sin gestionar múltiples SDKs:

from openai import OpenAI

client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Pool de modelos con niveles de costo/capacidad
MODELS = {
    "router": "gpt-4.1-mini",        # $0.40/1M tokens entrada - clasificación rápida
    "simple": "gpt-4.1-mini",         # $0.40/1M tokens entrada - extracción, formateo
    "reasoning": "claude-sonnet-4-6",  # $3.00/1M tokens entrada - planificación, análisis
    "complex": "gpt-4.1",             # $2.00/1M tokens entrada - generación de código, multi-pasos
    "budget": "deepseek-chat",         # $0.28/1M tokens entrada - procesamiento masivo
}

def route_task(task: str) -> str:
    """Usa un modelo barato para clasificar la complejidad de la tarea."""
    response = client.chat.completions.create(
        model=MODELS["router"],
        messages=[
            {"role": "system", "content": """Clasifica esta tarea en una categoría:
- simple: extracción de datos, formateo, traducción
- reasoning: análisis, planificación, comparación
- complex: generación de código, resolución de problemas multi-pasos
- budget: procesamiento masivo, tareas no críticas
Responde solo con el nombre de la categoría."""},
            {"role": "user", "content": task}
        ],
        max_tokens=10
    )
    category = response.choices[0].message.content.strip().lower()
    return MODELS.get(category, MODELS["simple"])

def execute_task(task: str, context: str = "") -> str:
    """Dirige la tarea al modelo apropiado y la ejecuta."""
    model = route_task(task)
    messages = []
    if context:
        messages.append({"role": "system", "content": context})
    messages.append({"role": "user", "content": task})

    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    return response.choices[0].message.content

Agente Real: Pipeline de Revisión de Código

Aquí tienes un agente multi-modelo práctico que revisa pull requests:

def review_pr(diff: str) -> dict:
    """Pipeline multi-modelo para revisión de PR."""

    # Paso 1: Clasificar cambios (modelo barato)
    classification = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Clasifica estos cambios de código: {diff[:2000]}\n"
                       "Categorías: bugfix, feature, refactor, docs, test"
        }],
        max_tokens=20
    ).choices[0].message.content

    # Paso 2: Escaneo de seguridad (modelo de razonamiento)
    security = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[{
            "role": "system",
            "content": "Eres un revisor de seguridad. Revisa: "
                       "inyección SQL, XSS, bypass de autenticación, secretos en el código, "
                       "deserialización insegura. Sé específico con los números de línea."
        }, {
            "role": "user",
            "content": f"Revisa este diff en busca de problemas de seguridad:\n{diff}"
        }]
    ).choices[0].message.content

    # Paso 3: Calidad del código (modelo general)
    quality = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{
            "role": "user",
            "content": f"Revisa la calidad del código: nombres, estructura, "
                       f"manejo de errores, cobertura de tests.\n{diff}"
        }]
    ).choices[0].message.content

    # Paso 4: Resumen (modelo barato)
    summary = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Resume esta revisión de PR en 3 puntos clave:\n"
                       f"Tipo: {classification}\n"
                       f"Seguridad: {security[:500]}\n"
                       f"Calidad: {quality[:500]}"
        }]
    ).choices[0].message.content

    return {
        "classification": classification,
        "security": security,
        "quality": quality,
        "summary": summary
    }

Desglose de costos para una revisión típica de PR (diff de 2K tokens):

Paso Modelo Tokens de Entrada Costo
Clasificación GPT-4.1-mini ~2,100 $0.0008
Seguridad Claude Sonnet 4.6 ~2,500 $0.0075
Calidad GPT-4.1 ~2,500 $0.0050
Resumen GPT-4.1-mini ~1,200 $0.0005
Total ~$0.014

Usar Claude Sonnet 4.6 para los cuatro pasos costaría ~$0.028. El enfoque multi-modelo reduce costos en un 50% mientras usa el modelo más fuerte donde más importa (revisión de seguridad).

Integración con LangChain

from langchain_openai import ChatOpenAI

# Crear instancias de modelos con diferentes configuraciones
fast = ChatOpenAI(
    model="gpt-4.1-mini",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

reasoning = ChatOpenAI(
    model="claude-sonnet-4-6",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Uso en cadenas de LangChain
from langchain_core.prompts import ChatPromptTemplate

classify_chain = ChatPromptTemplate.from_template(
    "Clasifica: {input}"
) | fast

analyze_chain = ChatPromptTemplate.from_template(
    "Analiza en profundidad: {input}"
) | reasoning

Cuándo Usar Agentes Multi-Modelo

El enrutamiento multi-modelo añade complejidad. Vale la pena cuando:

  • Tu agente maneja tipos de tareas diversas (no solo chat)
  • Los costos mensuales de API superan los $100 (el ahorro se vuelve significativo)
  • Necesitas fortalezas específicas de modelos (Claude para código, Gemini para contexto largo, GPT para velocidad)
  • La latencia importa para algunos pasos pero no para otros

Para chatbots simples o agentes de propósito único, un solo modelo está bien. El overhead del enrutamiento no se justifica cuando cada solicitud necesita la misma capacidad.

Puntos Clave

  1. Usa el modelo más barato que maneje bien cada paso
  2. Reserva los modelos caros para tareas que realmente los requieren
  3. Los pasos de clasificación/enrutamiento siempre deben usar el modelo más barato disponible
  4. Mide el costo real por ejecución de agente, no solo el precio por token
  5. Un agregador API con una clave simplifica significativamente el acceso multi-modelo

Accede a todos los modelos con una sola API: lemondata.cc ofrece más de 300 modelos con una sola clave API. Construye agentes multi-modelo sin gestionar múltiples cuentas de proveedores.

Share: