Tutorial API Claude Opus 4.7: Membangun Chart Digitizer

Pekan lalu dirilis Claude Opus 4.7, iterasi terbaru dari model andalan Anthropic. Dengan peningkatan sekitar tiga kali lipat pada resolusi visual dan kepatuhan yang lebih literal terhadap prompt kompleks, Opus 4.7 dirancang untuk menavigasi antarmuka pengguna yang rumit dan mengurai diagram teknis berfidelitas tinggi dengan tingkat presisi baru yang sangat tajam.

Dalam tutorial ini, saya akan memandu Anda melalui perubahan utama yang diperkenalkan di Claude Opus 4.7. Kita akan menjelajahi apa itu model ini, fitur-fitur penting yang dibawanya, dan cara menyiapkannya secara lokal dengan Python. Terakhir, kita akan membangun proyek demonstrasi multi-langkah yang sepenuhnya fungsional: sebuah chart digitizer visual beresolusi tinggi yang otonom.

Saya merekomendasikan mengikuti kursus Introduction to Claude Models jika Anda ingin mempelajari lebih lanjut tentang model bahasa besar (LLM) Anthropic.

Apa itu Claude Opus 4.7?

Claude Opus 4.7 adalah LLM andalan terbaru dari Anthropic. Karena perusahaan membatasi Claude Mythos Preview yang lebih kuat hanya untuk pakar keamanan yang disetujui, Opus 4.7 tetap menjadi antarmuka pemrograman aplikasi utama yang tersedia luas untuk pengembang umum.

Versi ini menghadirkan peningkatan di beberapa area berbeda: 

• Interpretasi data visual
• Logika matematis
• Pengikutan instruksi
• Menghafal konten dari lingkungan pengkodean yang kompleks 

Para pengembang mencatat peningkatan nyata dalam kemampuannya mengikuti instruksi ketat dan menghindari loop pemrosesan repetitif. Opus 4.7 secara inheren memeriksa ulang pekerjaannya dan meninjau asumsi sebelum menulis kode, yang sangat mengurangi kemungkinan agen terjebak dalam loop kesalahan berkelanjutan.

Saat melihat data tolok ukur, satu hasil menonjol. Dalam tes SWE-bench Pro yang menuntut, yang mengukur seberapa baik AI memperbaiki bug perangkat lunak GitHub open-source nyata, Opus 4.7 mencapai peningkatan 10,9 poin dibanding pendahulunya. Lompatan ini memantapkan peran keluarga model Opus sebagai primus pemrograman agentic.

Untuk mempelajari lebih lanjut tentang model ini, lihat panduan kami tentang Claude Opus 4.7.

Apa yang Baru di Claude Opus 4.7?

Transisi ke Opus 4.7 memperkenalkan beberapa bidang kontrol baru sepenuhnya untuk mengelola sumber daya komputasi dan beberapa pergeseran dalam rekayasa prompt. Berikut perubahan besar dan fitur baru yang perlu Anda ketahui:

• Visi multimodal beresolusi tinggi: Model ini mendorong dimensi gambar maksimum yang diterima hingga 2.576 piksel pada sisi terpanjang, menghasilkan resolusi efektif sekitar 3,75 megapiksel. Pemetaan koordinat geometris telah ditata ulang, artinya koordinat bounding box kini memiliki pemetaan 1:1 yang ditegakkan secara ketat dengan piksel gambar sebenarnya, yang menghilangkan kebutuhan akan matematika faktor skala yang rumit.

• Pemikiran adaptif: Anggaran pemikiran yang diperluas (misalnya, budget_tokens) telah dihapus sepenuhnya. Mengirim permintaan warisan akan mengembalikan kesalahan penolakan HTTP 400. Sebagai gantinya, Opus 4.7 mewajibkan penggunaan "pemikiran adaptif" (thinking: {"type": "adaptive"}), yang memungkinkan model mengalokasikan secara dinamis anggaran penalaran internalnya berdasarkan kompleksitas prompt.

• Kontrol upaya yang granular: Nilai parameter baru, xhigh (ekstra tinggi), diposisikan secara matematis di antara konfigurasi upaya standar high dan upaya maksimum max. Anthropic sangat merekomendasikan xhigh sebagai titik awal optimal untuk pengkodean agentic dan pemecahan masalah kompleks. Model ini juga bergeser ke arah "literalisme" absolut; model mengeksekusi teks persis seperti yang diberikan tanpa "membaca di antara baris".

