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
Guarda tu progreso
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
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:
Aprendizajes de esta lección
- Obtener y gestionar la API KEY de OpenAI de forma segura.
- Configurar variables de entorno para integrar OpenAI con LangChain.
- Inicializar y utilizar modelos de OpenAI en LangChain mediante diferentes métodos.
- Ajustar parámetros de los modelos para controlar su comportamiento.
- Conocer la alternativa de Azure OpenAI y su integración con LangChain.
Completa LangChain y certifícate
Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs