Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Arhitektuurid mitme tööriistaga tootmises

Õppetund 20 / 20 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Arhitektuurid mitme tööriistaga tootmises
  2. Kihiline arhitektuur
  3. Tootmise orkestreerija
  4. Deklaratiivne konfiguratsioon
  5. Jälgitavus ja monitooring
  6. Kulude haldamine
  7. Muster: intelligentne ruuter
  8. Tootmise kontrollnimekiri
  9. Peamised punktid
  10. Testi oma teadmisi

Uuendatud 2. novembril 2026 OpenAI dokumentatsiooni põhjal: Code Interpreteri tööriist nõuab nüüd parameetrit container (lisatud kõigile näidetele), tekstisisendi osad on tüübitud kui input_text ja veebiotsing kasutab tööriista web_search (web_search_preview on nüüd aegunud tööriist ilma domeenifiltriteta). Genereeritud failid laaditakse alla, kasutades 10. õppetükist pärit funktsioone fichiers_generes ja telecharger. Allikad: Code Interpreter · Veebiotsing.

Arhitektuurid mitme tööriistaga tootmises

Mitme tööriistaga prototüüp toimib seetõttu, et seda kasutab üks inimene, kes tunneb selle piire ja taaskäivitab selle tõrke korral. Tootmine eemaldab kõik kolm tingimust korraga. Kriitiliseks ei muutu mitte vastuse kvaliteet – see oli juba olemas –, vaid kolm omadust, mida prototüübil puudus: teadmine, mis juhtus, kui päring ebaõnnestus; võime takistada lõpmatul tsüklil eelarvet tühjendamast; ja võimalus käitumist muuta ilma uut versiooni kasutusele võtmata.

Allpool toodud mustrid lahendavad igaüks ühe neist nõuetest. Ära võta kõiki korraga kasutusele: alusta jälgitavusest, sest ilma selleta ei tea sa isegi, millist teistest sul puudu on.

Kihiline arhitektuur

Murekohtade eraldamine kihtidesse ei ole arhitektuuriline elegants: see muudab iga osa asendatavaks. Konkreetne kasu seisneb selles, et saad muuta orkestreerimist liidest puutumata jättes või lisada tööriista äriloogikat ümber kirjutamata. Allpool olevad neli kihti on minimaalne jaotus, mis praktikas vastu peab.

# Kiht 1: Liides - päringute vastuvõtt
# Kiht 2: Orkestreerimine - tsükli haldamine ja suunamine
# Kiht 3: Täitmine - tööriista ja funktsiooni väljakutsed
# Kiht 4: Jälgitavus - logid, meetrikad, jäljed

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:
    """Täitmise jälgimine monitooringuks."""
    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

Tootmise orkestreerija

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:
        """Ehitab tööriistade massiivi konfiguratsioonist."""
        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:
        """Seob funktsioonide nimed nende teostustega."""
        return config.get("implementations", {})

    def executer(self, requete: str, fichiers: list = None,
                 max_tours: int = 10) -> dict:
        """Teostab päringu täieliku jälgimisega."""
        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

                # Tuvasta funktsioonide väljakutsed
                appels = [
                    item for item in response.output
                    if item.type == "function_call"
                ]

                # Salvesta kasutatud tööriistad
                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
                    }

                # Teosta kohandatud funktsioonid
                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:
        """Teostab funktsioone veakäitlusega."""
        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

Deklaratiivne konfiguratsioon

Süsteemi määratluste viimine koodist konfiguratsiooni muudab seda, kes saab sekkuda. Süsteemi vihje kohandamine, tööriista eemaldamine või kululae muutmine muutub faili muudatuseks – ülevaadatavaks ja pööratavaks – mitte kasutuselevõtuks. Süsteemis, mis areneb iganädalaselt, on see erinevus iteratsiooni ja reageerimise vahel.

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")

Jälgitavus ja monitooring

Meetrikate armatuurlaud

Alustamiseks piisab kolmest meetrikast ja igaüks neist vastab erinevale küsimusele: latentsus tööriista kohta ütleb, milline neist süsteemi aeglustab; tõrgete määr tööriista kohta näitab, milline on habras; ja kulu päringu kohta paljastab, milline kasvab kontrollimatult. Globaalne keskmine üle kõigi kolme ei vasta ühelegi neist küsimustest.

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:
        """Hindab täitmise kulu dollarites."""
        # Ligikaudsed hinnad gpt-5.6-terra jaoks: 2 $ / 12 $ miljoni kohta
        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]))