• Anggaran tugas: Untuk memitigasi secara matematis loop agentic yang tak terkendali, Opus 4.7 memperkenalkan "task budgets" (saat ini dalam beta publik). Dengan mendefinisikan task_budget, pengembang secara eksplisit memberi tahu model tentang total alokasi token absolut untuk seluruh siklus hidup tugas. Model terus melacak hitungan mundur ini dan mengatur diri sendiri untuk memastikan penyelesaian tugas yang mulus.

• Alat memori sisi klien: Opus 4.7 sangat mahir menulis ke dan membaca dari scratchpad terkelola. Untuk memformalkannya, Anthropic meningkatkan alat memori sisi klien, menyediakan kemampuan sinkronisasi berbasis git yang dioptimalkan untuk alur kerja MemFS (Memory File System).

Menyiapkan Lingkungan Claude Opus 4.7

Sebelum mulai membuat kode untuk proyek demo, kita perlu menyiapkan lingkungan yang mendukung Opus 4.7. Untuk tutorial ini, kita akan menggunakan Python asinkron, karena ini merupakan standar industri untuk alur kerja padat data dan berkonkurensi tinggi.

Kita perlu memasang Python 3.8 atau lebih tinggi di sistem. Saya sangat merekomendasikan membuat lingkungan virtual terisolasi untuk mencegah konflik dependensi.

Berikut cara membuat dan mengaktifkan lingkungan bernama opus_4_7 menggunakan Anaconda:

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

Membangun Chart Digitizer Otonom Beresolusi Tinggi dengan Claude Opus 4.7

Untuk menerapkan kemampuan teoretis Claude Opus 4.7 ke aplikasi praktis, kita akan membangun sebuah chart digitizer otonom beresolusi tinggi.

Data scientist sering menjumpai data berharga yang terkunci sebagai gambar statis atau PDF (seperti scatter plot, bar chart, atau line graph). Menggunakan model AI yang lebih lama memerlukan penulisan matematika faktor skala yang rumit untuk mengotomatiskan ekstraksi data dari grafik tersebut.

Dalam proyek ini, kita akan membangun skrip Python yang mengambil tangkapan layar grafik apa pun dan membuat berkas CSV berisi data mentahnya. 

Secara eksplisit, kita akan:

• Memanfaatkan visi 3,75MP dan pemetaan piksel 1:1 yang baru untuk membaca grafik dengan sempurna.

• Menggunakan pemikiran adaptif pada tingkat upaya xhigh untuk menyimpulkan sumbu X dan Y secara ketat.

• Menghasilkan Pandas DataFrame yang bersih berisi titik data yang tepat.

Saya akan memandu Anda langkah demi langkah. Tutorial ini berdiri sendiri, tetapi jika Anda ingin mempelajari lebih lanjut tentang kemampuan model atau mengalami kendala saat menerapkan agen Anda sendiri, lihat dokumentasi resminya.

Langkah 1: Siapkan kunci API

Pertama-tama, kita perlu mengaktifkan autentikasi. Untuk itu, kita perlu membuat kunci API di Anthropic Developer Console.

Jangan pernah meng-hardcode kredensial API langsung ke repositori kode sumber Anda. Sebagai gantinya, buat berkas .env yang aman di direktori root proyek Anda:

ANTHROPIC_API_KEY=<paste_your_api_key_here>

Perhatikan bahwa model ini tidak gratis. Untuk mengaktifkan kunci API, kita perlu menambahkan kredit ke akun. Kabar baiknya, harga model sama dengan dua model sebelumnya:

Langkah 2: Pasang dependensi Python

Selanjutnya, mari kita pasang pustaka yang diperlukan. Kita akan membutuhkan:

• anthropic, SDK resmi anthropic untuk integrasi API;

• python-dotenv untuk manajemen variabel lingkungan;

• pandas untuk menyusun data hasil ekstraksi.

Buka terminal Anda dan jalankan perintah berikut (pastikan lingkungan opus_4_7 yang kita buat di atas sedang aktif):

pip install anthropic python-dotenv pandas

