Claude Sonnet 4: Ein praktischer Leitfaden für Entwickler

Mit der Veröffentlichung von Claude Sonnet 4 haben Entwicklerinnen und Entwickler jetzt Zugang zu leistungsstarken neuen Funktionen - darunter die Ausführung von nativem Code, eine flexible Datei-API und die dynamische Nutzung von Tools. Diese Funktionen eröffnen spannende Möglichkeiten für die Entwicklung von KI-gesteuerten Anwendungen, die über einfache Textinteraktionen hinausgehen.

In diesem Tutorial führe ich dich durch diese neuen Funktionen, indem ich einen Python-basierten Agenten baue, der fortgeschrittene mathematische Probleme direkt von deinem Terminal aus lösen kann. Du lernst, wie dudas neu eingeführte Werkzeug zur Ausführung von nativem Code und die Datei-API verwendest.

Am Ende wirst du einen funktionierenden Agenten haben, der von Claude Sonnet 4 angetrieben wird, um Probleme zu analysieren, Python-Code zu schreiben und auszuführen und visuelle Darstellungen wie die untenstehenden zu erstellen.

Im GitHub-Repository für dieses Projekt findest duden gesamten Code für die Erstellung der Anwendung.

Wenn du gerade erst anfängst, mit LLMs wie Claude zu bauen, zeigt dir diese Roadmap für KI-Entwickler/innen diewichtigsten Tools, Fähigkeiten und Lernwege für den Einstieg.

Was ist neu in der Anthropic API?

Bevor wir uns dem Tutorial widmen, werfen wir einen Blick auf die kürzlich veröffentlichten neuen Funktionen, die über die Anthropic API verfügbar sind. Wenn du sie schon kennst, kannst du sie gerne überspringen.

Ich denke, die gesamte Ankündigung von Claude 4 lässt sichin diesem einen Bild zusammenfassen:

Die Claude 4 Modelle (Opus und Sonnet 4) schlagen die Konkurrenz bei verifizierten Softwareentwicklungsaufgaben mit deutlichem Abstand. Anthropic hat dieses Kunststück vollbracht, indem es einige wichtige Änderungen am Verhalten der Modelle vorgenommen hat:

1. Lange Laufzeiten: Beide Modelle unterstützen mehrere Stunden kontinuierliche Aufgabenausführung, um Probleme mit Tausenden von Schritten zu lösen.
2. Erweitertes Denken mit Werkzeugeinsatz: Beide Modelle können nun Werkzeuge wie die Websuche während des erweiterten Denkens nutzen, so dass Claude zwischen dem Denken und der Nutzung von Werkzeugen abwechseln kann, um die Antworten zu verbessern.
3. Parallele Werkzeugausführung: Die Modelle können jetzt mehrere Werkzeuge gleichzeitig und nicht mehr nacheinander verwenden.
4. Eine genauere Anleitung findest du unter: Die verbesserte Steuerbarkeit gibt den Nutzern mehr Kontrolle über die Umsetzung und darüber, wie Claude auf Anweisungen reagiert.
5. Verbesserte Speichermöglichkeiten: Wenn die Modelle Zugriff auf lokale Dateien erhalten, können sie wichtige Fakten extrahieren und speichern, um die Kontinuität zu wahren und stillschweigendes Wissen über die Zeit aufzubauen.
6. Reduziertes Shortcut-Verhalten: Im Vergleich zu den Vorgängerversionen ist die Wahrscheinlichkeit, dass beide Modelle Abkürzungen oder Schlupflöcher nutzen, um Aufgaben zu erledigen, um 65 % gesunken (weitere Details findest du im vollständigen Ankündigungspost).

Im Rahmen der Ankündigung der Claude 4-Modellfamilie hat Anthropic außerdem vier neue Funktionen für hinzugefügt, mit denen KI-Agenten erstellt werden können: das Code-Ausführungs-Tool, die Datei-API, der MCP-Connector und das erweiterte Prompt-Caching. Diese Tools verändern die Art und Weise, wie Entwickler KI-Anwendungen erstellen können.

Werkzeug zur Codeausführung: Python-Code sicher ausführen

Mit dem Code-Ausführungstool Claude kannst du Python-Code in einer sicheren Sandbox-Umgebung ausführen. Anstatt nur Codevorschläge zu schreiben, kann Claude jetzt Code ausführen, die Ergebnisse analysieren und Lösungen iterieren.

