Claude Sonnet 4 : Un guide pratique pour les développeurs

Avec la sortie de Claude Sonnet 4, les développeurs ont maintenant accès à de nouvelles capacités puissantes - y compris l'exécution de code natif, une API de fichiers flexible, et l'utilisation d'outils dynamiques. Ces fonctionnalités ouvrent des perspectives passionnantes pour la création d'applications alimentées par l'IA qui vont au-delà des simples interactions textuelles.

Dans ce tutoriel, je vous guiderai à travers ces nouvelles fonctionnalités en construisant un agent basé sur Python qui peut résoudre des problèmes mathématiques avancés directement depuis votre terminal. Vous apprendrez à utiliser l'outil d'exécution de code natif nouvellement introduit et l'API des fichiers sur.

À la fin, vous aurez un agent fonctionnel alimenté par Claude Sonnet 4 pour analyser les problèmes, écrire et exécuter du code Python, et rendre des visuels comme ceux ci-dessous.

Consultez le dépôt GitHub de ce projet pour voirtout le code de construction de l'application.

Si vous commencez tout juste à construire avec des LLM comme Claude, cette feuille de route pour les développeurs d'IA présente lesoutils, les compétences et les parcours d'apprentissage essentiels pour démarrer.

Nouveautés de l'API Anthropique

Avant de commencer le tutoriel, examinons les nouvelles fonctionnalités récemment mises à disposition par l'intermédiaire de l'API Anthropic. N'hésitez pas à passer à l'étape suivante si vous les connaissez déjà.

Je pense que toute l' annonce de Claude 4 peut êtrerésumée dans cette image :

Les modèles Claude 4 (Opus et Sonnet 4) ont battu la concurrence dans les tâches de génie logiciel vérifiées avec une marge significative. Anthropic a réussi cet exploit en introduisant quelques changements importants dans le comportement des modèles :

1. Longues durées d'exécution: Les deux modèles prennent en charge plusieurs heures d'exécution continue de tâches pour résoudre des problèmes comportant des milliers d'étapes.
2. Réflexion approfondie avec utilisation d'outils: Les deux modèles peuvent désormais utiliser des outils tels que la recherche sur Internet pendant les phases de réflexion approfondie, ce qui permet à Claude d'alterner entre le raisonnement et l'utilisation d'outils pour améliorer ses réponses.
3. Exécution parallèle des outils: Les modèles peuvent désormais utiliser plusieurs outils simultanément plutôt que séquentiellement.
4. Instructions plus précises à la suite de: L'amélioration de la dirigeabilité permet aux utilisateurs de mieux contrôler les mises en œuvre et la façon dont Claude réagit aux instructions.
5. Amélioration des capacités de mémoire: Lorsqu'ils ont accès aux fichiers locaux, les modèles peuvent extraire et sauvegarder des faits essentiels pour maintenir la continuité et construire une connaissance tacite au fil du temps.
6. Réduction du comportement des raccourcis: Par rapport aux versions précédentes, les deux modèles sont 65 % moins susceptibles d'utiliser des raccourcis ou des échappatoires pour accomplir des tâches (voir l'annonce complète pour plus de détails).

De plus, dans le cadre de l'annonce de la famille de modèles Claude 4, Anthropic a ajouté quatre nouvelles fonctionnalités pour afin de construire des agents d'intelligence artificielle : l'outil d'exécution de code, l'API Fichiers, le connecteur MCP et la mise en cache étendue de l'invite. Ces outils modifient la façon dont les développeurs peuvent créer des applications d'IA.

Outil d'exécution de code : Exécuter du code Python en toute sécurité

L' outil d'exécution de code permet à Claude d'exécuter du code Python dans un environnement sandbox sécurisé. Au lieu de se contenter d'écrire des suggestions de code, Claude peut maintenant exécuter le code, analyser les résultats et itérer sur les solutions.

