Cómo utilizar el SDK de Claude Agent con Claude Sonnet 4.5

El SDK de Claude Agent describe un bucle de agente estructurado que implica cuatro pasos clave: recopilación de contexto, tomar medidas, verificación del trabajo, y repetir.

En la práctica, comienza con la búsqueda agencial para el contexto y añade la búsqueda semántica cuando necesites velocidad. Las acciones deben centrarse en herramientas de alta señal, scripts bash e integraciones con servicios externos a través del Protocolo de contexto de modelo. 

La verificación combina comprobaciones basadas en reglas, comentarios visuales y asistencia LLM opcional. Se recomienda continuar con la iteración para perfeccionar el rendimiento, ampliar las herramientas y mejorar las capacidades de búsqueda a medida que se desarrollan las funciones.

Características principales:

1. SDK: TypeScript y Python para backends web/Node.js y ciencia de datos, con conceptos compartidos para que los equipos puedan reutilizar patrones en todas las pilas.
2. Modos: Transmisión para una experiencia de usuario interactiva y de baja latencia, y ejecución única para procesos por lotes o deterministas: elige según la tarea para equilibrar velocidad y control.
3. Gestión del contexto: Compactación automática y control de contexto a largo plazo para evitar desbordamientos y mantener a los agentes en el programa durante sesiones prolongadas.
4. Herramientas: Operaciones de archivos integradas, ejecución de código y búsqueda web, además de extensibilidad para herramientas y datos externos a través de MCP.
5. Permisos: Controles de capacidad detallados (por ejemplo, modos de permiso/denegación y políticas por herramienta) para restringir lo que un agente puede hacer en producción.
6. Listo para la producción: Gestión de errores, gestión de sesiones y supervisión integradas para que puedas implementar agentes fiables con capacidad de observación desde el primer día.
7. Integración de Claude: Almacenamiento automático en caché de indicaciones y optimizaciones de rendimiento para reducir la latencia y los costes, al tiempo que se mejora el rendimiento.
8. Autenticación: Utiliza una clave API de Claude o utiliza proveedores como Amazon Bedrock y Google Vertex AI para adaptarte a tu entorno de implementación.
9. Mensajes del sistema: Define el rol, la experiencia y las pautas para moldear el comportamiento de los agentes de manera coherente en todas las tareas y sesiones.
10. Integraciones (MCP): Conecta herramientas personalizadas, bases de datos y API a través del protocolo abierto Model Context Protocol, un estándar respaldado por Anthropic con SDK oficiales de TypeScript y un ecosistema en crecimiento.

Introducción al SDK de Claude Agent en Python

Antes de comenzar a crear cualquier proyecto, deberás configurar algunos requisitos previos, instalar la CLI de Claude Code y el SDK de Claude Agent.

Requisitos previos

• Asegúrate de tener la versión 3.10 o superior de Python. 
• Para utilizar Claude Code CLI de forma eficaz, también es necesario instalar Node.js versión 18 o superior y el paquete NPM.

Instalar Claude Code CLI

Para Windows: 

Abre PowerShell y ejecuta el siguiente comando para descargar e instalar Claude Code:

irm https://claude.ai/install.ps1 | iex

Después de la instalación, añade C:\Users\\.local\bin a la ruta PATH de tu sistema. Reinicia PowerShell y deberías ver que Claude se está ejecutando.

Para otras plataformas:

Si tienes Node.js y NPM instalados, prueba a ejecutar el siguiente comando en la terminal para instalar Claude Code:

npm i -g @anthropic-ai/claude-code

Sigue las instrucciones para configurar tus variables de entorno de modo que puedas acceder a Claude Code simplemente escribiendo «claude» en la terminal.

Configuración de Claude Code

Después de instalar Claude Code, ábrelo escribiendo «claude» en el terminal e inicia sesión. Si tienes un plan Claude Pro o Max, selecciona «Iniciar sesión con tu cuenta de suscripción» para que el uso se contabilice en tu plan.

Si prefieres el pago por uso, autentícate con una clave API; la facturación se realizará a través de la consola de Anthropic. 

Por último, configura tus preferencias de tema e interfaz/CLI para que todo se adapte a tu flujo de trabajo desde el primer día.

He configurado mi Claude Code con la clave API. Puedes ver la configuración aquí:

Instalar Claude Agent SDK

