Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Bedste praksis og næste skridt

Lektion 18 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Hvad du har gennemgået
  2. Design af agenter, der holder
  3. Håndtering af fejl
  4. At se, hvad der sker
  5. Test af routing
  6. Referencearkitektur
  7. Hvor du skal hen nu
  8. Vigtige pointer
  9. Test din viden

Hvad du har gennemgået

Du har arbejdet dig igennem hele Mistral Agents API. Lad os opsummere, før vi dykker ned i produktionspraksis, da hver del af dette kursus bygger på det foregående.

De første tre lektioner lagde fundamentet: En AI-agent er et autonomt system med en perceptions-handlings-løkke; API’et hviler på tre objekter – Agent, Conversation og Entry; og det, der adskiller en agent fra en chatbot, er persistens, værktøjer og overdragelser (handoffs). Lektion 4 til 7 gjorde disse objekter brugbare: Oprettelse og konfiguration af agenter med client.beta.agents.create(), vedligeholdelse af persistente samtaler med conversations.start() og conversations.append(), samt brug af direkte tilstand uden en agent, når du prototyper, og persistens ikke tilfører værdi.

Lektion 8 til 11 tilføjede funktionalitet. web_search giver dig adgang til aktuelle oplysninger med automatiske kildehenvisninger; code_interpreter kører Python i en sandbox, hvilket giver agenten præcise resultater, hvor modellen alene ville approximere; image_generation producerer visuelle elementer ud fra tekstprompt; document_library bringer integreret RAG til dine egne dokumenter. Lektion 12 til 16 viste derefter flere agenter, der arbejder sammen: Overdragelser overfører kontrollen fra én agent til en anden, referencearkitekturen parrer en central router med specialister, server-tilstand automatiserer, hvor klient-tilstand holder dig i løkken, og ubegrænset kædning opdeles i lineære, stjerne- og hybride mønstre. Endelig afrundede lektion 17 det hele med guardrails, princippet om mindste privilegium og upstream-moderering.

Design af agenter, der holder

Én sætning opsummerer hele kurset: Én agent, ét ansvar, én beskrivelse, der siger, hvornår den skal kaldes. Kontrasten nedenfor gør forskellen håndgribelig.

# GODT — specialiseret agent med præcis beskrivelse
agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="invoice-processor",
    description="Processes invoices: extracts amounts, dates, vendors.",
    instructions="Extract invoice information into structured JSON.",
    tools=[{"type": "document_library", "library_ids": [invoices_lib.id]}]
)

# DÅRLIGT — generisk, vag agent
agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="helper",
    description="A helpful agent.",
    tools=[{"type": "web_search"}, {"type": "code_interpreter"}, {"type": "image_generation"}]
)

Den anden agent vil fejle på to måder på én gang. Ingen router vil vide, hvornår en forespørgsel skal overdrages til den, fordi “en hjælpsom agent” ikke beskriver nogen situation. Og når den endelig kaldes, lader dens tre værktøjer den frit søge på nettet efter noget, den burde have beregnet, eller illustrere noget, den blev bedt om at analysere.

Håndtering af fejl

Netværkskald fejler før eller siden. Et genforsøg med eksponentiel backoff absorberer forbigående hændelser uden at gøre en øjeblikkelig nedbremsning til en synlig nedetid.

import time

def safe_conversation(agent_id, query, max_retries=3):
    """Samtale med fejlhåndtering og genforsøg."""
    for attempt in range(max_retries):
        try:
            response = client.beta.conversations.start(
                agent_id=agent_id,
                inputs=query
            )
            return response
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)  # Eksponentiel backoff
    return None

Eksponentiel backoff – ét sekund, så to, så fire – adskiller en civiliseret gentagelse fra at hamre løs på en tjeneste, der allerede kæmper. Bemærk også, at det sidste forsøg gen-kaster undtagelsen i stedet for at returnere None: Din kaldende kode har brug for at vide, at operationen mislykkedes.

At se, hvad der sker

I produktion bliver en multi-agent-workflow, du ikke kan observere, umulig at fejlfinde. Klient-tilstand giver dig præcis de hooks, du har brug for.

import logging
import time

logger = logging.getLogger("agents")

def monitored_conversation(agent_id, query):
    """Samtale med overvågning."""
    start = time.time()

    response = client.beta.conversations.start(
        agent_id=agent_id,
        inputs=query,
        handoff_execution="client"
    )

    handoff_count = 0
    tool_count = 0

    for entry in response.outputs:
        if entry.type == "agent.handoff":
            handoff_count += 1
            logger.info(f"Handoff #{handoff_count}: → {entry.next_agent_id}")
        elif entry.type == "tool.execution":
            tool_count += 1
            logger.info(f"Tool #{tool_count}: {entry.tool_name}")

    duration = time.time() - start
    logger.info(f"Finished in {duration:.1f}s — {handoff_count} handoffs, {tool_count} tools")

    return response

Disse to tællere er mere værd, end deres enkelhed antyder: En afvigelse i det gennemsnitlige antal overdragelser signalerer en router, der tøver; en top i værktøjskald peger på dyre forespørgsler.

Omkostningskontrol reduceres derefter til konkrete beslutninger. Overvåg tokens per samtale, da det er den egentlige faktureringsenhed. Brug mistral-medium-latest, hvor mistral-large-latest ikke tilfører noget – det første supporttrin er et skoleeksempel. Sæt loft over max_tokens i completion_args for at undgå endeløse svar på simple spørgsmål, og deaktiver lagring med store=False, når persistens ikke er påkrævet.

Test af routing

Test et multi-agent-system som enhver telefoncentral: Fodre det med tilfælde, hvor du kender den forventede destination, og verificér, hvor de lander.

def test_agent_routing():
    """Verificerer, at routeren fordeler korrekt."""
    test_cases = [
        ("What is the price of Bitcoin?", "web-search-agent"),
        ("Calculate 25 * 48", "calculator-agent"),
        ("Summarize this document", "doc-agent"),
    ]

    for query, expected_agent_name in test_cases:
        response = client.beta.conversations.start(
            agent_id=router.id,
            inputs=query,
            handoff_execution="client"
        )

        for entry in response.outputs:
            if entry.type == "agent.handoff":
                target = client.beta.agents.get(agent_id=entry.next_agent_id)
                assert target.name == expected_agent_name, \
                    f"Incorrect routing for '{ query}': {target.name} instead of {expected_agent_name}"

Opbyg denne testsuite over tid: Hver forkert routet forespørgsel, du fanger i produktion, bliver til en ny linje i test_cases, og du vil vide, at omskrivning af en beskrivelse løser det målrettede tilfælde uden at ødelægge et andet.

Referencearkitektur

Til et produktionsprojekt er her en anbefalet arkitektur:

Application
    │
    ▼
Moderator Agent (filters requests)
    │
    ▼
Router Agent (distributes to specialists)
    ├── Search Agent (web_search)
    ├── Analysis Agent (code_interpreter)
    ├── Documents Agent (document_library)
    └── Creation Agent (image_generation)
    │
    ▼
Logging + Monitoring + Alerting

Den samler alt fra dette kursus: Moderatoren filtrerer før enhver eksekvering, routeren dirigerer uden nogensinde selv at svare, hver specialist bærer ét værktøj og ét ansvar, og observation omslutter hele systemet.

Hvor du skal hen nu

Fire retninger udvider, hvad du kan gøre nu. Function calling lader dig bygge dine egne custom tools ud over de indbyggede: Kald en forretnings-API, spørg en database, udløs en intern tjeneste. MCP Servers integrerer Model Context Protocol, som standardiserer, hvordan værktøjer eksponeres. Structured outputs tvinger svar ind i et JSON-skema, hvilket ændrer alt, når en agents output fodrer et andet system frem for en menneskelig læser. Endelig returnerer streaming svar i realtid i stedet for i én blok – afgørende ved lange kæder, hvor stille venten bliver ubehagelig.

Tre ressourcer ledsager dette næste skridt: Den officielle dokumentation på docs.mistral.ai/agents, Mistral-cookbooks, der giver komplette implementeringseksempler, og API-referencen, der dokumenterer hvert endpoint i detaljer.

Vigtige pointer

  • Specialisér dine agenter – én agent = ét ansvar
  • Overvåg – log hver overdragelse og hver værktøjseksekvering
  • Test – valider routing og hver agents svar
  • Sikr – guardrails, mindste privilegium, upstream-moderering
  • Optimér omkostninger – korrekt dimensioneret model, max_tokens, store=False når muligt
  • Mistral Agents er i beta – hold dig opdateret med API-ændringer

Test din viden

Agenter, indbyggede værktøjer, overdragelser: Har Agents API’et nogen blinde pletter tilbage?

1. Hvornår er en agent nødvendig – og hvornår er en chatbot nok?

Svar: En agent er berettiget, når du har brug for værktøjer, persistens og beslutninger i flere trin; til simpelt spørgsmål-svar er en standard samtale nok – arkitekturen følger behovet.

2. Hvad styrer persistente samtaler i Agents API'et?

Svar: Historik på Mistral-siden: Du fortsætter en samtale via dens ID uden at gensende hele konteksten – tilstanden bliver en tjeneste.

3. Oplist de tilgængelige indbyggede værktøjer og deres anvendelse.

Svar: web_search (real-tids information), code_interpreter (kør Python), image_generation (opret billeder), document_library (spørgsmål-svar på dine filer) – klar-til-brug funktionalitet, ingen implementering krævet.

4. Hvordan fungerer et multi-agent-system med overdragelser?

Svar: En router kvalificerer forespørgslen og sender den videre til den kompetente specialist-agent; hver agent forbliver simpel, orkestrering giver dækning – og overdragelser kædes i dybden.

5. Hvordan sikrer du agenter i produktion?

Svar: Med guardrails på input/output, snævert definerede værktøjer, sporbarhed af handlinger og menneskelig validering ved højrisikobeslutninger – autonomi optjenes gennem kontrol.

Specialiserede agenter, indbyggede værktøjer, routing, guardrails: Hele arkitekturen passer i fire ord – og dette kursus har fået dig til at bygge hver enkelt.