LangChain modelos openai

Obtener API KEY de OpenAI

Para utilizar los modelos de OpenAI en LangChain, necesitas obtener una clave de API que te permita autenticarte con los servicios de OpenAI. Esta clave actúa como tu credencial de acceso y debe mantenerse segura en todo momento.

Proceso de obtención de la API KEY

El primer paso es crear una cuenta en la plataforma de OpenAI. Dirígete a platform.openai.com y regístrate si aún no tienes una cuenta. Una vez dentro de tu panel de control, navega hasta la sección "API Keys" en el menú lateral.

En esta sección encontrarás la opción "Create new secret key". Al hacer clic, se generará una nueva clave que tendrá un formato similar a sk-proj-... seguido de una cadena alfanumérica. Es crucial que copies esta clave inmediatamente, ya que por motivos de seguridad no podrás volver a visualizarla completa una vez que cierres la ventana.

sk-proj-abcd1234efgh5678ijkl9012mnop3456qrst7890uvwx

Configuración de la variable de entorno

LangChain está diseñado para detectar automáticamente las credenciales de OpenAI a través de variables de entorno. La forma más segura y práctica de gestionar tu API KEY es utilizando un archivo .env en la raíz de tu proyecto.

Crea un archivo llamado .env y añade la siguiente línea:

OPENAI_API_KEY=tu_clave_api_aquí

Para que Python pueda cargar estas variables de entorno, necesitarás instalar la librería python-dotenv:

pip install python-dotenv

Luego, al inicio de tu script de Python, carga las variables de entorno:

from dotenv import load_dotenv
import os

# Cargar variables de entorno desde el archivo .env
load_dotenv()

# Verificar que la clave se ha cargado correctamente
api_key = os.getenv("OPENAI_API_KEY")
if api_key:
    print("API KEY cargada correctamente")
else:
    print("Error: No se pudo cargar la API KEY")

Consideraciones de seguridad

Es fundamental que nunca incluyas tu API KEY directamente en el código fuente. Siempre utiliza variables de entorno o archivos de configuración que estén excluidos del control de versiones.

Añade el archivo .env a tu .gitignore para evitar que se suba accidentalmente a repositorios públicos:

# Archivo .gitignore
.env
*.env

Gestión de costes

Ten en cuenta que el uso de la API de OpenAI tiene costes asociados basados en el número de tokens procesados. Puedes monitorizar tu uso y establecer límites de gasto en la sección "Usage" de tu panel de control de OpenAI.

Es recomendable configurar alertas de facturación para evitar gastos inesperados, especialmente durante el desarrollo y las pruebas de tu aplicación.

Alternativa con Azure OpenAI

Como alternativa a la API directa de OpenAI, puedes utilizar Azure OpenAI Service a través de Azure AI Foundry. Esta opción requiere obtener tanto una clave de API como un endpoint específico de tu instancia de Azure.

Para configurar Azure OpenAI, necesitarías las siguientes variables de entorno adicionales:

AZURE_OPENAI_API_KEY=tu_clave_azure
AZURE_OPENAI_ENDPOINT=https://tu-recurso.openai.azure.com/
AZURE_OPENAI_API_VERSION=2024-02-01

Esta configuración te permitirá utilizar los mismos modelos de OpenAI pero a través de la infraestructura de Azure, lo que puede ofrecer ventajas en términos de cumplimiento normativo y integración con otros servicios de Azure.

Invocar modelos de OpenAI en LangChain

Una vez configurada tu API KEY de OpenAI, puedes comenzar a utilizar los modelos de OpenAI directamente desde LangChain. La librería proporciona múltiples formas de interactuar con estos modelos, siendo las más comunes el uso de init_chat_model y la clase ChatOpenAI.

Instalación de dependencias

Antes de comenzar, necesitas instalar el paquete específico para OpenAI:

pip install langchain-openai

Esta librería contiene todas las integraciones necesarias para trabajar con los modelos de OpenAI desde LangChain, incluyendo tanto los modelos de chat como los de completado.

Opción 1: Usando init_chat_model

La función init_chat_model es la forma más moderna y recomendada de inicializar modelos de chat en LangChain 0.3. Esta función proporciona una interfaz unificada que funciona con múltiples proveedores.

from langchain_core.language_models import init_chat_model

# Inicializar el modelo usando init_chat_model
llm = init_chat_model(
    model="gpt-4.1",
    model_provider="openai",
    temperature=0.7
)

# Invocar el modelo con un mensaje simple
response = llm.invoke("Explica qué es la inteligencia artificial en una frase")
print(response.content)

Ejemplo

