1¿Necesitas máxima calidad y estabilidad?
2    → OpenAI GPT-4o
3 
4¿Trabajas principalmente con código?
5    → Anthropic Claude
6 
7¿Necesitas procesar documentos muy largos?
8    → Google Gemini (1M tokens)
9 
10¿El presupuesto es limitado?
11    → Mistral o Llama (self-hosted)
12 
13¿Requisitos enterprise estrictos?
14    → Azure OpenAI o Cohere

1from openai import OpenAI
2 
3client = OpenAI(api_key="sk-...")
4 
5# O usando variable de entorno (recomendado)
6# export OPENAI_API_KEY="sk-..."
7client = OpenAI()

1response = client.chat.completions.create(
2    model="gpt-4o",
3    messages=[
4        {"role": "system", "content": "Eres un asistente útil."},
5        {"role": "user", "content": "Explica qué es una API REST"}
6    ],
7    max_tokens=500,
8    temperature=0.7
9)
10 
11print(response.choices[0].message.content)

1stream = client.chat.completions.create(
2    model="gpt-4o",
3    messages=[{"role": "user", "content": "Cuenta hasta 10"}],
4    stream=True
5)
6 
7for chunk in stream:
8    if chunk.choices[0].delta.content:
9        print(chunk.choices[0].delta.content, end="")

1tools = [{
2    "type": "function",
3    "function": {
4        "name": "get_weather",
5        "description": "Obtener el clima de una ciudad",
6        "parameters": {
7            "type": "object",
8            "properties": {
9                "city": {"type": "string", "description": "Nombre de la ciudad"},
10                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
11            },
12            "required": ["city"]
13        }
14    }
15}]
16 
17response = client.chat.completions.create(
18    model="gpt-4o",
19    messages=[{"role": "user", "content": "¿Qué clima hace en Madrid?"}],
20    tools=tools,
21    tool_choice="auto"
22)
23 
24# El modelo devuelve la función a llamar y sus argumentos

1response = client.embeddings.create(
2    model="text-embedding-3-small",
3    input="Texto a convertir en vector"
4)
5 
6vector = response.data[0].embedding
7# Vector de 1536 dimensiones

1from anthropic import Anthropic
2 
3client = Anthropic(api_key="sk-ant-...")
4 
5# O variable de entorno
6# export ANTHROPIC_API_KEY="sk-ant-..."

1message = client.messages.create(
2    model="claude-3-5-sonnet-20241022",
3    max_tokens=1024,
4    system="Eres un experto en Python.",
5    messages=[
6        {"role": "user", "content": "Escribe una función de fibonacci"}
7    ]
8)
9 
10print(message.content[0].text)

1with client.messages.stream(
2    model="claude-3-5-sonnet-20241022",
3    max_tokens=1024,
4    messages=[{"role": "user", "content": "Cuenta una historia corta"}]
5) as stream:
6    for text in stream.text_stream:
7        print(text, end="", flush=True)

1response = client.messages.create(
2    model="claude-3-5-sonnet-20241022",
3    max_tokens=1024,
4    tools=[{
5        "name": "get_stock_price",
6        "description": "Obtiene el precio de una acción",
7        "input_schema": {
8            "type": "object",
9            "properties": {
10                "symbol": {"type": "string", "description": "Símbolo bursátil"}
11            },
12            "required": ["symbol"]
13        }
14    }],
15    messages=[{"role": "user", "content": "¿Cuál es el precio de AAPL?"}]
16)

1# Los prompts largos que se repiten se cachean automáticamente
2# Ahorro: ~90% en tokens de input cacheados
3# TTL: 5 minutos por defecto
4 
5response = client.messages.create(
6    model="claude-3-5-sonnet-20241022",
7    max_tokens=1024,
8    system=[{
9        "type": "text",
10        "text": "Tu system prompt largo aquí...",
11        "cache_control": {"type": "ephemeral"}  # Cachear esto
12    }],
13    messages=[{"role": "user", "content": "Pregunta"}]
14)

1import google.generativeai as genai
2 
3genai.configure(api_key="AIza...")
4 
5# O con Vertex AI (enterprise)
6from vertexai.generative_models import GenerativeModel

1model = genai.GenerativeModel("gemini-1.5-pro")
2 
3response = model.generate_content("Explica la teoría de la relatividad")
4print(response.text)

1model = genai.GenerativeModel("gemini-1.5-pro")
2chat = model.start_chat(history=[])
3 
4response = chat.send_message("Hola, ¿cómo estás?")
5print(response.text)
6 
7response = chat.send_message("¿Qué me dijiste antes?")
8print(response.text)

1# Procesar un libro completo
2with open("libro_completo.txt", "r") as f:
3    libro = f.read()  # 500K tokens
4 
5response = model.generate_content(f"""
6Analiza el siguiente libro y responde:
71. ¿Cuál es el tema principal?
82. ¿Quiénes son los personajes principales?
93. Resume en 3 párrafos
10 
11LIBRO:
12{libro}
13""")

1from google.generativeai import GenerativeModel
2from google.generativeai.types import Tool
3 
4model = GenerativeModel(
5    "gemini-1.5-pro",
6    tools=[Tool.from_google_search_retrieval()]
7)
8 
9response = model.generate_content(
10    "¿Cuáles son las últimas noticias sobre IA?"
11)
12# Incluye citas de búsqueda de Google

1from mistralai.client import MistralClient
2 
3client = MistralClient(api_key="...")
4 
5response = client.chat(
6    model="mistral-large-latest",
7    messages=[{"role": "user", "content": "Hola"}]
8)

1import cohere
2 
3co = cohere.Client("...")
4 
5response = co.chat(
6    model="command-r-plus",
7    message="Explica machine learning"
8)

1from openai import OpenAI
2 
3client = OpenAI(
4    api_key="...",
5    base_url="https://api.together.xyz/v1"
6)
7 
8response = client.chat.completions.create(
9    model="meta-llama/Llama-3.1-70B-Instruct-Turbo",
10    messages=[{"role": "user", "content": "Hola"}]
11)

1from groq import Groq
2 
3client = Groq(api_key="...")
4 
5response = client.chat.completions.create(
6    model="llama-3.1-70b-versatile",
7    messages=[{"role": "user", "content": "Hola"}]
8)

1from openai import OpenAI
2 
3client = OpenAI()
4conversation_history = []
5 
6def chat(user_message):
7    conversation_history.append({
8        "role": "user",
9        "content": user_message
10    })
11 
12    response = client.chat.completions.create(
13        model="gpt-4o-mini",
14        messages=[
15            {"role": "system", "content": "Eres un asistente amigable."}
16        ] + conversation_history,
17        max_tokens=500
18    )
19 
20    assistant_message = response.choices[0].message.content
21    conversation_history.append({
22        "role": "assistant",
23        "content": assistant_message
24    })
25 
26    return assistant_message
27 
28# Uso
29print(chat("Hola, me llamo Juan"))
30print(chat("¿Cómo me llamo?"))  # Recuerda "Juan"

1from fastapi import FastAPI
2from anthropic import Anthropic
3from pydantic import BaseModel
4 
5app = FastAPI()
6client = Anthropic()
7 
8class Query(BaseModel):
9    message: str
10    system_prompt: str = "Eres un asistente útil."
11 
12@app.post("/chat")
13async def chat(query: Query):
14    response = client.messages.create(
15        model="claude-3-5-sonnet-20241022",
16        max_tokens=1024,
17        system=query.system_prompt,
18        messages=[{"role": "user", "content": query.message}]
19    )
20 
21    return {
22        "response": response.content[0].text,
23        "usage": {
24            "input_tokens": response.usage.input_tokens,
25            "output_tokens": response.usage.output_tokens
26        }
27    }

1import google.generativeai as genai
2from pathlib import Path
3 
4genai.configure(api_key="...")
5model = genai.GenerativeModel("gemini-1.5-pro")
6 
7def analyze_document(file_path):
8    # Soporta PDF, DOCX, TXT, imágenes
9    file = genai.upload_file(file_path)
10 
11    response = model.generate_content([
12        "Analiza este documento y extrae:",
13        "1. Resumen ejecutivo",
14        "2. Puntos clave",
15        "3. Acciones recomendadas",
16        file
17    ])
18 
19    return response.text
20 
21# Uso
22analysis = analyze_document("informe_trimestral.pdf")
23print(analysis)

1def get_model_for_task(task_complexity):
2    if task_complexity == "simple":
3        return "gpt-4o-mini"  # $0.15/M
4    elif task_complexity == "medium":
5        return "claude-3-haiku"  # $0.25/M
6    else:
7        return "gpt-4o"  # $2.50/M
8 
9# Clasificar complejidad automáticamente
10def classify_complexity(query):
11    # Simple: preguntas directas, traducciones
12    # Medium: resúmenes, análisis básico
13    # Complex: razonamiento, código complejo
14    ...

1# Malo: enviar todo el historial siempre
2messages = full_conversation_history  # 50K tokens
3 
4# Bueno: solo los últimos N mensajes relevantes
5messages = conversation_history[-10:]  # ~5K tokens
6 
7# Mejor: resumir conversaciones largas
8if len(conversation_history) > 20:
9    summary = summarize(conversation_history[:-10])
10    messages = [{"role": "system", "content": f"Resumen: {summary}"}] + \
11               conversation_history[-10:]

1# System prompt largo (ej: 5000 tokens)
2SYSTEM_PROMPT = """
3[Instrucciones detalladas...]
4[Ejemplos...]
5[Contexto de la empresa...]
6"""
7 
8# Con caching: pagas 5000 tokens UNA vez
9# Sin caching: pagas 5000 tokens CADA consulta
10 
11# Ahorro: 90% en input tokens repetidos

1# En lugar de 100 llamadas individuales
2for item in items:
3    response = client.chat.completions.create(...)
4 
5# Usar Batch API (50% descuento, 24h delivery)
6batch = client.batches.create(
7    input_file_id="file-...",
8    endpoint="/v1/chat/completions",
9    completion_window="24h"
10)

1import hashlib
2from functools import lru_cache
3 
4@lru_cache(maxsize=1000)
5def cached_completion(prompt_hash):
6    # Solo llama a la API si no está en cache
7    ...
8 
9def get_completion(prompt):
10    prompt_hash = hashlib.md5(prompt.encode()).hexdigest()
11    return cached_completion(prompt_hash)

1import litellm
2 
3# Mismo código, diferentes proveedores
4response = litellm.completion(
5    model="gpt-4o",  # o "claude-3-5-sonnet" o "gemini/gemini-pro"
6    messages=[{"role": "user", "content": "Hola"}]
7)

1import time
2from openai import OpenAI, RateLimitError
3 
4client = OpenAI()
5 
6def robust_completion(messages, max_retries=3):
7    for attempt in range(max_retries):
8        try:
9            return client.chat.completions.create(
10                model="gpt-4o",
11                messages=messages
12            )
13        except RateLimitError:
14            wait_time = 2 ** attempt
15            time.sleep(wait_time)
16 
17    raise Exception("Max retries exceeded")