Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Arkitekturer med flere værktøjer i produktion

Lektion 20 af 20 Opdateret 2. november 2026 Udvikler
På denne side
  1. Arkitekturer med flere værktøjer i produktion
  2. Lagdelt arkitektur
  3. Produktionsorkestrator
  4. Deklarativ konfiguration
  5. Observerbarhed og overvågning
  6. Omkostningsstyring
  7. Mønster: Intelligent router
  8. Produktionscheckliste
  9. Vigtige pointer
  10. Test din viden

Opdateret 2. november 2026 baseret på OpenAI-dokumentation: Code Interpreter-værktøjet kræver nu en container-parameter (tilføjet til alle eksempler), tekstinput-dele er typet som input_text, og websøgning bruger web_search-værktøjet (web_search_preview er nu et forældet værktøj uden domænefiltre). Genererede filer hentes ved hjælp af funktionerne fichiers_generes og telecharger fra Lektion 10. Kilder: Code Interpreter · Websøgning.

Arkitekturer med flere værktøjer i produktion

En prototype med flere værktøjer fungerer, fordi én enkelt person bruger den, kender dens begrænsninger og genstarter den, hvis den fejler. Produktion fjerner alle tre betingelser på én gang. Det, der bliver afgørende, er ikke svarenes kvalitet – den var der allerede – men tre egenskaber, som prototypen manglede: at vide, hvad der skete, når et kald fejler, at forhindre en løbsk løkke i at tømme dit budget, og at kunne ændre adfærd uden at genudgive systemet.

Mønstrene nedenfor adresserer hver især ét af disse krav. Adoptér dem ikke alle på én gang: start med observerbarhed, for uden den ved du ikke engang, hvilke af de andre du mangler.

Lagdelt arkitektur

At adskille ansvarsområder i lag handler ikke om arkitektonisk elegance: det gør hver del udskiftelig. Den konkrete fordel er, at du kan ændre orkestrering uden at røre ved grænsefladen, eller tilføje et værktøj uden at omskrive forretningslogikken. De fire lag nedenfor er den minimale opdeling, der holder i praksis.

# Lag 1: Grænseflade - modtagelse af anmodninger
# Lag 2: Orkestrering - løkkehåndtering og routing
# Lag 3: Eksekvering - værktøjs- og funktionskald
# Lag 4: Observerbarhed - logs, metrikker, spor

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:
    """Eksekveringsspor til overvågning."""
    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

Produktionsorkestrator

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 værktøjsarrayet ud fra 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:
        """Mapper funktionsnavne til deres implementeringer."""
        return config.get("implementations", {})

    def executer(self, requete: str, fichiers: list = None,
                 max_tours: int = 10) -> dict:
        """Eksekverer en anmodning med komplet sporing."""
        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ér funktionskald
                appels = [
                    item for item in response.output
                    if item.type == "function_call"
                ]

                # Registrér brugte værktøjer
                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
                    }

                # Eksekvér brugerdefinerede 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:
        """Eksekverer funktioner med fejlhåndtering."""
        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

At flytte systemdefinitioner ud af koden og ind i konfigurationen ændrer, hvem der kan gribe ind. Justering af en systemprompt, fjernelse af et værktøj eller ændring af et omkostningsloft bliver til en filændring – som kan gennemgås og rulles tilbage – i stedet for en udrulning. På et system, der udvikler sig ugentligt, er det forskellen mellem at iterere og at reagere.

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

Observerbarhed og overvågning

Dashboard for metrikker

Tre metrikker er nok til at komme i gang, og hver besvarer et andet spørgsmål: latens per værktøj fortæller dig, hvilket der bremser systemet, fejlrate per værktøj fortæller dig, hvilket der er skrøbeligt, og omkostninger per anmodning fortæller dig, hvilket der løber løbsk. Et globalt gennemsnit på tværs af alle tre besvarer ingen af disse spørgsmål.

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:
        """Estimerer omkostningen i dollars for eksekveringen."""
        # Omtrentlige satser for gpt-5.6-terra: $2 / $12 per million
        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]))

Omkostningsstyring

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:
        """Tjekker om budgettet tillader eksekvering."""
        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 orkestratoren
gestionnaire_couts = GestionnaireCouts(budget_quotidien=100.0)

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

Efterhånden som brugstilfælde multipliceres, er fristelsen stor for at overlade alt til ét enkelt system udstyret med ethvert værktøj. Det er det dyreste valg: hver anmodning, selv trivielle, bærer hele sættet af værktøjsdefinitioner. En router, der først klassificerer anmodningen og derefter kalder en specialiseret orkestrator, holder kontekster korte og gør hver flow målbart 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:
        """Bestemmer domænet og router til den korrekte orkestrator."""
        # Hurtig klassifikation med en letvægtsmodel
        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))

# Brug
resultat = routeur.router("How many vacation days do I have left?")
# -> Router automatisk til HR-orkestratoren

Produktionscheckliste

Denne checkliste er bevidst kort. Den sigter ikke mod udtømmende dækning, men dækker de punkter, hvis fravær koster dig i incidenter snarere end ubehag – og som du ikke kan tilføje i hast, den dag systemet allerede er i brugernes 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"
    ]
}

Vigtige pointer

  • Opdel i lag: grænseflade, orkestrering, eksekvering, observerbarhed
  • Brug deklarativ konfiguration til at definere systemer
  • Spor hver eksekvering til overvågning og fejlfinding
  • Implementér en omkostningsmanager med et dagligt budget
  • En intelligent router fordeler anmodninger til de rigtige orkestratorer

Test din viden

Funktionskald, søgning, eksekvering: hele arsenalet på fem spørgsmål.

1. Hvad skal et godt funktionsskema indeholde?

Svar: Strengt typede og operationelle beskrivelser per parameter – dette er kontrakten, som modellen bruger til at beslutte, hvornår den skal kalde, og hvordan den skal udfylde; validering afviser resten.

2. Websøgning eller filsøgning: hvordan vælger du?

Svar: Websøgning til offentlige, recente oplysninger; filsøgning til dine indekserede dokumenter (chunking + indbygget rangering) – og hybridsøgning kombinerer begge, når svaret spænder over begge verdener.

3. Hvad muliggør Code Interpreter i API'et?

Svar: Eksekvering af kode i en sandbox: behandling af CSV/Excel/billeder, præcis beregning, produktion af diagrammer – modellen ræsonnerer, koden beregner, sandboxen isolerer.

4. Hvad bruges Tool Search til?

Svar: Til dynamisk at eksponere en stor katalog af værktøjer: modellen søger efter det relevante værktøj i stedet for at modtage hundrede skemaer på én gang – konteksten forbliver let, kapaciteterne forbliver store.

5. Hvilke regler gælder for en arkitektur med flere værktøjer i produktion?

Svar: Værktøjer med klart omfang, fejlhåndtering og fallbacks per værktøj, parallelle kald når uafhængige, og observerbarhed for hvert kald – robusthed designes værktøj for værktøj.

Hvert værktøj har sit terræn; produktion kombinerer dem – arkitekturen ovenfor er din referenceplan.