Esta aproximación es especialmente útil cuando trabajas con múltiples proveedores de modelos, ya que mantiene una interfaz consistente independientemente del proveedor subyacente.

Opción 2: Usando ChatOpenAI directamente

La clase ChatOpenAI te permite un control más granular sobre la configuración del modelo y es la opción preferida cuando trabajas exclusivamente con modelos de OpenAI.

from langchain_openai import ChatOpenAI

# Inicializar el modelo ChatOpenAI
llm = ChatOpenAI(
    model="gpt-4.1",
    temperature=0.7,
    max_tokens=1000
)

# Invocar el modelo
response = llm.invoke("¿Cuáles son las ventajas de usar Python para machine learning?")
print(response.content)

Ejemplo:

Configuración de parámetros del modelo

Ambas opciones te permiten configurar parámetros importantes que afectan el comportamiento del modelo:

from langchain_openai import ChatOpenAI

# Configuración detallada del modelo
llm = ChatOpenAI(
    model="gpt-4.1-mini",  # Modelo más económico
    temperature=0.3,       # Menor creatividad, más determinista
    max_tokens=500,        # Límite de tokens en la respuesta
    top_p=0.9,            # Control de diversidad
    frequency_penalty=0.1  # Penalización por repetición
)

# Ejemplo de uso con parámetros específicos
prompt = "Genera un resumen técnico sobre microservicios"
response = llm.invoke(prompt)
print(f"Respuesta ({len(response.content)} caracteres): {response.content}")

Trabajando con diferentes modelos

OpenAI ofrece varios modelos optimizados para diferentes casos de uso. Puedes cambiar fácilmente entre ellos modificando el parámetro model:

from langchain_openai import ChatOpenAI

# Modelo estándar para uso general
gpt4 = ChatOpenAI(model="gpt-4.1", temperature=0.7)

# Modelo optimizado para tareas más simples y económicas
gpt4_mini = ChatOpenAI(model="gpt-4.1-mini", temperature=0.7)

# Modelo optimizado para razonamiento complejo
o1_mini = ChatOpenAI(model="o1-mini", temperature=0.7)

# Comparar respuestas de diferentes modelos
prompt = "Explica el concepto de recursión en programación"

print("GPT-4.1:")
print(gpt4.invoke(prompt).content)

print("\nGPT-4.1-mini:")
print(gpt4_mini.invoke(prompt).content)

Manejo de respuestas

Las respuestas de los modelos de OpenAI en LangChain siguen un formato estructurado que incluye tanto el contenido como metadatos útiles:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4.1", temperature=0.5)
response = llm.invoke("¿Qué es LangChain?")

# Acceder al contenido de la respuesta
print("Contenido:", response.content)

# Acceder a metadatos adicionales
print("Modelo usado:", response.response_metadata.get('model_name'))
print("Tokens usados:", response.response_metadata.get('token_usage'))

Ejemplo:

Alternativa con Azure OpenAI

Si prefieres utilizar Azure OpenAI Service, puedes usar la clase AzureChatOpenAI que funciona de manera similar pero requiere configuración adicional:

from langchain_openai import AzureChatOpenAI

# Configurar Azure OpenAI (requiere variables de entorno adicionales)
azure_llm = AzureChatOpenAI(
    azure_deployment="gpt-4",  # Nombre de tu deployment en Azure
    api_version="2024-02-01",
    temperature=0.7
)

# Usar de la misma manera que ChatOpenAI
response = azure_llm.invoke("Explica las ventajas de usar Azure OpenAI")
print(response.content)

Esta opción es especialmente útil en entornos empresariales donde se requiere cumplimiento con políticas específicas de datos o integración con otros servicios de Azure.

Verificación de la configuración

Para asegurarte de que todo está configurado correctamente, puedes crear un script de verificación simple:

from langchain_openai import ChatOpenAI
import os

def verificar_configuracion():
    try:
        # Verificar que la API KEY está disponible
        if not os.getenv("OPENAI_API_KEY"):
            print("❌ API KEY no encontrada")
            return False
        
        # Intentar inicializar el modelo
        llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0.1)
        
        # Realizar una invocación de prueba
        response = llm.invoke("Di 'configuración correcta'")
        
        if "configuración correcta" in response.content.lower():
            print("✅ Configuración verificada correctamente")
            return True
        else:
            print("⚠️ Respuesta inesperada del modelo")
            return False
            
    except Exception as e:
        print(f"❌ Error en la configuración: {e}")
        return False

# Ejecutar verificación
verificar_configuracion()

Alternativa para testing, usar un modelo mock: