Construir con pensamiento extendido

weather_tool = {
    "name": "get_weather",
    "description": "Obtener el clima actual para una ubicación",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

# Primera solicitud - Claude responde con pensamiento y solicitud de herramienta
response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "¿Cuál es el clima en París?"}
    ]
)

# Extraer bloque de pensamiento y bloque de uso de herramienta
thinking_block = next((block for block in response.content
                      if block.type == 'thinking'), None)
tool_use_block = next((block for block in response.content
                      if block.type == 'tool_use'), None)

# Llamar a tu API de clima real, aquí es donde iría tu llamada real a la API
# supongamos que esto es lo que obtenemos
weather_data = {"temperature": 88}

# Segunda solicitud - Incluir bloque de pensamiento y resultado de herramienta
# No se generarán nuevos bloques de pensamiento en la respuesta
continuation = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "¿Cuál es el clima en París?"},
        # nota que el thinking_block se pasa junto con el tool_use_block
        # si esto no se pasa, se genera un error
        {"role": "assistant", "content": [thinking_block, tool_use_block]},
        {"role": "user", "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use_block.id,
            "content": f"Temperatura actual: {weather_data['temperature']}°F"
        }]}
    ]
)

import anthropic

client = anthropic.Anthropic()

# Definir herramientas
calculator_tool = {
    "name": "calculator",
    "description": "Realizar cálculos matemáticos",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Expresión matemática a evaluar"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Consultar base de datos de productos",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Consulta SQL a ejecutar"
            }
        },
        "required": ["query"]
    }
}

# Primera solicitud - Claude piensa una vez antes de todas las llamadas de herramientas
response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    messages=[{
        "role": "user",
        "content": "¿Cuál es el ingreso total si vendemos 150 unidades del producto A a $50 cada una, y cómo se compara esto con nuestro ingreso mensual promedio de la base de datos?"
    }]
)

# La respuesta incluye pensamiento seguido de usos de herramientas
# Nota: Claude piensa una vez al principio, luego toma todas las decisiones de herramientas
print("Primera respuesta:")
for block in response.content:
    if block.type == "thinking":
        print(f"Pensamiento (resumido): {block.thinking}")
    elif block.type == "tool_use":
        print(f"Uso de herramienta: {block.name} con entrada {block.input}")
    elif block.type == "text":
        print(f"Texto: {block.text}")

# Ejecutarías las herramientas y devolverías resultados...
# Después de obtener ambos resultados de herramientas, Claude responde directamente sin pensamiento adicional

import anthropic

client = anthropic.Anthropic()

# Mismas definiciones de herramientas que antes
calculator_tool = {
    "name": "calculator",
    "description": "Realizar cálculos matemáticos",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Expresión matemática a evaluar"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Consultar base de datos de productos",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Consulta SQL a ejecutar"
            }
        },
        "required": ["query"]
    }
}

# Primera solicitud con pensamiento intercalado habilitado
response = client.beta.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[{
        "role": "user",
        "content": "¿Cuál es el ingreso total si vendemos 150 unidades del producto A a $50 cada una, y cómo se compara esto con nuestro ingreso mensual promedio de la base de datos?"
    }]
)

print("Respuesta inicial:")
thinking_blocks = []
tool_use_blocks = []

for block in response.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Pensamiento: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Uso de herramienta: {block.name} con entrada {block.input}")
    elif block.type == "text":
        print(f"Texto: {block.text}")

# Primer resultado de herramienta (calculadora)
calculator_result = "7500"  # 150 * 50

# Continuar con primer resultado de herramienta
response2 = client.beta.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "¿Cuál es el ingreso total si vendemos 150 unidades del producto A a $50 cada una, y cómo se compara esto con nuestro ingreso mensual promedio de la base de datos?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        }
    ]
)

print("\nDespués del resultado de la calculadora:")
# Con pensamiento intercalado, Claude puede pensar sobre el resultado de la calculadora
# antes de decidir consultar la base de datos
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Pensamiento intercalado: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Uso de herramienta: {block.name} con entrada {block.input}")

# Segundo resultado de herramienta (base de datos)
database_result = "5200"  # Ejemplo de ingreso mensual promedio

# Continuar con segundo resultado de herramienta
response3 = client.beta.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "¿Cuál es el ingreso total si vendemos 150 unidades del producto A a $50 cada una, y cómo se compara esto con nuestro ingreso mensual promedio de la base de datos?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        },
        {
            "role": "assistant",
            "content": thinking_blocks[1:] + tool_use_blocks[1:]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[1].id,
                "content": database_result
            }]
        }
    ]
)

