Claude Sonnet 4: Een praktische gids voor developers

Anthropic lanceerde onlangs de vernieuwde Claude Sonnet 4.5, Claude Agents SDK en Imagine with Claude.

Met de release van Claude Sonnet 4 hebben developers nu toegang tot krachtige nieuwe mogelijkheden—waaronder native code‑executie, een flexibele Files API en dynamisch toolgebruik. Deze features openen spannende mogelijkheden om AI‑applicaties te bouwen die verder gaan dan simpele tekstinteracties.

In deze tutorial neem ik je stap voor stap mee langs deze nieuwe features door een Python‑gebaseerde agent te bouwen die geavanceerde wiskundevragen direct vanuit je terminal kan oplossen. Je leert te werken met de nieuw geïntroduceerde native code‑executietool en de Files API.

Aan het einde heb je een werkende agent, aangedreven door Claude Sonnet 4, die problemen analyseert, Pythoncode schrijft en uitvoert, en visuals rendert zoals hieronder.

Bekijk the GitHub‑repository van dit project om alle code te zien voor het bouwen van de applicatie.

Als je net begint met bouwen met LLM’s zoals Claude, dan schetst deze AI‑developer roadmap de essentiële tools, skills en leerroutes om te starten.

Wat is er nieuw in de Anthropic API

Voordat we in de tutorial duiken, kijken we naar de recent uitgebrachte nieuwe features in de Anthropic API. Sla dit gerust over als je ze al kent.

Ik denk dat de gehele aankondiging van Claude 4 kan worden samengevat in deze ene afbeelding:

Claude 4‑modellen (Opus en Sonnet 4) verslaan de concurrentie met een aanzienlijke voorsprong op geverifieerde software‑engineeringtaken. Anthropic bereikte dit door een paar belangrijke wijzigingen in het modelgedrag door te voeren:

1. Lange runtimes: Beide modellen ondersteunen meerdere uren continue taakuitvoering om problemen met duizenden stappen op te lossen.
2. Uitgebreid redeneren met toolgebruik: Beide modellen kunnen nu tijdens uitgebreid denken tools gebruiken, zoals websearch, waardoor Claude kan afwisselen tussen redeneren en toolgebruik om antwoorden te verbeteren.
3. Parallelle toolexecutie: De modellen kunnen nu meerdere tools gelijktijdig in plaats van sequentieel gebruiken.
4. Nauwkeuriger instructieopvolging: Verbeterde stuurbaarheid geeft gebruikers meer controle over implementaties en hoe Claude op instructies reageert.
5. Verbeterde geheugencapaciteiten: Met toegang tot lokale bestanden kunnen de modellen kernfeiten extraheren en opslaan om continuïteit te behouden en impliciete kennis in de tijd op te bouwen.
6. Minder shortcut‑gedrag: In vergelijking met eerdere versies zijn beide modellen 65% minder geneigd om shortcuts of mazen te gebruiken om taken te voltooien (zie de volledige aankondiging voor meer details).

Daarnaast heeft Anthropic als onderdeel van de Claude 4‑modelfamilie vier nieuwe features toegevoegd voor het bouwen van AI‑agents: de code‑executietool, Files API, MCP‑connector en uitgebreide promptcaching. Deze tools veranderen hoe developers AI‑applicaties kunnen bouwen.

Code‑executietool: Voer Pythoncode veilig uit

De code‑executietool stelt Claude in staat om Pythoncode uit te voeren in een beveiligde sandboxomgeving. In plaats van alleen codevoorstellen te doen, kan Claude nu code uitvoeren, resultaten analyseren en itereren op oplossingen.

Om de code‑executietool te gebruiken, voeg je deze toe aan je tools‑array en neem je de vereiste beta‑header op:

from anthropic import Anthropic

# Initialize client with the code execution beta header
client = Anthropic(
   default_headers={
       "anthropic-beta": "code-execution-2025-05-22"
   }
)

# Send a request that triggers code execution
response = client.messages.create(
   model="claude-sonnet-4-20250514",
   max_tokens=4096,
   messages=[{
       "role": "user",
       "content": "Solve the quadratic equation 2x² + 5x - 3 = 0 and plot the parabola"
   }],
   tools=[{
       "type": "code_execution_20250522",
       "name": "code_execution"
   }]
)

Wanneer Claude code uitvoert, bevat het antwoord zowel de gegenereerde code als de uitvoerresultaten. Zo parse je de verschillende componenten:

# Parse the response to extract code and results
for item in response.content:
   if item.type == "server_tool_use":
       # This contains the actual Python code Claude wrote
       print(f"Code executed:\n{item.input['code']}")
   elif item.type == "code_execution_tool_result":
       # This contains the output from running the code
       print(f"Output:\n{item.content['stdout']}")
       if item.content.get('stderr'):
           print(f"Errors:\n{item.content['stderr']}")

