Claude Opus 4.7 API-tutorial: een grafiekdigitalizer bouwen

Vorige week werd Claude Opus 4.7 gelanceerd, de nieuwste iteratie van Anthropics vlaggenschipmodel. Met grofweg een verdrievoudiging van de visuele resolutie en een meer letterlijke naleving van complexe prompts is Opus 4.7 gebouwd om ingewikkelde gebruikersinterfaces te navigeren en technische diagrammen met hoge fidelity te ontleden met een nieuw niveau van chirurgische precisie.

In deze tutorial neem ik je mee langs de belangrijkste wijzigingen die in Claude Opus 4.7 zijn geïntroduceerd. We bekijken wat het model is, welke cruciale nieuwe features het biedt en hoe je het lokaal instelt met Python. Tot slot bouwen we een volledig functioneel demoproject in meerdere stappen: een autonome, hogeresolutie-visual chart digitizer.

Ik raad je aan om onze cursus Introduction to Claude Models te volgen als je meer wilt leren over de grote taalmodellen (LLM’s) van Anthropic.

Wat is Claude Opus 4.7?

Claude Opus 4.7 is Anthropics nieuwste vlaggenschip-LLM. Omdat het bedrijf zijn krachtigere Claude Mythos Preview alleen beschikbaar stelt aan goedgekeurde security-experts, blijft Opus 4.7 de primaire, breed beschikbare application programming interface voor algemene developers.

Deze versie brengt upgrades op een paar verschillende vlakken: 

• Interpretatie van visuele data
• Wiskundige logica
• Instructies opvolgen
• Inhoud onthouden uit complexe codeomgevingen 

Developers melden duidelijke verbeteringen in het vermogen om strikte instructies te volgen en repetitieve verwerkingslussen te vermijden. Opus 4.7 controleert zijn werk van nature dubbel en beoordeelt aannames voordat het code schrijft, wat de kans aanzienlijk verkleint dat agents vastlopen in voortdurende foutlussen.

Bij het bekijken van benchmarkgegevens springt één resultaat eruit. In de veeleisende SWE-bench Pro-test, die meet hoe goed een AI echte open-source GitHub-softwarebugs oplost, behaalde Opus 4.7 een stijging van 10,9 punten ten opzichte van zijn voorganger. Deze sprong verstevigt de rol van de Opus-modelfamilie als de agentische programmeerprimus.

Wil je meer over het model leren, bekijk dan onze gids over Claude Opus 4.7.

Wat is er nieuw in Claude Opus 4.7?

De overgang naar Opus 4.7 introduceert verschillende volledig nieuwe control planes om rekencapaciteit te beheren en een paar verschuivingen in prompt engineering. Dit zijn de belangrijkste wijzigingen en nieuwe features die je moet kennen:

• Hogeresolutie multimodale visie: Het model verhoogt de maximaal geaccepteerde afbeeldingsafmeting naar 2.576 pixels aan de langste zijde, wat een effectieve resolutie van ongeveer 3,75 megapixels oplevert. Geometrische coördinatenmapping is herzien, wat betekent dat boundingbox-coördinaten nu een strikt afgedwongen 1:1-mapping met daadwerkelijke beeldpixels hebben. Dat elimineert de noodzaak van complexe schaalfactorberekeningen.

• Adaptief denken: Uitgebreide denkbudgetten (bijv. budget_tokens) zijn volledig verwijderd. Het indienen van legacy-verzoeken levert een HTTP 400-fout op. In plaats daarvan verplicht Opus 4.7 het gebruik van "adaptive thinking" (thinking: {"type": "adaptive"}), waardoor het model zijn interne redeneerbudget dynamisch kan toewijzen op basis van de complexiteit van de prompt.

• Genuanceerde inspanningscontrole: Een nieuwe parametervalue, xhigh (extra hoog), is wiskundig gepositioneerd tussen de standaard high-inspanning en de maximale max-configuraties. Anthropic raadt xhigh sterk aan als optimale startinstelling voor agentisch coderen en complexe probleemoplossing. Het model is ook meer richting absolute "literaliteit" verschoven; het voert exact uit wat er staat, zonder "tussen de regels door" te lezen.