Kulude haldamine

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:
        """Kontrollib, kas eelarve lubab täitmist."""
        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

# Integreerimine orkestreerijasse
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)

def executer_avec_budget(orchestreur, requete, **kwargs):
    cout_estime = 0.05  # Konservatiivne hinnang
    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

Muster: intelligentne ruuter

Kasutusjuhtumite kasvades on kiusatus usaldada kõik ühele süsteemile, mis on varustatud iga võimaliku tööriistaga. See on kõige kulukam valik: iga päring, isegi triviaalne, kannab endas kõigi tööriistade definitsioone. Ruuter, mis liigitab päringu esmalt ja kutsub seejärel spetsialiseeritud orkestreerija, hoiab kontekstid lühikesena ja võimaldab iga voogu eraldi mõõta.

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:
        """Määrab domeeni ja suunab õigele orkestreerijale."""
        # Kiire liigitamine kerge mudeliga
        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"  # Varuvariant

        logger.info(f"Requête routee vers : {domaine}")
        return self.orchestreurs[domaine].executer(requete)

# Konfiguratsioon
routeur = RouteurIntelligent()
routeur.enregistrer("commercial", OrchestreurProduction(config_assistant_commercial))
routeur.enregistrer("support", OrchestreurProduction(config_support))
routeur.enregistrer("rh", OrchestreurProduction(config_rh))

# Kasutamine
resultat = routeur.router("How many vacation days do I have left?")
# -> Suunab automaatselt HR-i orkestreerijale

Tootmise kontrollnimekiri

See kontrollnimekiri on tahtlikult lühike. See ei püüa olla ammendav, kuid katab punktid, mille puudumine maksab sulle intsidentides, mitte ebamugavuses – ja mida sa ei saa kiirustades lisada päeval, mil süsteem on juba kasutajate käes.

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"
    ]
}

Peamised punktid

  • Jaota kihtideks: liides, orkestreerimine, täitmine, jälgitavus
  • Kasuta süsteemide määratlemiseks deklaratiivset konfiguratsiooni
  • Jälgi iga täitmist monitooringuks ja silumiseks
  • Rakenda kuluhaldur koos päevase eelarvega
  • Intelligentne ruuter jaotab päringud õigetele orkestreerijatele

Testi oma teadmisi

Funktsioonide kutsumine, otsing, täitmine: kogu arsenali viies küsimuses.

1. Mida peaks hea funktsiooni skeem sisaldama?

Vastus: Rangelt tüübitud ja operatiivsed kirjeldused iga parameetri kohta – see on leping, mida mudel kasutab otsustamaks, millal kutsuda ja kuidas täita; valideerimine lükkab ülejäänu tagasi.

2. Veebiotsing või failiotsing: kuidas valida?

Vastus: Veebiotsing avaliku ja värske teabe jaoks; failiotsing sinu indekseeritud dokumentide jaoks (tükeldamine + sisseehitatud järjestus) – ja hübriidotsing ühendab mõlemad, kui vastus ulatub mõlemasse maailma.

3. Mida võimaldab Code Interpreter API-s?

Vastus: Koodi käivitamine liivakastis: töötle CSV/Excel/pilte, arvuta täpselt, loo graafikuid – mudel arutleb, kood arvutab, liivakast isoleerib.

4. Milleks on Tool Search?

Vastus: Suure tööriistade kataloogi dünaamiliseks avaldamiseks: mudel otsib asjakohast tööriista, selle asemel et saada korraga sada skeemi – kontekst jääb kergeks, võimekused jäävad tohutuks.

5. Millised reeglid kehtivad mitme tööriistaga arhitektuurile tootmises?

Vastus: Selge ulatusega tööriistad, veakäitlus ja varuvariandid iga tööriista jaoks, paralleelsed väljakutsed sõltumatute puhul ja jälgitavus iga väljakutse jaoks – töökindlus projekteeritakse tööriista haaval.

Igal tööriistal on oma maastik; tootmine ühendab need – ülalolev lõplik arhitektuur on sinu referentsplaan.