Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Arkitekturer med flera verktyg i produktion

Lektion 20 av 20 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Arkitekturer med flera verktyg i produktion
  2. Skiktad arkitektur
  3. Produktionsorkestrerare
  4. Deklarativ konfiguration
  5. Observerbarhet och övervakning
  6. Kostnadshantering
  7. Mönster: intelligent router
  8. Checklista för produktion
  9. Viktiga punkter
  10. Testa dina kunskaper

Uppdaterad 2 november 2026 baserat på OpenAI-dokumentation: verktyget Code Interpreter kräver nu en parameter container (lagts till i alla exempel), textinmatningsdelar är typade som input_text, och webbsökning använder verktyget web_search (web_search_preview är nu ett föråldrat verktyg utan domänfilter). Genererade filer hämtas med funktionerna fichiers_generes och telecharger från lektion 10. Källor: Code Interpreter · Web search.

Arkitekturer med flera verktyg i produktion

En prototyp med flera verktyg fungerar eftersom en enda person använder den, känner dess begränsningar och startar om den vid fel. I produktion försvinner alla tre förutsättningarna samtidigt. Det som blir avgörande är inte svarskvaliteten – den fanns redan där – utan tre egenskaper som prototypen saknade: att veta vad som hände när ett anrop misslyckas, att förhindra att en oändlig loop tömmer din budget, och att kunna ändra beteendet utan att behöva distribuera om koden.

Mönstren nedan adresserar var och en av dessa krav. Inför inte alla på en gång: börja med observerbarhet, för utan den vet du inte ens vilka av de andra du saknar.

Skiktad arkitektur

Att separera ansvarsområden i skikt handlar inte om arkitektonisk elegans: det gör varje del utbytbar. Den konkreta fördelen är att du kan ändra orkestreringen utan att röra gränssnittet, eller lägga till ett verktyg utan att skriva om affärslogiken. De fyra skikten nedan är den minimala uppdelning som håller i praktiken.

# Skikt 1: Gränssnitt - mottagande av förfrågningar
# Skikt 2: Orkestrering - loop-hantering och routning
# Skikt 3: Exekvering - verktygs- och funktionsanrop
# Skikt 4: Observerbarhet - loggar, mätvärden, spår

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:
    """Exekveringsspår för övervakning."""
    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

Produktionsorkestrerare

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:
        """Bygger verktygsarrayen från konfigurationen."""
        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:
        """Mappar funktionsnamn till deras implementationer."""
        return config.get("implementations", {})

    def executer(self, requete: str, fichiers: list = None,
                 max_tours: int = 10) -> dict:
        """Exekverar en förfrågan med fullständig spårning."""
        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

                # Identifiera funktionsanrop
                appels = [
                    item for item in response.output
                    if item.type == "function_call"
                ]

                # Registrera använda verktyg
                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
                    }

                # Exekvera anpassade funktioner
                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:
        """Exekverar funktioner med felhantering."""
        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

Deklarativ konfiguration

Att flytta systemdefinitioner ut ur koden och in i konfigurationen ändrar vem som kan ingripa. Att justera en systemprompt, ta bort ett verktyg eller ändra ett kostnadstak blir en filändring – granskningsbar och reversibel – istället för en distribution. På ett system som utvecklas varje vecka är det skillnaden mellan att iterera och att reagera.

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

Observerbarhet och övervakning

Mätvärdesdashboard

Tre mätvärden räcker för att komma igång, och vart och ett svarar på en annan fråga: latens per verktyg berättar vilket som bromsar systemet, felfrekvens per verktyg berättar vilket som är skört, och kostnad per förfrågan berättar vilket som skenar. Ett globalt genomsnitt över alla tre svarar på ingen av dessa frågor.

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:
        """Uppskattar kostnaden i dollar för exekveringen."""
        # Ungefärliga priser för gpt-5.6-terra: $2 / $12 per miljon
        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]))

Kostnadshantering

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:
        """Kontrollerar om budgeten tillåter exekvering."""
        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

# Integration i orkestreraren
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)

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

Mönster: intelligent router

När användningsområdena multipliceras blir frestelsen stor att lämna allt till ett enda system utrustat med varje verktyg. Det är det dyraste valet: varje förfrågan, även triviala, bär på hela uppsättningen av verktygsdefinitioner. En router som först klassificerar förfrågan och sedan anropar en specialiserad orkestrerare håller kontexterna korta och gör varje flöde mätbart separat.

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:
        """Bestämmer domänen och routar till rätt orkestrerare."""
        # Snabb klassificering med en lättviktig modell
        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"  # Fallback

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

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

# Användning
resultat = routeur.router("How many vacation days do I have left?")
# -> Routar automatiskt till HR-orkestreraren

Checklista för produktion

Denna checklista är avsiktligt kort. Den siktar inte på fullständighet utan täcker de punkter vars frånvaro kostar dig i incidenter snarare än obehag – och som du inte kan lägga till i hastighet den dag systemet redan är i användarnas händer.

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

Viktiga punkter

  • Dela upp i skikt: gränssnitt, orkestrering, exekvering, observerbarhet
  • Använd deklarativ konfiguration för att definiera system
  • Spåra varje exekvering för övervakning och felsökning
  • Implementera en kostnadshanterare med daglig budget
  • En intelligent router distribuerar förfrågningar till rätt orkestrerare

Testa dina kunskaper

Funktionsanrop, sökning, exekvering: hela arsenalen på fem frågor.

1. Vad bör ett bra funktionsschema innehålla?

Svar: Strikta typer och operativa beskrivningar per parameter – detta är kontraktet som modellen använder för att besluta när den ska anropa och hur den ska fylla i; validering avvisar resten.

2. Web Search eller File Search: hur väljer man?

Svar: Web Search för offentlig, färsk information; File Search för dina indexerade dokument (chunking + inbyggd rangordning) – och hybridsökning kombinerar båda när svaret spänner över båda världarna.

3. Vad möjliggör Code Interpreter i API:t?

Svar: Exekvera kod i en sandlåda: bearbeta CSV/Excel/bilder, beräkna exakt, producera diagram – modellen resonerar, koden beräknar, sandlådan isolerar.

4. Vad är Tool Search till för?

Svar: För att dynamiskt exponera en stor verktygskatalog: modellen söker efter rätt verktyg istället för att få hundra scheman på en gång – kontexten hålls lätt, kapaciteterna förblir omfattande.

5. Vilka regler gäller för en arkitektur med flera verktyg i produktion?

Svar: Verktyg med tydligt omfång, felhantering och fallbacks per verktyg, parallella anrop när de är oberoende, och observerbarhet för varje anrop – robusthet designas verktyg för verktyg.

Varje verktyg har sin terräng; produktion kombinerar dem – den slutgiltiga arkitekturen ovan är din referensplan.