Puntos clave
- ChatOpenAI toma base_url, api_key y model, por lo que cualquier endpoint compatible con OpenAI funciona.
- Usa la URL base https://api.uncensoredllmhub.com/v1 y el modelo uncensored.
- Las llamadas a herramientas están soportadas; para salida estructurada, el modo JSON es el método más seguro.
- Respeta los límites: 8 peticiones simultáneas en una clave completa, así que limita la concurrencia de tus lotes.
Instalar y conectar
La integración de LangChain con OpenAI es un paquete separado de la biblioteca principal. Instálalo con pip install langchain-openai. Obtén una clave desde la página de clave de API; los nuevos usuarios pueden reclamar $0,50 de crédito de prueba allí con un clic, sin necesidad de tarjeta.
Luego crea el objeto del modelo. Tres argumentos importan: model, base_url y api_key.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredllmhub.com/v1",
api_key="YOUR_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a lighthouse cat.").content)Esa es toda la integración. Todo lo que viene después, como prompts, analizadores, agentes y recuperadores, trata llm como cualquier otro modelo de chat. Si prefieres variables de entorno, el SDK de OpenAI lee OPENAI_API_KEY y OPENAI_BASE_URL, lo que facilita cambiar entre entornos sin tocar el código.
Qué admite el endpoint
El servicio expone POST /v1/chat/completions, POST /v1/responses y GET /v1/models. ChatOpenAI usa completados de chat por defecto, que es la opción segura. El modelo es un modelo de pesos abiertos ajustado para responder sin rechazos de contenido para uso adulto lícito, con una ventana de contexto de 100,000 tokens compartida por prompt y completion.
Características de petición soportadas en las que LangChain se basa: streaming sobre SSE con uso al final, llamadas a herramientas, modo JSON, y los parámetros de muestreo temperature, top_p, stop, seed y las penalizaciones. No disponible: embeddings, generación de imágenes o audio, ajuste fino. Si una cadena de recuperación necesita embeddings, usa un modelo de embeddings diferente para ese paso y mantén este endpoint para generación. Las notas completas de parámetros están en la documentación.
Un prompt, un modelo y un analizador
El patrón LCEL básico conecta un prompt al modelo y luego a un analizador de salida. El streaming viene de serie con .stream().
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
prompt = ChatPromptTemplate.from_messages([
("system", "You are a concise editor. Reply in {tone} tone."),
("human", "Improve this sentence: {text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"tone": "plain", "text": "The thing was done by the team."}))
for piece in chain.stream({"tone": "friendly", "text": "We regret to inform you of a delay."}):
print(piece, end="", flush=True)El mensaje de sistema establece el comportamiento para cada llamada. Debido a que la ventana de contexto es grande, también puedes alimentar texto de referencia largo a través de la plantilla de prompt sin un divisor en muchos casos. Los costos de entrada son $0,15 por 1M de tokens, por lo que un documento de 20.000 tokens en el prompt cuesta 20.000 / 1.000.000 x $0,15 = $0,003 por llamada.
Llamadas a herramientas
Las llamadas a herramientas siguen el formato de OpenAI: pasas definiciones de funciones, el modelo responde con tool_calls, ejecutas la función y devuelves el resultado como un mensaje con el rol de herramienta. LangChain envuelve esto en bind_tools.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def add(a: int, b: int) -> int:
"""Add two integers."""
return a + b
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([add])
msg = llm_tools.invoke("What is 41 plus 1? Use the tool.")
for call in msg.tool_calls:
print(call["name"], call["args"]) # run the function yourself, then send a ToolMessage backEl modelo solicita la llamada; tu código la ejecuta. En un marco de agente como LangGraph, un bucle hace esto por ti hasta que el modelo responda en texto plano. Mantén las descripciones de herramientas cortas y los nombres de argumentos claros. Si el modelo ignora una herramienta, ajusta la descripción y establece tool_choice para forzar la llamada mientras depuras.
Salida estructurada con modo JSON
El endpoint soporta el modo JSON, response_format: {"type":"json_object"}. En LangChain, pídelo a través de with_structured_output y elige el método de modo JSON, luego valida con un modelo Pydantic.
from pydantic import BaseModel
from langchain_openai import ChatOpenAI
class Ticket(BaseModel):
title: str
priority: str
llm = ChatOpenAI(model="uncensored", base_url="https://api.uncensoredllmhub.com/v1", api_key="YOUR_KEY")
structured = llm.with_structured_output(Ticket, method="json_mode")
print(structured.invoke("Return JSON with title and priority for: login page crashes on Safari, urgent."))Dos hábitos hacen que JSON sea fiable. Primero, di "JSON" y nombra las claves en el prompt, ya que el modo JSON garantiza sintaxis válida pero no tu esquema. Segundo, envuelve la llamada en un reintento que capture errores de validación y envíe el texto de error al modelo una vez. No dependas de la decodificación restringida por esquema a menos que la hayas probado con este endpoint.
Concurrencia, reintentos y control de costos
LangChain facilita las llamadas paralelas con .batch(), y ahí es donde los límites importan. Una clave completa permite 8 peticiones simultáneas y 300 por minuto. Una clave de prueba permite 2 y 60. Pasa config={"max_concurrency": 6} a batch para mantenerte por debajo del límite.
Cuando se supera el límite, la API devuelve HTTP 429 con el código rate_limited o concurrency, y un encabezado Retry-After: 5 en caso de sobrecarga temporal. ChatOpenAI tiene un argumento max_retries que maneja esto con retroceso; configúralo entre 3 y 5. Los streams ocupan una ranura hasta que finalizan, así que no dejes streams sin leer abiertos.
Ejemplo de costo calculado: un trabajo por lotes de 2.000 elementos, cada uno con 800 tokens de entrada y 150 tokens de salida. Entrada: 2.000 x 800 = 1.600.000 tokens = 1,6 x $0,15 = $0,24. Salida: 2.000 x 150 = 300.000 tokens = 0,3 x $0,50 = $0,15. El trabajo cuesta $0,39. Las solicitudes fallidas o rechazadas no se cobran, y el encabezado X-Balance-USD te permite vigilar tu saldo. Consulta precios para recargas, que van de $20 a $500 y se pueden pagar con cripto.
Agentes y memoria de conversación
Dos patrones surgen justo después de que funcione la primera cadena. El primero es la memoria de conversación. Los ayudantes de historial de mensajes de LangChain almacenan turnos pasados y los antepone a cada llamada. Dado que la ventana es de 100.000 tokens, puedes mantener historiales largos, pero recuerda que cada turno los reenvía. Un historial de 30.000 tokens en cada uno de 50 turnos significa 1.500.000 tokens de entrada, o 1.5 x $0,15 = $0,225 para la sesión. Resumir turnos antiguos una vez que el historial supera un límite de tamaño mantiene eso plano.
El segundo es el bucle del agente. En LangGraph, un agente preconstruido toma el mismo objeto llm más una lista de herramientas y repite hasta que el modelo deja de solicitar herramientas. Establece un número máximo de pasos para que un bucle que se confunde no pueda acumular tokens de entrada. Registra el encabezado de respuesta X-Request-Id para cualquier llamada que se comporte de manera extraña, ya que es el identificador a citar si contactas con soporte.
Solución de problemas
- 404 en cada llamada. La URL base debe terminar en
/v1y no debe incluir/chat/completions. - Modelo no encontrado. Usa
uncensoredexactamente. LangChain no valida los nombres de modelos para endpoints personalizados. - Advertencias de conteo de tokens. Algunas funciones de LangChain estiman los tokens con los tokenizers de OpenAI. Los conteos pueden diferir ligeramente del modelo real, así que confía en el uso devuelto por la API.
- Los bucles de agentes largos son costosos. Cada bucle reenvía todo el historial. Recorta la salida de herramientas antigua antes de que alcance la siguiente llamada.
Si tu cadena parece correcta y aún falla, llama al endpoint con curl básico para separar un problema de LangChain de un problema de cuenta.

