Puntos clave
- En Python usa ChatOpenAI(base_url=..., api_key=..., model="uncensored"). En JavaScript usa configuration.baseURL.
- Los prompts, cadenas, streaming, enlace de herramientas y modo JSON siguen funcionando a través de las interfaces estándar.
- Los embeddings no se ofrecen, por lo que OpenAIEmbeddings debe apuntar a otro servicio.
- Usa max_concurrency 8 con una clave completa y deja que los reintentos manejen las respuestas 429.
El cambio de dos líneas
Cuando buscas la URL base de OpenAI para langchain, la respuesta es breve. La clase de chat de OpenAI de LangChain envuelve el SDK de OpenAI, y ese SDK acepta una URL base personalizada. Configúralo para este servicio y nada más en tu cadena necesitará cambiar. Instala los paquetes con pip install langchain-openai langchain-core primero.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.openaiapiproxy.com/v1",
api_key="YOUR_KEY",
temperature=0.8,
)
print(llm.invoke("Describe a rainy harbor town in two sentences.").content)Esa es toda la integración. El servicio es compatible con OpenAI, pero es un producto independiente: un modelo de pesos abiertos, ejecutado por un proveedor independiente, sin rechazos de contenido para uso adulto lícito. No es la API oficial de OpenAI ni de ningún otro proveedor. Para obtener una clave, usa la página de claves de API; las cuentas nuevas pueden reclamar un crédito de prueba de $0.50 con un solo clic, sin tarjeta.
Por qué funciona: ChatOpenAI genera peticiones de completado de chat estándar y las envía a cualquier dirección que se le haya dado. El servicio responde con la forma de respuesta estándar, por lo que los objetos de mensaje, las devoluciones de llamada y los analizadores de LangChain se comportan como lo hacen contra cualquier otro proveedor. Mantienes las mismas abstracciones y solo cambia el destino. Como el destino es un modelo diferente, debes volver a probar tus prompts. Un prompt diseñado para persuadir a un modelo restrictivo para que coopere puede ser innecesario aquí, y las instrucciones más cortas suelen funcionar mejor.
Variables de entorno o argumentos explícitos
Puedes configurar lo mismo a través del entorno, y esto es útil para implementaciones. El SDK de OpenAI lee OPENAI_BASE_URL y OPENAI_API_KEY. La documentación antigua de LangChain usaba OPENAI_API_BASE para el mismo propósito. Debido a que los nombres han cambiado entre versiones, el hábito más seguro es pasar base_url y api_key explícitamente y leer tu propia variable.
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.openaiapiproxy.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
max_retries=3,
timeout=120,
)Un beneficio real de los argumentos explícitos: si tu proyecto también usa otro proveedor para otras tareas, una variable global perdida no puede redirigir ese tráfico al lugar equivocado. Dos objetos ChatOpenAI con diferentes URL base conviven en el mismo proceso.
La misma configuración en LangChain.js
En el paquete de JavaScript, la URL base va dentro de un objeto configuration que se pasa al SDK subyacente.
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.UNCENSORED_API_KEY,
configuration: {
baseURL: "https://api.openaiapiproxy.com/v1",
},
});
const res = await llm.invoke("Give me three names for a haunted ship.");
console.log(res.content);La capitalización es la trampa habitual: Python usa base_url, el SDK de JavaScript usa baseURL.
Un prompt, un modelo y un analizador
Una vez construido el modelo de chat, el lenguaje de expresiones de LangChain funciona como de costumbre. Esta cadena convierte un tema en una escena breve y devuelve una cadena simple.
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
prompt = ChatPromptTemplate.from_messages([
("system", "You write short scenes for an adult fiction platform."),
("human", "Write a scene about: {topic}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({"topic": "two smugglers meeting at a closed customs office"}))
for piece in chain.stream({"topic": "a stormy night at a mountain inn"}):
print(piece, end="", flush=True)El streaming se basa en los eventos enviados por el servidor (SSE) del servicio, que llegan a medida que el modelo los genera. Una llamada en streaming mantiene una ranura de concurrencia hasta que termina.
El operador | compone ejecutables, por lo que la misma cadena puede ganar posteriormente un recuperador, una segunda llamada de modelo o un analizador de salida sin tocar los pasos anteriores. Si mueves una plantilla de prompt entre proveedores, mantén la plantilla en un archivo para que puedas versionarla por separado de la configuración del endpoint.
Llamadas a funciones y salida JSON
LangChain convierte funciones de Python en esquemas de herramientas con el decorador @tool y las envía a través del parámetro estándar tools. El servicio soporta tools, tool_choice y tool_calls en streaming, por lo que bind_tools funciona.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
@tool
def lookup_character(name: str) -> str:
"""Return the notes for a character in the story bible."""
notes = {"Mara": "A ferry pilot with a fear of deep water."}
return notes.get(name, "No notes.")
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
llm_tools = llm.bind_tools([lookup_character])
reply = llm_tools.invoke("What do we know about Mara?")
for call in reply.tool_calls:
print(call["name"], call["args"])
print(lookup_character.invoke(call["args"]))Para el modo JSON, vincula el formato de respuesta y menciona JSON en tus instrucciones:
import json
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
json_llm = llm.bind(response_format={"type": "json_object"})
msg = json_llm.invoke("Return a JSON object with keys title and summary for a pirate novel.")
print(json.loads(msg.content))Incluso con el modo JSON, envuelve el análisis en manejo de errores. Independientemente del proveedor, la salida malformada ocurre ocasionalmente, y un único reintento con el error de análisis adjunto suele solucionarlo.
Historial de chat y documentos largos
Los modelos de chat de LangChain toman una lista de mensajes, y el historial es tuyo para gestionar. Las clases de mensajes hacen que los roles sean explícitos, lo cual es más claro que las tuplas cuando un prompt tiene varias partes.
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
messages = [
SystemMessage(content="You are the narrator of a slow-burn mystery."),
HumanMessage(content="Open with the detective arriving in town."),
]
first = llm.invoke(messages)
messages.append(AIMessage(content=first.content))
messages.append(HumanMessage(content="Now introduce the suspicious innkeeper."))
second = llm.invoke(messages)
print(second.content)
print(second.usage_metadata)La ventana de contexto es de 100.000 tokens, prompt y completación juntos. Eso es espacio para historiales de chat largos, una hoja de personaje y varias páginas de texto de referencia en una sola llamada. No significa que debas llenarla siempre. Los tokens de entrada se facturan a $0,15 por 1M, por lo que un prompt de 60.000 tokens cuesta 60.000 / 1.000.000 x $0,15 = $0,009 por llamada antes de que el modelo escriba una palabra. Un paso de recuperación que envía solo las tres páginas relevantes es más barato y a menudo da mejores respuestas.
Cuando un prompt se construye a partir de mucho texto recuperado, recuerda el límite de 8 MB en el cuerpo de la petición. Está muy por encima de lo que la ventana de tokens permite para texto normal, por lo que generalmente alcanzarás el límite de tokens primero, pero los datos pegados con cadenas largas sin interrupciones pueden comportarse de manera diferente.
Límites de peticiones, lotes y agentes
LangChain facilita el trabajo en paralelo, que es exactamente cómo te quedas sin capacidad por accidente. Una clave completa permite 8 peticiones simultáneas y 300 por minuto. Una clave de prueba permite 2 y 60. Usa el argumento de configuración para limitar la paralelización en lotes.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="uncensored", base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
titles = llm.batch(
[f"Suggest a title for episode {i} of a space western." for i in range(1, 25)],
config={"max_concurrency": 8},
)
for t in titles:
print(t.content)Si ves HTTP 429, el código de error indica por qué: rate_limited para peticiones por minuto, concurrency para demasiadas a la vez. En caso de sobrecarga temporal, la respuesta incluye Retry-After: 5. La lógica de reintento en el SDK subyacente maneja la mayor parte, pero los agentes que se distribuyen en muchas llamadas a funciones en paralelo aún pueden saturar una clave de prueba, así que reduce max_concurrency a 2 allí.
Bucle de agentes: cada paso envía la conversación creciente de vuelta como entrada, por lo que los tokens de entrada se acumulan más rápido que los tokens de salida. A $0,15 por 1M de entrada y $0,50 por 1M de salida, una ejecución de agente que envía 60.000 tokens de entrada en total y produce 6.000 tokens de salida cuesta 60.000 / 1.000.000 x $0,15 + 6.000 / 1.000.000 x $0,50 = $0,009 + $0,003 = $0,012. La página de precios muestra los tamaños de recarga.
Lo que no se traslada
- Embeddings. No hay endpoint de embeddings. Si tu cadena de recuperación se basa en
OpenAIEmbeddings, usa otra fuente de embeddings para esa parte y mantén solo el modelo de chat aquí. - Imágenes y audio. El servicio es solo de texto.
- Cambio de modelo. Hay un solo modelo,
uncensored. Un menú desplegable de nombres de modelos de proveedores no coincidirá. - Conteo de tokens por nombre. Las bibliotecas que adivinan los conteos de tokens desde el nombre del modelo pueden recurrir a una aproximación. Para números reales, lee
usage_metadataen el mensaje de respuesta.
La ventana de contexto es de 100,000 tokens para el prompt y la finalización juntos, lo cual es generoso para historiales de chat largos y relleno de documentos. Consulta la documentación para la lista completa de parámetros, y recuerda que el modelo no rechaza contenido adulto lícito, así que añade tus propios filtros a cualquier cadena pública. La regla estricta es sin contenido sexual que involucre a menores.
Depuración de una cadena que se comporta mal
Cuando una cadena produce una salida extraña, descubre qué salió realmente por la red antes de cambiar el prompt. Tres herramientas ayudan, en orden de esfuerzo.
- Imprime los metadatos de la respuesta. El mensaje devuelto por
invokellevaresponse_metadatayusage_metadata. Puedes verificar el motivo de finalización y los conteos de tokens sin configuración adicional. - Activa el registro de depuración.
set_debug(True)delangchain_core.globalsimprime cada prompt y respuesta en una cadena. Úsalo solo en desarrollo, porque imprime los prompts completos. - Reproduce la llamada con curl. Copia los mensajes renderizados de la salida de depuración en una solicitud a
https://api.openaiapiproxy.com/v1/chat/completions. Si curl se comporta igual, el problema está en tu prompt. Si difiere, el problema está en la cadena.
Síntomas típicos y dónde buscar: un error not-found suele significar que la URL base tiene un /v1 duplicado o le falta. Un mensaje sobre un modelo desconocido significa que el nombre no es uncensored. Listas vacías de llamadas a herramientas suelen significar que el prompt no dejó claro que se debía usar la herramienta, lo que una descripción de herramienta más clara soluciona. Y un agente que se queda atascado podría simplemente estar en cola detrás de sus propias llamadas a herramientas en paralelo en una clave de prueba, así que reduce la concurrencia.
Guarda una nota del encabezado ID de petición (X-Request-Id) de los fallos. Si un problema está del lado del servicio, la página de soporte explica cómo reportarlo, y ese ID acelera las cosas.
