Архитектури с множество инструменти в продукционна среда
На тази страница
Обновено на 2 ноември 2026 г. въз основа на документацията на OpenAI: инструментът Code Interpreter вече изисква параметър
container(добавен към всички примери), текстовите входни части са типизирани катоinput_text, а уеб търсенето използва инструментаweb_search(web_search_previewвече е остарял инструмент без филтри за домейни). Генерираните файлове се извличат чрез функциитеfichiers_generesиtelechargerот Урок 10. Източници: Code Interpreter · Web search.
Архитектури с множество инструменти в продукционна среда
Прототип с множество инструменти работи, защото се използва от един човек, който познава ограниченията му и го рестартира при отказ. Продукционната среда премахва и трите условия едновременно. Критично става не качеството на отговора – то вече го има – а три свойства, които прототипът липсва: да знаете какво се е случило при отказ на извикване, да предотвратите безкраен цикъл, който да изтощи бюджета Ви, и да можете да променяте поведението без повторно внедряване.
Шаблоните по-долу адресират всяко от тези изисквания. Не ги внедрявайте всички наведнъж: започнете с наблюдаемост, защото без нея няма да разберете кое от останалите Ви липсва.
Слоеста архитектура
Разделянето на отговорностите на слоеве не е архитектурна елегантност: то прави всяка част заменяема. Конкретната полза е, че можете да промените оркестрацията, без да докосвате интерфейса, или да добавите инструмент, без да преправяте бизнес логиката. Четирите слоя по-долу са минималното разделение, което се утвърждава на практика.
# Layer 1: Interface - request reception
# Layer 2: Orchestration - loop management and routing
# Layer 3: Execution - tool and function calls
# Layer 4: Observability - logs, metrics, 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:
"""Следене на изпълнението за мониторинг."""
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
Продукционен оркестратор
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:
"""Изгражда масива с инструменти от конфигурацията."""
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:
"""Свързва имената на функциите с техните реализации."""
return config.get("implementations", {})
def executer(self, requete: str, fichiers: list = None,
max_tours: int = 10) -> dict:
"""Изпълнява заявка с пълно проследяване."""
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
# Идентифициране на извиквания на функции
appels = [
item for item in response.output
if item.type == "function_call"
]
# Запис на използваните инструменти
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
}
# Изпълнение на потребителски функции
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:
"""Изпълнява функции с обработка на грешки."""
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
Декларативна конфигурация
Изнасянето на системните дефиниции от кода в конфигурация променя кой може да intervene. Коригирането на системен промпт, премахването на инструмент или промяната на таван на разходите става промяна на файл – подлежаща на преглед и обратима – вместо внедряване. При система, която се развива седмично, това е разликата между итерация и реакция.
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")
Наблюдаемост и мониторинг
Табло с метрики
Три метрики са достатъчни за начало и всяка отговаря на различен въпрос: латентност на инструмент показва кой забавя системата, честота на откази на инструмент показва кой е крехък, а цена на заявка показва кой излиза от контрол. Глобалното средно за и трите не отговаря на нито един от тези въпроси.
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:
"""Оценява разхода в долари за изпълнението."""
# Приблизителни тарифи за gpt-5.6-terra: $2 / $12 на милион
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]))
Управление на разходите
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:
"""Проверява дали бюджетът позволява изпълнение."""
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
# Интеграция в оркестратора
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)
def executer_avec_budget(orchestreur, requete, **kwargs):
cout_estime = 0.05 # Консервативна оценка
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
Шаблон: интелигентен маршрутизатор
С умножаването на случаите на употреба изкушението е да предадете всичко на една система, оборудвана с всеки инструмент. Това е най-скъпият избор: всяка заявка, дори тривиалните, носи пълния набор от дефиниции на инструменти. Маршрутизатор, който първо класифицира заявката, след което извиква специализиран оркестратор, поддържа контекстите кратки и прави всеки поток измерим отделно.
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:
"""Определя домейна и насочва към правилния оркестратор."""
# Бърза класификация с лек модел
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" # Резервен вариант
logger.info(f"Requête routee vers : {domaine}")
return self.orchestreurs[domaine].executer(requete)
# Конфигурация
routeur = RouteurIntelligent()
routeur.enregistrer("commercial", OrchestreurProduction(config_assistant_commercial))
routeur.enregistrer("support", OrchestreurProduction(config_support))
routeur.enregistrer("rh", OrchestreurProduction(config_rh))
# Използване
resultat = routeur.router("How many vacation days do I have left?")
# -> Автоматично насочва към HR оркестратора
Контролен списък за продукционна среда
Този списък е умишлено кратък. Не цели изчерпателност, а покрива точките, чието отсъствие Ви струва инциденти, а не дискомфорт – и които не можете да добавите набързо в деня, когато системата вече е в ръцете на потребителите.
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"
]
}
Ключови изводи
- Разделете на слоеве: интерфейс, оркестрация, изпълнение, наблюдаемост
- Използвайте декларативна конфигурация за дефиниране на системи
- Проследявайте всяко изпълнение за мониторинг и отстраняване на грешки
- Внедрете мениджър на разходите с дневен бюджет
- Интелигентен маршрутизатор разпределя заявките към правилните оркестратори
Проверете знанията си
Извикване на функции, търсене, изпълнение: целият арсенал в пет въпроса.
1. Какво трябва да съдържа една добра схема на функция?
Отговор: Строги типове и оперативни описания за всеки параметър – това е договорът, който моделът използва, за да реши кога да извика и как да попълни; валидацията отхвърля останалото.
2. Уеб търсене или Търсене във файлове: как да изберете?
Отговор: Уеб търсене за публична, скорошна информация; Търсене във файлове за Вашите индексирани документи (chunking + вградено класиране) – а хибридното търсене комбинира и двете, когато отговорът обхваща и двата свята.
3. Какво позволява Code Interpreter в API?
Отговор: Изпълнение на код в пясъчник: обработка на CSV/Excel/изображения, точни изчисления, създаване на графики – моделът разсъждава, кодът изчислява, пясъчникът изолира.
4. За какво служи Tool Search?
Отговор: За динамично излагане на голям каталог с инструменти: моделът търси подходящия инструмент, вместо да получава сто схеми наведнъж – контекстът остава лек, възможностите остават обширни.
5. Какви правила важат за архитектура с множество инструменти в продукционна среда?
Отговор: Инструменти с ясен обхват, обработка на грешки и резервни варианти за всеки инструмент, паралелни извиквания при независимост и наблюдаемост за всяко извикване – надеждността се проектира инструмент по инструмент.
Всеки инструмент има своя терен; продукционната среда ги комбинира – крайната архитектура по-горе е Вашият референтен план.