Um das Tool zur Codeausführung zu verwenden, füge es zu deinem tools Array hinzu und füge den erforderlichen Beta-Header ein:

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"
   }]
)

Wenn Claude einen Code ausführt, enthält die Antwort sowohl den erzeugten Code als auch die Ergebnisse der Ausführung. Hier erfährst du, wie du die verschiedenen Komponenten analysierst:

# 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-Einschränkungen: Die Code-Ausführungsumgebung hat mehrere eingebaute Sicherheitsbeschränkungen. Claude läuft in einem isolierten Container ohne Internetzugang, mit begrenzten Rechenressourcen (1 GB RAM, 5 GB Festplattenspeicher und 1 CPU) und hat keinen Zugriff auf dein lokales Dateisystem. In der Umgebung sind beliebte Bibliotheken wie numpy, pandas, matplotlib und scipy vorinstalliert, aber du kannst während der Ausführung keine weiteren Pakete installieren.

Dateien API: Persistenter Dateikontext für komplexe Aufgaben

Mit der Datei-API von kannst du Dokumente einmal hochladen und sie in mehreren Konversationen referenzieren. Damit entfällt die Notwendigkeit, große Dokumente in jede API-Anfrage aufzunehmen.

Als erstes lädst du deine Datei auf die Server von Anthropic hoch:

# 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

Nach dem Hochladen referenzierst du die Datei in deinen API-Aufrufen mit dem Inhaltstyp container_upload:

# 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"
   }]
)

Wenn Claude während der Codeausführung Dateien erstellt (z. B. Plots oder verarbeitete Daten), kannst du sie extrahieren und herunterladen:

# 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-Anschluss: Integriere Claude in jeden Arbeitsablauf

Der MCP-Konnektor bringt die Unterstützung des Model Context Protocol direkt in die API. MCPs ermöglichen Claude die Verbindung zu externen Diensten wie Datenbanken, APIs und Produktivitätstools ohne eigenen Integrationscode.

Früher musste man für die Verbindung zu MCP-Servern eine Client-Infrastruktur aufbauen. Jetzt kannst du in deiner API-Anfrage einfach die URL eines entfernten MCP-Servers angeben, und Claude findet automatisch die verfügbaren Tools, verwaltet die Verbindungen und kümmert sich um die Authentifizierung.

Dies eröffnet dir den Zugang zu einem wachsenden Ökosystem von MCP-Servern von Unternehmen wie Zapier und Asana, mit denen du Agenten erstellen kannst, die deinen Kalender lesen, Projektmanagement-Tools aktualisieren oder mit Hunderten von anderen Diensten integrieren können.

Erste Schritte mit Claude Sonnet 4: Projektübersicht und Einrichtung

Jetzt, wo wir die neuen API-Funktionen kennen, können wir unseren interaktiven Mathe-Problemlöser bauen. Es wird die Fähigkeiten von Claude zur Codeausführung mit der Dateiverarbeitung kombinieren, um einen vollständigen mathematischen Assistenten zu schaffen.

Unsere Anwendung akzeptiert mathematische Fragen in natürlicher Sprache, führt Python-Code aus, um sie zu lösen, erstellt Visualisierungen und speichert umfassende Berichte.

Eine strukturierte Herangehensweise an Projekte wie dieses findest du im Lernpfad KI-Anwendungen entwickeln.

> Hinweis: Da wir lange Codeblöcke mit Erklärungen auflockern werden, kann es sein, dass die Einrückung des Codes in den Snippets nicht ganz korrekt ist. Aus diesem Grund empfehlen wir, das GitHub-Repositorium für dieses Projekt in einem separaten Tab zu öffnen, während du dem Projekt folgst.

Schritt 0: Richte deine Claude Sonnet 4 Projektumgebung ein

Bevor wir Code schreiben, müssen wir unsere Entwicklungsumgebung und Abhängigkeiten einrichten.

Erstelle ein neues Verzeichnis für dein Projekt und lege die benötigten Dateien an:

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

Erstelle eine requirements.txt Datei mit den notwendigen Abhängigkeiten:

anthropic>=0.42.0

Installiere die Abhängigkeiten:

pip install -r requirements.txt

Setze deinen Anthropic-API-Schlüssel als Umgebungsvariable:

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

Schritt 1: Entwirf die Anwendungsstruktur

Beginnen wir damit, die Grundstruktur unserer Klasse MathSolver zu erstellen. Diese Klasse wird alle wichtigen Funktionen übernehmen: API-Kommunikation, Dateiverwaltung und Benutzerinteraktion.

