Claude Opus 4.7 API-Tutorial: Einen Chart-Digitalisierer bauen

Letzte Woche erschien Claude Opus 4.7, Anthropics neueste Iteration seines Flaggschiff-Modells. Mit einer etwa dreifach höheren visuellen Auflösung und einer wörtlicheren Auslegung komplexer Prompts ist Opus 4.7 darauf ausgelegt, komplexe Benutzeroberflächen zu navigieren und hochauflösende technische Diagramme mit neuer Präzision zu analysieren.

In diesem Tutorial führe ich dich durch die wichtigsten Neuerungen in Claude Opus 4.7. Wir schauen uns an, was das Modell ist, welche zentralen Features es mitbringt und wie du es lokal mit Python einrichtest. Abschließend bauen wir ein voll funktionsfähiges, mehrstufiges Demoprojekt: einen autonomen, hochauflösenden visuellen Chart-Digitalisierer.

Wenn du mehr über Anthropics Large Language Models (LLMs) lernen möchtest, empfehle ich unseren Kurs Introduction to Claude Models.

Was ist Claude Opus 4.7?

Claude Opus 4.7 ist Anthropics neuestes Flaggschiff-LLM. Da das Unternehmen sein leistungsstärkeres Claude Mythos Preview nur für geprüfte Sicherheitsexperten freigibt, bleibt Opus 4.7 die wichtigste, breit verfügbare API für allgemeine Entwicklerzwecke.

Diese Version bringt Verbesserungen in mehreren Bereichen:

• Interpretation visueller Daten
• Mathematische Logik
• Instruktionsbefolgung
• Gedächtnis für Inhalte aus komplexen Codeumgebungen

Entwickler berichten von deutlichen Fortschritten beim Befolgen strikter Anweisungen und der Vermeidung repetitiver Verarbeitungsschleifen. Opus 4.7 überprüft seine Arbeit von Haus aus doppelt und hinterfragt Annahmen, bevor es Code schreibt. Das verringert die Gefahr, dass Agenten in endlosen Fehlerschleifen feststecken, erheblich.

Ein Benchmark sticht besonders hervor: Im anspruchsvollen SWE-bench Pro, der misst, wie gut eine KI reale Open-Source-GitHub-Bugs behebt, legte Opus 4.7 gegenüber seinem Vorgänger um 10,9 Punkte zu. Dieser Sprung festigt die Rolle der Opus-Modellfamilie als Referenz für agentisches Programmieren.

Wenn du mehr über das Modell erfahren möchtest, lies unseren Leitfaden zu Claude Opus 4.7.

Was ist neu in Claude Opus 4.7?

Der Wechsel zu Opus 4.7 führt mehrere neue Steuerungsebenen zur Verwaltung von Rechenressourcen ein und verändert die Prompt-Entwicklung. Hier sind die wichtigsten Änderungen und neuen Features:

• Hochauflösende multimodale Vision: Das Modell akzeptiert nun Bilder mit bis zu 2.576 Pixeln an der längsten Kante und erreicht damit effektiv rund 3,75 Megapixel. Die geometrische Koordinatenabbildung wurde überarbeitet: Bounding-Box-Koordinaten besitzen jetzt eine strikt erzwungene 1:1-Abbildung zu tatsächlichen Bildpixeln. Komplexe Skalierungsfaktoren entfallen.

• Adaptive Thinking: Erweiterte Denkbudgets (z. B. budget_tokens) wurden vollständig entfernt. Alte Anfragen führen zu einem HTTP-400-Fehler. Stattdessen erzwingt Opus 4.7 die Nutzung von „Adaptive Thinking“ (thinking: {"type": "adaptive"}) und weist dem Modell dynamisch ein internes Reasoning-Budget basierend auf der Prompt-Komplexität zu.

• Feinkörnige Aufwandssteuerung: Ein neuer Parameterwert, xhigh (extra hoch), positioniert sich mathematisch zwischen dem Standard-high und dem Maximum max. Anthropic empfiehlt xhigh ausdrücklich als optimalen Startpunkt für agentisches Codieren und komplexe Problemlösungen. Zudem agiert das Modell stärker „wörtlich“: Es führt exakt den bereitgestellten Text aus, ohne „zwischen den Zeilen“ zu lesen.

