Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Architecture multi-outils en production

Les 20 van 20 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Architecture multi-outils en production
  2. Architecture en couches
  3. Orchestrateur de production
  4. Configuration déclarative
  5. Observabilité et surveillance
  6. Gestion des coûts
  7. Modèle : routeur intelligent
  8. Liste de contrôle pour la production
  9. Belangrijkste punten
  10. Testez vos connaissances

Mis à jour le 2 novembre 2026 sur la base de 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 comme input_text, et la recherche web utilise l’outil web_search (web_search_preview est désormais un outil hérité sans filtres de domaine). Les fichiers générés sont récupérés à l’aide des fonctions fichiers_generes et telecharger de la leçon 10. Sources : Code Interpreter · Recherche web.

Architecture 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 simultanément ces trois conditions. Ce qui devient critique n’est pas la qualité de la réponse — elle était déjà là — mais trois propriétés dont le prototype était dépourvu : savoir ce qu’il s’est passé lors d’un échec d’appel, empêcher une boucle infinie de vider votre budget, et pouvoir modifier le comportement sans redéploiement.

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

Architecture en couches

Séparer les préoccupations en couches n’est pas une élégance architecturale : cela rend chaque partie remplaçable. L’avantage concret est que vous pouvez 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é - journaux, 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 la surveillance."""
    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 à partir de 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 à 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 une traçabilité complète."""
        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 des 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

Déplacer les définitions du système hors du code vers la configuration change qui peut intervenir. Ajuster une invite 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 surveillance

Tableau de bord des métriques

Trois métriques suffisent pour commencer, et chacune répond à une question différente : la latence par outil vous indique lequel ralentit le système, le taux d’échec par outil vous indique lequel est fragile, et le coût par requête vous indique 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, transporte l’ensemble complet des définitions d’outils. Un routeur qui classe d’abord la requête, puis appelle un orchestrateur spécialisé, maintient des 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 l'orchestrateur correct."""
        # 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))

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

Liste de contrôle pour la production

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

checklist = {
    "securite": [
        "Valider les arguments pour chaque fonction",
        "Limitation du débit par utilisateur",
        "Assainir les entrées et sorties",
        "Aucune donnée sensible dans les journaux"
    ],
    "fiabilite": [
        "Nouvelle tentative avec backoff sur les erreurs transitoires",
        "Disjoncteur par service externe",
        "Délai d'attente par outil et par requête globale",
        "Repli lorsqu'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": [
        "Journalisation structurée 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 des coûts avant exécution",
        "Rapport de dépenses hebdomadaire",
        "Optimisation du choix du modèle par complexité"
    ]
}

Belangrijkste punten

  • Décomposer en couches : interface, orchestration, exécution, observabilité
  • Utiliser une configuration déclarative pour définir les systèmes
  • Tracer chaque exécution pour la surveillance et le débogage
  • Implémenter un gestionnaire de coûts avec un budget quotidien
  • Un routeur intelligent distribue les requêtes aux bons orchestrateurs

Testez vos 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 vos documents indexés (découpage + classement intégré) — et la recherche hybride combine les deux lorsque la réponse s’étend aux deux mondes.

3. Que permet Code Interpreter dans l'API ?

Réponse : Exécuter du code dans un bac à sable : traiter des 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 vaste catalogue d’outils : le modèle recherche l’outil pertinent au lieu de recevoir une centaine de 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 avec un périmètre clair, une gestion des erreurs et des replis par outil, des appels parallèles lorsque 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 votre plan de référence.