Pour utiliser l'outil d'exécution de code, ajoutez-le à votre tableau tools et incluez l'en-tête beta requis :

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

Lorsque Claude exécute un code, la réponse contient à la fois le code généré et les résultats de son exécution. Voici comment analyser les différents composants :

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

Limites du bac à sable : L'environnement d'exécution du code comporte plusieurs restrictions de sécurité intégrées. Claude s'exécute dans un conteneur isolé, sans accès à Internet, avec des ressources informatiques limitées (1 Go de RAM, 5 Go d'espace disque et 1 CPU), et ne peut pas accéder à votre système de fichiers local. L'environnement est préinstallé avec des bibliothèques populaires telles que numpy, pandas, matplotlib, et scipy, mais vous ne pouvez pas installer d'autres paquets pendant l'exécution.

Fichiers API : Contexte de fichier persistant pour les tâches complexes

L' API Fichiers permet à de télécharger des documents une seule fois et d'y faire référence dans plusieurs conversations. Il n'est donc plus nécessaire d'inclure des documents volumineux dans chaque demande d'API.

Tout d'abord, téléchargez votre fichier sur les serveurs d'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

Une fois téléchargé, référencez le fichier dans vos appels API à l'aide du type de contenu 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"
   }]
)

Lorsque Claude crée des fichiers pendant l'exécution du code (comme des graphiques ou des données traitées), vous pouvez les extraire et les télécharger :

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

Connecteur MCP : Branchez Claude sur n'importe quel flux de travail

Le connecteur MCP apporte la prise en charge du protocole de contexte de modèle directement à l'API. Les MCP permettent à Claude de se connecter à des services externes tels que des bases de données, des API et des outils de productivité sans code d'intégration personnalisé.

Auparavant, la connexion aux serveurs MCP nécessitait la mise en place d'une infrastructure client. Désormais, il vous suffit de fournir l'URL d'un serveur MCP distant dans votre demande d'API, et Claude découvre automatiquement les outils disponibles, gère les connexions et l'authentification.

Cela ouvre l'accès à un écosystème croissant de serveurs MCP de sociétés telles que Zapier et Asana, vous permettant de créer des agents qui peuvent lire votre calendrier, mettre à jour des outils de gestion de projet ou s'intégrer à des centaines d'autres services.

S'initier à Claude Sonnet 4 : Vue d'ensemble du projet et configuration

Maintenant que nous comprenons les nouvelles fonctionnalités de l'API, construisons notre solution interactive de problèmes mathématiques. Il combinera les capacités d'exécution de code de Claude avec la manipulation de fichiers pour créer un assistant mathématique complet.

Notre application acceptera des questions mathématiques en langage naturel, exécutera du code Python pour les résoudre, générera des visualisations et enregistrera des rapports complets.

Pour une approche structurée de la construction de projets de ce type, consultez le cursus Développer des applications d'IA.

> Note : Étant donné que nous séparons les longs blocs de code par des explications, l'indentation du code peut ne pas être tout à fait exacte dans les extraits. Pour cette raison, nous vous recommandons d'ouvrir le dépôt GitHub de ce projet dans un onglet séparé pendant que vous suivez les instructions.

Étape 0 : Créez l'environnement de votre projet Claude Sonnet 4

Avant d'écrire le moindre code, configurons notre environnement de développement et nos dépendances.

Créez un nouveau répertoire pour votre projet et installez les fichiers nécessaires :

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

Créez un fichier requirements.txt avec les dépendances nécessaires :

anthropic>=0.42.0

Installez les dépendances :

pip install -r requirements.txt

Définissez votre clé API Anthropic comme variable d'environnement :

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

Étape 1 : Concevoir la structure de l'application

Commençons par créer la structure de base de notre classe MathSolver. Cette classe prend en charge toutes les fonctionnalités principales : Communication API, gestion de fichiers et interaction avec l'utilisateur.

Commençons par définir les importations et la structure de base :

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