• Task-Budgets: Um ausufernde agentische Schleifen zu begrenzen, führt Opus 4.7 „Task Budgets“ ein (aktuell Public Beta). Mit einem task_budget definieren Entwickler explizit das gesamte Token-Kontingent für den kompletten Aufgabenlebenszyklus. Das Modell zählt kontinuierlich herunter und steuert sich selbst, um die Aufgabe innerhalb des Budgets sauber abzuschließen.

• Client-seitiges Memory-Tool: Opus 4.7 kann hervorragend auf ein verwaltetes Notizfeld (Scratchpad) schreiben und daraus lesen. Dafür hat Anthropic das client-seitige Memory-Tool erweitert und eine git-gestützte Synchronisierung optimiert für MemFS-Workflows (Memory File System) bereitgestellt.

Einrichtung einer Claude Opus 4.7-Umgebung

Bevor wir unser Demoprojekt codieren, richten wir unsere Umgebung für Opus 4.7 ein. In diesem Tutorial verwenden wir asynchrones Python, da es in datenintensiven, hochgradig parallelen Workflows der Branchenstandard ist.

Du brauchst Python 3.8 oder höher auf deinem System. Ich empfehle dringend, eine isolierte virtuelle Umgebung anzulegen, um Abhängigkeitskonflikte zu vermeiden.

So erstellst und aktivierst du mit Anaconda eine Umgebung namens opus_4_7:

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

Einen autonomen High-Resolution-Chart-Digitalisierer mit Claude Opus 4.7 bauen

Um die theoretischen Fähigkeiten von Claude Opus 4.7 praktisch zu nutzen, bauen wir einen autonomen Chart-Digitalisierer in hoher Auflösung.

Data Scientists stoßen ständig auf wertvolle Daten, die als statische Bilder oder PDFs „eingeschlossen“ sind (etwa Scatterplots, Balken- oder Liniendiagramme). Mit älteren KI-Modellen musste man komplexe Skalierungslogik schreiben, um die Daten automatisiert aus diesen Diagrammen zu extrahieren.

In diesem Projekt schreiben wir ein Python-Skript, das einen Screenshot eines Diagramms nimmt und daraus eine CSV-Datei mit den Rohdaten erzeugt.

Konkret werden wir:

• Die neue 3,75-MP-Vision und die 1:1-Pixelabbildung nutzen, um das Diagramm präzise auszulesen.

• Adaptive Thinking mit dem Aufwandslevel xhigh einsetzen, um X- und Y-Achsen exakt herzuleiten.

• Einen sauberen Pandas DataFrame mit den exakten Datenpunkten ausgeben.

Ich führe dich Schritt für Schritt durch den Prozess. Dieses Tutorial ist in sich geschlossen. Wenn du mehr über die Fähigkeiten des Modells wissen willst oder bei eigenen Agenten hängen bleibst, wirf einen Blick in die offizielle Dokumentation.

Schritt 1: API-Schlüssel einrichten

Zuerst müssen wir die Authentifizierung aktivieren. Lege dazu einen API-Schlüssel in der Anthropic Developer Console an.

Harte API-Zugangsdaten haben im Quellcode-Repository nichts verloren. Erstelle stattdessen eine sichere .env-Datei im Projektstammverzeichnis:

ANTHROPIC_API_KEY=<paste_your_api_key_here>

Beachte, dass das Modell nicht kostenlos ist. Damit der API-Schlüssel funktioniert, musst du Guthaben aufladen. Gute Nachrichten: Die Preise sind identisch zu den beiden vorherigen Modellen:

Schritt 2: Python-Abhängigkeiten installieren

Als Nächstes installieren wir die benötigten Bibliotheken. Wir brauchen:

• anthropic, das offizielle Anthropic-SDK für die API-Integration;

• python-dotenv für das Management von Umgebungsvariablen;

• pandas zur Strukturierung der extrahierten Daten.

Öffne dein Terminal und führe folgenden Befehl aus (stelle sicher, dass die oben erstellte opus_4_7-Umgebung aktiviert ist):

pip install anthropic python-dotenv pandas

Schritt 3: Einen Text-Chatbot mit Adaptive Thinking erstellen

Wir legen die Basis mit einer einfachen asynchronen Kommandozeilenoberfläche. Dieser Schritt führt das neue xhigh-Aufwandslevel und die Adaptive-Thinking-Architektur von Opus 4.7 ein. Erstelle eine Datei chart_digitizer.py und füge folgenden Code ein:

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

Du kannst das mit folgendem Befehl ausführen:

python chart_digitizer.py

Dieses Skript zeigt, wie man eine Anfrage an Claude Opus 4.7 sendet, extrahiert aber noch keine Daten aus einem Diagramm. Es sendet lediglich den Prompt:

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

Schritt 4: Das Schema für die Datenextraktion definieren

Damit das Modell saubere Daten liefert, die wir in Pandas verwenden können, nutzen wir ein „Tool“ für strukturierten Output. Wir definieren ein JSON-Schema, das Claude exakt vorgibt, wie die extrahierten Diagrammkoordinaten zu formatieren sind.

Erweitere die Datei chart_digitizer.py um das Tool-Schema und einen System-Prompt direkt nach der Client-Initialisierung:

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

Um das Modell zum Einsatz des Tools und des System-Prompts zu zwingen, erweitern wir die Anfrage um die Parameter tool und 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",
        }
    )

Schritt 5: Task-Budget für komplexes visuelles Reasoning hinzufügen

Das visuelle Mapping von hunderten Datenpunkten und die exakte Wertberechnung erfordern enorme kognitive Verarbeitung. Um unsere Rechenkosten zu schützen, setzen wir ein Task-Budget. Wir definieren einen Richtwert von 80.000 Token für diesen Vorgang.

Dieses Limit lässt sich in der Anfrage über task_budget im output_config setzen:

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

Beachte die erforderlichen Beta-Header, um diese Fähigkeit zu aktivieren. Aktualisiere dazu die Client-Initialisierung wie folgt:

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

Schritt 6: Einen hochauflösenden visuellen Digitalisierer bauen

Im letzten Schritt integrieren wir die 3,75-MP-Fähigkeiten. Wir bauen eine robuste Hilfsfunktion für das Einlesen von Bildern und finalisieren den Code, der die Daten als CSV-Datei ausgibt.

Hier ist der vollständige, finale Code für unseren visuellen Digitalisierer:

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

Zum Testen habe ich dieses Diagramm von Yahoo Sports heruntergeladen, das die Besucherzahlen der FIFA-Weltmeisterschaft pro Jahr zeigt, und als fifa.webp gespeichert:

Wir führen das Skript wie zuvor aus, diesmal jedoch mit dem Dateinamen des Diagrammbildes als Argument:

python chart_digitizer.py fifa.webp 

Hier ist das Ergebnis:

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

Wenn wir das plotten, sehen wir, dass die Werte sehr genau sind, obwohl das Originaldiagramm keine Beschriftungen auf der Y-Achse hatte.

Fazit

Wir sind von einem einfachen asynchronen Chatbot zu einer sehr robusten visuellen Reasoning-Engine für Data Science übergegangen.

Da das Modell kein Downsampling benötigt, kann es komplexe Diagramme ohne Verlust subpixelgenauer Details auslesen. Probiere den Code ruhig mit verschiedenen anspruchsvollen Grafiken aus, um das Potenzial wirklich zu erleben!

In meinen Tests über mehrere Diagramme hinweg hat mich die Genauigkeit besonders beeindruckt. Dieses Skript ist kein fertiges Produkt – es gibt noch viel Optimierungspotenzial. Wenn du deine Fähigkeiten trainieren willst, hier ein paar Ideen:

• Metadaten wie Achseneinheiten und -beschriftungen extrahieren: Im obigen Beispiel steht im Chart 3,5, aber die Einheit ist unbekannt. Das Original meint 3,5M, also 3,5 Millionen Personen.
• Die Anzahl der Stichprobenpunkte steuern: Das Modell hat einige Schlüsselpunkte extrahiert, aber nicht für jedes einzelne Jahr die Besucherzahl.

Wenn dich das Programmieren mit Anthropics Modellen interessiert, empfehle ich dir unseren Kurs Software Development with Claude Code!