Arkitekturer med flere værktøjer i produktion
På denne side
Opdateret 2. november 2026 baseret på OpenAI-dokumentation: Code Interpreter-værktøjet kræver nu en
container-parameter (tilføjet til alle eksempler), tekstinput-dele er typet sominput_text, og websøgning brugerweb_search-værktøjet (web_search_previewer nu et forældet værktøj uden domænefiltre). Genererede filer hentes ved hjælp af funktionernefichiers_generesogtelechargerfra Lektion 10. Kilder: Code Interpreter · Websøgning.
Arkitekturer med flere værktøjer i produktion
En prototype med flere værktøjer fungerer, fordi én enkelt person bruger den, kender dens begrænsninger og genstarter den, hvis den fejler. Produktion fjerner alle tre betingelser på én gang. Det, der bliver afgørende, er ikke svarenes kvalitet – den var der allerede – men tre egenskaber, som prototypen manglede: at vide, hvad der skete, når et kald fejler, at forhindre en løbsk løkke i at tømme dit budget, og at kunne ændre adfærd uden at genudgive systemet.
Mønstrene nedenfor adresserer hver især ét af disse krav. Adoptér dem ikke alle på én gang: start med observerbarhed, for uden den ved du ikke engang, hvilke af de andre du mangler.
Lagdelt arkitektur
At adskille ansvarsområder i lag handler ikke om arkitektonisk elegance: det gør hver del udskiftelig. Den konkrete fordel er, at du kan ændre orkestrering uden at røre ved grænsefladen, eller tilføje et værktøj uden at omskrive forretningslogikken. De fire lag nedenfor er den minimale opdeling, der holder i praksis.
# Lag 1: Grænseflade - modtagelse af anmodninger
# Lag 2: Orkestrering - løkkehåndtering og routing
# Lag 3: Eksekvering - værktøjs- og funktionskald
# Lag 4: Observerbarhed - logs, metrikker, spor
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:
"""Eksekveringsspor til overvågning."""
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
Produktionsorkestrator
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:
"""Bygger værktøjsarrayet ud fra konfigurationen."""
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:
"""Mapper funktionsnavne til deres implementeringer."""
return config.get("implementations", {})
def executer(self, requete: str, fichiers: list = None,
max_tours: int = 10) -> dict:
"""Eksekverer en anmodning med komplet sporing."""
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
# Identificér funktionskald
appels = [
item for item in response.output
if item.type == "function_call"
]
# Registrér brugte værktøjer
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
}
# Eksekvér brugerdefinerede funktioner
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:
"""Eksekverer funktioner med fejlhåndtering."""
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
Deklarativ konfiguration
At flytte systemdefinitioner ud af koden og ind i konfigurationen ændrer, hvem der kan gribe ind. Justering af en systemprompt, fjernelse af et værktøj eller ændring af et omkostningsloft bliver til en filændring – som kan gennemgås og rulles tilbage – i stedet for en udrulning. På et system, der udvikler sig ugentligt, er det forskellen mellem at iterere og at reagere.
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")
Observerbarhed og overvågning
Dashboard for metrikker
Tre metrikker er nok til at komme i gang, og hver besvarer et andet spørgsmål: latens per værktøj fortæller dig, hvilket der bremser systemet, fejlrate per værktøj fortæller dig, hvilket der er skrøbeligt, og omkostninger per anmodning fortæller dig, hvilket der løber løbsk. Et globalt gennemsnit på tværs af alle tre besvarer ingen af disse spørgsmål.
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:
"""Estimerer omkostningen i dollars for eksekveringen."""
# Omtrentlige satser for gpt-5.6-terra: $2 / $12 per 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]))
Omkostningsstyring
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:
"""Tjekker om budgettet tillader eksekvering."""
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
# Integration i orkestratoren
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)
def executer_avec_budget(orchestreur, requete, **kwargs):
cout_estime = 0.05 # Konservativt estimat
if not gestionnaire_couts.peut_executer(cout_estime):
return {"erreur": "Daily budget reached", "restant": 0}
resultat = orchestreur.executer(requete, **kwargs)
cout_reel = resultat["trace"].tokens_total * 0.000002
gestionnaire_couts.enregistrer_depense(cout_reel)
return resultat
Mønster: Intelligent router
Efterhånden som brugstilfælde multipliceres, er fristelsen stor for at overlade alt til ét enkelt system udstyret med ethvert værktøj. Det er det dyreste valg: hver anmodning, selv trivielle, bærer hele sættet af værktøjsdefinitioner. En router, der først klassificerer anmodningen og derefter kalder en specialiseret orkestrator, holder kontekster korte og gør hver flow målbart separat.
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:
"""Bestemmer domænet og router til den korrekte orkestrator."""
# Hurtig klassifikation med en letvægtsmodel
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" # Fallback
logger.info(f"Requête routee vers : {domaine}")
return self.orchestreurs[domaine].executer(requete)
# Konfiguration
routeur = RouteurIntelligent()
routeur.enregistrer("commercial", OrchestreurProduction(config_assistant_commercial))
routeur.enregistrer("support", OrchestreurProduction(config_support))
routeur.enregistrer("rh", OrchestreurProduction(config_rh))
# Brug
resultat = routeur.router("How many vacation days do I have left?")
# -> Router automatisk til HR-orkestratoren
Produktionscheckliste
Denne checkliste er bevidst kort. Den sigter ikke mod udtømmende dækning, men dækker de punkter, hvis fravær koster dig i incidenter snarere end ubehag – og som du ikke kan tilføje i hast, den dag systemet allerede er i brugernes hænder.
checklist = {
"securite": [
"Validate arguments for each function",
"Rate limiting per user",
"Sanitize inputs and outputs",
"No sensitive data in logs"
],
"fiabilite": [
"Retry with backoff on transient errors",
"Circuit breaker per external service",
"Timeout per tool and per global request",
"Fallback when a tool is unavailable"
],
"performance": [
"Parallel execution of independent calls",
"Cache frequent search results",
"Limit the number of loop iterations",
"Choose the model adapted to complexity (gpt-5.6-terra vs gpt-5.6-terra)"
],
"observabilite": [
"Structured logging for each call",
"Latency and cost metrics",
"Alerts on error rate",
"Complete trace of each request"
],
"couts": [
"Daily budget with circuit breaker",
"Cost estimation before execution",
"Weekly spending report",
"Model choice optimization by complexity"
]
}
Vigtige pointer
- Opdel i lag: grænseflade, orkestrering, eksekvering, observerbarhed
- Brug deklarativ konfiguration til at definere systemer
- Spor hver eksekvering til overvågning og fejlfinding
- Implementér en omkostningsmanager med et dagligt budget
- En intelligent router fordeler anmodninger til de rigtige orkestratorer
Test din viden
Funktionskald, søgning, eksekvering: hele arsenalet på fem spørgsmål.
1. Hvad skal et godt funktionsskema indeholde?
Svar: Strengt typede og operationelle beskrivelser per parameter – dette er kontrakten, som modellen bruger til at beslutte, hvornår den skal kalde, og hvordan den skal udfylde; validering afviser resten.
2. Websøgning eller filsøgning: hvordan vælger du?
Svar: Websøgning til offentlige, recente oplysninger; filsøgning til dine indekserede dokumenter (chunking + indbygget rangering) – og hybridsøgning kombinerer begge, når svaret spænder over begge verdener.
3. Hvad muliggør Code Interpreter i API'et?
Svar: Eksekvering af kode i en sandbox: behandling af CSV/Excel/billeder, præcis beregning, produktion af diagrammer – modellen ræsonnerer, koden beregner, sandboxen isolerer.
4. Hvad bruges Tool Search til?
Svar: Til dynamisk at eksponere en stor katalog af værktøjer: modellen søger efter det relevante værktøj i stedet for at modtage hundrede skemaer på én gang – konteksten forbliver let, kapaciteterne forbliver store.
5. Hvilke regler gælder for en arkitektur med flere værktøjer i produktion?
Svar: Værktøjer med klart omfang, fejlhåndtering og fallbacks per værktøj, parallelle kald når uafhængige, og observerbarhed for hvert kald – robusthed designes værktøj for værktøj.
Hvert værktøj har sit terræn; produktion kombinerer dem – arkitekturen ovenfor er din referenceplan.