Tutoriel API Claude Opus 4.7 : créer un extracteur de données de graphiques

La semaine dernière a vu la sortie de Claude Opus 4.7, la dernière itération du modèle phare d’Anthropic. Avec une résolution visuelle environ triplée et une exécution plus littérale des consignes complexes, Opus 4.7 est taillé pour naviguer dans des interfaces riches et lire des schémas techniques haute fidélité avec une précision chirurgicale inédite.

Dans ce tutoriel, je vous guide à travers les principaux changements introduits par Claude Opus 4.7. Nous verrons ce qu’est ce modèle, ses nouveautés clés, et comment le mettre en place en local avec Python. Pour finir, nous construirons un projet de démonstration multi‑étapes complet : un extracteur autonome et haute résolution de données issues de graphiques.

Je vous recommande notre cours Introduction to Claude Models si vous souhaitez approfondir les grands modèles de langage (LLM) d’Anthropic.

Qu’est‑ce que Claude Opus 4.7 ?

Claude Opus 4.7 est le tout nouveau LLM phare d’Anthropic. L’entreprise réservant son modèle plus puissant, Claude Mythos Preview, à des experts en sécurité approuvés, Opus 4.7 demeure son interface API principale et largement accessible pour les développeurs.

Cette version apporte des améliorations dans plusieurs domaines :

• Interprétation de données visuelles
• Raisonnement mathématique
• Suivi des instructions
• Mémorisation de contenu dans des environnements de code complexes

Les développeurs notent des progrès sensibles dans sa capacité à suivre des consignes strictes et à éviter les boucles de traitement répétitives. Opus 4.7 vérifie spontanément son travail et remet en question ses hypothèses avant d’écrire du code, ce qui réduit fortement le risque que des agents restent bloqués dans des boucles d’erreurs continues.

Côté benchmarks, un résultat ressort particulièrement. Sur le très exigeant test SWE‑bench Pro, qui mesure la capacité d’une IA à corriger de vrais bugs de logiciels open source sur GitHub, Opus 4.7 enregistre un gain de 10,9 points par rapport à son prédécesseur. Cette progression confirme la place de la famille Opus comme référence de la programmation agentique.

Pour en savoir plus sur le modèle, consultez notre guide sur Claude Opus 4.7.

Quoi de neuf dans Claude Opus 4.7 ?

Le passage à Opus 4.7 introduit de nouveaux plans de contrôle pour gérer les ressources de calcul et modifie certaines pratiques d’ingénierie de prompts. Voici les principaux changements et fonctionnalités à connaître :

• Vision multimodale haute résolution : le modèle accepte désormais des images jusqu’à 2 576 pixels sur le bord le plus long, soit une résolution effective d’environ 3,75 mégapixels. La cartographie géométrique des coordonnées a été repensée : les boîtes englobantes respectent désormais un mapping strict 1:1 avec les pixels réels de l’image, supprimant le besoin de calculs d’échelle complexes.

• Pensée adaptative : les budgets de réflexion étendus (ex. budget_tokens) ont été entièrement supprimés. Soumettre des requêtes héritées renverra une erreur HTTP 400. À la place, Opus 4.7 impose l’usage de la « pensée adaptative » (thinking: {"type": "adaptive"}), qui permet au modèle d’allouer dynamiquement son budget de raisonnement interne selon la complexité du prompt.

• Contrôle granulaire de l’effort : une nouvelle valeur de paramètre, xhigh (extra élevé), se situe mathématiquement entre l’effort high standard et le maximum max. Anthropic recommande fortement xhigh comme point de départ optimal pour le codage agentique et la résolution de problèmes complexes. Le modèle tend également vers un « littéralisme » accru : il exécute le texte tel quel, sans « lire entre les lignes ».

• Budgets de tâche : pour atténuer mathématiquement les boucles agentiques incontrôlées, Opus 4.7 introduit les « task budgets » (actuellement en bêta publique). En définissant un task_budget, les développeurs indiquent explicitement au modèle l’allocation totale de tokens pour l’ensemble du cycle de la tâche. Le modèle suit en continu ce compte à rebours et s’auto‑régule pour garantir une fin de tâche maîtrisée.

• Outil de mémoire côté client : Opus 4.7 excelle pour écrire et lire dans un pense‑bête géré. Pour formaliser cela, Anthropic a amélioré l’outil de mémoire côté client, avec une synchronisation adossée à git, optimisée pour les workflows MemFS (Memory File System).

Configurer un environnement pour Claude Opus 4.7

Avant de coder notre projet de démonstration, préparons l’environnement pour supporter Opus 4.7. Dans ce tutoriel, nous utiliserons Python asynchrone, la norme du secteur pour des workflows intensifs en données et à forte concurrence.