Sandbox‑beperkingen: De code‑executieomgeving heeft diverse ingebouwde beveiligingsrestricties. Claude draait in een geïsoleerde container zonder internettoegang, met beperkte rekenmiddelen (1 GB RAM, 5 GB schijfruimte en 1 CPU) en kan je lokale bestandssysteem niet benaderen. De omgeving wordt geleverd met populaire libraries zoals numpy, pandas, matplotlib en scipy vooraf geïnstalleerd, maar je kunt tijdens de uitvoering geen extra packages installeren.

Files API: Persistente bestandscontext voor complexe taken

De Files API stelt je in staat om documenten één keer te uploaden en ze in meerdere conversaties te gebruiken. Zo hoef je geen grote documenten in elke API‑request mee te sturen.

Upload eerst je bestand naar de servers van Anthropic:

# Upload a file once - this stores it on Anthropic's servers
uploaded_file = client.beta.files.upload(
   file=open("sales_data.csv", "rb"),
   purpose="user_upload"
)
# The uploaded_file.id can now be referenced in multiple conversations

Na het uploaden verwijs je in je API‑calls naar het bestand met het container_upload‑contenttype:

# Reference the uploaded file in a conversation
response = client.messages.create(
   model="claude-sonnet-4-20250514",
   max_tokens=4096,
   messages=[{
       "role": "user",
       "content": [
           {"type": "text", "text": "Create a quarterly sales report from this data"},
           {"type": "container_upload", "file_id": uploaded_file.id}
       ]
   }],
   tools=[{
       "type": "code_execution_20250522",
       "name": "code_execution"
   }]
)

Wanneer Claude tijdens code‑executie bestanden aanmaakt (zoals plots of bewerkte data), kun je die extraheren en downloaden:

# Extract file IDs of any files Claude created during execution
def extract_created_files(response):
   file_ids = []
   for item in response.content:
       if item.type == 'code_execution_tool_result':
           content = item.content
           if content.get('type') == 'code_execution_result':
               # Look for file objects in the execution results
               for file_obj in content.get('content', []):
                   if 'file_id' in file_obj:
                       file_ids.append(file_obj['file_id'])
   return file_ids

# Download any files Claude created
created_files = extract_created_files(response)
for file_id in created_files:
   file_content = client.beta.files.download(file_id)
   file_content.write_to_file(f"output_{file_id}.png")

MCP‑connector: Koppel Claude aan elke workflow

De MCP‑connector brengt Model Context Protocol‑ondersteuning rechtstreeks naar de API. Met MCP’s kan Claude verbinden met externe services zoals databases, API’s en productiviteitstools zonder eigen integratiecode.

Voorheen vereiste de koppeling met MCP‑servers het bouwen van clientinfrastructuur. Nu kun je simpelweg een remote MCP‑server‑URL in je API‑request opgeven, en Claude ontdekt automatisch beschikbare tools, beheert verbindingen en regelt authenticatie.

Dit opent toegang tot een groeiend ecosysteem van MCP‑servers van bedrijven als Zapier en Asana, zodat je agents kunt bouwen die je agenda lezen, projectmanagementtools bijwerken of integreren met honderden andere services.

Aan de slag met Claude Sonnet 4: Projectoverzicht en setup

Nu we de nieuwe API‑features begrijpen, gaan we onze interactieve wiskunde‑oplosser bouwen. We combineren Claude’s code‑executiecapaciteiten met bestandsafhandeling tot een volledige wiskundige assistent.

Onze applicatie accepteert wiskundevragen in natuurlijke taal, voert Pythoncode uit om ze op te lossen, genereert visualisaties en slaat uitgebreide rapporten op.

Voor een gestructureerde aanpak van projecten als deze, bekijk de Developing AI Applications‑track.

> Let op: Omdat we lange codeblokken afwisselen met uitleg, kan de inspringing in snippets niet overal exact kloppen. We raden daarom aan om de GitHub‑repo van dit project in een apart tabblad te openen tijdens het volgen.

Stap 0: Richt je Claude Sonnet 4‑projectomgeving in

Voordat we code schrijven, zetten we de ontwikkelomgeving en dependencies op.

Maak een nieuwe directory voor je project en de benodigde bestanden:

mkdir math-solver
cd math-solver
touch math_solver.py demo_problems.py requirements.txt README.md

Maak een requirements.txt‑bestand met de benodigde dependencies:

anthropic>=0.42.0

Installeer de dependencies:

pip install -r requirements.txt

Stel je Anthropic API‑sleutel in als omgevingsvariabele:

