Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Arhitektūras ar vairākiem rīkiem ražošanā

Nodarbība 20 no 20 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Arhitektūras ar vairākiem rīkiem ražošanā
  2. Slāņota arhitektūra
  3. Ražošanas orķestrators
  4. Deklaratīva konfigurācija
  5. Novērojamība un monitorings
  6. Izmaksu vadība
  7. Modelis: inteliģents maršrutētājs
  8. Ražošanas kontrolsaraksts
  9. Galvenās atziņas
  10. Pārbaudi savas zināšanas

Atjaunināts 2026. gada 2. novembrī, pamatojoties uz OpenAI dokumentāciju: Code Interpreter rīkam tagad ir nepieciešams container parametrs (pievienots visiem piemēriem), teksta ievades daļas ir tipētas kā input_text, un tīmekļa meklēšana izmanto web_search rīku (web_search_preview tagad ir novecojis rīks bez domēna filtriem). Ģenerētie faili tiek iegūti, izmantojot fichiers_generes un telecharger funkcijas 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.