Parámetros y Configuración

Descripción de la cápsula

Inicializar un modelo es solo el primer paso. El comportamiento real del modelo — qué tan creativo es, cuántos tokens genera, cuánto espera antes de dar timeout — se controla con parámetros de configuración.

En esta cápsula aprenderás los parámetros más importantes (temperature, max_tokens, timeout, max_retries), cómo funciona el sistema de modelos configurables en runtime, y cómo usar base_url para proveedores compatibles con la API de OpenAI. Al dominar estos parámetros, podrás ajustar finamente cualquier modelo para tu caso de uso específico.

En el proyecto del módulo, estos parámetros te permitirán configurar cada proveedor de forma independiente según sus fortalezas.

temperature: controlar la creatividad

temperature controla qué tan "aleatorias" o "determinísticas" son las respuestas del modelo.

temperature baja (0.0-0.3) → Respuestas consistentes, predecibles
temperature media (0.4-0.7) → Balance entre creatividad y consistencia
temperature alta (0.8-1.0+) → Respuestas variadas, más creativas

Ejemplo práctico

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Temperature baja: respuestas consistentes
model_precise = init_chat_model("openai:gpt-4.1-mini", temperature=0.0)

# Ejecuta 3 veces — obtendrás respuestas muy similares
for i in range(3):
    response = model_precise.invoke("¿Cuál es la capital de Japón?")
    print(f"Run {i+1}: {response.content}")
# Output esperado:
# Run 1: La capital de Japón es Tokio.
# Run 2: La capital de Japón es Tokio.
# Run 3: La capital de Japón es Tokio.

print("---")

# Temperature alta: respuestas variadas
model_creative = init_chat_model("openai:gpt-4.1-mini", temperature=1.0)

for i in range(3):
    response = model_creative.invoke("Escribe un eslogan creativo para una cafetería")
    print(f"Run {i+1}: {response.content}")
# Output esperado: 3 eslóganes diferentes cada vez

¿Cuándo usar cada valor?

Regla general: Si necesitas respuestas consistentes y factuales, usa temperature baja. Si necesitas variedad y creatividad, sube la temperature.

max_tokens: limitar la longitud de respuesta

max_tokens define el número máximo de tokens que el modelo puede generar en su respuesta. Un token es aproximadamente 3/4 de una palabra en inglés (en español puede variar).

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Respuesta corta (máximo ~50 palabras)
model_short = init_chat_model("openai:gpt-4.1-mini", max_tokens=50)
response = model_short.invoke("Explica qué es machine learning")
print(f"Tokens: ~{len(response.content.split())}")
print(response.content)
# Output: Respuesta truncada a ~50 tokens

# Respuesta larga (hasta ~500 palabras)
model_long = init_chat_model("openai:gpt-4.1-mini", max_tokens=500)
response = model_long.invoke("Explica qué es machine learning")
print(f"Tokens: ~{len(response.content.split())}")
print(response.content)
# Output: Respuesta más detallada

¿Por qué limitar tokens?

• Costo: Pagas por tokens generados. Menos tokens = menor costo
• Latencia: Menos tokens = respuesta más rápida
• Control: En una API de chat, no quieres respuestas de 2000 palabras
• Structured output: Las respuestas JSON suelen necesitar pocos tokens

Valores típicos:

timeout y max_retries: robustez en producción

Las APIs de LLMs fallan. Tienen latencia variable, rate limits, y errores transitorios. timeout y max_retries te protegen.

timeout

Define cuántos segundos esperar antes de considerar que la petición falló.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Timeout de 30 segundos
model = init_chat_model(
    "openai:gpt-4.1-mini",
    timeout=30
)

response = model.invoke("Genera un ensayo sobre AI")
print(response.content)
# Si el modelo no responde en 30 segundos, lanza TimeoutError

max_retries

Define cuántas veces reintentar automáticamente si la petición falla.

# 3 reintentos automáticos ante errores transitorios
model = init_chat_model(
    "openai:gpt-4.1-mini",
    max_retries=3,
    timeout=30
)

response = model.invoke("Hola")
# Si falla la primera vez (error 429, 500, etc.), reintenta hasta 3 veces

Configuración recomendada para producción

model = init_chat_model(
    "openai:gpt-4.1-mini",
    temperature=0.3,
    max_tokens=500,
    timeout=30,
    max_retries=3
)

Regla: En desarrollo puedes omitir timeout/retries. En producción, siempre configúralos.

¿Qué errores reintenta max_retries?

No todos los errores se reintentan. El comportamiento depende del proveedor, pero en general:

Los reintentos usan exponential backoff automáticamente: primer reintento espera ~1s, segundo ~2s, tercero ~4s. Esto evita saturar un servicio ya sobrecargado.

Otros parámetros útiles

top_p (nucleus sampling)

Alternativa a temperature para controlar aleatoriedad. top_p=0.9 significa que el modelo solo considera tokens cuya probabilidad acumulada llega a 90%.