Lass uns zunächst die Importe und die grundlegende Struktur einrichten:

#!/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

Definieren wir nun die Struktur unserer Hauptklasse:

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

Schließlich fügen wir die Sitzungsverwaltung und den Einstiegspunkt hinzu:

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

Diese Struktur gibt uns einen klaren Fahrplan: Initialisierung, Problemlösung, Dateiverarbeitung, Berichterstellung und Benutzerinteraktion. Jede Methode hat eine bestimmte Aufgabe in unserem mathematischen Lösungskreislauf.

Bau eines mathematischen Lösers mit Claude Sonnet 4 Code Execution

Nun wollen wir die Kernfunktionalität mit Claudes Code-Ausführungstool und Streaming-Antworten implementieren.

Schritt 2: Claude mit sicheren API-Headern initialisieren

Lass uns die Methode __init__() implementieren, um die Einrichtung des API-Clients und die Erstellung des Verzeichnisses zu verwalten.

Zunächst kümmern wir uns um die Verwaltung der API-Schlüssel:

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"
           )

Als Nächstes richten wir den Anthropic-Client mit den erforderlichen Beta-Headern ein:

# 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"
       },
   )

Zum Schluss erstellen wir die Struktur des Ausgabeverzeichnisses:

# 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}")

Diese Initialisierung bewirkt drei wichtige Dinge:

1. API-Schlüsselverwaltung: Überprüft zuerst den Schlüssel in den Umgebungsvariablen und greift dann auf einen Parameter zurück.
2. Kundeneinrichtung: Erstellt einen Anthropic-Client mit Beta-Headern für die Codeausführung und einer Datei-API.
3. Verzeichnisstruktur: Erstellt organisierte Ordner zum Speichern von Bildern und Berichten.

Schritt 3: Schreibe die zentrale Solver-Funktion

Die Methode solve_problem() ist das Herzstück unserer Anwendung. Es sendet Anfragen an Claude mit Streaming-Unterstützung.

Beginnen wir mit der Funktionssignatur und der Ersteinrichtung:

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}")

Wir bearbeiten verschiedene Arten von Streaming-Events:

	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}")

Schließlich geben wir das Ergebnis zurück oder behandeln Fehler:

	# 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

Diese Funktion demonstriert mehrere wichtige Konzepte:

• Streaming-Unterstützung: Wir nutzen client.messages.stream() anstelle von client.messages.create(), um Echtzeit-Feedback zu bekommen, während Claude das Problem bearbeitet.
• Ereignisbehandlung: Die Streaming-API sendet verschiedene Ereignistypen:
• content_block_start: Wenn Claude beginnt, Text zu schreiben oder ein Werkzeug zu benutzen
• content_block_delta: Während Inhalte erstellt werden
• content_block_stop: Wenn ein Inhaltsblock fertig ist
• message_delta: Wenn die gesamte Nachricht vollständig ist
• Werkzeugspezifikation: Wir nehmen das Codeausführungswerkzeug in das tools Array mit dem genauen Typ "code_execution_20250522" auf.
• Strukturiertes Prompting: Unsere Aufforderung weist Claude deutlich darauf hin, die Codeausführung zu nutzen und alle Visualisierungen zu speichern.

Schritt 4: Löse mathematische Probleme mit Streaming-Code-Ausführung

Wenn Claude während der Codeausführung Dateien erstellt (z. B. Matplotlib-Plots), müssen wir ihre Datei-IDs extrahieren und sie lokal herunterladen.

Die Dateiextraktionsmethode navigiert durch die Antwortstruktur:

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", [])

Dann suchen wir nach Datei-IDs im Inhalt:

  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

Der Download-Prozess ruft Dateien ab und speichert sie lokal:

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))

Wir verfolgen heruntergeladene Dateien und behandeln Fehler:

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

• Logik der Dateiextraktion: Die Methode extract_files_from_response() navigiert durch die Antwortstruktur, um Datei-IDs zu finden. Die Ergebnisse der Codeausführung werden in einem bestimmten Format verschachtelt, wobei die Dateien im Array content erscheinen.
• Datei-Download-Prozess: Die Methode download_files():
• Ruft Metadaten für jede Datei ab (einschließlich des ursprünglichen Dateinamens)
• Lädt den Inhalt der Datei über die Files API herunter
• Speichert Dateien in unserer organisierten Verzeichnisstruktur
• Gibt eine Liste lokaler Dateipfade zur späteren Verwendung zurück