print("\nDespués del resultado de la base de datos:")
# Con pensamiento intercalado, Claude puede pensar sobre ambos resultados
# antes de formular la respuesta final
for block in response3.content:
    if block.type == "thinking":
        print(f"Pensamiento final: {block.thinking}")
    elif block.type == "text":
        print(f"Respuesta final: {block.text}")

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Eliminar elementos de script y estilo
    for script in soup(["script", "style"]):
        script.decompose()

    # Obtener texto
    text = soup.get_text()

    # Dividir en líneas y eliminar espacios en blanco al inicio y final de cada una
    lines = (line.strip() for line in text.splitlines())
    # Dividir titulares multi-línea en una línea cada una
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Descartar líneas en blanco
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Obtener el contenido del artículo
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Usar solo suficiente texto para almacenamiento en caché (primeros capítulos)
LARGE_TEXT = book_content[:5000]

SYSTEM_PROMPT=[
    {
        "type": "text",
        "text": "Eres un asistente de IA que se encarga del análisis literario. Analiza el siguiente texto cuidadosamente.",
    },
    {
        "type": "text",
        "text": LARGE_TEXT,
        "cache_control": {"type": "ephemeral"}
    }
]

MESSAGES = [
    {
        "role": "user",
        "content": "Analiza el tono de este pasaje."
    }
]

# Primera solicitud - establecer caché
print("Primera solicitud - estableciendo caché")
response1 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Uso de primera respuesta: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analiza los personajes en este pasaje."
})
# Segunda solicitud - mismos parámetros de pensamiento (se espera acierto de caché)
print("\nSegunda solicitud - mismos parámetros de pensamiento (se espera acierto de caché)")
response2 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Uso de segunda respuesta: {response2.usage}")

# Tercera solicitud - parámetros de pensamiento diferentes (se espera fallo de caché para mensajes)
print("\nTercera solicitud - parámetros de pensamiento diferentes (se espera fallo de caché para mensajes)")
response3 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Presupuesto de pensamiento cambiado
    },
    system=SYSTEM_PROMPT,  # El prompt del sistema permanece en caché
    messages=MESSAGES  # El caché de mensajes se invalida
)

print(f"Uso de tercera respuesta: {response3.usage}")

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Eliminar elementos de script y estilo
    for script in soup(["script", "style"]):
        script.decompose()

    # Obtener texto
    text = soup.get_text()

    # Dividir en líneas y eliminar espacios en blanco al inicio y final de cada una
    lines = (line.strip() for line in text.splitlines())
    # Dividir titulares multi-línea en una línea cada una
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Descartar líneas en blanco
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Obtener el contenido del artículo
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Usar solo suficiente texto para almacenamiento en caché (primeros capítulos)
LARGE_TEXT = book_content[:5000]

# Sin prompt del sistema - almacenamiento en caché en mensajes en su lugar
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {
                "type": "text",
                "text": "Analiza el tono de este pasaje."
            }
        ]
    }
]

# Primera solicitud - establecer caché
print("Primera solicitud - estableciendo caché")
response1 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    messages=MESSAGES
)

print(f"Uso de primera respuesta: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analiza los personajes en este pasaje."
})
# Segunda solicitud - mismos parámetros de pensamiento (se espera acierto de caché)
print("\nSegunda solicitud - mismos parámetros de pensamiento (se espera acierto de caché)")
response2 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Mismo presupuesto de pensamiento
    },
    messages=MESSAGES
)

print(f"Uso de segunda respuesta: {response2.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response2.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analiza el escenario en este pasaje."
})

# Tercera solicitud - presupuesto de pensamiento diferente (se espera fallo de caché)
print("\nTercera solicitud - presupuesto de pensamiento diferente (se espera fallo de caché)")
response3 = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Presupuesto de pensamiento diferente rompe caché
    },
    messages=MESSAGES
)

print(f"Uso de tercera respuesta: {response3.usage}")

import anthropic

client = anthropic.Anthropic()

# Usar un prompt especial que desencadena pensamiento redactado (solo para propósitos de demostración)
response = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB"
    }]
)

# Identificar bloques de pensamiento redactado
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("La respuesta contiene bloques de pensamiento redactado")
    # Estos bloques aún son usables en solicitudes posteriores

    # Extraer todos los bloques (tanto redactados como no redactados)
    all_thinking_blocks = [
        block for block in response.content
        if block.type in ["thinking", "redacted_thinking"]
    ]

    # Cuando se pasa a solicitudes posteriores, incluir todos los bloques sin modificación
    # Esto preserva la integridad del razonamiento de Claude

    print(f"Se encontraron {len(all_thinking_blocks)} bloques de pensamiento en total")
    print(f"Estos bloques aún son facturables como tokens de salida")