LemonData logoLemonData

Paramètres

Langue
Blog

Construire des Agents IA avec Plusieurs Modèles : Un Guide Pratique d’Architecture

L
LemonData
·26 février 2026·25 vues
#agents IA#multimodèle#architecture#tutoriel#LangChain
Construire des Agents IA avec Plusieurs Modèles : Un Guide Pratique d’Architecture

Construire des Agents IA avec Plusieurs Modèles : Guide Pratique d’Architecture

La plupart des agents IA utilisent un seul modèle pour tout. L’étape de planification, les appels aux outils, la synthèse, la récupération d’erreurs. Cela fonctionne pour des démonstrations. En production, c’est gaspilleur.

Une étape de planification nécessitant un raisonnement approfondi n’a pas besoin du même modèle qu’une étape d’extraction JSON. Une tâche de génération de code a des exigences différentes d’une tâche de classification. Utiliser Claude Opus 4.6 (25 $/1M tokens en sortie) pour formater une chaîne de date, c’est comme engager un architecte senior pour peindre un mur.

Voici comment construire des agents qui dirigent chaque étape vers le modèle optimal.

L’Architecture d’Agent Multi-Modèle

Demande Utilisateur
    │
    ▼
┌─────────────┐
│   Routeur    │  ← Classe la complexité de la tâche
│  (modèle rapide)│
└──────┬──────┘
       │
   ┌───┴───┐
   ▼       ▼
┌──────┐ ┌──────┐
│Simple│ │Complexe│
│Modèle│ │Modèle  │
└──┬───┘ └──┬───┘
   │        │
   ▼        ▼
┌─────────────┐
│ Agrégateur  │  ← Combine les résultats
│ (modèle rapide)│
└─────────────┘

Trois composants :

  1. Un routeur qui classe les tâches entrantes selon leur complexité
  2. Un pool de modèles adaptés à différents types de tâches
  3. Un agrégateur qui combine les résultats si nécessaire

Implémentation avec le SDK OpenAI

En utilisant une seule clé API via un agrégateur, vous pouvez accéder à tous les modèles sans gérer plusieurs SDK :

from openai import OpenAI

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

# Pool de modèles avec niveaux de coût/capacité
MODELS = {
    "router": "gpt-4.1-mini",        # 0,40 $/1M tokens in - classification rapide
    "simple": "gpt-4.1-mini",        # 0,40 $/1M tokens in - extraction, formatage
    "reasoning": "claude-sonnet-4-6",# 3,00 $/1M tokens in - planification, analyse
    "complex": "gpt-4.1",            # 2,00 $/1M tokens in - génération de code, multi-étapes
    "budget": "deepseek-chat",       # 0,28 $/1M tokens in - traitement en masse
}

def route_task(task: str) -> str:
    """Utilise un modèle économique pour classer la complexité de la tâche."""
    response = client.chat.completions.create(
        model=MODELS["router"],
        messages=[
            {"role": "system", "content": """Classe cette tâche dans une catégorie :
- simple : extraction de données, formatage, traduction
- reasoning : analyse, planification, comparaison
- complex : génération de code, résolution multi-étapes
- budget : traitement en masse, tâches non critiques
Réponds uniquement avec le nom de la catégorie."""},
            {"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 tâche vers le modèle approprié et l’exécute."""
    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

Agent Réel : Pipeline de Revue de Code

Voici un agent multi-modèle pratique qui révise les pull requests :

def review_pr(diff: str) -> dict:
    """Pipeline de revue PR multi-modèle."""

    # Étape 1 : Classifier les changements (modèle économique)
    classification = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Classifie ces changements de code : {diff[:2000]}\n"
                       "Catégories : bugfix, feature, refactor, docs, test"
        }],
        max_tokens=20
    ).choices[0].message.content

    # Étape 2 : Analyse de sécurité (modèle de raisonnement)
    security = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[{
            "role": "system",
            "content": "Vous êtes un relecteur de sécurité. Vérifiez : "
                       "injection SQL, XSS, contournement d’authentification, secrets dans le code, "
                       "désérialisation non sécurisée. Soyez précis sur les numéros de ligne."
        }, {
            "role": "user",
            "content": f"Analysez ce diff pour des problèmes de sécurité :\n{diff}"
        }]
    ).choices[0].message.content

    # Étape 3 : Qualité du code (modèle général)
    quality = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{
            "role": "user",
            "content": f"Revue de la qualité du code : nommage, structure, "
                       f"gestion des erreurs, couverture des tests.\n{diff}"
        }]
    ).choices[0].message.content

    # Étape 4 : Résumé (modèle économique)
    summary = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Résume cette revue PR en 3 points clés :\n"
                       f"Type : {classification}\n"
                       f"Sécurité : {security[:500]}\n"
                       f"Qualité : {quality[:500]}"
        }]
    ).choices[0].message.content

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

Répartition des coûts pour une revue PR typique (diff de 2K tokens) :

Étape Modèle Tokens d’entrée Coût
Classification GPT-4.1-mini ~2 100 0,0008 $
Sécurité Claude Sonnet 4.6 ~2 500 0,0075 $
Qualité GPT-4.1 ~2 500 0,0050 $
Résumé GPT-4.1-mini ~1 200 0,0005 $
Total ~0,014 $

Utiliser Claude Sonnet 4.6 pour les quatre étapes coûterait environ 0,028 $. L’approche multi-modèle réduit les coûts de 50 % tout en utilisant le modèle le plus performant là où c’est le plus important (revue de sécurité).

Intégration LangChain

from langchain_openai import ChatOpenAI

# Créer des instances de modèles avec différentes configurations
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"
)

# Utilisation dans les chaînes LangChain
from langchain_core.prompts import ChatPromptTemplate

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

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

Quand Utiliser des Agents Multi-Modèles

Le routage multi-modèles ajoute de la complexité. Cela vaut le coup lorsque :

  • Votre agent gère des types de tâches variés (pas seulement du chat)
  • Les coûts API mensuels dépassent 100 $ (les économies deviennent significatives)
  • Vous avez besoin de forces spécifiques des modèles (Claude pour le code, Gemini pour les longs contextes, GPT pour la rapidité)
  • La latence est importante pour certaines étapes mais pas pour d’autres

Pour des chatbots simples ou des agents à usage unique, un seul modèle suffit. Le surcoût du routage n’est pas justifié si chaque requête nécessite la même capacité.

Points Clés à Retenir

  1. Utilisez le modèle le moins cher qui gère bien chaque étape
  2. Réservez les modèles coûteux aux tâches qui en ont vraiment besoin
  3. Les étapes de classification/routage doivent toujours utiliser le modèle le moins cher disponible
  4. Mesurez le coût réel par exécution d’agent, pas seulement le prix par token
  5. Un agrégateur API avec une seule clé simplifie grandement l’accès multi-modèles

Accédez à tous les modèles via une seule API : lemondata.cc propose plus de 300 modèles avec une seule clé API. Construisez des agents multi-modèles sans gérer plusieurs comptes fournisseurs.

Share: