Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Architectures multi-outils en production

20. lecke 20 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Architectures multi-outils en production
  2. Architecture en couches
  3. Orchestrateur de production
  4. Configuration déclarative
  5. Observabilité et monitoring
  6. Gestion des coûts
  7. Modèle : routeur intelligent
  8. Checklist de production
  9. Főbb megállapítások
  10. Teste tes connaissances

Mis à jour le 2 novembre 2026 selon la documentation OpenAI : l’outil Code Interpreter nécessite désormais un paramètre container (ajouté à tous les exemples), les parties de texte en entrée sont typées input_text, et la recherche web utilise l’outil web_search (web_search_preview est désormais un outil legacy sans filtres de domaine). Les fichiers générés sont récupérés via les fonctions fichiers_generes et telecharger de la Leçon 10. Sources : Code Interpreter · Recherche web.

Architectures multi-outils en production

Un prototype multi-outils fonctionne car une seule personne l’utilise, connaît ses limites et le redémarre en cas d’échec. La production supprime ces trois conditions d’un coup. Ce qui devient critique, ce n’est pas la qualité de la réponse — elle était déjà là — mais trois propriétés absentes du prototype : savoir ce qui s’est passé lors d’un échec d’appel, empêcher une boucle infinie de vider ton budget, et pouvoir modifier le comportement sans redéploiement.

Les modèles ci-dessous répondent chacun à l’une de ces exigences. Ne les adopte pas tous d’un coup : commence par l’observabilité, car sans elle, tu ne sauras même pas laquelle des autres te manque.

Architecture en couches

Séparer les responsabilités en couches n’est pas une élégance architecturale : cela rend chaque partie remplaçable. L’avantage concret est que tu peux changer l’orchestration sans toucher à l’interface, ou ajouter un outil sans réécrire la logique métier. Les quatre couches ci-dessous constituent la décomposition minimale qui tient la route en pratique.

# Couche 1 : Interface - réception des requêtes
# Couche 2 : Orchestration - gestion des boucles et routage
# Couche 3 : Exécution - appels d'outils et de fonctions
# Couche 4 : Observabilité - logs, métriques, traces

from openai import OpenAI
from dataclasses import dataclass, field
from datetime import datetime
import json
import time
import logging

logger = logging.getLogger("multi-outils")

@dataclass
class TraceExecution:
    """Trace d'exécution pour le monitoring."""
    requete_id: str
    debut: float = field(default_factory=time.time)
    tours: list = field(default_factory=list)
    outils_utilises: list = field(default_factory=list)
    tokens_total: int = 0
    erreurs: list = field(default_factory=list)
    duree_totale: float = 0.0

Orchestrateur de production

class OrchestreurProduction:
    def __init__(self, config: dict):
        self.client = OpenAI()
        self.config = config
        self.tools = self._construire_tools(config)
        self.dispatcher = self._construire_dispatcher(config)

    def _construire_tools(self, config: dict) -> list:
        """Construit le tableau d'outils depuis la configuration."""
        tools = []

        if config.get("file_search"):
            tools.append({
                "type": "file_search",
                "vector_store_ids": config["file_search"]["vector_stores"],
                "max_num_results": config["file_search"].get("max_results", 10)
            })

        if config.get("web_search"):
            tools.append({
                "type": "web_search",
                "search_context_size": config["web_search"].get("context_size", "medium")
            })

        if config.get("code_interpreter"):
            tools.append({"type": "code_interpreter", "container": {"type": "auto"}})

        for func in config.get("fonctions", []):
            tools.append(func)

        return tools

    def _construire_dispatcher(self, config: dict) -> dict:
        """Mappe les noms de fonctions vers leurs implémentations."""
        return config.get("implementations", {})

    def executer(self, requete: str, fichiers: list = None,
                 max_tours: int = 10) -> dict:
        """Exécute une requête avec traçage complet."""
        trace = TraceExecution(
            requete_id=f"req_{int(time.time()*1000)}"
        )

        content = [{"type": "input_text", "text": requete}]
        if fichiers:
            for fid in fichiers:
                content.append({"type": "input_file", "file_id": fid})

        messages = [{"role": "user", "content": content}]

        try:
            for tour in range(max_tours):
                debut_tour = time.time()

                response = self.client.responses.create(
                    model=self.config.get("model", "gpt-5.6-terra"),
                    input=messages,
                    tools=self.tools,
                    instructions=self.config.get("instructions", "")
                )

                trace.tokens_total += response.usage.total_tokens

                # Identifier les appels de fonction
                appels = [
                    item for item in response.output
                    if item.type == "function_call"
                ]

                # Enregistrer les outils utilisés
                for item in response.output:
                    if hasattr(item, "type"):
                        trace.outils_utilises.append(item.type)

                trace.tours.append({
                    "numero": tour + 1,
                    "appels_fonction": len(appels),
                    "duree": time.time() - debut_tour
                })

                if not appels:
                    trace.duree_totale = time.time() - trace.debut
                    return {
                        "reponse": response.output_text,
                        "trace": trace
                    }

                # Exécuter les fonctions personnalisées
                resultats = self._executer_fonctions(appels, trace)
                messages = response.output + resultats

        except Exception as e:
            trace.erreurs.append(str(e))
            trace.duree_totale = time.time() - trace.debut
            logger.error(f"Erreur requête {trace.requete_id}: {e}")
            return {"reponse": None, "erreur": str(e), "trace": trace}

        trace.duree_totale = time.time() - trace.debut
        return {"reponse": "Limite de tours", "trace": trace}

    def _executer_fonctions(self, appels: list, trace: TraceExecution) -> list:
        """Exécute les fonctions avec gestion d'erreurs."""
        resultats = []
        for appel in appels:
            try:
                func = self.dispatcher.get(appel.name)
                if not func:
                    raise ValueError(f"Fonction inconnue : {appel.name}")

                args = json.loads(appel.arguments)
                resultat = func(**args)
                resultats.append({
                    "type": "function_call_output",
                    "call_id": appel.call_id,
                    "output": json.dumps(resultat)
                })
            except Exception as e:
                trace.erreurs.append(f"{appel.name}: {str(e)}")
                resultats.append({
                    "type": "function_call_output",
                    "call_id": appel.call_id,
                    "output": json.dumps({"error": str(e)})
                })
        return resultats

Configuration déclarative

Sortir les définitions système du code pour les mettre dans la configuration change qui peut intervenir. Ajuster un prompt système, retirer un outil ou modifier un plafond de coût devient une modification de fichier — vérifiable et réversible — au lieu d’un déploiement. Sur un système qui évolue chaque semaine, c’est la différence entre itérer et réagir.

config_assistant_commercial = {
    "model": "gpt-5.6-terra",
    "instructions": (
        "You are a sales assistant. You have access to CRM data, "
        "product documentation, the web, and data analysis. "
        "Prioritize internal data, enrich with web data."
    ),
    "file_search": {
        "vector_stores": ["vs_fiches_produit", "vs_propositions"],
        "max_results": 10
    },
    "web_search": {
        "context_size": "medium"
    },
    "code_interpreter": True,
    "fonctions": [
        {
            "type": "function",
            "name": "creer_opportunite",
            "description": "Create an opportunity in the CRM",
            "parameters": {
                "type": "object",
                "properties": {
                    "client": {"type": "string"},
                    "montant": {"type": "number"},
                    "probabilite": {"type": "integer"}
                },
                "required": ["client", "montant", "probabilite"],
                "additionalProperties": False
            },
            "strict": True
        }
    ],
    "implementations": {
        "creer_opportunite": lambda client, montant, probabilite:
            crm_service.creer_opportunite(client, montant, probabilite)
    }
}

orchestreur = OrchestreurProduction(config_assistant_commercial)
resultat = orchestreur.executer("Prepare a proposal for Acme Corp")

Observabilité et monitoring

Tableau de bord des métriques

Trois métriques suffisent pour commencer, et chacune répond à une question différente : la latence par outil t’indique lequel ralentit le système, le taux d’échec par outil te montre lequel est fragile, et le coût par requête révèle lequel s’emballe. Une moyenne globale sur les trois ne répond à aucune de ces questions.

class MetriquesMultiOutils:
    def __init__(self):
        self.requetes = []

    def enregistrer(self, trace: TraceExecution):
        self.requetes.append({
            "id": trace.requete_id,
            "timestamp": datetime.now().isoformat(),
            "duree": trace.duree_totale,
            "tours": len(trace.tours),
            "tokens": trace.tokens_total,
            "outils": list(set(trace.outils_utilises)),
            "erreurs": len(trace.erreurs),
            "cout_estime": self._estimer_cout(trace)
        })

    def _estimer_cout(self, trace: TraceExecution) -> float:
        """Estime le coût en dollars de l'exécution."""
        # Tarifs approximatifs pour gpt-5.6-terra : 2 $ / 12 $ par million
        cout_input = trace.tokens_total * 0.6 * 0.000002
        cout_output = trace.tokens_total * 0.4 * 0.000012
        return round(cout_input + cout_output, 4)

    def rapport(self) -> dict:
        if not self.requetes:
            return {}
        durees = [r["duree"] for r in self.requetes]
        tokens = [r["tokens"] for r in self.requetes]
        couts = [r["cout_estime"] for r in self.requetes]

        return {
            "total_requetes": len(self.requetes),
            "duree_moyenne": sum(durees) / len(durees),
            "tokens_moyen": sum(tokens) / len(tokens),
            "cout_total": sum(couts),
            "taux_erreur": sum(1 for r in self.requetes if r["erreurs"] > 0) / len(self.requetes),
            "outils_les_plus_utilises": self._outils_frequents()
        }

    def _outils_frequents(self) -> dict:
        compteur = {}
        for r in self.requetes:
            for outil in r["outils"]:
                compteur[outil] = compteur.get(outil, 0) + 1
        return dict(sorted(compteur.items(), key=lambda x: -x[1]))

Gestion des coûts

class GestionnaireCouts:
    def __init__(self, budget_quotidien: float = 50.0):
        self.budget = budget_quotidien
        self.depenses_jour = 0.0
        self.date_reset = datetime.now().date()

    def peut_executer(self, cout_estime: float) -> bool:
        """Vérifie si le budget permet l'exécution."""
        aujourdhui = datetime.now().date()
        if aujourdhui > self.date_reset:
            self.depenses_jour = 0.0
            self.date_reset = aujourdhui

        return (self.depenses_jour + cout_estime) <= self.budget

    def enregistrer_depense(self, cout: float):
        self.depenses_jour += cout

    def budget_restant(self) -> float:
        return self.budget - self.depenses_jour

# Intégration dans l'orchestrateur
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)

def executer_avec_budget(orchestreur, requete, **kwargs):
    cout_estime = 0.05  # Estimation conservative
    if not gestionnaire_couts.peut_executer(cout_estime):
        return {"erreur": "Budget quotidien atteint", "restant": 0}

    resultat = orchestreur.executer(requete, **kwargs)
    cout_reel = resultat["trace"].tokens_total * 0.000002
    gestionnaire_couts.enregistrer_depense(cout_reel)

    return resultat

Modèle : routeur intelligent

À mesure que les cas d’usage se multiplient, la tentation est de tout confier à un seul système équipé de tous les outils. C’est le choix le plus coûteux : chaque requête, même triviale, porte la définition complète de tous les outils. Un routeur qui classe d’abord la requête, puis appelle un orchestrateur spécialisé, garde les contextes courts et rend chaque flux mesurable séparément.

class RouteurIntelligent:
    def __init__(self):
        self.client = OpenAI()
        self.orchestreurs = {}

    def enregistrer(self, domaine: str, orchestreur: OrchestreurProduction):
        self.orchestreurs[domaine] = orchestreur

    def router(self, requete: str) -> dict:
        """Détermine le domaine et route vers le bon orchestrateur."""
        # Classification rapide avec un modèle léger
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=f"Classify this request into a domain: {requete}\n"
                  f"Available domains: {list(self.orchestreurs.keys())}\n"
                  f"Respond only with the domain name.",
        )

        domaine = response.output_text.strip().lower()

        if domaine not in self.orchestreurs:
            domaine = "general"  # Repli

        logger.info(f"Requête routée vers : {domaine}")
        return self.orchestreurs[domaine].executer(requete)

