API LLM personalizada de LangChain: apúntala a cualquier URL base
Para usar una API LLM personalizada de LangChain no necesitas escribir una clase personalizada: el adaptador de chat compatible con OpenAI acepta una URL base, una clave y un nombre de modelo. Aquí está la configuración exacta, más streaming, herramientas, salida JSON, reintentos y límites de peticiones. y manejo de límites.
Puntos clave
- ChatOpenAI toma base_url, api_key y model, por lo que no se necesita subclasificación.
- Usa el modelo uncensored y la URL base https://api.llmapistatus.com/v1.
- Las llamadas a herramientas, el streaming y el modo JSON pasan todos por el endpoint.
- Limita las cadenas paralelas a 8 para no superar el límite de concurrencia; no se ofrecen embeddings.

La respuesta corta: ChatOpenAI con una URL base diferente
LangChain se conecta a servidores estilo OpenAI mediante el paquete langchain-openai. Su clase ChatOpenAI te permite sobrescribir el destino de las peticiones, justo lo que necesita un endpoint personalizado. Instala el paquete y pasa tres valores: la base URL https://api.llmapistatus.com/v1, tu clave y el ID del modelo uncensored.
Instala con pip install -U langchain-openai langchain-core.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmapistatus.com/v1",
api_key=os.environ["LLM_API_KEY"],
temperature=0.7,
)
print(llm.invoke("Reply with the single word: ready").content)
Si eso imprime una respuesta, el cableado es correcto. Obtienes una clave desde la página de clave de API; el inicio rápido muestra el mismo cambio para usuarios del SDK directo. El endpoint sirve POST /v1/chat/completions y GET /v1/models, y esos dos métodos son todo lo que necesita el wrapper de OpenAI para chat.
Una palabra sobre el término "LLM personalizado". LangChain también documenta una forma de escribir tu propio modelo de chat subclasificando una clase base, lo cual tiene sentido para APIs que no hablan el formato OpenAI. Este endpoint sí lo habla, por lo que la subclasificación solo añadiría código para mantener. Úsalo solo si necesitas comportamiento que el adaptador no puede expresar.
Construir una cadena con prompts y análisis de salida
Con el objeto de modelo en su lugar, todo lo demás en LangChain funciona como lo hace con cualquier modelo de chat. Aquí hay una pequeña cadena escrita en el estilo de lenguaje de expresiones: una plantilla de prompt, el modelo y un analizador de cadena.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You are a blunt technical editor. Answer in at most {limit} words."),
("human", "Rewrite this for clarity:\n\n{text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({
"limit": 60,
"text": "The thing that we did was basically to make the cache be invalidated on write.",
}))
Nada en esta cadena sabe o le importa que el modelo esté detrás de un dominio diferente. Ese es el beneficio de la API compatible: los prompts, las clases de memoria, los recuperadores y los agentes escritos contra la interfaz de chat estándar siguen funcionando. Lo que debes verificar por tu lado es el prompt mismo. Un modelo ajustado para responder sin rechazos de contenido sigue las instrucciones literalmente, por lo que los prompts de sistema vagos producen un comportamiento vago. Establece el rol, el formato y la longitud.
Vale la pena conocer un límite antes de diseñar un pipeline de recuperación. Este servicio es solo de texto. No hay embeddings, por lo que OpenAIEmbeddings apuntando a esta base URL fallará. Usa un modelo de embedding local u otro proveedor para el vector store, y usa este endpoint solo para generación.
Tokens de streaming a medida que llegan
El endpoint soporta server-sent events al enviar stream: true, y LangChain lo convierte en un iterador. No estableces la bandera tú mismo; llamar a .stream() lo hace.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
for chunk in llm.stream("Write a four-line poem about a failing cron job."):
print(chunk.content, end="", flush=True)
print()
Para servidores asíncronos usa astream. La misma llamada existe en la librería JavaScript:
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.LLM_API_KEY,
configuration: { baseURL: "https://api.llmapistatus.com/v1" },
});
const stream = await llm.stream("Write a four-line poem about a failing cron job.");
for await (const chunk of stream) {
process.stdout.write(chunk.content);
}
Recuerda que una petición en streaming mantiene su ranura de concurrencia hasta que llega el último evento. Si un usuario cierra la pestaña del navegador y tu servidor sigue leyendo el stream, esa ranura permanece ocupada. Cancela la petición upstream cuando el cliente se desconecte. Los números de uso llegan al final del stream, que es donde lees los conteos finales de tokens para los registros de facturación.
Llamadas a funciones y agentes
Las llamadas a funciones están disponibles: el endpoint acepta tools y tool_choice, hace streaming de tool_calls de vuelta, y toma tus resultados como mensajes con role: "tool". En LangChain adjuntas herramientas con bind_tools y dejas que el framework construya los mensajes.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.tools import tool
@tool
def get_order_status(order_id: str) -> str:
'Look up the status of an order by its id.'
return f"Order {order_id} shipped yesterday."
llm_tools = llm.bind_tools([get_order_status])
ai = llm_tools.invoke("Where is order A-1042?")
print(ai.tool_calls)
Ejecutar la llamada y devolver el resultado es la segunda mitad del bucle:
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
# llm_tools comes from the previous snippet
from langchain_core.messages import HumanMessage, ToolMessage
messages = [HumanMessage("Where is order A-1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)
for call in ai.tool_calls:
result = get_order_status.invoke(call["args"])
messages.append(ToolMessage(content=result, tool_call_id=call["id"]))
print(llm_tools.invoke(messages).content)
Los modelos de pesos abiertos varían en qué tan bien eligen herramientas y rellenan argumentos. Mantén las descripciones de herramientas cortas y concretas, usa pocas herramientas por llamada, y valida los argumentos en tu función en lugar de confiar en ellos. Si un agente entra en bucle, reduce la temperatura y establece un número máximo de pasos en tu ejecutor de agente.
Salida estructurada y JSON
El modo JSON es compatible a través de response_format: {"type": "json_object"}. En LangChain la ruta más fácil es with_structured_output usando el método de modo JSON, que también valida el resultado contra un esquema.
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from pydantic import BaseModel
class Ticket(BaseModel):
title: str
priority: str
tags: list[str]
structured = llm.with_structured_output(Ticket, method="json_mode")
result = structured.invoke(
"Return JSON with keys title, priority and tags for this report: "
"login page times out on mobile, affects many users."
)
print(result)
El modo JSON garantiza que la salida sea un objeto JSON, no que tenga los campos que querías. Dos hábitos ayudan. Primero, nombra las claves en el prompt, como arriba; la instrucción para producir JSON debe ser explícita. Segundo, envuelve la llamada en un reintento que vuelva a analizar en caso de fallo. La comprobación de pydantic captura campos faltantes y tipos incorrectos, y un solo reintento con el mensaje de error adjunto suele arreglarlo.
También puedes establecer response_format directamente cuando construyes el modelo con model_kwargs={"response_format": {"type": "json_object"}}, lo cual es útil para cadenas simples que terminan en un analizador JSON.
Límites de peticiones, reintentos y cadenas paralelas
Los trabajos por lotes y los agentes realizan muchas llamadas a la vez, y aquí es donde un endpoint personalizado difiere de un modelo local. Una clave completa permite 8 peticiones simultáneas y 300 peticiones por minuto. Una clave de prueba permite 2 simultáneas y 60 por minuto. Al superar un límite, la API responde con HTTP 429 y el código de error rate_limited o concurrency; en sobrecarga temporal responde 429 con Retry-After: 5.
Dos configuraciones de LangChain manejan la mayoría de ello. El modelo toma max_retries, que reintenta fallos transitorios con retroceso, y los runnables aceptan un valor max_concurrency en su configuración para trabajo por lotes:
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmapistatus.com/v1",
api_key=os.environ["LLM_API_KEY"],
max_retries=4,
timeout=120,
)
questions = [f"Summarise item {i} in one sentence." for i in range(40)]
answers = llm.batch(questions, config={"max_concurrency": 6})
Establecer el límite a 6 en una clave completa deja espacio para otras dos peticiones, como una petición visible para el usuario desde la misma aplicación. En una clave de prueba usa 1 o 2. No confíes solo en los reintentos para un problema de concurrencia: si el límite está por encima del máximo, los reintentos simplemente recrean la misma colisión. Leer X-RateLimit-Limit-Requests y X-RateLimit-Limit-Concurrency de los encabezados de respuesta te dice qué está permitido para tu clave.
Las entradas largas están bien hasta la ventana de 100.000 tokens, compartida entre prompt y completion, y el cuerpo de la petición está limitado a 8 MB. Los splitters de texto de LangChain configurados para unos pocos miles de tokens por chunk te mantienen lejos de ambos.
Solución de problemas de un endpoint personalizado
La mayoría de los problemas con una URL base personalizada entran en una lista corta, y cada uno tiene una prueba rápida.
- Errores de autenticación. LangChain también lee la variable de entorno
OPENAI_API_KEY. Si pasasapi_keyexplícitamente, ese valor gana, pero una variable obsoleta aún puede confundir un segundo objeto de modelo que olvidaste configurar. Pasa la clave cada vez, y dale a la variable otro nombre comoLLM_API_KEY. - Errores de no encontrado. La base URL debe terminar en
/v1. LangChain añade/chat/completionspor sí misma, por lo que añadirlo a la base URL produce una ruta duplicada. - Modelo desconocido. Haz una petición
GET /v1/modelscon la misma clave y copia el ID que imprima. Debería seruncensored. - Bloqueos silenciosos en cadenas largas. Establece
timeouten el modelo y registra el encabezado de respuestaX-Request-Id. Si contactas con soporte, esa ID les permite encontrar la petición exacta. - Salidas sorprendentes. Imprime el prompt final antes de que se envíe. La mayoría de las respuestas extrañas en LangChain provienen de una plantilla que rellenó una variable con algo inesperado, no del modelo.
En caso de duda, reproduce la petición fallida con curl plano contra la misma URL. Si curl funciona y LangChain no, la falla está en tu cadena; si ambas fallan, verifica la clave y el saldo.
Verificar el costo mientras construyes
Las cadenas ocultan los recuentos de tokens, así que mide pronto. Cada respuesta incluye uso, y los encabezados de respuesta incluyen X-Balance-USD. El precio es $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida, cobrados del crédito prepago.
Un ejemplo práctico: una cadena de recuperación que envía 6.000 tokens de contexto y pregunta y recibe 400 tokens de vuelta cuesta 6.000 x $0,15 / 1M = $0,0009 para entrada más 400 x $0,50 / 1M = $0,0002 para salida, es decir $0,0011 por llamada. Ejecutar 5.000 de estas llamadas en un barrido de prueba cuesta $5,50. Eso es útil saberlo antes de dejar un bucle de agente ejecutándose toda la noche.
Las peticiones fallidas o rechazadas no se cobran. La página de precios lista cantidades de recarga desde $20 hasta $500 con bonificaciones, y las cuentas nuevas pueden reclamar un crédito de prueba de $0,50 con un clic, suficiente para unas pocas cientos de llamadas de prueba pequeñas mientras conectas las cosas.
Más guías
Preguntas y respuestas
¿Tengo que subclasificar la clase base del modelo de chat de LangChain?
No. El endpoint es compatible con OpenAI, por lo que ChatOpenAI con una base_url personalizada, api_key y modelo funciona. La subclasificación solo es necesaria para APIs que usan un formato diferente.
¿Puedo usar OpenAIEmbeddings con este endpoint?
No. El servicio es solo de texto y no tiene embeddings. Usa un modelo de embeddings local u otro proveedor para vectores, y usa este endpoint para la generación.
¿Qué nombre de modelo debo pasar?
Pasa uncensored como el modelo. GET /v1/models devuelve el mismo ID.
¿Por qué obtengo errores 429 en un trabajo por lotes?
Has excedido las peticiones por minuto o las peticiones simultáneas. Reduce max_concurrency a menos de 8 en una clave completa, o a 2 en una clave de prueba, y mantén los reintentos habilitados.
¿Funciona el streaming de LangChain aquí?
Sí. Llamar a stream o astream usa eventos enviados por el servidor, y el uso se envía al final del streaming.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.