model = init_chat_model("openai:gpt-4.1-mini", top_p=0.9)

Recomendación: Usa temperature O top_p, no ambos al mismo tiempo. temperature es más intuitivo y el más usado.

stop (secuencias de parada)

El modelo deja de generar texto cuando encuentra una de las secuencias de parada.

# El modelo se detendrá si genera "###" o "FIN"
model = init_chat_model("openai:gpt-4.1-mini", stop=["###", "FIN"])

Útil para controlar el formato de salida en casos donde no usas structured output.

Pasar múltiples parámetros

Todos los parámetros se pasan como kwargs a init_chat_model:

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Configuración completa para producción
model = init_chat_model(
    "openai:gpt-4.1-mini",
    temperature=0.3,       # Respuestas consistentes
    max_tokens=500,         # Máximo 500 tokens de respuesta
    timeout=30,             # Timeout de 30 segundos
    max_retries=3,          # 3 reintentos automáticos
)

response = model.invoke("¿Qué es RAG?")
print(response.content)

Modelos configurables en runtime

Una de las features más potentes de init_chat_model es la capacidad de crear modelos que cambian de configuración en runtime sin reinicializarse.

¿Qué problema resuelve?

Imagina que tienes un sistema donde el usuario elige qué modelo usar, o donde quieres cambiar entre modelos dependiendo de la complejidad de la pregunta. Sin modelos configurables, necesitarías crear múltiples instancias:

# Sin configurable — múltiples instancias
model_gpt = init_chat_model("openai:gpt-4.1")
model_claude = init_chat_model("anthropic:claude-sonnet-4-20250514")

# Elegir cuál usar
if complexity == "high":
    response = model_gpt.invoke(question)
else:
    response = model_claude.invoke(question)

Con modelos configurables, una sola instancia maneja todo:

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Crear modelo configurable (sin especificar modelo fijo)
configurable_model = init_chat_model(
    configurable_fields="any",  # Permite configurar cualquier campo
    temperature=0.5
)

# Usar con OpenAI
response = configurable_model.invoke(
    "Hola",
    config={"configurable": {"model": "openai:gpt-4.1-mini"}}
)
print(f"OpenAI: {response.content}")

# Usar con Anthropic — misma instancia, diferente modelo
response = configurable_model.invoke(
    "Hola",
    config={"configurable": {"model": "anthropic:claude-haiku-4-20250514"}}
)
print(f"Anthropic: {response.content}")

Configurar campos específicos

Puedes limitar qué campos son configurables:

# Solo permite cambiar el modelo, no otros parámetros
configurable_model = init_chat_model(
    configurable_fields=["model"],
    temperature=0.3  # Fijo, no configurable
)

# Cambiar modelo en runtime
response = configurable_model.invoke(
    "Hola",
    config={"configurable": {"model": "openai:gpt-4.1-mini"}}
)

¿Cuándo usar modelos configurables?

• ✅ Cuando el usuario elige el modelo (UI con selector)
• ✅ Cuando tienes routing automático (modelo A para simple, modelo B para complejo)
• ✅ Para A/B testing de modelos
• ✅ Para fallback dinámico

base_url: proveedores compatibles con OpenAI

Muchos proveedores de LLMs son compatibles con la API de OpenAI — usan el mismo formato de peticiones HTTP. Puedes conectar con ellos usando base_url:

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

# Proveedor compatible con OpenAI API (ejemplo: Together AI)
model = init_chat_model(
    "openai:meta-llama/Llama-3.1-70B-Instruct",
    base_url="https://api.together.xyz/v1",
    api_key="tu-together-api-key"
)

response = model.invoke("Hola")
print(response.content)

Esto funciona con proveedores como Together AI, Fireworks, Groq, Perplexity, y cualquier servidor que implemente la especificación OpenAI API.

Proveedores compatibles populares:

Comparación: parámetros comunes vs específicos por proveedor

Nota: temperature y max_tokens son universales. Parámetros como seed solo funcionan con proveedores específicos. Si pasas un parámetro no soportado, generalmente se ignora silenciosamente.

Conexión con el proyecto

En el Chat Multi-Proveedor con Fallback:

• Configurarás cada proveedor con temperature baja (0.3) para respuestas consistentes
• Usarás timeout para detectar rápido si un proveedor está caído
• Los max_retries evitarán fallos por errores transitorios
• Los modelos configurables te permitirán cambiar de proveedor sin reinicializar

Troubleshooting

Problema 1: temperature no parece tener efecto

Causa: Algunos modelos de reasoning (como o3-mini) ignoran temperature. Solución: Verifica que el modelo soporta el parámetro. Los modelos de reasoning tienen su propio sistema de control (reasoning effort levels, que verás en Cápsula 06).

Problema 2: Respuesta cortada a mitad de frase

Causa: max_tokens demasiado bajo. Solución: Incrementa max_tokens o no lo especifiques para usar el default del modelo.

Problema 3: configurable_fields lanza error

