1pip install anthropic python-dotenv

1# .env
2ANTHROPIC_API_KEY=sk-ant-api03-...

1import anthropic
2from dotenv import load_dotenv
3 
4load_dotenv()
5 
6client = anthropic.Anthropic()  # Lee ANTHROPIC_API_KEY automáticamente

1import anthropic
2 
3client = anthropic.Anthropic()
4 
5message = client.messages.create(
6    model="claude-3-5-sonnet-20241022",
7    max_tokens=1024,
8    messages=[
9        {"role": "user", "content": "Explica qué es Python en una frase."}
10    ]
11)
12 
13print(message.content[0].text)
14# Output: Python es un lenguaje de programación de alto nivel,
15# interpretado y de propósito general, conocido por su sintaxis
16# clara y legible.

1import anthropic
2 
3client = anthropic.Anthropic()
4 
5with client.messages.stream(
6    model="claude-3-5-sonnet-20241022",
7    max_tokens=1024,
8    messages=[
9        {"role": "user", "content": "Escribe un poema corto sobre programación."}
10    ]
11) as stream:
12    for text in stream.text_stream:
13        print(text, end="", flush=True)

1import anthropic
2import asyncio
3 
4async def main():
5    client = anthropic.AsyncAnthropic()
6 
7    async with client.messages.stream(
8        model="claude-3-5-sonnet-20241022",
9        max_tokens=1024,
10        messages=[
11            {"role": "user", "content": "Cuenta hasta 10 lentamente."}
12        ]
13    ) as stream:
14        async for text in stream.text_stream:
15            print(text, end="", flush=True)
16 
17asyncio.run(main())

1message = client.messages.create(
2    model="claude-3-5-sonnet-20241022",
3    max_tokens=1024,
4    system="Eres un experto en Python con 20 años de experiencia. "
5           "Respondes de forma concisa y siempre incluyes ejemplos de código. "
6           "Usas español de España.",
7    messages=[
8        {"role": "user", "content": "¿Cómo ordeno una lista de diccionarios?"}
9    ]
10)

1conversation = []
2 
3def chat(user_message: str) -> str:
4    conversation.append({"role": "user", "content": user_message})
5 
6    response = client.messages.create(
7        model="claude-3-5-sonnet-20241022",
8        max_tokens=1024,
9        system="Eres un asistente de programación amigable.",
10        messages=conversation
11    )
12 
13    assistant_message = response.content[0].text
14    conversation.append({"role": "assistant", "content": assistant_message})
15 
16    return assistant_message
17 
18# Uso
19print(chat("Hola, ¿qué puedes hacer?"))
20print(chat("¿Puedes ayudarme con Python?"))
21print(chat("¿Cómo leo un archivo JSON?"))

1import anthropic
2import json
3 
4client = anthropic.Anthropic()
5 
6# Definir herramientas
7tools = [
8    {
9        "name": "get_weather",
10        "description": "Obtiene el clima actual de una ciudad",
11        "input_schema": {
12            "type": "object",
13            "properties": {
14                "city": {
15                    "type": "string",
16                    "description": "Nombre de la ciudad"
17                },
18                "unit": {
19                    "type": "string",
20                    "enum": ["celsius", "fahrenheit"],
21                    "description": "Unidad de temperatura"
22                }
23            },
24            "required": ["city"]
25        }
26    },
27    {
28        "name": "calculate",
29        "description": "Realiza cálculos matemáticos",
30        "input_schema": {
31            "type": "object",
32            "properties": {
33                "expression": {
34                    "type": "string",
35                    "description": "Expresión matemática a evaluar"
36                }
37            },
38            "required": ["expression"]
39        }
40    }
41]
42 
43# Funciones reales
44def get_weather(city: str, unit: str = "celsius") -> dict:
45    # En producción, llamarías a una API real
46    return {"city": city, "temperature": 22, "unit": unit, "condition": "soleado"}
47 
48def calculate(expression: str) -> float:
49    return eval(expression)  # En producción, usa una librería segura
50 
51# Llamar a Claude con tools
52response = client.messages.create(
53    model="claude-3-5-sonnet-20241022",
54    max_tokens=1024,
55    tools=tools,
56    messages=[
57        {"role": "user", "content": "¿Qué clima hace en Madrid? Y calcula 15 * 7"}
58    ]
59)
60 
61# Procesar tool calls
62for block in response.content:
63    if block.type == "tool_use":
64        tool_name = block.name
65        tool_input = block.input
66 
67        if tool_name == "get_weather":
68            result = get_weather(**tool_input)
69        elif tool_name == "calculate":
70            result = calculate(**tool_input)
71 
72        print(f"Tool: {tool_name}, Result: {result}")