Asegúrate de que Python está instalado y, a continuación, abre tu terminal. Para instalar el SDK de Claude Agent, ejecuta:

pip install claude-agent-sdk

Nota: Si te encuentras con un CLINotFoundError, asegúrate de haber instalado la CLI anterior y de que Claude esté incluido en tu PATH.

Creación de proyectos con Claude Agent SDK y Claude Sonnet 4.5

Ahora crearemos tres proyectos sencillos utilizando el SDK de Claude Agent como marco de trabajo, el código Claude para herramientas y uso informático, y Claude Sonnet 4.5 como modelo de IA.

1. Esquema del blog de una sola publicación: Una consulta sencilla de un solo paso que muestra el uso básico del SDK de Claude Agent sin herramientas.
2. InspireBot CLI: Este proyecto combina funciones de búsqueda web con una herramienta personalizada de citas motivacionales.
3. Aplicación NoteSmith Multi-Tool: Una completa aplicación para tomar notas que incluye múltiples herramientas, ganchos de seguridad y seguimiento del uso.

Todo el código fuente está disponible en el repositorio GitHub: kingabzpro/claude-agent-projects

1. Esquema de blog de una sola publicación

En este proyecto, utilizamos la función « query() » del SDK con Claude Sonnet 4.5 para crear el esquema de un blog. Esta es una consulta sencilla de un solo paso que muestra el uso básico del SDK de Claude Agent sin necesidad de herramientas.

El código consta de: 

1. Transmisión asíncrona: Utiliza asyncio con el iterador asíncronoquery() del SDK para obtener una salida sin bloqueo, token por token.
2. Mensaje y opciones: Define un esquema de blog PROMPT y configura el modelo/persona a través de ClaudeAgentOptions.
3. Flujo de mensajes escritos: Repite los mensajes; extrae solo contenido AssistantMessage → TextBlock.
4. Salida en tiempo real: Imprime el texto a medida que llega (end="") para obtener una vista limpia de la consola de transmisión.
5. Gestión de resultados: Ignora ResultMessage, dejando que el flujo termine de forma natural.
6. Punto de entrada: Ejecuta todo con asyncio.run(main()) cuando se ejecuta un script.
7. Personalizable y minimalista: Fácil de intercambiar modelo/solicitud; script ligero, ideal para demostraciones o procesos.

oneshot_outline.py:

import asyncio
from claude_agent_sdk import (
    query,
    ClaudeAgentOptions,
    AssistantMessage,
    TextBlock,
    ResultMessage,
)

PROMPT = """Create a crisp markdown outline (H2/H3 bullets) for a 500-word blog post:
Title: Why Sovereign AI Compute Matters in 2026
Audience: CTOs and Heads of AI
Tone: pragmatic, non-hype
Include: 3 buyer pains, 3 evaluation criteria, 1 closing CTA
"""

async def main():
    options = ClaudeAgentOptions(
        model="sonnet", 
        system_prompt="You are a precise technical copy strategist."
    )

    async for msg in query(prompt=PROMPT, options=options):
        if isinstance(msg, AssistantMessage):
            for block in msg.content:
                if isinstance(block, TextBlock):
                    print(block.text, end="")  # only the outline
        elif isinstance(msg, ResultMessage):
            pass  # let the iterator end naturally

if __name__ == "__main__":
    asyncio.run(main())

Ejecutaremos el script y luego guardaremos el resultado como un archivo Markdown. 

python oneshot_outline.py > outline.md 

Puedes abrir el archivo Markdown y comprobar que se ha generado el texto técnico adecuado. 

Puedes volver a tu panel de control en https://console.anthropic.com/usage para comprobar tu uso. Como puedes ver, el modelo utiliza Claude Sonnet 4.5.

2. InspireBot CLI

En este proyecto, creamos un generador de motivación fácil de usar en el terminal que transmite citas utilizando Claude Sonnet 4.5. Primero intenta una búsqueda en la web y, a continuación, recurre a una herramienta personalizada inspire_me que devuelve citas aleatorias.

El código consta de:

• Herramienta de respaldo personalizada: Define inspire_me con citas motivacionales preestablecidas, registradas a través de create_sdk_mcp_server.
• Ayudas CLI: is_tty, typewrite, bold, faint añaden animación de máquina de escribir y salida con estilo en el terminal.
• Mensaje y opciones: Configurado con ClaudeAgentOptions, que permite herramientas (WebSearch + inspire_me) y una persona del sistema «InspireBot».
• La herramienta de streaming llama a: Repite los mensajes, mostrando el uso de la herramienta (ToolUseBlock), los resultados (ToolResultBlock) y el resultado final (TextBlock).
• Lógica de reserva: Si no aparece ninguna salida utilizable, se muestra por defecto una cita local aleatoria.
• UX interactivo: Muestra las entradas/resultados de la herramienta de transmisión y, a continuación, anima la frase inspiradora final con un efecto de máquina de escribir.

inspire_web.py:

import sys
import json
import asyncio
import random
import time
from typing import Any

from claude_agent_sdk import (
    query,
    ClaudeAgentOptions,
    tool,
    create_sdk_mcp_server,
    AssistantMessage,
    TextBlock,
    ToolUseBlock,
    ToolResultBlock,
    ResultMessage,
)

# -------------------------
# Custom fallback tool
# -------------------------
QUOTES = [
    "Dream big, start small -- but start.",
    "Stay curious, stay humble, keep building.",
    "Every expert was once a beginner.",
    "Small wins stack into big victories.",
    "Consistency beats intensity when intensity is inconsistent.",
]

@tool("inspire_me", "Return a random motivational quote", {})
async def inspire_me(_: dict) -> dict:
    return {"content": [{"type": "text", "text": random.choice(QUOTES)}]}

UTILS = create_sdk_mcp_server("inspire_util", "1.0.0", [inspire_me])

# -------------------------
# Tiny terminal helpers
# -------------------------
def is_tty() -> bool:
    try:
        return sys.stdout.isatty()
    except Exception:
        return False

def typewrite(text: str, delay: float = 0.02) -> None:
    """Print with a typewriter effect if TTY; otherwise plain print."""
    if not is_tty():
        print(text)
        return
    for ch in text:
        print(ch, end="", flush=True)
        time.sleep(delay)
    print()

def faint(s: str) -> str:
    """Dim text if terminal supports ANSI."""
    return s if not is_tty() else f"\033[2m{s}\033[0m"

def bold(s: str) -> str:
    return s if not is_tty() else f"\033[1m{s}\033[0m"

# -------------------------
# Main
# -------------------------
async def main():
    topic = "engineering focus" if len(sys.argv) < 2 else " ".join(sys.argv[1:])

    options = ClaudeAgentOptions(
        model="sonnet",  # switch to "sonnet-4.5" if your CLI lists it
        system_prompt=(
            "You are InspireBot.\n"
            "- First, try WebSearch to find a short, uplifting quote relevant to the user's topic.\n"
            "- If WebSearch is unhelpful or no clear quote is found, call the custom 'inspire_me' tool.\n"
            "- Output ONE short line only. No preface, no commentary, <= 120 characters."
        ),
        allowed_tools=[
            "WebSearch",
            "mcp__inspire_util__inspire_me",
        ],
        mcp_servers={"inspire_util": UTILS},
    )

    prompt = (
        "Find a short, uplifting quote for today's inspiration. "
        f"Topic: {topic}. Prefer something crisp and modern.\n"
        "If search yields multiple options, pick the best single line."
    )

    final_line_parts: list[str] = []

    if is_tty():
        print(bold("🌐 InspireBot (WebSearch + fallback tool)"))
        print(faint("Tip: pass a custom topic:  python inspire_web_animated.py \"women in leadership\""))
        print()

    async for message in query(prompt=prompt, options=options):
        # Stream assistant messages for tool usage + final text
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if isinstance(block, ToolUseBlock):
                    tool_name = block.name
                    tool_input = block.input or {}
                    print(f"{bold('🛠️  Tool used:')} {tool_name}")
                    print(f"{faint('   input:')} {json.dumps(tool_input, ensure_ascii=False)}")
                elif isinstance(block, ToolResultBlock):
                    # Show summarized tool result text if present
                    shown = False
                    if isinstance(block.content, list):
                        for part in block.content:
                            if isinstance(part, dict) and part.get("type") == "text":
                                text = (part.get("text") or "").strip()
                                if text:
                                    preview = text if len(text) <= 200 else (text[:197] + "...")
                                    print(f"{faint('   result:')} {preview}")
                                    shown = True
                                    break
                    if not shown:
                        print(f"{faint('   result:')} (no textual content)")
                elif isinstance(block, TextBlock):
                    # This should be the final "inspiration" line content
                    final_line_parts.append(block.text)

        elif isinstance(message, ResultMessage):
            # allow the iterator to finish naturally (no break)
            pass

    final_line = " ".join(part.strip() for part in final_line_parts).strip()
    if not final_line:
        final_line = random.choice(QUOTES)  # ultimate fallback, just in case

    # Animate the final line (typewriter), or plain if not a TTY
    typewrite(final_line, delay=0.02)

if __name__ == "__main__":
    asyncio.run(main())

Ejecutaremos el script con el tema predeterminado utilizando el siguiente comando:  

python inspire_web.py

Como podemos ver, muestra las herramientas utilizadas, los datos introducidos en esas herramientas y, a continuación, genera una cita motivadora.  

Proporcionemos al script de Python un tema personalizado:  

python inspire_web.py "Sadness and Love"

Esto devuelve una cita motivacional que incluye las palabras clave «amor» y «tristeza».

3. Aplicación multitarea NoteSmith

En este proyecto, creamos un asistente de investigación multifuncional que guarda y busca notas localmente, resume páginas web y transmite los resultados con Claude Sonnet 4.5. Combina herramientas MCP personalizadas, herramientas integradas y un gancho de seguridad para ofrecer una experiencia CLI más completa.

El código consta de:

• Almacenamiento local: Guarda notas en el disco con marcas de tiempo; admite búsquedas que no distinguen entre mayúsculas y minúsculas utilizando una lógica grep sencilla.
• Herramientas MCP personalizadas: save_note (almacenar texto) y find_note (buscar notas), registradas en create_sdk_mcp_server.
• Gancho de seguridad: block_dangerous_bash rechaza los comandos de terminal dañinos (por ejemplo, rm -rf /) antes de la ejecución de la herramienta.
• Indicaciones y comandos del sistema: Define /summarize, /note ,/find, /help ,/exit; uso de herramientas de dirección de comandos (WebFetch, save_note, find_note).
• Interacción en streaming: Utiliza ClaudeSDKClient para gestionar AssistantMessage, ToolUseBlock, ToolResultBlock, imprimiendo texto y resultados de herramientas en tiempo real.
• Seguimiento del uso: Imprime un pie de página con el nombre del modelo, los tokens y el coste enla salida de error de , manteniendo limpia la salida principal.
• Interfaz de chat: Funciona como un REPL ligero en el que escribes comandos (/note, /find, /summarize) y obtienes respuestas inmediatas, lo que te da la sensación de estar chateando con un asistente.

note_smith.py:

import sys
import json
import asyncio
from datetime import datetime
from pathlib import Path
from typing import Any

from claude_agent_sdk import (
    ClaudeSDKClient,
    ClaudeAgentOptions,
    AssistantMessage,
    TextBlock,
    ToolUseBlock,
    ToolResultBlock,
    ResultMessage,
    tool,
    create_sdk_mcp_server,
    HookMatcher,
    HookContext,
)

# ----------------------------
# Storage (simple local notes)
# ----------------------------

NOTES_DIR = Path(__file__).parent / "notes"
NOTES_DIR.mkdir(exist_ok=True)

def _ts() -> str:
    return datetime.now().strftime("%Y-%m-%d_%H-%M-%S")

def save_note_to_disk(text: str) -> str:
    path = NOTES_DIR / f"note_{_ts()}.txt"
    path.write_text(text.strip() + "\n", encoding="utf-8")
    return str(path)

def grep_notes(pattern: str) -> list[str]:
    pat = pattern.lower()
    out: list[str] = []
    for p in NOTES_DIR.glob("*.txt"):
        for i, line in enumerate(p.read_text(encoding="utf-8").splitlines(), start=1):
            if pat in line.lower():
                out.append(f"{p.name}:{i}: {line}")
    return out

# ----------------------------
# Custom MCP tools
# ----------------------------

@tool("save_note", "Save a short note to local disk", {"text": str})
async def save_note(args: dict[str, Any]) -> dict[str, Any]:
    path = save_note_to_disk(args["text"])
    return {"content": [{"type": "text", "text": f"Saved note → {path}"}]}

@tool("find_note", "Find notes containing a pattern (case-insensitive)", {"pattern": str})
async def find_note(args: dict[str, Any]) -> dict[str, Any]:
    hits = grep_notes(args["pattern"])
    body = "\n".join(hits) if hits else "No matches."
    return {"content": [{"type": "text", "text": body}]}

