Conecta LangChain en cuatro líneas
Si quieres usar modelos open source de langchain sin alojar nada, el camino más corto es una API compatible con OpenAI. La clase de chat de OpenAI de LangChain no le importa quién responda, siempre que el endpoint hable el mismo protocolo. Cambias la base URL y la clave, y el resto de tus cadenas, prompts y agentes permanecen igual.
Este servicio aloja un modelo de pesos abiertos, ejecutado por un proveedor independiente y ajustado para responder sin rechazos de contenido para uso adulto lícito. No es la API oficial de ningún proveedor de modelos ni es un enrutador entre proveedores. Instala el paquete y crea el objeto del modelo:
pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
Esa es toda la conexión. Mantén la clave en una variable de entorno en proyectos reales y léela con os.environ en lugar de escribirla en el archivo. Si aún no tienes una clave, la página de la clave muestra cómo registrarte y reclamar $0,50 de crédito de prueba, sin necesidad de tarjeta.
Node.js y LangChain.js
El paquete de JavaScript sigue la misma idea, pasando la base URL a través de un objeto de configuración.
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.API_KEY,
temperature: 0.7,
configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});
const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);
Si ves un 404 o una página HTML en el error, la base URL suele estar mal. Debe terminar en /v1. Los dos endpoints detrás de escena son POST /v1/chat/completions y GET /v1/models, y no se necesita nada más para el modelo de chat de LangChain.
¿Es mejor alojar o ejecutar localmente un modelo open source en LangChain?
LangChain también puede ejecutar modelos abiertos en tu propia máquina, por ejemplo a través de Ollama o un servidor local. Esa ruta tiene ventajas reales, y es honesto decirlo. Los modelos locales no tienen costo por token, funcionan sin conexión y mantienen cada byte en tu hardware. El precio es el hardware: necesitas suficiente memoria GPU para el modelo que elijas, mantienes el entorno de ejecución y el rendimiento está limitado por tu máquina.
| Pregunta | Servidor local | Esta API alojada |
|---|---|---|
| Costo inicial | Hardware o una GPU alquilada | Ninguno; crédito prepago desde $20 |
| Costo por token | Ninguno, pero desgaste de energía y hardware | $0,15 por 1M de entrada, $0,50 por 1M de salida |
| Ventana de contexto | Depende de la memoria que tengas | 100.000 tokens |
| Concurrencia | Depende de tu configuración | 8 en una clave completa |
| Ubicación de los datos | Tu máquina | Alojado; prompts no usados para entrenamiento |
Un patrón común es prototipar contra el endpoint alojado, luego decidir con conteos reales de tokens si una implementación local tiene sentido. Como ambos lados hablan el protocolo de OpenAI, cambiar es un cambio de una línea en base_url, y las cadenas que construiste permanecen intactas. La página sobre qué es un modelo sin censura explica qué cambios de comportamiento produce el ajuste.
Herramientas y un agente simple
Las llamadas a herramientas pasan por el campo tools al estilo de OpenAI, y bind_tools de LangChain lo construye por ti a partir de una función de Python decorada. El modelo devuelve solicitudes de llamada a herramientas, y los resultados vuelven como mensajes role: "tool".
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
@tool
def word_count(text: str) -> int:
'''Count the words in a piece of text.'''
return len(text.split())
agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)
El bucle del agente llama al modelo, ejecuta la herramienta cuando se pide, y envía la salida de vuelta hasta que el modelo responde en texto plano. Aplican dos precauciones. Dale a cada herramienta un docstring escrito para el modelo, porque ese texto es lo que lee para elegir una herramienta. Y establece un límite de recursión en los agentes para que una ejecución confundida no siga gastando crédito; LangGraph acepta un recursion_limit en la configuración.
Para control directo sin un agente, usa llm.bind_tools([word_count]) e inspecciona .tool_calls en el mensaje devuelto tú mismo.
Salida estructurada con modo JSON
Para trabajos de extracción, pasa el parámetro de modo JSON a través de bind. El prompt debe indicarle al modelo qué claves quieres, ya que el modo JSON solo lo empuja a producir un objeto JSON válido.
import json
from langchain_core.prompts import ChatPromptTemplate
json_llm = llm.bind(response_format={"type": "json_object"})
prompt = ChatPromptTemplate.from_messages([
("system", "Return a JSON object with keys title, genre and summary."),
("human", "{idea}"),
])
chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)
Valida el resultado con Pydantic o una verificación simple de claves antes de usarlo. El modo no aplica un esquema, por lo que es posible que falte un campo, y un reintento con un prompt más claro suele solucionarlo.
Streaming y concurrencia
El streaming corre sobre eventos enviados por el servidor y funciona con el método estándar stream. El uso se envía al final del stream.
for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
print(chunk.content, end="", flush=True)
Cuando procesas muchos elementos, batch los ejecuta en paralelo, y aquí es donde importan los límites. Una clave completa permite 8 peticiones simultáneas y 300 peticiones por minuto. Una clave de prueba permite 2 y 60. Una petición en streaming mantiene su slot hasta que termina el streaming. Pasa un límite para que LangChain nunca exceda lo que tu clave permite:
prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})
Si aún ves HTTP 429, el código de error te dice qué límite alcanzaste: rate_limited para peticiones por minuto, concurrency para demasiadas a la vez. Un 429 con un encabezado Retry-After: 5 marca sobrecarga temporal. ChatOpenAI tiene una opción max_retries que reintenta en estos errores con retroceso; establécela en 3 o 4 para trabajos por lotes.
Una cadena de recuperación sin un endpoint de embeddings
Esta API cubre solo la generación, por lo que una cadena de recuperación necesita dos proveedores: uno para embeddings y otro para el paso de chat. LangChain hace eso fácil, porque la vector store y el modelo de chat son objetos separados. Usa cualquier modelo de embeddings que prefieras, de una biblioteca local u otro servicio, para indexar tus documentos. Luego pasa el texto recuperado al modelo de chat a través del prompt.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
("human", "{question}"),
])
chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})
Aquí top_chunks es lo que tu retriever devolvió. Limita a los pocos fragmentos que importan. Cuatro fragmentos de 300 tokens suman 1.200 tokens por llamada, lo cual está bien, pero cuarenta fragmentos suman 12.000 y hacen cada petición diez veces más pesada.
Lista de comprobación de solución de problemas
- Errores de autenticación: confirma que la clave está en
api_key, no en un parámetro diferente, y que ninguna variable de entornoOPENAI_API_KEYesté anulando silenciosamente lo que querías pasar. - Modelo no encontrado: el ID del modelo es exactamente
uncensored. Llama aGET /v1/modelspara ver qué lista el servidor. - Argumentos de herramienta extraños: lee la cadena de argumentos crudos, ajusta la descripción de la herramienta y baja la temperatura a alrededor de 0,2 para ejecuciones de agente.
- Seguimiento y depuración: activa el modo verboso o de depuración de LangChain localmente para ver cada prompt que se envía y cada respuesta que se recibe.
- Pruebas repetibles: pasa
seedy una temperatura baja cuando comparas versiones de prompt, para que las diferencias vengan de tu cambio y no de la suerte del muestreo.
Costo de una carga de trabajo de LangChain
La facturación es por token desde el crédito prepago. No hay suscripción, las peticiones fallidas o rechazadas no se cobran, y el crédito no caduca. Las recargas son cualquier cantidad entera desde $20 hasta $500, con cripto (USDT en TRC20, USDC en Base), con un bono del 5% desde $50, 10% desde $100 y 15% desde $200. La página de precios tiene los detalles.
Trabaja con un ejemplo. Un bot de soporte responde 2.000 preguntas en un día. Cada petición envía alrededor de 1.500 tokens (prompt del sistema, fragmentos recuperados, pregunta) y devuelve alrededor de 250 tokens.
- Entrada: 2.000 x 1.500 = 3.000.000 tokens, por lo que 3 x $0,15 = $0,45.
- Salida: 2.000 x 250 = 500.000 tokens, por lo que 0,5 x $0,50 = $0,25.
- Total: $0,70 por día para 2.000 respuestas, o $0,00035 cada una.
Las cadenas de recuperación son donde los costos pueden desviarse, porque cada fragmento recuperado adicional añade tokens de entrada a cada llamada. Registra usage_metadata de las respuestas, vigila el tamaño promedio del prompt y recorta la cantidad de fragmentos antes de escalar. La documentación de la API lista todos los parámetros admitidos si quieres ir más allá.