# Configuration
routeur = RouteurIntelligent()
routeur.enregistrer("commercial", OrchestreurProduction(config_assistant_commercial))
routeur.enregistrer("support", OrchestreurProduction(config_support))
routeur.enregistrer("rh", OrchestreurProduction(config_rh))

# Usage
resultat = routeur.router("How many vacation days do I have left?")
# -> Route automatiquement vers l'orchestrateur RH

Checklist de production

Cette checklist est volontairement courte. Elle ne vise pas l’exhaustivité mais couvre les points dont l’absence te coûte en incidents plutôt qu’en inconfort — et que tu ne peux pas ajouter à la hâte le jour où le système est déjà entre les mains des utilisateurs.

checklist = {
    "securite": [
        "Valider les arguments de chaque fonction",
        "Limitation de débit par utilisateur",
        "Nettoyer les entrées et sorties",
        "Aucune donnée sensible dans les logs"
    ],
    "fiabilite": [
        "Réessayer avec backoff sur erreurs transitoires",
        "Disjoncteur par service externe",
        "Timeout par outil et par requête globale",
        "Repli quand un outil est indisponible"
    ],
    "performance": [
        "Exécution parallèle des appels indépendants",
        "Mise en cache des résultats de recherche fréquents",
        "Limiter le nombre d'itérations de boucle",
        "Choisir le modèle adapté à la complexité (gpt-5.6-terra vs gpt-5.6-terra)"
    ],
    "observabilite": [
        "Logging structuré pour chaque appel",
        "Métriques de latence et de coût",
        "Alertes sur le taux d'erreur",
        "Trace complète de chaque requête"
    ],
    "couts": [
        "Budget quotidien avec disjoncteur",
        "Estimation du coût avant exécution",
        "Rapport de dépenses hebdomadaire",
        "Optimisation du choix du modèle par complexité"
    ]
}

Főbb megállapítások

  • Décompose en couches : interface, orchestration, exécution, observabilité
  • Utilise une configuration déclarative pour définir les systèmes
  • Trace chaque exécution pour le monitoring et le débogage
  • Implémente un gestionnaire de coûts avec un budget quotidien
  • Un routeur intelligent distribue les requêtes vers les bons orchestrateurs

Teste tes connaissances

Appel de fonction, recherche, exécution : tout l’arsenal en cinq questions.

1. Que doit contenir un bon schéma de fonction ?

Réponse : Des types stricts et des descriptions opérationnelles par paramètre — c’est le contrat que le modèle utilise pour décider quand appeler et comment remplir ; la validation rejette le reste.

2. Recherche Web ou Recherche de Fichiers : comment choisir ?

Réponse : Recherche Web pour les informations publiques et récentes ; Recherche de Fichiers pour tes documents indexés (découpage + classement intégré) — et la recherche hybride combine les deux quand la réponse spanne les deux mondes.

3. Que permet Code Interpreter dans l'API ?

Réponse : Exécuter du code dans un bac à sable : traiter CSV/Excel/images, calculer avec précision, produire des graphiques — le modèle raisonne, le code calcule, le bac à sable isole.

4. À quoi sert Tool Search ?

Réponse : À exposer dynamiquement un large catalogue d’outils : le modèle recherche l’outil pertinent au lieu de recevoir cent schémas d’un coup — le contexte reste léger, les capacités restent vastes.

5. Quelles règles s'appliquent à une architecture multi-outils en production ?

Réponse : Des outils au périmètre clair, une gestion d’erreurs et des replis par outil, des appels parallèles quand indépendants, et une observabilité pour chaque appel — la robustesse se conçoit outil par outil.

Chaque outil a son terrain ; la production les combine — l’architecture finale ci-dessus est ton plan de référence.