Nous avons besoin de Python 3.8 ou supérieur installé sur notre machine. Je recommande vivement de créer un environnement virtuel isolé pour éviter les conflits de dépendances.

Voici comment créer et activer un environnement nommé opus_4_7 avec Anaconda :

conda create -n opus_4_7 python=3.10 -y
conda activate opus_4_7

Créer un extracteur autonome haute résolution de graphiques avec Claude Opus 4.7

Pour mettre en pratique les capacités théoriques de Claude Opus 4.7, nous allons construire un extracteur autonome, haute résolution, de données issues de graphiques.

Les data scientists croisent en permanence des données précieuses enfermées dans des images ou des PDF statiques (nuages de points, histogrammes, courbes, etc.). Avec d’anciens modèles d’IA, il fallait écrire des calculs d’échelle complexes pour automatiser l’extraction de données depuis ces graphiques.

Dans ce projet, nous allons créer un script Python qui prend une capture d’écran de n’importe quel graphique et génère un fichier CSV avec les données brutes.

Concrètement, nous allons :

• Exploiter la vision 3,75 MP et le mapping 1:1 pour lire parfaitement le graphique.

• Utiliser la pensée adaptative au niveau d’effort xhigh pour déduire rigoureusement les axes X et Y.

• Produire un DataFrame Pandas propre contenant les points exacts.

Je vous accompagne pas à pas. Ce tutoriel est autonome, mais si vous souhaitez en savoir plus sur les capacités du modèle ou si vous bloquez sur vos propres agents, consultez sa documentation officielle.

Étape 1 : configurer la clé API

Avant tout, nous devons activer l’authentification. Pour cela, créez une clé API dans la console développeur Anthropic.

Ne stockez jamais vos identifiants API en dur dans votre dépôt de code. Générez plutôt un fichier .env sécurisé à la racine du projet :

ANTHROPIC_API_KEY=<paste_your_api_key_here>

Notez que le modèle n’est pas gratuit. Pour activer la clé, vous devez créditer votre compte. La bonne nouvelle : la tarification reste identique aux deux versions précédentes :

Étape 2 : installer les dépendances Python

Installons ensuite les bibliothèques nécessaires. Il nous faut :

• anthropic, le SDK officiel d’Anthropic pour l’intégration API ;

• python-dotenv pour la gestion des variables d’environnement ;

• pandas pour structurer les données extraites.

Ouvrez votre terminal et exécutez la commande suivante (assurez‑vous que l’environnement opus_4_7 créé plus haut est actif) :

pip install anthropic python-dotenv pandas

Étape 3 : créer un agent texte avec pensée adaptative

Posons les bases avec une interface en ligne de commande asynchrone. Cette étape introduit le nouveau niveau d’effort xhigh et l’architecture de pensée adaptative d’Opus 4.7. Créez un fichier chart_digitizer.py et ajoutez le code suivant :

import os
import asyncio
from dotenv import load_dotenv
from anthropic import AsyncAnthropic

# Ingest secure environment variables
load_dotenv()

# Initialize the asynchronous Anthropic client
client = AsyncAnthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY")
)

async def test_adaptive_thinking():
    print("Initiating Text Agent with Adaptive Thinking...")
    
    response = await client.messages.create(
        model="claude-opus-4-7",
        max_tokens=64000,
        stream=True, # Required for long responses
        thinking={"type": "adaptive"}, # NEW: Replaces budget_tokens
        output_config={"effort": "xhigh"}, # NEW: Extra high effort level
        messages=[
            {"role": "user", "content": "Explain why 1:1 pixel mapping is crucial for data extraction."}
        ]
    )
    
    # Parse the streaming response structure
    async with response as stream:
        async for event in stream:
            if event.type == "content_block_start":
                if event.content_block.type == "thinking":
                    print("\n--- Internal Reasoning Trace ---")
                elif event.content_block.type == "text":
                    print("\n--- Final Output ---")
            elif event.type == "content_block_delta":
                if event.delta.type == "thinking_delta":
                    print(event.delta.thinking, end="", flush=True)
                elif event.delta.type == "text_delta":
                    print(event.delta.text, end="", flush=True)

if __name__ == "__main__":
    asyncio.run(test_adaptive_thinking())

Exécutez‑le avec la commande :

python chart_digitizer.py

Ce script illustre comment envoyer une requête à Claude Opus 4.7, mais il n’extrait pas encore de données depuis un graphique. Il se contente d’envoyer le prompt :

Explain why 1:1 pixel mapping is crucial for data extraction.

Étape 4 : définir le schéma d’extraction des données

Pour garantir que le modèle nous renvoie des données propres, prêtes à l’emploi dans Pandas, nous allons utiliser un « Tool » pour imposer une sortie structurée. Nous définissons un schéma JSON qui indique précisément à Claude comment formater les coordonnées extraites du graphique.