Langkah 3: Buat chatbot teks dengan pemikiran adaptif

Mari kita membangun fondasinya dengan membuat antarmuka baris perintah asinkron dasar. Langkah ini memperkenalkan tingkat upaya xhigh yang baru dari Opus 4.7 dan arsitektur pemikiran adaptif. Buat berkas bernama chart_digitizer.py dan tambahkan kode berikut:

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

Kita dapat menjalankannya dengan perintah:

python chart_digitizer.py

Skrip ini menunjukkan cara mengirim permintaan ke Claude Opus 4.7, tetapi belum mengekstrak data dari grafik. Skrip ini hanya mengirim prompt:

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

Langkah 4: Definisikan skema ekstraksi data

Untuk menjamin model memberi kita data bersih yang dapat digunakan di Pandas, kita akan menggunakan sebuah "Tool" untuk memaksa keluaran terstruktur. Kita mendefinisikan skema JSON yang memberi tahu Claude secara tepat bagaimana memformat koordinat grafik yang diekstraksi.

Perbarui berkas chart_digitizer.py untuk menyertakan skema tool dan system prompt setelah inisialisasi klien:

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

Untuk memaksa model menggunakan tool dan system prompt, kita memperbarui permintaan untuk memasukkan parameter tool dan 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",
        }
    )

Langkah 5: Tambahkan anggaran tugas untuk penalaran visual yang kompleks

Memetakan ratusan titik data secara visual dan menghitung nilai pastinya membutuhkan pemrosesan kognitif yang sangat besar. Untuk melindungi kredit komputasi kita, kita menerapkan Task Budget. Kita akan menetapkan batas saran sebesar 80.000 token untuk operasi ini. 

Kita dapat menetapkan batas ini pada permintaan dengan menambahkan task_budget ke 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
        }
    )

Perhatikan header beta yang diperlukan untuk membuka kemampuan ini. Untuk menyiapkannya, kita perlu memperbarui cara kita menginisialisasi agen menjadi:

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

Langkah 6: Bangun visual digitizer beresolusi tinggi

Pada fase terakhir, kita mengintegrasikan kemampuan visual 3,75MP. Kita akan membangun fungsi utilitas yang andal untuk menangani pemasukan gambar dan menyelesaikan kode untuk menghasilkan berkas CSV berisi data. 

Berikut kode lengkap final untuk visual digitizer kita:

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

Untuk mengujinya, saya mengunduh grafik ini dari Yahoo Sports, yang menampilkan jumlah penonton Piala Dunia FIFA per tahun ke dalam berkas bernama fifa.webp: 

Kita mengeksekusi skrip seperti sebelumnya, tetapi dengan memberikan nama gambar grafik sebagai argumen:

python chart_digitizer.py fifa.webp 

Hasilnya seperti ini:

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

Jika kita memplotnya, kita dapat memverifikasi bahwa hasilnya sangat akurat meski grafik asli tidak memiliki label pada sumbu y.

Kesimpulan

Kita telah berhasil beralih dari membangun chatbot asinkron sederhana menjadi membangun mesin penalaran visual yang sangat tangguh untuk data science.

Karena model tidak memerlukan downsampling, model dapat membaca grafik kompleks tanpa kehilangan fidelitas subpiksel. Saya merekomendasikan menguji basis kode ini dengan berbagai grafik kompleks untuk benar-benar mengapresiasi kemampuannya!

Saat saya menguji model pada banyak grafik, saya sangat terkesan dengan akurasinya. Skrip ini tidak boleh diperlakukan sebagai produk final, karena masih banyak ruang untuk perbaikan. Jika Anda ingin melatih keterampilan Anda, berikut beberapa saran:

• Ekstrak metadata seperti satuan dan label sumbu: Pada contoh di atas, grafik menampilkan 3,5, tetapi kita tidak tahu satuannya. Grafik asli merepresentasikan 3,5M, artinya 3,5 juta orang.
• Aktifkan kontrol atas jumlah titik sampel: Model mengekstrak beberapa titik kunci, tetapi tidak mengekstrak jumlah penonton untuk setiap tahun.

Jika Anda tertarik pemrograman menggunakan model Anthropic, saya sangat merekomendasikan Anda mengikuti kursus Software Development with Claude Code!