UTILS_SERVER = create_sdk_mcp_server(
    name="notes_util",
    version="1.0.0",
    tools=[save_note, find_note],
)

# ----------------------------
# Optional safety hook (Bash)
# ----------------------------

async def block_dangerous_bash(
    input_data: dict[str, Any],
    tool_use_id: str | None,
    context: HookContext
):
    if input_data.get("tool_name") == "Bash":
        cmd = str(input_data.get("tool_input", {}).get("command", "")).strip().lower()
        if "rm -rf /" in cmd or "format c:" in cmd:
            return {
                "hookSpecificOutput": {
                    "hookEventName": "PreToolUse",
                    "permissionDecision": "deny",
                    "permissionDecisionReason": "Dangerous command blocked"
                }
            }
    return {}

# ----------------------------
# Prompts & UI
# ----------------------------

SYSTEM_PROMPT = """You are NoteSmith, a concise research assistant.
- Prefer bullet answers with crisp takeaways.
- When the user asks to /summarize <url>, use WebFetch to retrieve and then summarize 5 key points + a 1-line TL;DR.
- When the user types /note <text>, call the custom save_note tool.
- When the user types /find <pattern>, call the custom find_note tool.
- Keep answers short unless asked to expand.
"""

HELP = """Commands:
  /summarize <url>      Summarize a webpage (WebFetch)
  /note <text>          Save a note locally
  /find <pattern>       Search saved notes
  /help                 Show this help
  /exit                 Quit
"""

# Use the broadest model label for compatibility; switch to "sonnet-4.5" if your CLI lists it.
MODEL = "sonnet"

# ----------------------------
# Main app
# ----------------------------

async def main():
    options = ClaudeAgentOptions(
        model=MODEL,
        system_prompt=SYSTEM_PROMPT,
        permission_mode="acceptEdits",
        allowed_tools=[
            # Built-ins (Claude may use these if relevant)
            "WebFetch", "Read", "Write", "Grep", "Glob",
            # Our MCP tools (SDK prefixes mcp__<alias>__<toolname>)
            "mcp__utils__save_note",
            "mcp__utils__find_note",
        ],
        mcp_servers={"utils": UTILS_SERVER},
        hooks={"PreToolUse": [HookMatcher(hooks=[block_dangerous_bash])]},
        setting_sources=None,  # no filesystem settings; everything is programmatic
    )

    print("💡 NoteSmith (Claude Sonnet)\n")
    print(HELP)

    async with ClaudeSDKClient(options=options) as client:
        while True:
            user = input("\nYou: ").strip()
            if not user:
                continue
            if user.lower() in {"/exit", "exit", "quit"}:
                print("Bye!")
                break
            if user.lower() in {"/help", "help"}:
                print(HELP)
                continue

            # Lightweight command parsing (the system prompt also guides tool usage)
            if user.startswith("/summarize "):
                url = user.split(" ", 1)[1].strip()
                prompt = f"Summarize this URL using WebFetch and return 5 bullets + TL;DR:\n{url}"
            elif user.startswith("/note "):
                text = user.split(" ", 1)[1]
                prompt = f'Please call tool save_note with text="{text}"'
            elif user.startswith("/find "):
                patt = user.split(" ", 1)[1]
                prompt = f'Please call tool find_note with pattern="{patt}"'
            else:
                prompt = user

            await client.query(prompt)

            # -------- Response streaming with footer to STDERR --------
            model_used = None
            usage = None
            cost = None

            async for message in client.receive_response():
                if isinstance(message, AssistantMessage):
                    if model_used is None:
                        model_used = message.model  # e.g., "sonnet" or "sonnet-4.5"
                    for block in message.content:
                        if isinstance(block, TextBlock):
                            print(block.text, end="", flush=True)  # stdout
                        elif isinstance(block, ToolUseBlock):
                            print(f"\n🛠️  Using tool: {block.name} with input: {json.dumps(block.input)}")
                        elif isinstance(block, ToolResultBlock):
                            if isinstance(block.content, list):
                                for part in block.content:
                                    if isinstance(part, dict) and part.get("type") == "text":
                                        print(f"\n🔎 Tool says: {part.get('text')}")
                elif isinstance(message, ResultMessage):
                    usage = message.usage or {}
                    cost = message.total_cost_usd
                    # Do not break early; let stream end naturally

            # Footer (model + tokens + cost) → STDERR so normal output stays clean
            def _token_summary(u: dict) -> str:
                total = u.get("total_tokens")
                if total is None:
                    it, ot = u.get("input_tokens"), u.get("output_tokens")
                    if it is not None or ot is not None:
                        total = (it or 0) + (ot or 0)
                if total is None:
                    return "tokens=?"
                if "input_tokens" in u or "output_tokens" in u:
                    return f"tokens={total} (in={u.get('input_tokens','?')}, out={u.get('output_tokens','?')})"
                return f"tokens={total}"

            footer = (
                f"\n\n-- Turn done. model={(model_used or options.model)} "
                f"{_token_summary(usage or {})} cost={cost if cost is not None else '?'} --"
            )
            print(footer, file=sys.stderr)

