Lo que necesitas antes de comenzar
LangChain se comunica con cualquier servidor que implemente el protocolo de chat completions de OpenAI, por lo que no hay integración especial que instalar. Tu punto de partida es el mismo paquete que usarías para OpenAI: langchain-openai para Python o @langchain/openai para Node. Solo cambian tres valores.
- Base URL:
https://api.deepseekapipricing.com/v1 - Modelo:
uncensored - Clave: enviada como
Authorization: Bearer <key>, que el cliente hace por ti
Una aclaración sobre la nomenclatura. Este endpoint es un servicio independiente que ejecuta un modelo de pesos abiertos ajustado para responder sin rechazos de contenido para uso adulto lícito. No es la API oficial de DeepSeek ni un router entre proveedores, por lo que el nombre del modelo es siempre uncensored, no un ID de modelo de proveedor. Si necesitas una clave, la página de clave de API muestra los pasos de registro y la prueba de $0,50 con un clic.
Instala y realiza la primera llamada en Python
Instala los paquetes:
pip install -U langchain-openai langchain-core
# then use base_url https://api.deepseekapipricing.com/v1 and model "uncensored"
Luego crea el objeto del modelo. Pasa la clave explícitamente en lugar de confiar en la variable de entorno OPENAI_API_KEY, que podría contener una clave real de OpenAI que no deseas enviar a un host diferente.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.deepseekapipricing.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
temperature=0.7,
max_retries=2,
)
print(llm.invoke("Say hello in five words.").content)
Si esto imprime un saludo, la conexión, la clave y el nombre del modelo son correctos. El error más común en esta etapa es omitir /v1 en la base URL, lo que típicamente produce un error de no encontrado.
Prompts, cadenas y streaming
Desde aquí, LangChain funciona como de costumbre. Una plantilla de prompt, el modelo y un analizador de salida se componen en una cadena con el operador pipe:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You write tight, vivid scene descriptions for adult fiction."),
("human", "Describe this setting in under 80 words: {setting}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"setting": "a flooded subway station at night"}))
El streaming se realiza mediante eventos enviados por el servidor. En LangChain llamas a stream, y cada fragmento contiene un trozo de texto. Configura stream_usage=True en el modelo si quieres el recuento de tokens al final del stream; la API envía el uso en el último evento.
llm_stream = ChatOpenAI(
model="uncensored",
base_url="https://api.deepseekapipricing.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
stream_usage=True,
)
for chunk in llm_stream.stream("Write a four-line poem about a night train."):
print(chunk.content, end="", flush=True)
Una petición transmitida mantiene su espacio de concurrencia hasta que finalice el stream, así que si abandonas un stream sin cerrarlo, ese espacio permanece ocupado más tiempo del esperado.
Node y TypeScript
El paquete de JavaScript toma la base URL dentro de un objeto configuration:
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.UNCENSORED_API_KEY,
configuration: { baseURL: "https://api.deepseekapipricing.com/v1" },
maxRetries: 2,
});
const res = await llm.invoke("Say hello in five words.");
console.log(res.content);
const stream = await llm.stream("Write a four-line poem about a night train.");
for await (const chunk of stream) {
process.stdout.write(chunk.content);
}
Ejecútalo como un módulo ES ("type": "module" en package.json, o un archivo .mjs). Todo lo demás en la API de Node, incluidas las plantillas de prompt y los runnables, se comporta como lo hace con cualquier otro modelo de chat.
Llamadas a funciones y agentes
La API admite el formato de herramientas de OpenAI: los parámetros tools y tool_choice, tool_calls en streaming, y los resultados de las herramientas devueltos como mensajes con role: "tool". En LangChain declaras las herramientas con un decorador y las adjuntas con bind_tools:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, ToolMessage
@tool
def order_status(order_id: str) -> str:
"""Return the shipping status of an order."""
return f"Order {order_id} left the warehouse yesterday."
llm_tools = llm.bind_tools([order_status])
messages = [HumanMessage("Where is order 1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)
for call in ai.tool_calls:
result = order_status.invoke(call["args"])
messages.append(ToolMessage(content=result, tool_call_id=call["id"]))
print(llm_tools.invoke(messages).content)
Escribir el bucle a mano una vez vale los diez minutos. Te muestra exactamente qué devolvió el modelo, qué argumentos eligió para cada llamada y dónde una mala descripción de herramienta lleva a una suposición incorrecta. Una vez que quede claro, cambia a un agente preconstruido y mantén la versión escrita a mano como referencia de depuración.
Ese es todo el bucle hecho a mano: el modelo pide una herramienta, tú la ejecutas, devuelves el resultado y el modelo escribe la respuesta final. Si prefieres un bucle de agente listo para usar, el paquete langgraph ofrece create_react_agent(llm, [order_status]), y lo invocas con {"messages": [("user", "Where is order 1042?")]}.
Qué tan bien elige herramientas un modelo depende del modelo, así que prueba con tus esquemas de herramientas reales. Descripciones de herramientas cortas y específicas y una temperatura baja ayudan. Un agente que hace seis llamadas con un historial creciente de aproximadamente 27.000 tokens de entrada en total y 1.800 tokens de salida cuesta aproximadamente $0,00405 más $0,0009, o aproximadamente medio centavo.
Salida estructurada con modo JSON
El modo JSON es compatible a través de response_format. Vincúlalo al modelo y también indica en el prompt que deseas JSON con claves específicas, ya que la bandera de formato controla la sintaxis, no tu esquema:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
import json
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke(
"Return a JSON object with keys title (string) and tags (list of 3 strings) "
"for a short story about a lighthouse keeper."
)
data = json.loads(msg.content)
print(data["title"], data["tags"])
Valida el resultado analizado con Pydantic o tus propias comprobaciones antes de confiar en él, y maneja json.JSONDecodeError con un reintento. Para trabajos de extracción grandes, analiza cada respuesta de forma defensiva en lugar de asumir que la primera es limpia.
Recuperación, memoria y callbacks
Esta API no tiene un endpoint de embeddings, por lo que un pipeline de recuperación necesita una fuente separada de embeddings. Todo después de la recuperación es chat simple. Una cadena de recuperación típica extrae los mejores fragmentos de tu almacén vectorial, los pega en el prompt y le pide al modelo que responda a partir de ese texto. Debido a que la ventana de contexto es de 100.000 tokens, puedes permitirte fragmentos generosos, pero recuerda la factura: cada token de contexto recuperado es entrada a $0,15 por millón, por lo que 20.000 tokens de contexto cuestan $0,003 por pregunta.
Para la memoria de chat, el enfoque más simple es una lista de mensajes que recortas por número de tokens antes de cada llamada. LangChain ofrece utilidades como trim_messages para esto. Mantén el mensaje del sistema y los últimos turnos, y elimina o resume el medio una vez que el historial alcanza un límite que elijas. Un historial más pequeño también mantiene las respuestas enfocadas y reduce el costo de cada turno, porque todo el historial se reenvía como entrada cada vez.
Los callbacks son el lugar para registrar cuánto costó una llamada. Cada respuesta incluye un bloque de usage con tokens de prompt y completion, y en LangChain el mensaje devuelto lo lleva en usage_metadata:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
msg = llm.invoke("Name three rivers.")
u = msg.usage_metadata
cost = u["input_tokens"] * 0.15 / 1_000_000 + u["output_tokens"] * 0.50 / 1_000_000
print(u, f"${cost:.6f}")
Registra el costo con el ID de solicitud para que una factura sorprendente pueda rastrearse hasta una cadena.
Prompts del sistema y tono
El modelo no tiene rechazos de contenido integrados, por lo que el mensaje del sistema es donde estableces el comportamiento de tu producto: la persona, el tono, los temas que debe evitar y el formato de la respuesta. Escríbelo como harías un brief para un nuevo colega. Corto y específico funciona mejor que largo y vago. El contenido que involucra a menores de edad es un límite estricto en este servicio, así que no construyas prompts que se acerquen a ello.
Una lista de verificación breve antes de lanzar
- La clave vive en una variable de entorno o en un almacén de secretos, nunca en el repositorio.
max_concurrencyestá establecido en el límite de tu clave, o por debajo si otros servicios comparten la clave.- Los reintentos usan un back-off corto, y las respuestas 429 con
Retry-After: 5se respetan. - Los streams se cierran en la desconexión del cliente para liberar espacios.
- Las salidas JSON se analizan de forma defensiva y se validan.
- Los costos se registran por cadena desde el bloque de uso.
- Existe un plan de respaldo para el caso en que el endpoint no sea accesible, incluso si el plan de respaldo es un mensaje de error.
Sigue esa lista y la integración se comportará como cualquier otro modelo de chat de LangChain. La diferencia está en el lado del contenido, donde las solicitudes que otros modelos rechazan para uso adulto legal son respondidas.
Límites de peticiones, concurrencia y errores comunes
Una clave completa permite 8 peticiones concurrentes y 300 peticiones por minuto. Una clave de prueba permite 2 peticiones concurrentes y 60 por minuto. El cuerpo de la petición puede tener hasta 8 MB, y la ventana de contexto es de 100.000 tokens cubriendo prompt y completion juntos.
Los ayudantes de lotes de LangChain distribuyen peticiones, así que establece un límite que coincida con tu clave:
# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
inputs = [{"setting": s} for s in ["a rooftop garden", "a desert diner", "a quiet harbor"]]
results = chain.batch(inputs, config={"max_concurrency": 8})
Usa 2 en lugar de 8 en una clave de prueba. Cuando excedes un límite, la API devuelve HTTP 429 con el código de error rate_limited (demasiadas peticiones por minuto) o concurrency (demasiadas a la vez). En sobrecarga temporal también devuelve 429, con un encabezado Retry-After: 5. La configuración max_retries en el cliente maneja casos transitorios, pero si ves el código de error concurrency repetidamente, reduce max_concurrency en lugar de añadir reintentos.
- Errores «no encontrado» en cada llamada: verifica que la URL base termine en
/v1. - Error de autenticación: falta la clave o tiene un error tipográfico; confirma que se pasa a través de
api_key. - Errores del modelo: el nombre del modelo debe ser exactamente
uncensored. - Ejecuciones lentas por lotes: los streams atascados retienen espacios de concurrencia, así que ciérralos o establece un tiempo de espera.
El precio es de $0,15 por millón de tokens de entrada y $0,50 por millón de tokens de salida, y las peticiones fallidas o rechazadas no se cobran. La página de precios lista las recargas, y la documentación cubre cada parámetro y los encabezados de respuesta, incluyendo X-Request-Id y X-Balance-USD, que son útiles para registrar en un callback de LangChain.