Causa: Versión de langchain sin soporte para modelos configurables. Solución:

pip install --upgrade langchain langchain-core

Ejercicios

Ejercicio 1: Temperature experiment (Fácil)

Crea dos modelos con temperature 0.0 y 1.0 respectivamente. Haz la misma pregunta creativa a ambos 3 veces y observa la diferencia en variabilidad.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

model_precise = init_chat_model("openai:gpt-4.1-mini", temperature=0.0)
model_creative = init_chat_model("openai:gpt-4.1-mini", temperature=1.0)

question = "Inventa un nombre para una startup de AI"

print("=== Temperature 0.0 ===")
for i in range(3):
    r = model_precise.invoke(question)
    print(f"  {i+1}: {r.content}")

print("\n=== Temperature 1.0 ===")
for i in range(3):
    r = model_creative.invoke(question)
    print(f"  {i+1}: {r.content}")

Ejercicio 2: Limitar respuesta (Fácil)

Haz que el modelo responda en exactamente una frase usando max_tokens. Experimenta con diferentes valores hasta encontrar el rango correcto.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

for max_t in [20, 50, 100]:
    model = init_chat_model("openai:gpt-4.1-mini", max_tokens=max_t)
    response = model.invoke("Explica qué es Docker")
    print(f"max_tokens={max_t}: {response.content}")
    print(f"  (longitud: {len(response.content)} caracteres)")
    print()

Ejercicio 3: Config de producción (Medio)

Crea una función create_production_model(provider) que retorne un modelo configurado con parámetros aptos para producción: temperature baja, timeout de 30s, 3 retries, y max_tokens de 1000.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

PROVIDER_MODELS = {
    "openai": "openai:gpt-4.1-mini",
    "anthropic": "anthropic:claude-haiku-4-20250514",
    "google": "google_genai:gemini-2.0-flash",
}

def create_production_model(provider: str):
    """Crea un modelo con configuración production-ready."""
    if provider not in PROVIDER_MODELS:
        raise ValueError(f"Proveedor no soportado: {provider}")
    
    return init_chat_model(
        PROVIDER_MODELS[provider],
        temperature=0.3,
        max_tokens=1000,
        timeout=30,
        max_retries=3
    )

# Uso
model = create_production_model("openai")
response = model.invoke("¿Qué es un microservicio?")
print(response.content)

Ejercicio 4: Timeout robusto (Medio)

Crea una función que llame a un modelo con timeout de 5 segundos y maneje el error de timeout de forma elegante, retornando un mensaje de fallback.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

def safe_invoke(question: str, timeout_seconds: int = 5) -> str:
    """Invoca el modelo con timeout y retorna fallback si falla."""
    model = init_chat_model(
        "openai:gpt-4.1-mini",
        timeout=timeout_seconds,
        max_retries=1
    )
    
    try:
        response = model.invoke(question)
        return response.content
    except Exception as e:
        return f"[Modelo no disponible: {type(e).__name__}]"

# Uso
result = safe_invoke("¿Qué es Docker?")
print(result)

Ejercicio 5: Modelo configurable (Medio)

Crea un modelo configurable que permita cambiar el proveedor en runtime. Haz la misma pregunta con 2 proveedores diferentes usando la misma instancia.

from dotenv import load_dotenv
load_dotenv()

from langchain.chat_models import init_chat_model

configurable = init_chat_model(
    configurable_fields="any",
    temperature=0.3
)

question = "¿Qué es un agente de AI?"

providers = [
    ("OpenAI", "openai:gpt-4.1-mini"),
    ("Anthropic", "anthropic:claude-haiku-4-20250514"),
]

for name, model_id in providers:
    response = configurable.invoke(
        question,
        config={"configurable": {"model": model_id}}
    )
    print(f"{name}: {response.content[:150]}...")
    print()

Resumen

En esta cápsula aprendiste:

• temperature controla la creatividad: 0.0 para consistencia, 1.0 para variación
• max_tokens limita la longitud de respuesta y controla costos
• timeout y max_retries hacen tu aplicación robusta ante fallos de API
• Los parámetros se pasan como kwargs a init_chat_model
• Los modelos configurables permiten cambiar modelo/proveedor en runtime sin reinicializar
• base_url conecta con proveedores compatibles con la API de OpenAI
• En producción: siempre configura temperature, timeout, y retries

Próxima cápsula: Invoke, Stream y Batch — los 3 modos de ejecución que determinan cómo recibes las respuestas del modelo.

Recursos adicionales

1. Chat Model Parameters - Parámetros estándar en docs oficiales
2. Configurable Runnables - Guía de modelos configurables
3. OpenAI API Parameters - Referencia de parámetros OpenAI
4. Anthropic API Parameters - Referencia de parámetros Anthropic
5. Temperature and Sampling - Cómo funciona temperature internamente
6. LangChain Error Handling - Retry y error handling

Módulo 1 — LangChain & LangGraph: From Chains to Agents