• Taakbudgetten: Om runaway agentische lussen wiskundig te beperken, introduceert Opus 4.7 "task budgets" (momenteel in publieke bèta). Door een task_budget te definiëren, informeren developers het model expliciet over de absolute totale token-toelage voor de volledige taaklevenscyclus. Het model houdt dit aftellen continu bij en modereert zichzelf om een nette taakafronding te garanderen.

• Client-side geheugentool: Opus 4.7 is uitzonderlijk bedreven in schrijven naar en lezen uit een beheerde kladblokomgeving. Om dit te formaliseren, heeft Anthropic de client-side geheugentool verbeterd, met git-ondersteunde synchronisatie, geoptimaliseerd voor MemFS (Memory File System)-workflows.

Een Claude Opus 4.7-omgeving opzetten

Voordat we onze demo gaan coderen, moeten we de omgeving inrichten om Opus 4.7 te ondersteunen. Voor deze tutorial gebruiken we asynchroon Python, omdat dat de industriestandaard is voor data-intensieve workflows met hoge gelijktijdigheid.

We hebben Python 3.8 of hoger nodig op ons systeem. Ik raad sterk aan om een geïsoleerde virtuele omgeving te maken om afhankelijkheidsconflicten te voorkomen.

Zo maak en activeer je zo’n omgeving met de naam opus_4_7 met Anaconda:

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

Een autonome hogeresolutie-grafiekdigitalizer bouwen met Claude Opus 4.7

Om de theoretische mogelijkheden van Claude Opus 4.7 in een praktische toepassing te gieten, bouwen we een autonome hogeresolutie-grafiekdigitalizer.

Data scientists komen voortdurend waardevolle data tegen die opgesloten zit in statische afbeeldingen of pdf’s (zoals scatterplots, staafdiagrammen of lijngrafieken). Met oudere AI-modellen moest je complexe schaalfactorwiskunde schrijven om het extraheren van data uit deze grafieken te automatiseren.

In dit project bouwen we een Pythonscript dat een screenshot van een willekeurige grafiek neemt en een CSV-bestand met de ruwe data maakt. 

We gaan expliciet:

• De nieuwe 3,75MP-visie en 1:1-pixelmapping gebruiken om de grafiek perfect uit te lezen.

• Adaptief denken gebruiken op het xhigh-inspanningniveau om de X- en Y-assen rigoureus af te leiden.

• Een schone Pandas DataFrame produceren met de exacte datapunten.

Ik begeleid je stap voor stap door dit proces. Deze tutorial is zelfvoorzienend, maar als je meer wilt weten over de mogelijkheden van het model of vastloopt bij het bouwen van je eigen agents, bekijk dan de officiële documentatie.

Stap 1: Stel de API-sleutel in

Allereerst moeten we authenticatie inschakelen. Daarvoor maken we een API-sleutel aan in de Anthropic Developer Console.

Hardcode API-inloggegevens nooit rechtstreeks in je broncode-repository. Genereer in plaats daarvan een beveiligd .env-bestand in de hoofdmap van je project:

ANTHROPIC_API_KEY=<paste_your_api_key_here>

Let op dat het model niet gratis is. Om de API-sleutel te activeren, moeten we tegoed aan ons account toevoegen. Het goede nieuws is dat de prijs gelijk is aan die van de twee vorige modellen:

Stap 2: Installeer Python-afhankelijkheden

Laten we vervolgens de benodigde libraries installeren. We hebben nodig:

• anthropic, de officiële Anthropic-SDK voor API-integratie;

• python-dotenv voor het beheren van omgevingsvariabelen;

• pandas om onze geëxtraheerde data te structureren.

Open je terminal en voer de volgende opdracht uit (zorg dat de hierboven gemaakte opus_4_7-omgeving actief is):

pip install anthropic python-dotenv pandas

