LemonData logoLemonData

Configurações

Idioma
Blog

Construindo Agentes de IA com Múltiplos Modelos: Um Guia Prático de Arquitetura

L
LemonData
·26 de fevereiro de 2026·17 visualizações
#agentes de IA#multimodelo#arquitetura#tutorial#LangChain
Construindo Agentes de IA com Múltiplos Modelos: Um Guia Prático de Arquitetura

Construindo Agentes de IA com Múltiplos Modelos: Um Guia Prático de Arquitetura

A maioria dos agentes de IA utiliza um único modelo para tudo. A etapa de planejamento, as chamadas de ferramentas (tool calls), a sumarização, a recuperação de erros. Isso funciona para demonstrações. Em produção, é um desperdício.

Uma etapa de planejamento que exige raciocínio profundo não precisa do mesmo modelo que uma etapa de extração de JSON. Uma tarefa de geração de código tem requisitos diferentes de uma tarefa de classificação. Usar o Claude Opus 4.6 ($25/1M output tokens) para formatar uma string de data é como contratar um arquiteto sênior para pintar uma parede.

Veja como construir agentes que roteiam cada etapa para o modelo ideal.

A Arquitetura de Agente Multi-Modelo

Requisição do Usuário
    │
    ▼
┌─────────────┐
│  Roteador    │  ← Classifica a complexidade da tarefa
│(modelo rápido)│
└──────┬──────┘
       │
   ┌───┴───┐
   ▼       ▼
┌──────┐ ┌──────┐
│Modelo│ │Modelo│
│Simples│ │Complexo│
└──┬───┘ └──┬───┘
   │        │
   ▼        ▼
┌─────────────┐
│  Agregador   │  ← Combina os resultados
│(modelo rápido)│
└─────────────┘

Três componentes:

  1. Um roteador que classifica as tarefas recebidas por complexidade
  2. Um pool de modelos correspondentes a diferentes tipos de tarefas
  3. Um agregador que combina os resultados quando necessário

Implementação com OpenAI SDK

Usando uma única chave de API por meio de um agregador, você pode acessar todos os modelos sem gerenciar múltiplos SDKs:

from openai import OpenAI

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

# Model pool with cost/capability tiers
MODELS = {
    "router": "gpt-4.1-mini",        # $0.40/1M in - fast classification
    "simple": "gpt-4.1-mini",         # $0.40/1M in - extraction, formatting
    "reasoning": "claude-sonnet-4-6",  # $3.00/1M in - planning, analysis
    "complex": "gpt-4.1",             # $2.00/1M in - code gen, multi-step
    "budget": "deepseek-chat",         # $0.28/1M in - bulk processing
}

def route_task(task: str) -> str:
    """Use a cheap model to classify task complexity."""
    response = client.chat.completions.create(
        model=MODELS["router"],
        messages=[
            {"role": "system", "content": """Classify this task into one category:
- simple: data extraction, formatting, translation
- reasoning: analysis, planning, comparison
- complex: code generation, multi-step problem solving
- budget: bulk processing, non-critical tasks
Reply with just the category name."""},
            {"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:
    """Route task to appropriate model and execute."""
    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 do Mundo Real: Pipeline de Code Review

Aqui está um agente multi-modelo prático que revisa pull requests:

def review_pr(diff: str) -> dict:
    """Multi-model PR review pipeline."""

    # Step 1: Classify changes (cheap model)
    classification = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Classify these code changes: {diff[:2000]}\n"
                       "Categories: bugfix, feature, refactor, docs, test"
        }],
        max_tokens=20
    ).choices[0].message.content

    # Step 2: Security scan (reasoning model)
    security = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[{
            "role": "system",
            "content": "You are a security reviewer. Check for: "
                       "SQL injection, XSS, auth bypass, secrets in code, "
                       "unsafe deserialization. Be specific about line numbers."
        }, {
            "role": "user",
            "content": f"Review this diff for security issues:\n{diff}"
        }]
    ).choices[0].message.content

    # Step 3: Code quality (general model)
    quality = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{
            "role": "user",
            "content": f"Review code quality: naming, structure, "
                       f"error handling, test coverage.\n{diff}"
        }]
    ).choices[0].message.content

    # Step 4: Summary (cheap model)
    summary = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Summarize this PR review in 3 bullet points:\n"
                       f"Type: {classification}\n"
                       f"Security: {security[:500]}\n"
                       f"Quality: {quality[:500]}"
        }]
    ).choices[0].message.content

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

Detalhamento de custos para uma revisão de PR típica (diff de 2K tokens):

Etapa Modelo Tokens de Entrada Custo
Classificar GPT-4.1-mini ~2.100 $0,0008
Segurança Claude Sonnet 4.6 ~2.500 $0,0075
Qualidade GPT-4.1 ~2.500 $0,0050
Resumo GPT-4.1-mini ~1.200 $0,0005
Total ~$0,014

Usar o Claude Sonnet 4.6 para todas as quatro etapas custaria cerca de $0,028. A abordagem multi-modelo reduz os custos em 50%, utilizando o modelo mais potente onde ele é mais importante (revisão de segurança).

Integração com LangChain

from langchain_openai import ChatOpenAI

# Create model instances with different configs
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"
)

# Use in LangChain chains
from langchain_core.prompts import ChatPromptTemplate

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

analyze_chain = ChatPromptTemplate.from_template(
    "Analyze in depth: {input}"
) | reasoning

Quando Usar Agentes Multi-Modelo

O roteamento multi-modelo adiciona complexidade. Vale a pena quando:

  • Seu agente lida com diversos tipos de tarefas (não apenas chat)
  • Os custos mensais de API excedem $100 (a economia torna-se significativa)
  • Você precisa de pontos fortes específicos de modelos (Claude para código, Gemini para contextos longos, GPT para velocidade)
  • A latência é importante para algumas etapas, mas não para outras

Para chatbots simples ou agentes de propósito único, um único modelo é suficiente. O overhead do roteamento não se justifica quando cada requisição exige a mesma capacidade.

Principais Conclusões

  1. Use o modelo mais barato que lide bem com cada etapa
  2. Reserve modelos caros para tarefas que genuinamente precisem deles
  3. As etapas de classificação/roteamento devem sempre usar o modelo mais barato disponível
  4. Meça o custo real por execução do agente, não apenas o preço por token
  5. Um agregador de API com uma única chave simplifica significativamente o acesso multi-modelo

Acesse todos os modelos através de uma única API: lemondata.cc fornece mais de 300 modelos com uma única chave de API. Construa agentes multi-modelo sem gerenciar múltiplas contas de provedores.

Share: