Best Practices en vervolgstappen
Op deze pagina
Wat u heeft behandeld
U heeft de volledige Mistral Agents API doorlopen. Laten we een samenvatting maken voordat we ingaan op productiewerkwijzen, aangezien elk onderdeel van deze cursus voortbouwt op het vorige.
De eerste drie lessen legden de basis: een AI-agent is een autonoom systeem met een perceptie-actielus; de API rust op drie objecten—Agent, Conversation en Entry; en wat een agent onderscheidt van een chatbot is persistentie, tools en overdrachten (handoffs). Lessen 4 tot en met 7 maakten deze objecten bruikbaar: agents maken en configureren met client.beta.agents.create(), persistente conversaties onderhouden met conversations.start() en conversations.append(), en het gebruik van de directe modus zonder agent wanneer u prototypeert en persistentie geen meerwaarde biedt.
Lessen 8 tot en met 11 voegden mogelijkheden toe. web_search geeft u toegang tot actuele informatie met automatische citaten; code_interpreter draait Python in een sandbox, waardoor de agent exacte resultaten krijgt waar het model alleen zou benaderen; image_generation produceert visualisaties op basis van tekstprompts; document_library brengt geïntegreerde RAG naar uw eigen documenten. Lessen 12 tot en met 16 toonden vervolgens hoe meerdere agents samenwerken: overdrachten dragen de controle over van de ene agent naar de andere, de referentiearchitectuur koppelt een centrale router aan specialisten, servermodus automatiseert waar clientmodus u in de lus houdt, en onbeperkte ketenvorming splitst op in lineaire, ster- en hybride patronen. Tot slot rondde les 17 alles af met guardrails, het principe van de minste bevoegdheid en upstream-moderatie.
Agents ontwerpen die standhouden
Één zin vat de hele cursus samen: één agent, één verantwoordelijkheid, één beschrijving die zegt wanneer deze aangeroepen moet worden. Het onderstaande contrast maakt het verschil tastbaar.
# GOED — gespecialiseerde agent met precieze beschrijving
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]}]
)
# SLECHT — generieke, vage 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"}]
)
De tweede agent zal op twee manieren tegelijk falen. Geen enkele router zal weten wanneer een verzoek aan deze agent moet worden overgedragen, omdat “een behulpzame agent” geen enkele situatie beschrijft. En wanneer deze wel wordt aangeroepen, laten de drie tools hem vrij om op het web te zoeken naar iets dat hij had moeten berekenen, of om iets te illustreren waarvoor hij gevraagd werd te analyseren.
Foutafhandeling
Netwerkaanroepen falen vroeg of laat. Een retry-mechanisme met exponentiële backoff absorbeert tijdelijke incidenten zonder dat een momentele vertraging uitgroeit tot een zichtbare storing.
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
Exponentiële backoff—één seconde, dan twee, dan vier—maakt het verschil tussen een beschaafde retry en het hameren op een service die het al moeilijk heeft. Merk ook op dat de laatste poging de exception opnieuw gooit in plaats van None terug te geven: uw aanroeper moet weten dat de bewerking is mislukt.
Zien wat er gebeurt
In productie wordt een multi-agent workflow die u niet kunt observeren onmogelijk om te debuggen. De clientmodus geeft u precies de hooks die u nodig heeft.
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
Die twee tellers zijn meer waard dan hun eenvoud suggereert: een verschuiving in het gemiddelde aantal overdrachten signaleert een router die aarzelt; een piek in tool-aanroepen wijst op dure queries.
Kostenbeheersing komt dan neer op concrete beslissingen. Monitor tokens per conversatie, aangezien dat de echte factureerbare eenheid is. Gebruik mistral-medium-latest waar mistral-large-latest niets toevoegt—het eerste supportniveau is een schoolvoorbeeld daarvan. Begrens max_tokens in completion_args om eindeloze antwoorden op simpele vragen te voorkomen, en schakel opslag uit met store=False wanneer persistentie niet vereist is.
Routing testen
Test een multi-agent systeem zoals elke telefooncentrale: voer cases in waarvan u de verwachte bestemming kent, en verifieer waar ze landen.
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}"
Bouw deze testsuite na verloop van tijd uit: elke verkeerd gerouteerde aanvraag die u in productie vangt, wordt een extra regel in test_cases, en u zult weten dat het herschrijven van een beschrijving de gerichte case oplost zonder een andere te breken.
Referentiearchitectuur
Voor een productieproject is hier een aanbevolen architectuur:
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
Dit brengt alles samen uit deze cursus: de moderator filtert voordat enige uitvoering plaatsvindt, de router stuurt door zonder ooit zelf antwoord te geven, elke specialist draagt één tool en één verantwoordelijkheid, en observatie omhult het hele systeem.
Waar nu naartoe?
Vier richtingen breiden uit wat u nu kunt doen. Function calling laat u uw eigen custom tools bouwen naast de ingebouwde: roep een business-API aan, query een database, trigger een interne service. MCP Servers integreren het Model Context Protocol, dat standaardiseert hoe tools worden blootgesteld. Structured outputs dwingen antwoorden in een JSON-schema, wat alles verandert wanneer de output van een agent een ander systeem voedt in plaats van een menselijke lezer. Tot slot geeft streaming antwoorden in real-time terug in plaats van in één blok—doorslaggevend bij lange ketens, waar stil wachten ongemakkelijk wordt.
Drie bronnen begeleiden deze volgende stap: de officiële documentatie op docs.mistral.ai/agents, de Mistral cookbooks die complete implementatievoorbeelden bieden, en de API Reference die elk endpoint tot in detail documenteert.
Belangrijkste punten
- Specialiseer uw agents—één agent = één verantwoordelijkheid
- Monitor—log elke overdracht en tool-uitvoering
- Test—valideer routing en de antwoorden van elke agent
- Beveilig—guardrails, minste bevoegdheid, upstream-moderatie
- Optimaliseer kosten—model op maat, max_tokens, store=False waar mogelijk
- Mistral Agents bevinden zich in beta—houd API-wijzigingen bij
Test uw kennis
Agents, ingebouwde tools, overdrachten: heeft de Agents API nog blinde vlekken?
1. Wanneer is een agent noodzakelijk—en wanneer volstaat een chatbot?
Antwoord: Een agent is gerechtvaardigd wanneer u tools, persistentie en meerstapsbeslissingen nodig heeft; voor simpele Q&A volstaat een standaard conversatie—de architectuur volgt de behoefte.
2. Wat beheren persistente conversaties in de Agents API?
Antwoord: Geschiedenis aan de kant van Mistral: u zet een conversatie voort via zijn ID zonder de volledige context opnieuw te verzenden—de state wordt een service.
3. Noem de beschikbare ingebouwde tools en hun gebruik.
Antwoord: web_search (real-time informatie), code_interpreter (Python uitvoeren), image_generation (afbeeldingen maken), document_library (Q&A over uw bestanden)—kant-en-klare mogelijkheden, geen implementatie vereist.
4. Hoe werkt een multi-agent systeem met overdrachten?
Antwoord: Een router kwalificeert het verzoek en geeft het door aan de bevoegde specialist-agent; elke agent blijft simpel, orchestratie biedt dekking—en overdrachten ketenen in de diepte.
5. Hoe beveiligt u agents in productie?
Antwoord: Met guardrails op inputs/outputs, nauw afgebakende tools, traceerbaarheid van acties en menselijke validatie bij beslissingen met hoge stakes—autonomie wordt verdiend door controle.
Gespecialiseerde agents, ingebouwde tools, routing, guardrails: de complete architectuur past in vier woorden—en deze cursus liet u elk onderdeel bouwen.