Architecture multi-outils en production
Op deze pagina
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 commeinput_text, et la recherche web utilise l’outilweb_search(web_search_previewest désormais un outil hérité sans filtres de domaine). Les fichiers générés sont récupérés à l’aide des fonctionsfichiers_generesettelechargerde 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.