Définissons maintenant la structure de notre classe principale :

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

Enfin, nous ajoutons la gestion de la session et le point d'entrée :

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

Cette structure nous donne une feuille de route claire : initialisation, résolution de problèmes, traitement de fichiers, génération de rapports et interaction avec l'utilisateur. Chaque méthode a une responsabilité spécifique dans notre processus de résolution des problèmes mathématiques.

Construire un solveur mathématique avec l'exécution du code de Claude Sonnet 4

Mettons maintenant en œuvre la fonctionnalité de base en utilisant l'outil d'exécution de code de Claude et les réponses en continu.

Étape 2 : Initialiser Claude avec des en-têtes API sécurisés

Mettons en œuvre la méthode __init__() pour gérer la configuration du client API et la création du répertoire.

Tout d'abord, nous nous occupons de la gestion des clés d'API :

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

Ensuite, nous configurons le client Anthropic avec les en-têtes beta nécessaires :

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

Enfin, nous créons la structure du répertoire de sortie :

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

Cette initialisation a trois fonctions importantes :

1. Gestion des clés d'API : Vérifie d'abord la clé dans les variables d'environnement, puis se rabat sur un paramètre.
2. Configuration du client : Crée un client Anthropic avec des en-têtes beta pour l'exécution du code et des fichiers API.
3. Structure du répertoire : Crée des dossiers organisés pour le stockage des images et des rapports.

Étape 3 : Écrire la fonction de base du solveur

La méthode solve_problem() est le cœur de notre application. Il envoie des demandes à Claude qui prend en charge la diffusion en continu.

Commençons par la signature de la fonction et la configuration initiale :

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

Nous traitons différents types d'événements en continu :

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

Enfin, nous renvoyons le résultat ou traitons les erreurs :

	# 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

Cette fonction illustre plusieurs concepts importants :

• Prise en charge de la diffusion en continu : Nous utilisons client.messages.stream() au lieu de client.messages.create() pour obtenir un retour d'information en temps réel pendant que Claude travaille sur le problème.
• Gestion des événements: L'API de diffusion en continu envoie différents types d'événements :
• content_block_start: Lorsque Claude commence à écrire un texte ou à utiliser un outil
• content_block_delta: Au fur et à mesure que le contenu est généré
• content_block_stop: Lorsqu'un bloc de contenu est terminé
• message_delta: Lorsque le message est complet
• Spécification de l'outil: Nous incluons l'outil d'exécution de code dans le tableau tools avec le type exact "code_execution_20250522".
• Incitation structurée: Notre message indique clairement à Claude d'utiliser l'exécution de code et de sauvegarder toutes les visualisations.

Étape 4 : Résoudre des problèmes mathématiques grâce à l'exécution de code en continu

Lorsque Claude crée des fichiers pendant l'exécution du code (comme les graphiques de matplotlib), nous devons extraire leurs identifiants de fichier et les télécharger localement.

La méthode d'extraction de fichiers permet de naviguer dans la structure de réponse :

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

Nous recherchons ensuite les identifiants de fichiers dans le contenu :

  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

Le processus de téléchargement récupère les fichiers et les enregistre localement :

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

Nous assurons le cursus des fichiers téléchargés et gérons les erreurs :

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

• Logique d'extraction des fichiers : La méthode extract_files_from_response() parcourt la structure de la réponse pour trouver les identifiants des fichiers. Les résultats de l'exécution du code sont imbriqués dans un format spécifique où les fichiers apparaissent dans le tableau content.
• Processus de téléchargement de fichiers: La méthode download_files():
• Obtient les métadonnées de chaque fichier (y compris le nom du fichier original).
• Télécharge le contenu du fichier à l'aide de l'API Fichiers
• Sauvegarde des fichiers dans notre structure de répertoire organisée
• Renvoie une liste de chemins d'accès aux fichiers locaux pour une utilisation ultérieure