Tutorial da API Claude Opus 4.7: construindo um digitalizador de gráficos

Na semana passada, foi lançado o Claude Opus 4.7, a iteração mais recente do modelo carro-chefe da Anthropic. Com um aumento de aproximadamente três vezes na resolução visual e uma adesão mais literal a prompts complexos, o Opus 4.7 foi feito para navegar por interfaces intrincadas e interpretar diagramas técnicos de alta fidelidade com um novo nível de precisão cirúrgica.

Neste tutorial, vou apresentar as principais mudanças do Claude Opus 4.7. Vamos explorar o que é o modelo, os novos recursos críticos que ele traz e como configurá-lo localmente com Python. Por fim, vamos construir um projeto demonstrativo completo, em múltiplas etapas: um digitalizador autônomo de gráficos visuais em alta resolução.

Se você quer saber mais sobre os modelos de linguagem da Anthropic (LLMs), recomendo nosso curso Introduction to Claude Models.

O que é o Claude Opus 4.7?

Claude Opus 4.7 é o novo LLM carro-chefe da Anthropic. Como a empresa restringe o mais potente Claude Mythos Preview apenas a especialistas em segurança aprovados, o Opus 4.7 segue como a principal API amplamente disponível para desenvolvedores em geral.

Esta versão traz melhorias em várias frentes: 

• Interpretação de dados visuais
• Lógica matemática
• Seguimento de instruções
• Memorização de conteúdo em ambientes de código complexos 

Desenvolvedores relatam avanços notáveis na capacidade do modelo de seguir instruções rígidas e evitar loops de processamento repetitivos. O Opus 4.7 confere duplo check ao próprio trabalho e revisa premissas antes de escrever código, o que reduz muito a chance de agentes ficarem presos em ciclos contínuos de erros.

Ao observar benchmarks, um resultado chama atenção. No exigente teste SWE-bench Pro, que mede quão bem uma IA corrige bugs reais em softwares de código aberto no GitHub, o Opus 4.7 obteve um aumento de 10,9 pontos em relação ao antecessor. Esse salto consolida a família Opus como referência em programação agentic.

Para saber mais sobre o modelo, confira nosso guia do Claude Opus 4.7.

O que há de novo no Claude Opus 4.7?

A evolução para o Opus 4.7 introduz novos planos de controle para gerenciar recursos computacionais e algumas mudanças em prompt engineering. Aqui estão as principais novidades que você precisa conhecer:

• Visão multimodal em alta resolução: O modelo aumenta a dimensão máxima aceita de imagem para 2.576 pixels no maior lado, oferecendo resolução efetiva de ~3,75 megapixels. O mapeamento geométrico de coordenadas foi reformulado: os bounding boxes agora têm mapeamento 1:1 estritamente aplicado com os pixels reais da imagem, eliminando a necessidade de cálculos complicados de fator de escala.

• Pensamento adaptativo: Os orçamentos de pensamento estendido (por exemplo, budget_tokens) foram removidos. Solicitações antigas retornam erro HTTP 400. Em vez disso, o Opus 4.7 exige o uso de "adaptive thinking" (thinking: {"type": "adaptive"}), permitindo que o modelo aloque dinamicamente seu orçamento interno de raciocínio conforme a complexidade do prompt.

• Controle granular de esforço: Um novo valor de parâmetro, xhigh (extra alto), foi posicionado matematicamente entre os níveis high e max. A Anthropic recomenda fortemente o xhigh como ponto de partida ideal para codificação agentic e resolução de problemas complexos. O modelo também ficou mais "literal"; ele executa exatamente o que está no texto, sem "ler nas entrelinhas".

• Orçamentos de tarefa: Para mitigar matematicamente loops agentic descontrolados, o Opus 4.7 introduz os "task budgets" (atualmente em beta público). Ao definir um task_budget, desenvolvedores informam ao modelo o limite total absoluto de tokens para todo o ciclo da tarefa. O modelo acompanha esse contador e se autorregula para concluir a tarefa de forma elegante.

• Ferramenta de memória no client: O Opus 4.7 é excepcionalmente competente em escrever e ler de um scratchpad gerenciado. Para formalizar isso, a Anthropic aprimorou a ferramenta de memória no lado do cliente, com sincronização via Git otimizada para fluxos de trabalho em MemFS (Memory File System).

Configurando um ambiente para o Claude Opus 4.7

Antes de começarmos a codificar o projeto de demonstração, precisamos preparar o ambiente para o Opus 4.7. Neste tutorial, vamos usar Python assíncrono, pois é o padrão do mercado para workloads intensivos em dados e de alta simultaneidade.

É necessário ter o Python 3.8 ou superior instalado. Recomendo fortemente criar um ambiente virtual isolado para evitar conflitos de dependências.

Veja como criar e ativar um ambiente chamado opus_4_7 usando Anaconda:

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

Construindo um digitalizador autônomo de gráficos em alta resolução com o Claude Opus 4.7

Para transformar as capacidades teóricas do Claude Opus 4.7 em uma aplicação prática, vamos construir um digitalizador autônomo de gráficos em alta resolução.

