programa
Fundamentos de agentes de IA
6 h
La semana pasada se lanzó Claude Opus 4.7, la última iteración del modelo insignia de Anthropic. Con un aumento aproximado por tres en la resolución visual y una adhesión más literal a indicaciones complejas, Opus 4.7 está diseñado para moverse por interfaces intrincadas y analizar diagramas técnicos de alta fidelidad con una precisión quirúrgica inédita.
En este tutorial, te guiaré por los principales cambios introducidos en Claude Opus 4.7. Veremos qué es el modelo, qué funciones nuevas incorpora y cómo configurarlo en local con Python. Por último, construiremos un proyecto de demostración completo y por etapas: un digitalizador autónomo de gráficos con alta resolución.
Si quieres aprender más sobre los modelos de lenguaje de gran tamaño (LLM) de Anthropic, te recomiendo nuestro curso Introduction to Claude Models.
¿Qué es Claude Opus 4.7?
Claude Opus 4.7 es el nuevo LLM insignia de Anthropic. Dado que la compañía limita su modelo más potente, Claude Mythos Preview, solo a expertos en seguridad aprobados, Opus 4.7 sigue siendo su principal API de acceso general para desarrolladores.
Esta versión trae mejoras en varias áreas:
- Interpretación de datos visuales
- Lógica matemática
- Seguimiento de instrucciones
- Memorización de contenido en entornos de código complejos
Los desarrolladores han notado mejoras claras en su capacidad para seguir instrucciones estrictas y evitar bucles repetitivos de procesamiento. Opus 4.7 comprueba de forma inherente su propio trabajo y revisa supuestos antes de escribir código, lo que reduce en gran medida el riesgo de que los agentes se queden atascados en bucles de error continuos.
Al mirar los benchmarks, destaca un resultado. En la exigente prueba SWE-bench Pro, que mide cómo corrige una IA errores reales en software open source de GitHub, Opus 4.7 logró un aumento de 10,9 puntos respecto a su predecesor. Este salto consolida a la familia Opus como referente en programación agentic.
Para saber más sobre el modelo, consulta nuestra guía de Claude Opus 4.7.
¿Qué hay de nuevo en Claude Opus 4.7?
El paso a Opus 4.7 introduce varios planos de control nuevos para gestionar recursos computacionales y algunos cambios en el prompt engineering. Estas son las novedades y cambios clave que debes conocer:
-
Visión multimodal de alta resolución: El modelo eleva la dimensión máxima aceptada en imágenes a 2.576 píxeles en el lado más largo, lo que supone una resolución efectiva de ~3,75 megapíxeles. Se ha renovado el mapeo de coordenadas geométricas: las coordenadas de los bounding boxes ahora tienen un mapeo 1:1 estricto con los píxeles reales de la imagen, eliminando la necesidad de cálculos complejos de escala.
-
Pensamiento adaptativo: Se han eliminado por completo los presupuestos de razonamiento ampliado (por ejemplo,
budget_tokens). Enviar peticiones heredadas devolverá un error HTTP 400. En su lugar, Opus 4.7 obliga a usar "adaptive thinking" (thinking: {"type": "adaptive"}), que permite al modelo asignar dinámicamente su propio presupuesto interno de razonamiento en función de la complejidad del prompt. -
Control granular del esfuerzo: Un nuevo valor de parámetro,
xhigh(extra alto), se sitúa matemáticamente entre la configuración estándarhighy la máximamax. Anthropic recomienda encarecidamentexhighcomo punto de partida óptimo para programación agentic y resolución de problemas complejos. El modelo también se ha orientado hacia un "literalismo" absoluto; ejecuta exactamente el texto proporcionado sin "leer entre líneas". -
Presupuestos de tarea: Para mitigar matemáticamente los bucles agentic descontrolados, Opus 4.7 introduce los "task budgets" (actualmente en beta pública). Al definir un
task_budget, los desarrolladores indican de forma explícita al modelo el total absoluto de tokens permitido para todo el ciclo de vida de la tarea. El modelo monitoriza continuamente esta cuenta atrás y se autorregula para asegurar un cierre ordenado. -
Herramienta de memoria en cliente: Opus 4.7 es excepcionalmente hábil escribiendo y leyendo desde un bloc de notas gestionado. Para formalizarlo, Anthropic ha mejorado la herramienta de memoria en cliente, incorporando sincronización respaldada por git optimizada para flujos de trabajo con MemFS (Memory File System).
Configurar un entorno para Claude Opus 4.7
Antes de ponernos a programar el proyecto de demo, necesitamos preparar el entorno para que soporte Opus 4.7. En este tutorial usaremos Python asíncrono, ya que es el estándar del sector para flujos de trabajo intensivos en datos y de alta concurrencia.
Necesitamos tener instalado Python 3.8 o superior. Te recomiendo encarecidamente crear un entorno virtual aislado para evitar conflictos de dependencias.
Así puedes crear y activar un entorno llamado opus_4_7 con Anaconda:
conda create -n opus_4_7 python=3.10 -y
conda activate opus_4_7Crear un digitalizador autónomo de gráficos en alta resolución con Claude Opus 4.7
Para llevar las capacidades teóricas de Claude Opus 4.7 a una aplicación práctica, construiremos un digitalizador autónomo de gráficos en alta resolución.
Los data scientists se encuentran constantemente con datos valiosos encerrados en imágenes estáticas o PDFs (como diagramas de dispersión, gráficos de barras o líneas). Con modelos de IA anteriores, había que escribir complejos cálculos de escala para automatizar la extracción de datos de estos gráficos.
En este proyecto, crearemos un script en Python que toma una captura de pantalla de cualquier gráfico y genera un archivo CSV con los datos en bruto.
En concreto, vamos a:
-
Usar la nueva visión de 3,75 MP y el mapeo 1:1 de píxeles para leer el gráfico a la perfección.
-
Usar pensamiento adaptativo con nivel de esfuerzo
xhighpara deducir rigurosamente los ejes X e Y. -
Generar un DataFrame de Pandas limpio con los puntos de datos exactos.
Te acompañaré paso a paso. Este tutorial es autosuficiente, pero si quieres profundizar en las capacidades del modelo o te atascas al implementar tus propios agentes, consulta su documentación oficial.
Paso 1: configurar la clave de API
Lo primero es habilitar la autenticación. Para ello, debemos crear una clave de API en la Anthropic Developer Console.
Nunca incluyas credenciales de API directamente en tu repositorio. En su lugar, genera un archivo seguro .env en la raíz de tu proyecto:
ANTHROPIC_API_KEY=<paste_your_api_key_here>Ten en cuenta que el modelo no es gratuito. Para activar la clave de API, debemos añadir créditos a nuestra cuenta. La buena noticia es que el precio del modelo es el mismo que en las dos versiones anteriores:
Paso 2: instalar dependencias de Python
A continuación, instalemos las librerías necesarias. Vamos a necesitar:
-
anthropic, el SDK oficial de Anthropic para integrar la API; -
python-dotenvpara gestionar variables de entorno; -
pandaspara estructurar los datos extraídos.
Abre tu terminal y ejecuta el siguiente comando (asegúrate de tener activo el entorno opus_4_7 que creamos antes):
pip install anthropic python-dotenv pandasPaso 3: crear un chatbot de texto con pensamiento adaptativo
Empecemos por construir una interfaz básica asíncrona en la línea de comandos. Este paso introduce el nuevo nivel de esfuerzo xhigh y la arquitectura de pensamiento adaptativo de Opus 4.7. Crea un archivo llamado chart_digitizer.py y añade el siguiente código:
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 ejecutarlo con el comando:
python chart_digitizer.pyEste script muestra cómo enviar una solicitud a Claude Opus 4.7, pero aún no extrae datos de un gráfico. Solo envía el prompt:
Explain why 1:1 pixel mapping is crucial for data extraction.Paso 4: definir el esquema de extracción de datos
Para garantizar que el modelo nos devuelva datos limpios que podamos usar en Pandas, utilizaremos una "Tool" para forzar una salida estructurada. Definimos un esquema JSON que indica a Claude exactamente cómo formatear las coordenadas extraídas del gráfico.
Para obligar al modelo a usar la herramienta y el system prompt, actualiza el archivo chart_digitizer.py para incluir el esquema de la herramienta y un prompt de sistema tras la inicialización del cliente:
# 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 forzar al modelo a usar la herramienta y el system prompt, actualizamos la petición para incluir los parámetros tool y 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",
}
)Paso 5: añadir presupuesto de tarea para razonamiento visual complejo
Mapear visualmente cientos de puntos y calcular sus valores exactos requiere un gran esfuerzo de cómputo. Para proteger nuestros créditos, imponemos un presupuesto de tarea. Estableceremos un límite orientativo de 80.000 tokens para esta operación.
Podemos fijar este límite en la solicitud añadiendo un task_budget al 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
}
)Fíjate en las cabeceras beta necesarias para activar esta función. Para configurarlo, debemos inicializar el agente así:
client = AsyncAnthropic(
api_key=os.environ.get("ANTHROPIC_API_KEY"),
default_headers={"anthropic-beta": "task-budgets-2026-03-13"}
)Paso 6: crear un digitalizador visual de alta resolución
En la fase final, integramos las capacidades visuales de 3,75 MP. Construiremos una función utilitaria robusta para gestionar la ingestión de imágenes y finalizaremos el código para generar un archivo CSV con los datos.
Este es el código final y completo de nuestro 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 probarlo, descargué este gráfico de Yahoo Sports, que muestra la asistencia a la Copa Mundial de la FIFA por año, en un archivo llamado fifa.webp:
Ejecutamos el script como antes, pero pasando el nombre de una imagen de gráfico como argumento:
python chart_digitizer.py fifa.webp Este es el 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 1870000Si lo representamos, podemos comprobar que es muy preciso, a pesar de que el gráfico original no tenía etiquetas en el eje Y.
Conclusión
Hemos pasado de crear un simple chatbot asíncrono a construir un motor de razonamiento visual altamente robusto para data science.
Como el modelo no requiere reducir la resolución, puede leer gráficos complejos sin perder fidelidad subpíxel. Te recomiendo probar este código con distintos gráficos complejos para apreciar de verdad sus capacidades.
Al probar el modelo en varios gráficos, me impresionó especialmente su precisión. Este script no debe tomarse como un producto final, aún hay margen de mejora. Si quieres practicar tus habilidades, aquí tienes algunas ideas:
- Extraer metadatos como unidades y etiquetas de los ejes: en el ejemplo, el gráfico muestra 3,5, pero no sabemos la unidad. El gráfico original representa 3,5M, es decir, 3,5 millones de personas.
- Permitir controlar el número de puntos muestreados: el modelo extrajo algunos puntos clave, pero no la asistencia de todos y cada uno de los años.
Si te interesa programar con los modelos de Anthropic, te recomiendo mucho nuestro curso Software Development with Claude Code.