export ANTHROPIC_API_KEY="your-api-key-here"

Stap 1: Ontwerp de applicatiestructuur

We beginnen met het maken van de basisstructuur van onze MathSolver‑klasse. Deze klasse handelt alle hoofdfuncties af: API‑communicatie, bestandsbeheer en gebruikersinteractie.

Eerst zetten we de imports en basisstructuur op:

#!/usr/bin/env python3
"""
Interactive Math Problem Solver using Claude 4 Code Execution Tool

This application allows users to ask math questions in natural language,
gets solutions using Claude's code execution capabilities, and saves
both visualizations and detailed markdown reports.
"""

import os
import json
import datetime
from pathlib import Path
from typing import List, Dict, Any
from anthropic import Anthropic

Nu definiëren we de hoofdklassestructuur:

class MathSolver:
   def __init__(self, api_key: str = None):
       """Initialize the Math Solver with Anthropic client."""
       # API setup and directory creation will go here
       pass

   def solve_problem(self, question: str) -> Dict[str, Any]:
       """Send a math question to Claude and get solution with code execution."""
       pass
Here are the methods for file and report handling:
def extract_files_from_response(self, response) -> List[str]:
       """Extract file IDs from Claude's response."""
       pass

   def download_files(self, file_ids: List[str]) -> List[str]:
       """Download files created by code execution to local storage."""
       pass

   def extract_code_blocks(self, response) -> List[str]:
       """Extract all code blocks from the response."""
       Pass

Tot slot voegen we sessiebeheer en het entrypoint toe:

def generate_markdown_report(self, result: Dict[str, Any], downloaded_files: List[str]) -> str:
       """Generate a comprehensive markdown report of the solution."""
       pass

   def run_interactive_session(self):
       """Run the main interactive session loop."""
       pass


def main():
   """Main entry point for the application."""
   pass

Deze structuur geeft een helder stappenplan: initialisatie, probleemoplossing, bestandsafhandeling, rapportgeneratie en gebruikersinteractie. Elke methode heeft een specifieke verantwoordelijkheid binnen onze wiskunde‑pipeline.

Een wiskunde‑oplosser bouwen met Claude Sonnet 4‑code‑executie

Laten we nu de kernfunctionaliteit implementeren met Claude’s code‑executietool en streamingantwoorden.

Stap 2: Initialiseer Claude met veilige API‑headers

We implementeren de __init__()‑methode voor het opzetten van de API‑client en het aanmaken van directories.

Eerst regelen we het beheer van de API‑sleutel:

def __init__(self, api_key: str = None):
   """Initialize the Math Solver with Anthropic client."""
   if not api_key:
       api_key = os.getenv("ANTHROPIC_API_KEY")
       if not api_key:
           raise ValueError(
               "Please set ANTHROPIC_API_KEY environment variable or provide api_key"
           )

Vervolgens zetten we de Anthropic‑client op met de vereiste beta‑headers:

# Initialize client with both code execution and files API headers
   self.client = Anthropic(
       api_key=api_key,
       default_headers={
           "anthropic-beta": "code-execution-2025-05-22,files-api-2025-04-14"
       },
   )

Tot slot maken we de outputdirectorystructuur aan:

# Create organized output directories
   self.output_dir = Path("math_solver_output")
   self.images_dir = self.output_dir / "images"
   self.reports_dir = self.output_dir / "reports"

   self.output_dir.mkdir(exist_ok=True)
   self.images_dir.mkdir(exist_ok=True)
   self.reports_dir.mkdir(exist_ok=True)

   print(f"📁 Output directories created:")
   print(f"   • Images: {self.images_dir}")
   print(f"   • Reports: {self.reports_dir}")

Deze initialisatie doet drie belangrijke dingen:

1. API‑sleutelbeheer: Controleert eerst op de sleutel in omgevingsvariabelen en valt anders terug op een parameter.
2. Clientsetup: Maakt een Anthropic‑client met beide beta‑headers voor code‑executie en Files API.
3. Directorystructuur: Maakt geordende mappen voor het opslaan van afbeeldingen en rapporten.

Stap 3: Schrijf de kernfunctie van de solver

De solve_problem()‑methode is het hart van onze applicatie. Deze verstuurt requests naar Claude met streamingondersteuning.

We beginnen met de functiedeclaratie en initiële setup:

def solve_problem(self, question: str) -> Dict[str, Any]:
   """
   Send a math question to Claude and get solution with code execution.
   """
   print(f"\n🤔 Thinking about: {question}")

   try:
       # Use streaming to show real-time progress
       with self.client.messages.stream(
           model="claude-sonnet-4-20250514",
           max_tokens=4096,
Now we configure the message and tool specification:
messages=[
               {
                   "role": "user",
                   "content": f"""Solve this math problem using code execution:

Problem: {question}

Please:
1. Solve the problem with actual Python code
2. Create visualizations using matplotlib if helpful
3. Save any plots as PNG files using plt.savefig()
4. Show your calculations step by step
5. Use descriptive filenames for saved plots

Execute Python code to solve this problem.""",
               }
           ],
           tools=[{"type": "code_execution_20250522", "name": "code_execution"}],
       ) as stream:
The streaming event processing handles real-time updates:
print("\n💭 Claude is working...")

           # Process streaming events and show progress
           for event in stream:
               if event.type == "content_block_start":
                   if hasattr(event.content_block, "type"):
                       if event.content_block.type == "text":
                           print("\n📝 Response:", end=" ", flush=True)
                       elif event.content_block.type == "server_tool_use":
                           print(f"\n🔧 Using tool: {event.content_block.name}")

We verwerken verschillende types streamingevents:

	elif event.type == "content_block_delta":
                   if hasattr(event.delta, "text"):
                       print(event.delta.text, end="", flush=True)

               elif event.type == "content_block_stop":
                   print("", flush=True)  # New line

               elif event.type == "message_delta":
                   if hasattr(event.delta, "stop_reason"):
                       print(f"\n✅ Completed: {event.delta.stop_reason}")

Tot slot retourneren we het resultaat of handelen we errors af:

	# Get the final message
           final_message = stream.get_final_message()

           return {
               "response": final_message,
               "question": question,
               "timestamp": datetime.datetime.now().isoformat(),
           }

   except Exception as e:
       print(f"❌ Error solving problem: {e}")
       return None

Deze functie laat een paar belangrijke concepten zien:

• Streamingondersteuning: We gebruiken client.messages.stream() in plaats van client.messages.create() om realtime feedback te krijgen terwijl Claude aan het probleem werkt.
• Eventafhandeling: De streaming‑API stuurt verschillende eventtypes:
• content_block_start: wanneer Claude begint met tekstschrijven of een tool gebruikt
• content_block_delta: terwijl content wordt gegenereerd
• content_block_stop: wanneer een contentblok klaar is
• message_delta: wanneer het volledige bericht is afgerond
• Toolspecificatie: We nemen de code‑executietool op in de tools‑array met exact het type "code_execution_20250522".
• Gestructureerde prompting: Onze prompt instrueert Claude duidelijk om code‑executie te gebruiken en eventuele visualisaties op te slaan.

Stap 4: Los wiskundeproblemen op met streaming code‑executie

Wanneer Claude tijdens code‑executie bestanden aanmaakt (zoals matplotlib‑plots), moeten we hun file‑ID’s extraheren en ze lokaal downloaden.

De methode voor bestandsextractie navigeert door de responsstructuur:

def extract_files_from_response(self, response) -> List[str]:
   """Extract file IDs from Claude's response."""
   file_ids = []

   for item in response.content:
       if item.type == "code_execution_tool_result":
           content_item = item.content
          
           if isinstance(content_item, dict):
               if content_item.get("type") == "code_execution_result":
                   content_list = content_item.get("content", [])

Daarna zoeken we in de content naar file‑ID’s:

  for file_item in content_list:
                       if isinstance(file_item, dict) and "file_id" in file_item:
                           file_ids.append(file_item["file_id"])

   return file_ids

Het downloadproces haalt bestanden op en slaat ze lokaal op:

def download_files(self, file_ids: List[str]) -> List[str]:
   """Download files created by code execution to local storage."""
   downloaded_files = []

   for file_id in file_ids:
       try:
           # Get file metadata and download content
           file_metadata = self.client.beta.files.retrieve_metadata(file_id)
           filename = file_metadata.filename
          
           file_content = self.client.beta.files.download(file_id)
           local_path = self.images_dir / filename
           file_content.write_to_file(str(local_path))

We houden gedownloade bestanden bij en handelen errors af:

downloaded_files.append(str(local_path))
           print(f"✅ Downloaded: {filename}")

       except Exception as e:
           print(f"❌ Error downloading file {file_id}: {e}")

   return downloaded_files

• Logica voor bestandsextractie: De methode extract_files_from_response() navigeert door de responsstructuur om file‑ID’s te vinden. Code‑executieresultaten zijn genest in een specifiek formaat waarbij bestanden verschijnen in de content‑array.
• Proces voor bestandsdownload: De download_files()‑methode:
• Haalt metadata op voor elk bestand (inclusief de oorspronkelijke bestandsnaam)
• Downloadt de bestandsinhoud via de Files API
• Slaat bestanden op in onze geordende directorystructuur
• Retourneert een lijst met lokale bestandspaden voor later gebruik