Tu primera app con la API

🛠️ En la práctica — crear y guardar la key

Paso 1 — Crear la cuenta y la key. Entrá a console.anthropic.com, creá tu cuenta de desarrollador y agregá un saldo pequeño (con $5 sobra de sobra para todo este libro — los requests de práctica cuestan fracciones de centavo). En la sección de API keys, generá una nueva. Copiala de inmediato: por seguridad solo se muestra completa una vez.

Paso 2 — Guardarla como variable de entorno. El SDK busca automáticamente la variable ANTHROPIC_API_KEY.

En Linux/macOS (o WSL), agregala a tu archivo de perfil de shell:

# Agregá esta línea a ~/.bashrc o ~/.zshrc
export ANTHROPIC_API_KEY="tu-key-aqui"

# Recargá el perfil y verificá
source ~/.bashrc
echo $ANTHROPIC_API_KEY

En Windows (PowerShell):

[Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", "tu-key-aqui", "User")
# Cerrá y reabrí la terminal para que tome efecto

Paso 3 — Para proyectos, un .env ignorado por git. Alternativa común por proyecto: un archivo .env con ANTHROPIC_API_KEY=... cargado con la librería python-dotenv — y la línea .env en tu .gitignore antes del primer commit.

🛠️ En la práctica

El SDK (Software Development Kit) oficial de Python envuelve la API HTTP en clases y funciones cómodas:

pip install anthropic

Tu primer programa con Claude, completo:

import anthropic

client = anthropic.Anthropic()  # lee ANTHROPIC_API_KEY del entorno
respuesta = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    system="Sos un tutor de programación paciente.",  # opcional
    messages=[{"role": "user", "content": "Explicame qué es una variable."}],
)
print(respuesta.content[0].text)

Guardalo como primer_request.py, corré python primer_request.py, y leé la explicación de Claude en tu terminal. Acabás de hacer tu primer request. Ahora desarmémoslo línea por línea.

🛠️ En la práctica — chat con memoria en 25 líneas

import anthropic

client = anthropic.Anthropic()
historial = []  # acá vive la "memoria"

print("Chat con Claude (escribí 'salir' para terminar)\n")

while True:
    pregunta = input("Vos: ")
    if pregunta.lower() == "salir":
        break

    # 1. Agregar el mensaje del usuario al historial
    historial.append({"role": "user", "content": pregunta})

    # 2. Mandar TODO el historial (no solo la última pregunta)
    respuesta = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        messages=historial,
    )
    texto = respuesta.content[0].text

    # 3. Agregar la respuesta al historial — clave para el próximo turno
    historial.append({"role": "assistant", "content": texto})

    print(f"\nClaude: {texto}\n")

Probalo: decile tu nombre, preguntá dos cosas más, y después preguntale "¿cómo me llamo?". Se acuerda — porque tu lista historial se acuerda.

Fijate en la mecánica de la lista: user, assistant, user, assistant... siempre alternando, siempre empezando por user. Si rompés la alternancia (dos user seguidos, o empezar por assistant), la API devuelve error 400.

El costo escondido del historial: cada turno reenvía todo lo anterior como tokens de entrada — el turno 20 de una conversación larga es mucho más caro que el turno 2. Por eso las conversaciones largas se truncan o resumen en apps reales (cap. 5).

🛠️ En la práctica — Avance del proyecto: el tutor

Todo el capítulo junto en un programa real: un tutor de estudio por consola, con memoria, streaming, manejo de errores y contador de tokens. Guardalo como tutor.py.

"""Tutor de consola con Claude — proyecto del capítulo 4.

Uso:  python tutor.py
Requiere:  pip install anthropic  +  ANTHROPIC_API_KEY en el entorno.
"""

import anthropic

MODELO = "claude-opus-4-8"
MAX_TOKENS = 2048

SYSTEM = (
    "Sos un tutor universitario paciente para estudiantes de El Salvador. "
    "Explicá con claridad y con ejemplos locales cuando sumen. "
    "Si te piden resolver tareas, guiá con preguntas antes de dar la solución. "
    "Si no estás seguro de un dato, decilo explícitamente."
)

def conversar(client, historial):
    """Manda el historial completo y muestra la respuesta en streaming.

    Devuelve (texto, usage) o (None, None) si hubo error recuperable.
    """
    try:
        with client.messages.stream(
            model=MODELO,
            max_tokens=MAX_TOKENS,
            system=SYSTEM,
            messages=historial,
        ) as stream:
            print("\nTutor: ", end="")
            for fragmento in stream.text_stream:
                print(fragmento, end="", flush=True)
            print()
            final = stream.get_final_message()

        if final.stop_reason == "max_tokens":
            print("\n[Aviso: respuesta cortada por max_tokens]")
        return final.content[0].text, final.usage

    except anthropic.AuthenticationError:
        print("\nAPI key inválida. Configurá ANTHROPIC_API_KEY y volvé a correr.")
        raise SystemExit(1)
    except anthropic.RateLimitError:
        print("\nDemasiados requests. Esperá un minuto y repetí la pregunta.")
        return None, None
    except anthropic.APIError as e:
        print(f"\nError de la API: {e.message}")
        return None, None

def main():
    client = anthropic.Anthropic()
    historial = []
    total_entrada, total_salida = 0, 0

    print("=== Tutor de estudio ===")
    print("Comandos: 'salir' termina | 'reset' borra la conversación\n")

    while True:
        pregunta = input("Vos: ").strip()
        if not pregunta:
            continue
        if pregunta.lower() == "salir":
            break
        if pregunta.lower() == "reset":
            historial = []
            print("[Conversación reiniciada]\n")
            continue

        historial.append({"role": "user", "content": pregunta})
        texto, usage = conversar(client, historial)

        if texto is None:
            historial.pop()  # el request falló: sacamos la pregunta huérfana
            continue

        historial.append({"role": "assistant", "content": texto})
        total_entrada += usage.input_tokens
        total_salida += usage.output_tokens
        print()

    print("\n=== Sesión terminada ===")
    print(f"Tokens de entrada: {total_entrada} | de salida: {total_salida}")

if __name__ == "__main__":
    main()

Detalles de diseño que valen la pena notar:

• historial.pop() tras un fallo: si el request murió, la pregunta quedaría como mensaje user huérfano — y el siguiente turno tendría dos user seguidos → error 400. Limpiar el historial en fallos es de los bugs sutiles más comunes en chats caseros.
• El comando reset: vaciar la lista = nueva conversación. Así de literal es la naturaleza stateless.
• El contador de tokens: todavía no calcula dólares — ese es exactamente el punto de partida del capítulo 5, donde el tutor gana presupuesto, caché y conciencia de costos.

Tu centro de productividad ya tiene sus tres alas: Proyectos para estudiar, Claude Code para programar, y tu primera herramienta propia con la API.