Cientistas de dados frequentemente se deparam com dados valiosos presos em imagens estáticas ou PDFs (como scatter plots, gráficos de barras ou de linhas). Em modelos de IA mais antigos, era preciso escrever cálculos de escala complexos para automatizar a extração de dados desses gráficos.

Neste projeto, vamos criar um script em Python que tira um screenshot de qualquer gráfico e gera um arquivo CSV com os dados brutos. 

Vamos, explicitamente:

• Usar a visão de 3,75 MP e o mapeamento 1:1 por pixel para ler o gráfico com perfeição.

• Usar pensamento adaptativo no nível de esforço xhigh para deduzir rigorosamente os eixos X e Y.

• Gerar um Pandas DataFrame limpo com os pontos de dados exatos.

Vou te guiar passo a passo. Este tutorial é autossuficiente, mas, se quiser se aprofundar nas capacidades do modelo ou travar ao implementar seus próprios agentes, consulte a documentação oficial.

Passo 1: configurar a chave de API

Primeiro, precisamos habilitar a autenticação. Para isso, crie uma chave de API no Anthropic Developer Console.

Nunca versione credenciais de API diretamente no repositório. Em vez disso, gere um arquivo .env seguro na raiz do projeto:

ANTHROPIC_API_KEY=<paste_your_api_key_here>

Atenção: o modelo não é gratuito. Para habilitar a chave, é preciso adicionar créditos à conta. A boa notícia é que o preço do modelo é o mesmo dos dois anteriores:

Passo 2: instalar dependências do Python

Agora vamos instalar as bibliotecas necessárias. Vamos precisar de:

• anthropic, o SDK oficial da Anthropic para integração com a API;

• python-dotenv para gerenciar variáveis de ambiente;

• pandas para estruturar os dados extraídos.

Abra o terminal e execute o comando abaixo (garanta que o ambiente opus_4_7 criado acima está ativo):

pip install anthropic python-dotenv pandas

Passo 3: criar um chatbot de texto com pensamento adaptativo

Vamos começar criando uma interface básica assíncrona de linha de comando. Este passo introduz o novo nível de esforço xhigh e a arquitetura de pensamento adaptativo do Opus 4.7. Crie um arquivo chamado chart_digitizer.py e adicione o código a seguir:

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

Podemos executar com o comando:

python chart_digitizer.py

Este script mostra como enviar uma solicitação ao Claude Opus 4.7, mas ainda não extrai dados de um gráfico. Ele apenas envia o prompt:

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

Passo 4: definir o esquema de extração de dados

Para garantir que o modelo nos entregue dados limpos e prontos para uso no Pandas, vamos usar uma "Tool" para forçar a saída estruturada. Definimos um esquema JSON que diz ao Claude exatamente como formatar as coordenadas extraídas do gráfico.

Atualize o arquivo chart_digitizer.py para incluir o schema da tool e um system prompt após a inicialização do 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.
"""

Para forçar o uso da tool e do system prompt, atualize a requisição para incluir os parâmetros tool e 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",
        }
    )

Passo 5: adicionar task budget para raciocínio visual complexo

Mapear visualmente centenas de pontos de dados e calcular seus valores exatos exige muito processamento cognitivo. Para proteger nossos créditos de computação, vamos impor um orçamento de tarefa. Vamos definir um limite orientativo de 80.000 tokens para esta operação. 

Esse limite pode ser definido na requisição adicionando um task_budget ao 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
        }
    )

Observe os headers beta necessários para ativar esse recurso. Para configurá-los, atualize a inicialização do agente para:

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

Passo 6: construir o digitalizador visual em alta resolução

Na fase final, vamos integrar as capacidades visuais de 3,75 MP. Vamos criar uma função utilitária robusta para ingestão de imagens e finalizar o código para gerar um arquivo CSV com os dados. 

Aqui está o código final e completo do nosso digitalizador visual:

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

Para testar, baixei este gráfico do Yahoo Sports, que mostra a audiência da Copa do Mundo da FIFA por ano, e salvei em um arquivo chamado fifa.webp: 

Executamos o script como antes, mas passando o nome da imagem do gráfico como argumento:

python chart_digitizer.py fifa.webp 

Veja o resultado:

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

Se plotarmos isso, dá para verificar que está muito preciso, mesmo o gráfico original não tendo rótulos no eixo Y.

Conclusão

Saímos de um simples chatbot assíncrono para um mecanismo de raciocínio visual altamente robusto para ciência de dados.

Como o modelo não exige downsampling, ele lê gráficos complexos sem perder fidelidade subpixel. Recomendo testar esta base de código com gráficos variados e complexos para realmente sentir o potencial!

Ao testar o modelo em vários gráficos, me impressionou especialmente a precisão. Este script não deve ser tratado como produto final, pois ainda há muito espaço para melhorias. Se você quer praticar suas habilidades, aqui vão algumas ideias:

• Extrair metadados como unidades e rótulos dos eixos: no exemplo acima, o gráfico mostra 3,5, mas não sabemos a unidade. O gráfico original representa 3,5M, ou seja, 3,5 milhões de pessoas.
• Permitir controle sobre a quantidade de pontos amostrados: o modelo extraiu alguns pontos-chave, mas não a quantidade de espectadores de todos os anos.

Se você tem interesse em programar usando os modelos da Anthropic, recomendo muito o curso Software Development with Claude Code!