1import anthropic
2import base64
3 
4client = anthropic.Anthropic()
5 
6# Leer imagen y convertir a base64
7with open("imagen.jpg", "rb") as f:
8    image_data = base64.standard_b64encode(f.read()).decode("utf-8")
9 
10message = client.messages.create(
11    model="claude-3-5-sonnet-20241022",
12    max_tokens=1024,
13    messages=[
14        {
15            "role": "user",
16            "content": [
17                {
18                    "type": "image",
19                    "source": {
20                        "type": "base64",
21                        "media_type": "image/jpeg",
22                        "data": image_data
23                    }
24                },
25                {
26                    "type": "text",
27                    "text": "Describe esta imagen en detalle."
28                }
29            ]
30        }
31    ]
32)
33 
34print(message.content[0].text)

1message = client.messages.create(
2    model="claude-3-5-sonnet-20241022",
3    max_tokens=1024,
4    messages=[
5        {
6            "role": "user",
7            "content": [
8                {
9                    "type": "image",
10                    "source": {
11                        "type": "url",
12                        "url": "https://example.com/imagen.jpg"
13                    }
14                },
15                {
16                    "type": "text",
17                    "text": "¿Qué ves en esta imagen?"
18                }
19            ]
20        }
21    ]
22)

1import anthropic
2from anthropic import APIError, RateLimitError, APIConnectionError
3 
4client = anthropic.Anthropic()
5 
6def safe_call(messages: list) -> str:
7    try:
8        response = client.messages.create(
9            model="claude-3-5-sonnet-20241022",
10            max_tokens=1024,
11            messages=messages
12        )
13        return response.content[0].text
14 
15    except RateLimitError:
16        print("Rate limit alcanzado. Esperando...")
17        time.sleep(60)
18        return safe_call(messages)  # Retry
19 
20    except APIConnectionError:
21        print("Error de conexión. Reintentando...")
22        time.sleep(5)
23        return safe_call(messages)
24 
25    except APIError as e:
26        print(f"Error de API: {e}")
27        return None

1# Usar Haiku para tareas simples
2def quick_task(prompt: str) -> str:
3    return client.messages.create(
4        model="claude-3-5-haiku-20241022",  # Más barato
5        max_tokens=256,  # Limitar output
6        messages=[{"role": "user", "content": prompt}]
7    ).content[0].text
8 
9# Usar Sonnet para tareas complejas
10def complex_task(prompt: str) -> str:
11    return client.messages.create(
12        model="claude-3-5-sonnet-20241022",
13        max_tokens=4096,
14        messages=[{"role": "user", "content": prompt}]
15    ).content[0].text

1# Anthropic ofrece caching para system prompts largos
2# Reduce costos hasta 90% en prompts repetidos
3response = client.messages.create(
4    model="claude-3-5-sonnet-20241022",
5    max_tokens=1024,
6    system=[
7        {
8            "type": "text",
9            "text": "Tu system prompt muy largo aquí...",
10            "cache_control": {"type": "ephemeral"}
11        }
12    ],
13    messages=[{"role": "user", "content": "Pregunta"}]
14)

1from anthropic import Anthropic
2 
3client = Anthropic()
4tokens = client.count_tokens("Tu texto aquí")
5print(f"Tokens: {tokens}")