Arkitekturer med flera verktyg i produktion
På denna sida
Uppdaterad 2 november 2026 baserat på OpenAI-dokumentation: verktyget Code Interpreter kräver nu en parameter
container(lagts till i alla exempel), textinmatningsdelar är typade sominput_text, och webbsökning använder verktygetweb_search(web_search_previewär nu ett föråldrat verktyg utan domänfilter). Genererade filer hämtas med funktionernafichiers_generesochtelechargerfrån lektion 10. Källor: Code Interpreter · Web search.
Arkitekturer med flera verktyg i produktion
En prototyp med flera verktyg fungerar eftersom en enda person använder den, känner dess begränsningar och startar om den vid fel. I produktion försvinner alla tre förutsättningarna samtidigt. Det som blir avgörande är inte svarskvaliteten – den fanns redan där – utan tre egenskaper som prototypen saknade: att veta vad som hände när ett anrop misslyckas, att förhindra att en oändlig loop tömmer din budget, och att kunna ändra beteendet utan att behöva distribuera om koden.
Mönstren nedan adresserar var och en av dessa krav. Inför inte alla på en gång: börja med observerbarhet, för utan den vet du inte ens vilka av de andra du saknar.
Skiktad arkitektur
Att separera ansvarsområden i skikt handlar inte om arkitektonisk elegans: det gör varje del utbytbar. Den konkreta fördelen är att du kan ändra orkestreringen utan att röra gränssnittet, eller lägga till ett verktyg utan att skriva om affärslogiken. De fyra skikten nedan är den minimala uppdelning som håller i praktiken.
# Skikt 1: Gränssnitt - mottagande av förfrågningar
# Skikt 2: Orkestrering - loop-hantering och routning
# Skikt 3: Exekvering - verktygs- och funktionsanrop
# Skikt 4: Observerbarhet - loggar, mätvärden, spår
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:
"""Exekveringsspår för övervakning."""
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
Produktionsorkestrerare
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 verktygsarrayen från 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:
"""Mappar funktionsnamn till deras implementationer."""
return config.get("implementations", {})
def executer(self, requete: str, fichiers: list = None,
max_tours: int = 10) -> dict:
"""Exekverar en förfrågan med fullständig spårning."""
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
# Identifiera funktionsanrop
appels = [
item for item in response.output
if item.type == "function_call"
]
# Registrera använda verktyg
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
}
# Exekvera anpassade 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:
"""Exekverar funktioner med felhantering."""
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
Att flytta systemdefinitioner ut ur koden och in i konfigurationen ändrar vem som kan ingripa. Att justera en systemprompt, ta bort ett verktyg eller ändra ett kostnadstak blir en filändring – granskningsbar och reversibel – istället för en distribution. På ett system som utvecklas varje vecka är det skillnaden mellan att iterera och att reagera.
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")
Observerbarhet och övervakning
Mätvärdesdashboard
Tre mätvärden räcker för att komma igång, och vart och ett svarar på en annan fråga: latens per verktyg berättar vilket som bromsar systemet, felfrekvens per verktyg berättar vilket som är skört, och kostnad per förfrågan berättar vilket som skenar. Ett globalt genomsnitt över alla tre svarar på ingen av dessa frågor.
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:
"""Uppskattar kostnaden i dollar för exekveringen."""
# Ungefärliga priser för gpt-5.6-terra: $2 / $12 per miljon
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]))
Kostnadshantering
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:
"""Kontrollerar om budgeten tillåter exekvering."""
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 orkestreraren
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)
def executer_avec_budget(orchestreur, requete, **kwargs):
cout_estime = 0.05 # Konservativ uppskattning
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
När användningsområdena multipliceras blir frestelsen stor att lämna allt till ett enda system utrustat med varje verktyg. Det är det dyraste valet: varje förfrågan, även triviala, bär på hela uppsättningen av verktygsdefinitioner. En router som först klassificerar förfrågan och sedan anropar en specialiserad orkestrerare håller kontexterna korta och gör varje flöde mätbart 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:
"""Bestämmer domänen och routar till rätt orkestrerare."""
# Snabb klassificering med en lättviktig modell
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))
# Användning
resultat = routeur.router("How many vacation days do I have left?")
# -> Routar automatiskt till HR-orkestreraren
Checklista för produktion
Denna checklista är avsiktligt kort. Den siktar inte på fullständighet utan täcker de punkter vars frånvaro kostar dig i incidenter snarare än obehag – och som du inte kan lägga till i hastighet den dag systemet redan är i användarnas 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"
]
}
Viktiga punkter
- Dela upp i skikt: gränssnitt, orkestrering, exekvering, observerbarhet
- Använd deklarativ konfiguration för att definiera system
- Spåra varje exekvering för övervakning och felsökning
- Implementera en kostnadshanterare med daglig budget
- En intelligent router distribuerar förfrågningar till rätt orkestrerare
Testa dina kunskaper
Funktionsanrop, sökning, exekvering: hela arsenalen på fem frågor.
1. Vad bör ett bra funktionsschema innehålla?
Svar: Strikta typer och operativa beskrivningar per parameter – detta är kontraktet som modellen använder för att besluta när den ska anropa och hur den ska fylla i; validering avvisar resten.
2. Web Search eller File Search: hur väljer man?
Svar: Web Search för offentlig, färsk information; File Search för dina indexerade dokument (chunking + inbyggd rangordning) – och hybridsökning kombinerar båda när svaret spänner över båda världarna.
3. Vad möjliggör Code Interpreter i API:t?
Svar: Exekvera kod i en sandlåda: bearbeta CSV/Excel/bilder, beräkna exakt, producera diagram – modellen resonerar, koden beräknar, sandlådan isolerar.
4. Vad är Tool Search till för?
Svar: För att dynamiskt exponera en stor verktygskatalog: modellen söker efter rätt verktyg istället för att få hundra scheman på en gång – kontexten hålls lätt, kapaciteterna förblir omfattande.
5. Vilka regler gäller för en arkitektur med flera verktyg i produktion?
Svar: Verktyg med tydligt omfång, felhantering och fallbacks per verktyg, parallella anrop när de är oberoende, och observerbarhet för varje anrop – robusthet designas verktyg för verktyg.
Varje verktyg har sin terräng; produktion kombinerar dem – den slutgiltiga arkitekturen ovan är din referensplan.