Bästa praxis och nästa steg
På denna sida
Vad du har lärt dig
Du har gått igenom hela Mistral Agents API. Låt oss repetera innan vi dyker ner i produktionspraxis, eftersom varje del av denna kurs bygger på den föregående.
De tre första lektionerna lade grunden: en AI-agent är ett autonomt system med en perception-handling-loop; API:t vilar på tre objekt – Agent, Conversation och Entry; och det som skiljer en agent från en chattbot är uthållighet, verktyg och överlämningar. Lektion 4 till 7 gjorde dessa objekt användbara: skapa och konfigurera agenter med client.beta.agents.create(), upprätthåll uthålliga konversationer med conversations.start() och conversations.append(), och använd direktläge utan en agent när du prototyper och uthållighet inte tillför något värde.
Lektion 8 till 11 lade till funktioner. web_search ger dig tillgång till aktuell information med automatiska källhänvisningar; code_interpreter kör Python i en sandlåda, vilket ger agenten exakta resultat där modellen ensam bara skulle approximera; image_generation producerar visuellt innehåll från textprompter; document_library bringar integrerad RAG till dina egna dokument. Lektion 12 till 16 visade sedan hur flera agenter arbetar tillsammans: överlämningar överför kontrollen från en agent till en annan, referensarkitekturen parar ihop en central router med specialister, serverläge automatiserar där klientläge håller dig i loopen, och obegränsad kedjebildning bryts ner i linjära, stjärnformade och hybrida mönster. Slutligen rundade lektion 17 av allt med skyddsräcken, principen om minsta privilegium och upstream-moderering.
Att designa agenter som håller
En mening fångar hela kursen: en agent, ett ansvar, en beskrivning som säger när den ska anropas. Kontrasten nedan gör skillnaden påtaglig.
# BRA — specialiserad agent med precis beskrivning
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ÅLIGT — generell, 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 andra agenten kommer att misslyckas på två sätt samtidigt. Ingen router vet när den ska överlämna en begäran till den, eftersom “en hjälpsam agent” inte beskriver någon situation. Och när den väl anropas, låter dess tre verktyg den fritt söka på webben efter något den borde ha beräknat, eller illustrera något den blev ombedd att analysera.
Hantering av fel
Nätverksanrop misslyckas förr eller senare. Ett försök med exponentiell backoff absorberar övergående incidenter utan att vända en tillfällig nedgång till ett synligt avbrott.
import time
def safe_conversation(agent_id, query, max_retries=3):
"""Conversation with error handling and retry."""
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) # Exponential backoff
return None
Exponentiell backoff – en sekund, sedan två, sedan fyra – skiljer en civiliserad återhämtning från att hamra på en tjänst som redan kämpar. Notera också att det sista försöket återkastar undantaget istället för att returnera None: din anropare behöver veta att operationen misslyckades.
Att se vad som händer
I produktion blir ett fleragentsarbetsflöde du inte kan observera omöjligt att felsöka. Klientläge ger dig exakt de krokar du behöver.
import logging
import time
logger = logging.getLogger("agents")
def monitored_conversation(agent_id, query):
"""Conversation with monitoring."""
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
Dessa två räknare är värda mer än deras enkelhet antyder: en avdrift i det genomsnittliga antalet överlämningar signalerar en router som tvekar; en topp i verktygsanrop pekar på dyra förfrågningar.
Kostnadskontroll handlar sedan om konkreta beslut. Övervaka tokens per konversation, eftersom det är den verkliga debiteringsenheten. Använd mistral-medium-latest överallt där mistral-large-latest inte tillför något – den första supportnivån är ett skolboksexempel. Sätt tak för max_tokens i completion_args för att undvika oändliga svar på enkla frågor, och inaktivera lagring med store=False när uthållighet inte krävs.
Testa routning
Testa ett fleragentsystem som vilken växel som helst: mata det med fall där du känner till det förväntade målet, och verifiera var de hamnar.
def test_agent_routing():
"""Verifies that the router distributes correctly."""
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}"
Bygg denna testsuite över tid: varje felroutad begäran du fångar i produktion blir en ny rad i test_cases, och du kommer att veta att en omskrivning av en beskrivning fixar det riktade fallet utan att bryta ett annat.
Referensarkitektur
För ett produktionsprojekt är här en rekommenderad 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 sammanför allt från denna kurs: moderatorn filtrerar innan någon exekvering, routern dirigerar utan att någonsin svara själv, varje specialist bär på ett verktyg och ett ansvar, och observation omsluter hela systemet.
Vart du går härnäst
Fyra riktningar utökar vad du kan göra nu. Function calling låter dig bygga dina egna anpassade verktyg bortom de inbyggda: anropa ett affärs-API, fråga en databas, trigga en intern tjänst. MCP Servers integrerar Model Context Protocol, vilket standardiserar hur verktyg exponeras. Structured outputs tvingar svar in i ett JSON-schema, vilket förändrar allt när en agents output matar ett annat system snarare än en mänsklig läsare. Slutligen returnerar streaming svar i realtid istället för i ett block – avgörande vid långa kedjor, där tyst väntan blir obekväm.
Tre resurser åtföljer detta nästa steg: den officiella dokumentationen på docs.mistral.ai/agents, Mistral-cookbooks som tillhandahåller kompletta implementeringsexempel, och API-referensen som dokumenterar varje slutpunkt i detalj.
Viktiga punkter
- Specialisera dina agenter – en agent = ett ansvar
- Övervaka – logga varje överlämning och verktygsexekvering
- Testa – validera routning och varje agents svar
- Säkra – skyddsräcken, minsta privilegium, upstream-moderering
- Optimera kostnader – rätt storlek på modell, max_tokens, store=False när möjligt
- Mistral Agents är i beta – håll dig uppdaterad med API-förändringar
Testa dina kunskaper
Agenter, inbyggda verktyg, överlämningar: har Agents API några blindfläckar kvar?
1. När är en agent nödvändig – och när räcker en chattbot?
Svar: En agent är motiverad när du behöver verktyg, uthållighet och beslut i flera steg; för enkel fråga-svar räcker en standardkonversation – arkitekturen följer behovet.
2. Vad hanterar uthålliga konversationer i Agents API?
Svar: Historik på Mistral-sidan: du fortsätter en konversation via dess ID utan att skicka om hela kontexten – tillståndet blir en tjänst.
3. Lista de inbyggda verktygen som finns tillgängliga och deras användning.
Svar: web_search (realtidsinformation), code_interpreter (kör Python), image_generation (skapa bilder), document_library (fråga-svar på dina filer) – färdiga funktioner, ingen implementering krävs.
4. Hur fungerar ett fleragentsystem med överlämningar?
Svar: En router kvalificerar begäran och skickar den till den kompetenta specialistagenten; varje agent förblir enkel, orkestrering ger täckning – och överlämningar kedjas på djupet.
5. Hur säkrar du agenter i produktion?
Svar: Med skyddsräcken på indata/utdata, snävt avgränsade verktyg, spårbarhet för åtgärder och mänsklig validering vid beslut med hög insats – autonomi förtjänas genom kontroll.
Specialiserade agenter, inbyggda verktyg, routning, skyddsräcken: hela arkitekturen ryms i fyra ord – och denna kurs fick dig att bygga var och en av dem.