Mettez à jour le fichier chart_digitizer.py pour inclure le schéma de l’outil et un prompt système après l’initialisation du client :

# Define the JSON schema to force structured data extraction
extraction_tool = {
    "name": "save_chart_data",
    "description": "Saves the extracted data points from the chart into a structured format.",
    "input_schema": {
        "type": "object",
        "properties": {
            "x_axis_label": {"type": "string", "description": "The label for the X axis"},
            "y_axis_label": {"type": "string", "description": "The label for the Y axis"},
            "data_points": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "x": {"type": "number", "description": "X-axis value"},
                        "y": {"type": "number", "description": "Y-axis value"}
                    },
                    "required": ["x", "y"]
                }
            }
        },
        "required": ["x_axis_label", "y_axis_label", "data_points"]
    }
}

SYSTEM_PROMPT = """
You are an expert Data Scientist. Your task is to digitize the provided chart image.
Execute the following strict, literal directives:
1. Scan the image using your 1:1 pixel mapping capabilities to identify the X and Y axes, their scales, and all plotted data points.
2. Utilize your adaptive thinking space to perform the mathematical conversions from visual pixel locations to the actual chart values.
3. You MUST use the 'save_chart_data' tool to output the final extracted data points. 
Do not guess. Be highly precise.
"""

Pour forcer le modèle à utiliser l’outil et le prompt système, mettez à jour la requête avec les paramètres tool et system :

response = await client.messages.create(
        model="claude-opus-4-7",
        max_tokens=64000,
        stream=True,
        thinking={"type": "adaptive"},
        system=SYSTEM_PROMPT, # Add to enable the system prompt
        tools=[extraction_tool], # Add to provide the tool to the model
        messages=messages,
        output_config={
            "effort": "xhigh",
        }
    )

Étape 5 : ajouter un budget de tâche pour le raisonnement visuel complexe

Cartographier visuellement des centaines de points et calculer leurs valeurs exactes exige une puissance de calcul importante. Pour protéger notre budget de calcul, nous appliquons un budget de tâche. Nous allons définir une limite indicative de 80 000 tokens pour cette opération.

Nous pouvons fixer cette limite dans la requête via le task_budget au sein de output_config :

response = await client.messages.create(
        model="claude-opus-4-7",
        max_tokens=64000,
        stream=True,
        thinking={"type": "adaptive"},
        system=SYSTEM_PROMPT,
        tools=[extraction_tool],
        messages=messages,
        output_config={
            "effort": "xhigh",
            "task_budget": {"type": "tokens", "total": 80000} # Add to limit output tokens
        }
    )

Notez l’en‑tête bêta requis pour activer cette fonctionnalité. Pour cela, mettez à jour l’initialisation de l’agent comme suit :

client = AsyncAnthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
    default_headers={"anthropic-beta": "task-budgets-2026-03-13"}
)

Étape 6 : construire l’extracteur visuel haute résolution

Dans la phase finale, nous intégrons les capacités visuelles 3,75 MP. Nous allons créer une fonction utilitaire robuste pour l’ingestion d’images et finaliser le code pour produire un fichier CSV avec les données.

Voici le code final et complet de notre extracteur visuel :

import os
import asyncio
import mimetypes
import sys
from dotenv import load_dotenv
from anthropic import AsyncAnthropic
import base64
import pandas as pd

# Ingest secure environment variables
load_dotenv()

# Initialize the asynchronous Anthropic client
client = AsyncAnthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
    default_headers={"anthropic-beta": "task-budgets-2026-03-13"}
)

# Define the JSON schema to force structured data extraction
extraction_tool = {
    "name": "save_chart_data",
    "description": "Saves the extracted data points from the chart into a structured format.",
    "input_schema": {
        "type": "object",
        "properties": {
            "x_axis_label": {"type": "string", "description": "The label for the X axis"},
            "y_axis_label": {"type": "string", "description": "The label for the Y axis"},
            "data_points": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "x": {"type": "number", "description": "X-axis value"},
                        "y": {"type": "number", "description": "Y-axis value"}
                    },
                    "required": ["x", "y"]
                }
            }
        },
        "required": ["x_axis_label", "y_axis_label", "data_points"]
    }
}

SYSTEM_PROMPT = """
You are an expert Data Scientist. Your task is to digitize the provided chart image.
Execute the following strict, literal directives:
1. Scan the image using your 1:1 pixel mapping capabilities to identify the X and Y axes, their scales, and all plotted data points.
2. Utilize your adaptive thinking space to perform the mathematical conversions from visual pixel locations to the actual chart values.
3. You MUST use the 'save_chart_data' tool to output the final extracted data points. 
Do not guess. Be highly precise.
"""

