Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Redeneren in agents en conversaties

Les 4 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Drie manieren om een redeneermodel aan te roepen
  2. Een agent die redeneert
  3. Conversatie-uitvoer lezen
  4. Een conversatie zonder agent
  5. Redeneren en tools
  6. Vergelijking van de drie benaderingen
  7. Best practices voor integratie
  8. Belangrijkste punten

Les herschreven op 2 november 2026 voor Mistral Small 4 en Large 4. De documentatie van Mistral stelt dat reasoning_effort beschikbaar is op de Agents- en Conversations-endpoints binnen het veld completion_args. Bronnen: Reasoning · Python SDK — Conversations.

Drie manieren om een redeneermodel aan te roepen

Eerdere lessen maakten gebruik van de Chat Completions API: u stuurde bij elke oproep de volledige geschiedenis mee en plaatste reasoning_effort direct in het verzoek. Mistral biedt twee andere interfaces: de Agents API, die een herbruikbare configuratie opslaat (model, instructies, tools, parameters), en de Conversations API, die de geschiedenis op de server bewaart. Bij deze twee API’s stelt u het redeneerniveau niet op het hoogste niveau in; u nestelt het binnen completion_args, samen met andere generatieparameters.

Een agent die redeneert

Door het redeneerniveau in de agentdefinitie in te stellen, voorkomt u dat u dit bij elke oproep hoeft te herhalen en zorgt u ervoor dat uw hele team dezelfde instelling gebruikt:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

agent = client.beta.agents.create(
    model="mistral-small-2603",
    name="Financial Analyst",
    instructions=(
        "You analyze financial situations for SMEs. "
        "End every response with a quantified recommendation and its assumptions."
    ),
    completion_args={"reasoning_effort": "high"},
)

reponse = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Our working capital requirement has doubled in a year while revenue grew by 15%. What should we look at first?",
)

Conversatie-uitvoer lezen

Een conversatie geeft geen choices terug; het retourneert een lijst met items (outputs). Het antwoord van het model bevindt zich in items van het type message.output. Net als bij Chat Completions is de inhoud een string of een lijst met chunks die een ThinkChunk kunnen bevatten. De functie separer uit Les 3 werkt precies zoals eerder:

for entry in reponse.outputs:
    if entry.type == "message.output":
        reflexion, texte = separer(entry.content)
        print(texte)

Andere items beschrijven wat er tijdens de beurt is gebeurd, zoals tool-uitvoering (tool.execution) of een functieaanroep. Negeer deze als u alleen geïnteresseerd bent in het eindantwoord.

Een conversatie zonder agent

Voor eenmalige taken accepteert de Conversations API direct een model, zonder voorafgaande agent-configuratie. De server bewaart de geschiedenis en u zet de uitwisseling voort met conversations.append, waarbij u het redeneerniveau voor een specifieke beurt indien nodig aanpast:

conv = client.beta.conversations.start(
    model="mistral-large-4-0",
    inputs="Propose a migration plan for a 2 TB PostgreSQL database with zero downtime.",
    completion_args={"reasoning_effort": "high"},
)

suite = client.beta.conversations.append(
    conversation_id=conv.conversation_id,
    inputs="Summarize this plan in five steps for executive leadership.",
    completion_args={"reasoning_effort": "low"},   # a summary doesn't need deep reflection
)

Dit is een concreet voordeel ten opzichte van Chat Completions, waar de documentatie vereist dat u het volledige bericht van de assistent, inclusief reflectie, bij elke nieuwe beurt opnieuw afspeelt (Les 7). Met de Conversations API bewaart de server de geschiedenis; u hoeft deze niet bij elke oproep opnieuw te verzenden.

Redeneren en tools

Een agent kan redeneren en tools combineren: tools en completion_args zijn onafhankelijke velden bij het aanmaken van een agent. Een analyse-agent kan zo webzoekopdrachten en diepgaand redeneren combineren:

agent_veille = client.beta.agents.create(
    model="mistral-small-2603",
    name="Competitive Intelligence",
    instructions="You compare competitor offers using cited public sources.",
    tools=[{"type": "web_search"}],
    completion_args={"reasoning_effort": "high"},
)

Houd echter rekening met de kosten: reflectie en tool-aanroepen tellen samen op in de rekening voor een enkele beurt.

Vergelijking van de drie benaderingen

CriteriumChat CompletionsAgentsConversations
Waar redeneren instellenreasoning_effort in het verzoekcompletion_args in de agentcompletion_args in start of append
GeschiedenisBij elke oproep opnieuw verzenden, inclusief reflectieGedragen door de conversatieBewaard op de server
Ingebouwde tools (web_search…)NeeJaJa
Typisch gebruikEenmalige oproepen, volledige controleGedeelde, herbruikbare configuratieUitwisselingen in meerdere beurten

Best practices voor integratie

Stel het redeneerniveau in de agent in wanneer de taak uniform is, en per beurt wanneer deze varieert: een initiële analysebeurt op high, gevolgd door herformuleringsbeurten op low of none, afhankelijk van het model. Verifieer dat de waarde geschikt is voor het model van de agent: Small 4 accepteert high en none; Large 4 accepteert low, medium en high. Log tot slot het tokengebruik per beurt; dit is de enige manier om te weten of redeneren lonend is voor uw use case.

Belangrijkste punten

  • Geef in de Agents- en Conversations-API’s reasoning_effort door binnen completion_args
  • Antwoorden komen binnen in outputs; tekst bevindt zich in items van het type message.output, inclusief reflectie
  • De Conversations API bewaart de geschiedenis op de server: geen behoefte om deze bij elke beurt opnieuw te verzenden
  • U kunt het niveau bij elke beurt wijzigen met conversations.append
  • Een agent kan ingebouwde tools en redeneren combineren, tegen de kosten van cumulatiever gebruik