Stap 3: Maak een tekstchatbot met adaptief denken

Laten we de basis leggen met een eenvoudige asynchrone command-line interface. Deze stap introduceert het nieuwe xhigh-inspanningniveau en de adaptieve denkarcitectuur van Opus 4.7. Maak een bestand met de naam chart_digitizer.py en voeg de volgende code toe:

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

Dit kun je uitvoeren met de opdracht:

python chart_digitizer.py

Dit script laat zien hoe je een verzoek naar Claude Opus 4.7 stuurt, maar het extraheert nog geen data uit een grafiek. Het stuurt alleen de prompt:

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

Stap 4: Definieer het schema voor data-extractie

Om te garanderen dat het model ons schone data levert die we in Pandas kunnen gebruiken, gaan we een "Tool" gebruiken om gestructureerde output af te dwingen. We definiëren een JSON-schema dat Claude precies vertelt hoe de geëxtraheerde grafiekcoördinaten geformatteerd moeten worden.

Werk het bestand chart_digitizer.py bij om het toolschema en een systeemprompt toe te voegen na de client-initialisatie:

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

Om het model te dwingen de tool en systeemprompt te gebruiken, werken we het verzoek bij met de parameters tool en 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",
        }
    )

Stap 5: Voeg een taakbudget toe voor complexe visuele redenering

Het visueel in kaart brengen van honderden datapunten en het exact berekenen van hun waarden vereist enorme cognitieve verwerking. Om onze compute-tegoeden te beschermen, handhaven we een taakbudget. We stellen een adviserende limiet van 80.000 tokens in voor deze operatie. 

We kunnen deze limiet instellen in het verzoek door een task_budget toe te voegen aan 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
        }
    )

Let op de bèta-headers die nodig zijn om deze mogelijkheid te ontgrendelen. Om dit in te stellen, moeten we de manier waarop we de agent initialiseren bijwerken naar:

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

Stap 6: Bouw een hogeresolutie-visual digitalizer

In de laatste fase integreren we de 3,75MP-visuele mogelijkheden. We bouwen een robuuste hulpfunctie voor het inlezen van afbeeldingen en ronden de code af om een CSV-bestand met de data uit te voeren. 

Hier is de complete, definitieve code voor onze visual digitalizer:

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

Om het te testen, heb ik deze grafiek van Yahoo Sports gedownload, die de FIFA-wereldbekeropkomst per jaar laat zien, in een bestand met de naam fifa.webp: 

We voeren het script uit zoals eerder, maar dan met de naam van een grafiekafbeelding als argument:

python chart_digitizer.py fifa.webp 

Hier is het resultaat:

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

Als we dit plotten, kunnen we verifiëren dat het erg nauwkeurig is, ook al had de originele grafiek geen labels op de y-as.

Conclusie

We zijn succesvol overgestapt van het bouwen van een simpele asynchrone chatbot naar het bouwen van een zeer robuuste engine voor visuele redenering voor data science.

Omdat het model geen downsampling vereist, kan het complexe grafieken lezen zonder subpixelfidelity te verliezen. Ik raad aan om deze codebase met verschillende complexe grafieken te testen om zijn capaciteiten echt te waarderen!

Toen ik het model op meerdere grafieken testte, was ik vooral onder de indruk van de nauwkeurigheid. Dit script moet niet als eindproduct worden gezien, want er is nog genoeg ruimte voor verbetering. Wil je je skills oefenen, overweeg dan het volgende:

• Extraheer metadata zoals eenheden en labels van assen: in het voorbeeld hierboven toont de grafiek 3,5, maar we kennen de eenheid niet. De oorspronkelijke grafiek staat voor 3,5M, oftewel 3,5 miljoen mensen.
• Maak het aantal samplepunten instelbaar: het model extraheerde een paar kernpunten, maar haalde niet het aantal bezoekers voor elk afzonderlijk jaar op.

Als je geïnteresseerd bent in programmeren met Anthropics modellen, raad ik je sterk aan onze cursus Software Development with Claude Code te volgen!