def encode_high_res_image(image_path: str) -> tuple[str, str]:
    if not os.path.exists(image_path):
        raise FileNotFoundError(f"Critical Error: Image not located at {image_path}")
    with open(image_path, "rb") as image_file:
        base64_data = base64.b64encode(image_file.read()).decode("utf-8")

    media_type, _ = mimetypes.guess_type(image_path)
    if not media_type or not media_type.startswith("image/"):
        media_type = "image/png"
    return base64_data, media_type

async def digitize_chart(image_path: str = "chart.jpg"):
    print("\nInitiating Opus 4.7 Autonomous Chart Digitization...")
    IMAGE_PATH = image_path
    base64_image_data, media_type = encode_high_res_image(IMAGE_PATH)

    messages = [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": media_type,
                        "data": base64_image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Please digitize this chart and extract the data points."
                }
            ]
        }
    ]

    response = await client.messages.create(
        model="claude-opus-4-7",
        max_tokens=64000,
        stream=True,
        thinking={"type": "adaptive"},
        system=SYSTEM_PROMPT,
        tools=[extraction_tool],
        messages=messages,
        output_config={
            "effort": "xhigh",
            "task_budget": {"type": "tokens", "total": 80000}
        }
    )

    # Accumulate tool input and thinking from the stream
    import json
    tool_name = None
    tool_input_json = ""
    thinking_text = ""

    async with response as stream:
        async for event in stream:
            if event.type == "content_block_start":
                if event.content_block.type == "tool_use":
                    tool_name = event.content_block.name
                    tool_input_json = ""
                elif event.content_block.type == "thinking":
                    thinking_text = ""
            elif event.type == "content_block_delta":
                if event.delta.type == "input_json_delta":
                    tool_input_json += event.delta.partial_json
                elif event.delta.type == "thinking_delta":
                    thinking_text += event.delta.thinking

    if thinking_text:
        print("\n--- Internal Thinking (Math & Scaling) ---")
        print(thinking_text[:500] + "...\n[Cognitive trace truncated]")

    if tool_name == "save_chart_data" and tool_input_json:
        print("\n--- Data Extraction Complete! ---")
        chart_data = json.loads(tool_input_json)
        df = pd.DataFrame(chart_data["data_points"])

        print(f"\nX-Axis: {chart_data['x_axis_label']}")
        print(f"Y-Axis: {chart_data['y_axis_label']}")
        print("\nExtracted DataFrame:")
        print(df.head(10))

        output_path = "chart_data.csv"
        df.to_csv(output_path, index=False)
        print(f"\nDataFrame saved to {output_path}")

if __name__ == "__main__":
    image_path = sys.argv[1] if len(sys.argv) > 1 else "chart.jpg"
    asyncio.run(digitize_chart(image_path))

Pour le tester, j’ai téléchargé ce graphique depuis Yahoo Sports, qui montre la fréquentation de la Coupe du monde de la FIFA par année, dans un fichier nommé fifa.webp :

Nous exécutons le script comme précédemment, mais en passant le nom d’une image de graphique en argument :

python chart_digitizer.py fifa.webp 

Voici le résultat :

Extracted DataFrame:
      x        y
0  1930   590000
1  1934   375000
2  1938   375000
3  1950  1040000
4  1954   770000
5  1958   820000
6  1962   890000
7  1966  1560000
8  1970  1600000
9  1974  1870000

En le traçant, on peut vérifier que le résultat est très fidèle, bien que le graphique d’origine n’affichait pas d’étiquettes sur l’axe Y.

Conclusion

Nous sommes passés d’un simple chatbot asynchrone à un moteur de raisonnement visuel très robuste pour la data science.

Comme le modèle n’exige pas de sous‑échantillonnage, il lit des graphiques complexes sans perdre la fidélité sub‑pixel. Je vous invite à tester cette base de code sur une variété de graphiques pour prendre la mesure de ses capacités !

En testant le modèle sur plusieurs graphiques, j’ai été particulièrement impressionné par sa justesse. Ce script ne doit pas être considéré comme un produit fini : de nombreuses améliorations restent possibles. Pour vous exercer, voici quelques pistes :

• Extraire des métadonnées comme les unités et étiquettes d’axes : dans l’exemple ci‑dessus, le graphique affiche 3,5, mais sans l’unité. Le graphique d’origine représente 3,5 M, donc 3,5 millions de personnes.
• Permettre le contrôle du nombre de points échantillonnés : le modèle a extrait quelques points clés, mais n’a pas récupéré la fréquentation pour chaque année.

Si la programmation avec les modèles d’Anthropic vous intéresse, je vous recommande vivement notre cours Software Development with Claude Code !