# Entry
if __name__ == "__main__":
    asyncio.run(main())

Para ejecutar la aplicación, escribe el siguiente comando en la terminal:

python note_smith.py

Esto iniciará la interfaz de chat CLI con comandos útiles.

Primero resumiremos la página web. He proporcionado la URL de tu sitio web con tu portafolio:

/resumir abid.work

En primer lugar, el agente determinará qué herramientas utilizar, obtendrá el contenido de la página web, extraerá cinco puntos clave y los mostrará en la interfaz de chat. Al final, mostrará un informe de uso que incluye el nombre del modelo, el uso de tokens y el coste.

I'll fetch and summarize the content from that URL for you.                                    
🛠️  Using tool: WebFetch with input: {"url": "https://abid.work", "prompt": "Extract the main content and key information from this page, including what the person does, their background, projects, and any notable achievements or areas of focus."}


**5 Key Points:**

• **Prolific Tech Educator** - Authored 500+ articles making data science & ML accessible through tutorials, cheat sheets, and practical guides

• **Certified Data Scientist** - Professional focus on building innovative machine learning solutions across NLP, computer vision, and MLOps

• **Multi-Domain Expertise** - Covers Python, SQL, AI, and end-to-end ML workflows with hands-on project demonstrations

• **Content-First Philosophy** - Maintains extensive portfolio including blogs, tutorials, book reviews, and career resources

• **Open Contributor** - Active on GitHub (kingabzpro) sharing code and projects with the community

**TL;DR:** Abid Ali Awan is a certified data scientist who's authored 500+ educational articles and tutorials, specializing in ML, NLP, and making complex tech concepts accessible to learners.

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=326 (in=6, out=320) cost=0.062402849999999996 --

A continuación, guardemos una nota:

/nota ¿qué es el amor?

Te hemos indicado que guardes la nota con el texto «¿Qué es el amor?».

🛠️  Using tool: mcp__utils__save_note with input: {"text": "what is love"}


✓ Note saved: "what is love"

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=81 (in=6, out=75) cost=0.07421549999999999 --

Por último, encontraremos la nota proporcionando una palabra clave de la misma:

/encontrar el amor

Como puedes ver, ha encontrado el archivo y ha mostrado el texto que contiene.

🛠️  Using tool: mcp__utils__find_note with input: {"pattern": "love"}


**Found 1 note matching "love":**

• `note_2025-09-30_17-18-02.txt` - "what is love"

-- Turn done. model=claude-sonnet-4-5-20250929 tokens=105 (in=6, out=99) cost=0.08423339999999999 --

Conclusión 

El SDK de Claude Agent es fácil de configurar, especialmente si ya tienes Claude Code instalado localmente. Todo lo que se necesita es instalar el paquete SDK. 

El SDK de Python ofrece dos formas principales de interactuar con Claude:

• query() – Una API sencilla para la generación de texto, ideal para casos de uso ligeros, aunque no es compatible con herramientas.
• ClaudeSDKClient – Una API con todas las funciones que te permite reanudar sesiones, utilizar herramientas, mantener el control manual y mucho más.

En este tutorial, hemos explorado el último modelo de Anthropic, Claude Sonnet 4.5, y hemos presentado el nuevo SDK de Claude Agent. Hemos seguido el proceso de instalación y hemos creado tres proyectos de ejemplo para demostrar sus capacidades.

Si te interesa experimentar con flujos de trabajo agenticos, te recomiendo encarecidamente que pruebes este SDK.