Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

code_interpreter Tool: Python uitvoeren

Les 9 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Code uitvoeren in de Mistral Cloud
  2. Een agent maken met Code Interpreter
  3. Een uitvoering activeren
  4. Responsstructuur
  5. Wat de tool in de praktijk verandert
  6. Combineren met andere tools
  7. Beperkingen van de sandbox
  8. Belangrijkste punten

Code uitvoeren in de Mistral Cloud

Met de tool code_interpreter kan uw agent Python-code schrijven en uitvoeren binnen een gesandboxde container. Dit is de ideale keuze voor berekeningen, data-analyse, het genereren van grafieken en codevalidatie. Het gaat hier niet alleen om gemak: een LLM die in zijn hoofd “rekent”, produceert een plausibel resultaat, geen correct resultaat. Door de bewerking over te dragen aan een echte interpreter, vervangt u token-voorspelling door verifieerbare uitvoering, wat u code oplevert die u kunt controleren.

Een agent maken met Code Interpreter

De instructies voor deze agent vereisen dat de code wordt getoond voordat deze wordt uitgevoerd, zodat u controle heeft over wat er daadwerkelijk draait.

from mistralai.client import Mistral
import os

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

agent = client.beta.agents.create(
    model="mistral-medium-latest",
    name="Code Agent",
    instructions="""You are a Python programming assistant.
- Use the code interpreter to run code when necessary
- Always show the code before executing it
- Explain results clearly""",
    tools=[{"type": "code_interpreter"}],
    completion_args={"temperature": 0.3, "top_p": 0.95}
)

Een uitvoering activeren

Een eenvoudig verzoek tot berekening volstaat om de tool te activeren; er is geen speciale instructie van uw kant nodig.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Calculate the first 20 Fibonacci numbers."
)

De agent schrijft vervolgens een Python-script om de reeks te berekenen, voert dit uit in de sandbox en presenteert de resultaten samen met uitleg. De twintig waarden die u ontvangt, komen voort uit daadwerkelijke uitvoering: ze zijn exact, zelfs voorbij het punt waar een model doorgaans fouten begint te maken.

Responsstructuur

U kunt dit mechanisme direct aflezen in de geretourneerde items; uw code moet onderscheid maken tussen tekst en uitvoeringsresultaten.

for entry in response.outputs:
    if entry.type == "message.output":
        # First response: "I will calculate..." or final result
        print(f"Message: {entry.content}")

    elif entry.type == "tool.execution":
        # Executed code and result
        print(f"Code: {entry.info.code}")
        print(f"Output: {entry.info.code_output}")

De agent begint met een message.output waarin wordt aangekondigd wat er gaat gebeuren. Daarna volgt de tool.execution waarin de code draait: info.code bevat het script en info.code_output bevat de uitvoer. Een tweede message.output sluit de reeks af, waarin de agent de resultaten interpreteert en uitlegt. Deze twee velden, info.code en info.code_output, vormen uw audittrail; bewaar ze in uw applicatielogs, zodat u elk door de agent geproduceerd cijfer kunt reproduceren en betwisten.

Wat de tool in de praktijk verandert

Data-analyse is de meest voor de hand liggende use case. Lever een reeks waarden aan en vraag om statistieken: het gemiddelde, de mediaan en de standaardafwijking worden berekend, niet geschat.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="""Here are the monthly sales (in K€): 
    Jan: 120, Feb: 135, Mar: 142, Apr: 128, May: 155, Jun: 168
    Calculate the mean, median, standard deviation, and trend."""
)

Het genereren van grafieken sluit hier naadloos op aan, aangezien de omgeving plotting-bibliotheken bevat.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Create a bar chart of cloud market shares in Europe: AWS 31%, Azure 25%, GCP 11%, OVH 8%, Others 25%"
)

De agent gebruikt matplotlib om de grafiek te genereren. Het resultaat is een afbeeldingsbestand dat toegankelijk is in de respons; zorg er dus voor dat uw leescode dit geval afhandelt, anders toont u alleen de begeleidende tekstcommentaar.

Codevalidatie is een derde use case, minder voor de hand liggend maar waardevol. Dien een functie in samen met de te dekken testcases: de agent redeneert niet alleen over de code, maar voert deze ook uit. In het onderstaande voorbeeld onthult de input "Madam" een fout die bij een simpele code-review waarschijnlijk over het hoofd zou worden gezien.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="""Check if this function is correct:
    
def is_palindrome(s):
    return s == s[::-1]

Test it with: "radar", "hello", "kayak", "Madam"
"""
)

Toegepaste wiskunde rondt de lijst af: het oplossen van stelsels vergelijkingen, lineaire algebra, optimalisatie. Ook hier berust de respons op een solver, niet op intuïtie.

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Solve the system of equations: 2x + 3y = 12, 4x - y = 5"
)

Combineren met andere tools

Een agent kan meerdere tools tegelijkertijd ingeschakeld hebben; hier zit vaak de echte meerwaarde: search haalt verse data op die code vervolgens omzet in analyse.

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Complete Analyst",
    description="Search + Calculation",
    instructions="Search for recent data then analyze it with code.",
    tools=[
        {"type": "web_search"},
        {"type": "code_interpreter"}
    ]
)

response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Find the current price of Bitcoin and calculate its percentage change over the last 30 days."
)

De agent kiest automatisch welke tool hij in elke stap gebruikt. Bij dit verzoek koppelt hij de twee: u kunt geen verandering berekenen zonder eerst de waarden op te halen, en u kunt die waarden niet ophalen zonder webtoegang.

Beperkingen van de sandbox

Deze geïsoleerde omgeving legt beperkingen op die u moet kennen voordat u uw applicatie ontwerpt. Bibliotheken zijn beperkt: standaard Python-pakketten zijn beschikbaar—numpy, pandas, matplotlib, onder andere—maar niet alle third-party pakketten, wat uw interne afhankelijkheden uitsluit. De code heeft geen netwerktoegang, dus data moet via context of een andere tool bij de code komen, nooit via een HTTP-call die in het script is geschreven. De uitvoeringstijd is begrensd, dus langlopende processen worden onderbroken: splits grote volumes op in plaats van te hopen op één enkele run. Tot slot is er geen persistentie tussen calls; een bestand dat tijdens één uitvoering is gemaakt, wordt bij de volgende niet gevonden.

Belangrijkste punten

  • code_interpreter voert Python uit in een beveiligde sandbox aan de kant van Mistral
  • De respons bevat de uitgevoerde code (info.code) en de uitvoer (info.code_output)
  • Ideaal voor berekeningen, data-analyse en het genereren van grafieken
  • Kan worden gecombineerd met andere tools (web_search, enz.)
  • De sandbox heeft beperkingen: geen netwerktoegang, beperkte bibliotheken, geen persistentie