Arhitektūras ar vairākiem rīkiem ražošanā
Šajā lapā
Atjaunināts 2026. gada 2. novembrī, pamatojoties uz OpenAI dokumentāciju: Code Interpreter rīkam tagad ir nepieciešams
containerparametrs (pievienots visiem piemēriem), teksta ievades daļas ir tipētas kāinput_text, un tīmekļa meklēšana izmantoweb_searchrīku (web_search_previewtagad ir novecojis rīks bez domēna filtriem). Ģenerētie faili tiek iegūti, izmantojotfichiers_generesuntelechargerfunkcijas no 10. nodarbības. Avoti: Code Interpreter · Tīmekļa meklēšana.
Arhitektūras ar vairākiem rīkiem ražošanā
Prototips ar vairākiem rīkiem darbojas, jo to lieto viens cilvēks, kurš zina tā robežas un restartē to kļūmes gadījumā. Ražošanas vide vienlaikus novērš visus trīs šos nosacījumus. Kritiski svarīga vairs nav atbilžu kvalitāte — tā jau bija nodrošināta —, bet gan trīs īpašības, kuru prototipam trūka: zināt, kas noticis, ja izsaukums neizdodas; novērst nekontrolētu ciklu, kas iztērē tavu budžetu; un spēja mainīt uzvedību, nepārpublicējot sistēmu.
Turpmāk aprakstītie modeļi risina katru no šīm prasībām. Neievies tos visus uzreiz: sāc ar novērojamību, jo bez tās tu pat neuzzināsi, kuras no pārējām tev trūkst.
Slāņota arhitektūra
Atbildību sadalīšana slāņos nav arhitektūras greznība: tas padara katru daļu aizvietojamu. Konkrētais ieguvums ir tas, ka vari mainīt orķestrāciju, nepieskaroties saskarnei, vai pievienot rīku, nerakstot biznesa loģiku no jauna. Tālāk minētie četri slāņi ir minimālais sadalījums, kas iztur pārbaudi praksē.
# 1. slānis: Saskarne - pieprasījumu saņemšana
# 2. slānis: Orķestrācija - ciklu vadība un maršrutēšana
# 3. slānis: Izpilde - rīku un funkciju izsaukumi
# 4. slānis: Novērojamība - žurnāli, metrikas, izsekošana
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:
"""Izpildes izsekošana monitoringu vajadzībām."""
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
Ražošanas orķestrators
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:
"""Veido rīku masīvu no konfigurācijas."""
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:
"""Kartē funkciju nosaukumus to implementācijām."""
return config.get("implementations", {})
def executer(self, requete: str, fichiers: list = None,
max_tours: int = 10) -> dict:
"""Izpilda pieprasījumu ar pilnu izsekošanu."""
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ē funkciju izsaukumus
appels = [
item for item in response.output
if item.type == "function_call"
]
# Reģistrē izmantotos rīkus
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
}
# Izpilda pielāgotās funkcijas
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:
"""Izpilda funkcijas ar kļūdu apstrādi."""
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
Deklaratīva konfigurācija
Sistēmu definīciju pārvietošana no koda uz konfigurāciju maina to, kurš var iejaukties. Sistēmas prompta pielāgošana, rīka noņemšana vai izmaksu griestu mainīšana kļūst par faila izmaiņu — pārskatāmu un atgriezenisku —, nevis par pārpublicēšanu. Sistēmā, kas attīstās ik nedēļu, tā ir atšķirība starp iterēšanu un reaģēšanu.
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")
Novērojamība un monitorings
Metriku panelis
Lai sāktu, pietiek ar trim metrikām, un katra atbild uz citu jautājumu: latentums pa rīkiem norāda, kurš bremzē sistēmu; kļūmju biežums pa rīkiem parāda, kurš ir trausls; un izmaksas par pieprasījumu atklāj, kurš rada nekontrolētu tēriņu pieaugumu. Vidējais rādītājs visiem trim kopā neatbild uz nevienu no šiem jautājumiem.
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:
"""Aprēķina izpildes aptuvenās izmaksas dolāros."""
# Aptuvenās likmes priekš gpt-5.6-terra: 2 USD / 12 USD par miljonu
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]))
Izmaksu vadība
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:
"""Pārbauda, vai budžets ļauj veikt izpildi."""
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
# Integrācija orķestratorā
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)
def executer_avec_budget(orchestreur, requete, **kwargs):
cout_estime = 0.05 # Konservatīva aplēse
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
Modelis: inteliģents maršrutētājs
Līdz ar lietojumu gadījumu pieaugumu rodas kārdinājums visu uzticēt vienai sistēmai, kas aprīkota ar visiem rīkiem. Tas ir dārgākais risinājums: katrs pieprasījums, pat visbanālākais, nes līdzi visu rīku definīciju kopu. Maršrutētājs, kas vispirms klasificē pieprasījumu un pēc tam izsauc specializētu orķestratoru, uztur kontekstus īsus un ļauj katru plūsmu mērīt atsevišķi.
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:
"""Nosaka domēnu un novirza uz pareizo orķestratoru."""
# Ātra klasifikācija, izmantojot vieglu modeli
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" # Rezerves variants
logger.info(f"Requête routee vers : {domaine}")
return self.orchestreurs[domaine].executer(requete)
# Konfigurācija
routeur = RouteurIntelligent()
routeur.enregistrer("commercial", OrchestreurProduction(config_assistant_commercial))
routeur.enregistrer("support", OrchestreurProduction(config_support))
routeur.enregistrer("rh", OrchestreurProduction(config_rh))
# Lietojums
resultat = routeur.router("How many vacation days do I have left?")
# -> Automātiski novirza uz HR orķestratoru
Ražošanas kontrolsaraksts
Šis kontrolsaraksts ir apzināti īss. Tas necenšas būt исчерпывающий, bet aptver punktus, kuru trūkums rada incidentus, nevis tikai neērtības — un kurus nevar steidzami pievienot dienā, kad sistēma jau ir lietotāju rokās.
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"
]
}
Galvenās atziņas
- Sadali slāņos: saskarne, orķestrācija, izpilde, novērojamība
- Izmanto deklaratīvu konfigurāciju sistēmu definēšanai
- Izseko katru izpildi monitoringam un atkļūdošanai
- Ievies izmaksu pārvaldnieku ar dienas budžetu
- Inteliģents maršrutētājs sadala pieprasījumus pareizajiem orķestratoriem
Pārbaudi savas zināšanas
Funkciju izsaukumi, meklēšana, izpilde: viss arsenāls piecos jautājumos.
1. Kam jābūt labā funkcijas shēmā?
Atbilde: Stingri tipi un operacionāli apraksti katram parametram — tas ir līgums, ko modelis izmanto, lai lemtu, kad izsaukt un kā aizpildīt; validācija noraida pārējo.
2. Tīmekļa meklēšana vai failu meklēšana: kā izvēlēties?
Atbilde: Tīmekļa meklēšana publiskai, jaunākai informācijai; failu meklēšana taviem indeksētajiem dokumentiem (sadalīšana + iebūvēta rangēšana) — un hibrīda meklēšana apvieno abus, ja atbilde sniedzas pāri abām pasaulēm.
3. Ko API ļauj darīt Code Interpreter?
Atbilde: Izpildīt kodu smilškastē: apstrādāt CSV/Excel/attēlus, precīzi aprēķināt, ģenerēt diagrammas — modelis spriež, kods rēķina, smilškaste izolē.
4. Kam domāta rīku meklēšana (Tool Search)?
Atbilde: Lai dinamiski eksponētu lielu rīku katalogu: modelis meklē atbilstošo rīku, nevis saņem simtiem shēmu vienlaikus — konteksts paliek viegls, iespējas — plašas.
5. Kādi noteikumi attiecas uz arhitektūru ar vairākiem rīkiem ražošanā?
Atbilde: Rīki ar skaidru darbības jomu, kļūdu apstrāde un rezerves varianti katram rīkam, paralēli izsaukumi, ja tie ir neatkarīgi, un novērojamība katram izsaukumam — noturība tiek projektēta rīku pa rīkam.
Katram rīkam ir sava teritorija; ražošana tos apvieno — iepriekšējā galīgā arhitektūra ir tavs atsauces plāns.