Architektúry s viacerými nástrojmi v produkcii
Na tejto strane
Aktualizované 2. novembra 2026 na základe dokumentácie OpenAI: nástroj Code Interpreter teraz vyžaduje parameter
container(pridaný do všetkých príkladov), časti textového vstupu sú typované akoinput_texta webové vyhľadávanie používa nástrojweb_search(web_search_previewje teraz zastaraný nástroj bez filtrov domén). Vygenerované súbory sa získavajú pomocou funkciífichiers_generesatelechargerz Lekcie 10. Zdroje: Code Interpreter · Web search.
Architektúry s viacerými nástrojmi v produkcii
Prototyp s viacerými nástrojmi funguje preto, že ho používa jedna osoba, pozná jeho obmedzenia a pri zlyhaní ho reštartuje. Produkcia odstráni všetky tri podmienky naraz. Kritické nie je už len kvalita odpovede – tá tu bola aj predtým – ale tri vlastnosti, ktoré prototypu chýbali: vedieť, čo sa stalo pri zlyhaní volania, zabrániť tomu, aby nekontrolovaná slučka vyčerpala tvoj rozpočet, a mať možnosť upraviť správanie bez nutnosti nového nasadenia.
Nižšie uvedené vzory riešia každú z týchto požiadaviek. Neimplementuj ich všetky naraz: začni pozorovateľnosťou, pretože bez nej ani nezistíš, ktoré z ostatných ti chýbajú.
Vrstvená architektúra
Rozdelenie zodpovedností do vrstiev nie je architektonická elegancia: robí každú časť vymeniteľnou. Konkrétnym prínosom je, že môžeš zmeniť orchestráciu bez dotyku rozhrania alebo pridať nástroj bez prepisovania obchodnej logiky. Štyri nižšie uvedené vrstvy predstavujú minimálne rozdelenie, ktoré sa osvedčuje v praxi.
# Vrstva 1: Rozhranie - prijímanie požiadaviek
# Vrstva 2: Orchestrácia - správa slučiek a smerovanie
# Vrstva 3: Exekúcia - volania nástrojov a funkcií
# Vrstva 4: Pozorovateľnosť - logy, metriky, stopy
from openai import OpenAI
from dataclasses import dataclass, field
from datetime import datetime
import json
import time
import logging
logger = logging.getLogger("multi-nastroje")
@dataclass
class StopaExekucie:
"""Stopa exekúcie pre monitorovanie."""
id_poziadavky: str
start: float = field(default_factory=time.time)
cykly: list = field(default_factory=list)
pouzite_nastroje: list = field(default_factory=list)
tokeny_celkom: int = 0
chyby: list = field(default_factory=list)
celkovy_cas: float = 0.0
Produkčný orchestrátor
class OrchestrujProdukcny:
def __init__(self, konfiguracia: dict):
self.klient = OpenAI()
self.konfiguracia = konfiguracia
self.nastroje = self._vytvor_nastroje(konfiguracia)
self.dispacer = self._vytvor_dispacer(konfiguracia)
def _vytvor_nastroje(self, konfiguracia: dict) -> list:
"""Vytvorí pole nástrojov z konfigurácie."""
nastroje = []
if konfiguracia.get("file_search"):
nastroje.append({
"type": "file_search",
"vector_store_ids": konfiguracia["file_search"]["vector_stores"],
"max_num_results": konfiguracia["file_search"].get("max_results", 10)
})
if konfiguracia.get("web_search"):
nastroje.append({
"type": "web_search",
"search_context_size": konfiguracia["web_search"].get("context_size", "medium")
})
if konfiguracia.get("code_interpreter"):
nastroje.append({"type": "code_interpreter", "container": {"type": "auto"}})
for func in konfiguracia.get("funkcie", []):
nastroje.append(func)
return nastroje
def _vytvor_dispacer(self, konfiguracia: dict) -> dict:
"""Mapuje názvy funkcií na ich implementácie."""
return konfiguracia.get("implementacie", {})
def vykonaj(self, pozadavka: str, subory: list = None,
max_cyklov: int = 10) -> dict:
"""Vykoná požiadavku s kompletným sledovaním."""
stopa = StopaExekucie(
id_poziadavky=f"req_{int(time.time()*1000)}"
)
obsah = [{"type": "input_text", "text": pozadavka}]
if subory:
for fid in subory:
obsah.append({"type": "input_file", "file_id": fid})
spravy = [{"role": "user", "content": obsah}]
try:
for cyklus in range(max_cyklov):
start_cyklu = time.time()
odpoved = self.klient.responses.create(
model=self.konfiguracia.get("model", "gpt-5.6-terra"),
input=spravy,
tools=self.nastroje,
instructions=self.konfiguracia.get("instructions", "")
)
stopa.tokeny_celkom += odpoved.usage.total_tokens
# Identifikácia volaní funkcií
volania = [
item for item in odpoved.output
if item.type == "function_call"
]
# Záznam použitých nástrojov
for item in odpoved.output:
if hasattr(item, "type"):
stopa.pouzite_nastroje.append(item.type)
stopa.cykly.append({
"cislo": cyklus + 1,
"pocet_volani_funkcii": len(volania),
"trvanie": time.time() - start_cyklu
})
if not volania:
stopa.celkovy_cas = time.time() - stopa.start
return {
"odpoved": odpoved.output_text,
"stopa": stopa
}
# Exekúcia vlastných funkcií
vysledky = self._vykonaj_funkcie(volania, stopa)
spravy = odpoved.output + vysledky
except Exception as e:
stopa.chyby.append(str(e))
stopa.celkovy_cas = time.time() - stopa.start
logger.error(f"Chyba požiadavky {stopa.id_poziadavky}: {e}")
return {"odpoved": None, "chyba": str(e), "stopa": stopa}
stopa.celkovy_cas = time.time() - stopa.start
return {"odpoved": "Limit cyklov dosiahnutý", "stopa": stopa}
def _vykonaj_funkcie(self, volania: list, stopa: StopaExekucie) -> list:
"""Vykoná funkcie s ošetrením chýb."""
vysledky = []
for volanie in volania:
try:
func = self.dispacer.get(volanie.name)
if not func:
raise ValueError(f"Neznáma funkcia: {volanie.name}")
args = json.loads(volanie.arguments)
vysledok = func(**args)
vysledky.append({
"type": "function_call_output",
"call_id": volanie.call_id,
"output": json.dumps(vysledok)
})
except Exception as e:
stopa.chyby.append(f"{volanie.name}: {str(e)}")
vysledky.append({
"type": "function_call_output",
"call_id": volanie.call_id,
"output": json.dumps({"error": str(e)})
})
return vysledky
Deklaratívna konfigurácia
Presunutie definícií systému z kódu do konfigurácie mení to, kto môže zasahovať. Úprava systémového promptu, odstránenie nástroja alebo zmena cenového stropu sa stáva zmenou súboru – kontrolovateľnou a vratnou – namiesto nasadenia. Pri systéme, ktorý sa vyvíja týždenne, je to rozdiel medzi iteráciou a reakciou.
konfiguracia_asistenta_obchod = {
"model": "gpt-5.6-terra",
"instructions": (
"Si obchodný asistent. Máš prístup k dátam CRM, "
"produktovej dokumentácii, webu a analýze dát. "
"Uprednostni interné dáta, obohať ich o údaje z webu."
),
"file_search": {
"vector_stores": ["vs_listy_produktov", "vs_navrhy"],
"max_results": 10
},
"web_search": {
"context_size": "medium"
},
"code_interpreter": True,
"funkcie": [
{
"type": "function",
"name": "vytvor_prilezitost",
"description": "Vytvor príležitosť v CRM",
"parameters": {
"type": "object",
"properties": {
"klient": {"type": "string"},
"suma": {"type": "number"},
"pravdepodobnost": {"type": "integer"}
},
"required": ["klient", "suma", "pravdepodobnost"],
"additionalProperties": False
},
"strict": True
}
],
"implementacie": {
"vytvor_prilezitost": lambda klient, suma, pravdepodobnost:
crm_sluzba.vytvor_prilezitost(klient, suma, pravdepodobnost)
}
}
orchestrator = OrchestrujProdukcny(konfiguracia_asistenta_obchod)
vysledok = orchestrator.vykonaj("Priprav návrh pre Acme Corp")
Pozorovateľnosť a monitorovanie
Dashboard metrík
Na začiatok stačia tri metriky a každá odpovedá na inú otázku: latencia na nástroj ti povie, ktorý systém spomaľuje, miera zlyhania na nástroj ti ukáže, ktorý je krehký, a cena na požiadavku ti prezradí, ktorý sa vymyká kontrole. Globálny priemer naprieč všetkými tromi neodpovedá na žiadnu z týchto otázok.
class MetrikyViacNastrojov:
def __init__(self):
self.poziadavky = []
def zaznamenaj(self, stopa: StopaExekucie):
self.poziadavky.append({
"id": stopa.id_poziadavky,
"casova_peciatka": datetime.now().isoformat(),
"trvanie": stopa.celkovy_cas,
"cykly": len(stopa.cykly),
"tokeny": stopa.tokeny_celkom,
"nastroje": list(set(stopa.pouzite_nastroje)),
"chyby": len(stopa.chyby),
"odhadovane_naklady": self._odhadni_naklady(stopa)
})
def _odhadni_naklady(self, stopa: StopaExekucie) -> float:
"""Odhadne náklady v dolároch za exekúciu."""
# Približné sadzby pre gpt-5.6-terra: 2 $ / 12 $ za milión
naklady_vstup = stopa.tokeny_celkom * 0.6 * 0.000002
naklady_vystup = stopa.tokeny_celkom * 0.4 * 0.000012
return round(naklady_vstup + naklady_vystup, 4)
def sprav(self) -> dict:
if not self.poziadavky:
return {}
trvania = [r["trvanie"] for r in self.poziadavky]
tokeny = [r["tokeny"] for r in self.poziadavky]
naklady = [r["odhadovane_naklady"] for r in self.poziadavky]
return {
"celkovy_pocet_poziadaviek": len(self.poziadavky),
"priemerne_trvanie": sum(trvania) / len(trvania),
"priemerne_tokeny": sum(tokeny) / len(tokeny),
"celkove_naklady": sum(naklady),
"miera_chybovosti": sum(1 for r in self.poziadavky if r["chyby"] > 0) / len(self.poziadavky),
"najcastejsie_pouzite_nastroje": self._caste_nastroje()
}
def _caste_nastroje(self) -> dict:
pocitadlo = {}
for r in self.poziadavky:
for nastroj in r["nastroje"]:
pocitadlo[nastroj] = pocitadlo.get(nastroj, 0) + 1
return dict(sorted(pocitadlo.items(), key=lambda x: -x[1]))
Správa nákladov
class SpravcaNakladov:
def __init__(self, denny_rozpocet: float = 50.0):
self.rozpocet = denny_rozpocet
minule_naklady = 0.0
self.datum_resetu = datetime.now().date()
def moze_vykonat(self, odhad_nakladov: float) -> bool:
"""Skontroluje, či rozpočet umožňuje exekúciu."""
dnes = datetime.now().date()
if dnes > self.datum_resetu:
self.minule_naklady = 0.0
self.datum_resetu = dnes
return (self.minule_naklady + odhad_nakladov) <= self.rozpocet
def zaznamenaj_vydavok(self, naklad: float):
self.minule_naklady += naklad
def zvysny_rozpocet(self) -> float:
return self.rozpocet - self.minule_naklady
# Integrácia do orchestrátora
spravca_nakladov = SpravcaNakladov(denny_rozpocet=100.0)
def vykonaj_s_rozpoctom(orchestrator, pozadavka, **kwargs):
odhad_nakladov = 0.05 # Konzervatívny odhad
if not spravca_nakladov.moze_vykonat(odhad_nakladov):
return {"chyba": "Denný rozpočet vyčerpaný", "zvysok": 0}
vysledok = orchestrator.vykonaj(pozadavka, **kwargs)
realne_naklady = vysledok["stopa"].tokeny_celkom * 0.000002
spravca_nakladov.zaznamenaj_vydavok(realne_naklady)
return vysledok
Vzorec: inteligentný smerovač
S pribúdajúcimi prípadmi použitia vzniká pokušenie odovzdať všetko jednému systému vybavenému každým nástrojom. Je to najdrahšia voľba: každá požiadavka, aj tá triviálna, so sebou nesie celú sadu definícií nástrojov. Smerovač, ktorý najprv klasifikuje požiadavku a potom zavolá špecializovaného orchestrátora, udržiava kontexty krátke a umožňuje merať každý tok samostatne.
class InteligentnySmerovac:
def __init__(self):
self.klient = OpenAI()
self.orchestratory = {}
def registrovat(self, domena: str, orchestrator: OrchestrujProdukcny):
self.orchestratory[domena] = orchestrator
def smeruj(self, pozadavka: str) -> dict:
"""Určí doménu a smeruje na správny orchestrátor."""
# Rýchla klasifikácia pomocou ľahkého modelu
odpoved = self.klient.responses.create(
model="gpt-5.6-terra",
input=f"Klasifikuj túto požiadavku do domény: {pozadavka}\n"
f"Dostupné domény: {list(self.orchestratory.keys())}\n"
f"Odpovedz iba názvom domény.",
)
domena = odpoved.output_text.strip().lower()
if domena not in self.orchestratory:
domena = "vseobecne" # Záložná možnosť
logger.info(f"Požiadavka smerovaná do: {domena}")
return self.orchestratory[domena].vykonaj(pozadavka)
# Konfigurácia
smerovac = InteligentnySmerovac()
smerovac.registrovat("obchod", OrchestrujProdukcny(konfiguracia_asistenta_obchod))
smerovac.registrovat("podpora", OrchestrujProdukcny(konfiguracia_podpora))
smerovac.registrovat("hr", OrchestrujProdukcny(konfiguracia_hr))
# Použitie
vysledok = smerovac.smeruj("Koľko dní dovolenky mi ešte zostáva?")
# -> Automaticky smeruje na HR orchestrátor
Kontrolný zoznam pre produkciu
Tento zoznam je zámerne krátky. Nesnaží sa o vyčerpávajúcosť, ale pokrýva body, ktorých absencia ťa stojí incidenty namiesto nepríjemností – a ktoré nemôžeš rýchlo doplniť v deň, keď je systém už v rukách používateľov.
kontrolny_zoznam = {
"bezpecnost": [
"Validuj argumenty pre každú funkciu",
"Obmedzenie rýchlosti na používateľa",
"Čistenie vstupov a výstupov",
"Žiadne citlivé dáta v logoch"
],
"spolahlivost": [
"Opakovanie s oneskorením pri prechodných chybách",
"Istič obvodu pre každú externú službu",
"Časový limit pre každý nástroj a celú požiadavku",
"Záložné riešenie pri nedostupnosti nástroja"
],
"vykon": [
"Paralelná exekúcia nezávislých volaní",
"Ukladanie častých výsledkov vyhľadávania do cache",
"Obmedzenie počtu iterácií slučky",
"Výber modelu prispôsobený zložitosti (gpt-5.6-terra vs gpt-5.6-terra)"
],
"pozorovatelnost": [
"Štruktúrované logovanie pre každé volanie",
"Metriky latencie a nákladov",
"Upozornenia na mieru chýb",
"Kompletná stopa každej požiadavky"
],
"naklady": [
"Denný rozpočet s ističom obvodu",
"Odhad nákladov pred exekúciou",
"Týždenný report výdavkov",
"Optimalizácia výberu modelu podľa zložitosti"
]
}
Kľúčové poznatky
- Rozdeľ na vrstvy: rozhranie, orchestrácia, exekúcia, pozorovateľnosť
- Použi deklaratívnu konfiguráciu na definovanie systémov
- Sleduj každú exekúciu kvôli monitoringu a ladeniu
- Implementuj správcu nákladov s denným rozpočtom
- Inteligentný smerovač distribuuje požiadavky správnym orchestrátorom
Otestuj si svoje vedomosti
Volanie funkcií, vyhľadávanie, exekúcia: celý arzenál v piatich otázkach.
1. Čo by mala obsahovať dobrá schéma funkcie?
Odpoveď: Prísne typy a operačné popisy pre každý parameter – toto je zmluva, ktorú model používa na rozhodnutie, kedy volať a ako vyplniť; validácia zvyšok odmietne.
2. Webové vyhľadávanie alebo vyhľadávanie v súboroch: ako si vybrať?
Odpoveď: Webové vyhľadávanie pre verejné, nedávne informácie; vyhľadávanie v súboroch pre tvoje indexované dokumenty (chunking + vstavané hodnotenie) – a hybridné vyhľadávanie kombinuje obe, keď sa odpoveď nachádza v oboch svetoch.
3. Čo umožňuje Code Interpreter v API?
Odpoveď: Spúšťať kód v pieskovisku: spracovávať CSV/Excel/obrázky, presne počítať, vytvárať grafy – model uvažuje, kód počíta, pieskovisko izoluje.
4. Na čo slúži vyhľadávanie nástrojov (Tool Search)?
Odpoveď: Na dynamické vystavenie veľkého katalógu nástrojov: model hľadá relevantný nástroj namiesto toho, aby dostal sto schém naraz – kontext zostáva ľahký, schopnosti zostávajú rozsiahle.
5. Aké pravidlá platia pre architektúru s viacerými nástrojmi v produkcii?
Odpoveď: Nástroje s jasným rozsahom, ošetrenie chýb a záložné riešenia pre každý nástroj, paralelné volania pri nezávislosti a pozorovateľnosť pre každé volanie – robustnosť sa navrhuje nástroj po nástroji.
Každý nástroj má svoje teritórium; produkcia ich kombinuje – vyššie uvedená finálna architektúra je tvoj referenčný plán.