ES ▾

Uncensored Model HubModelos open source de LangChain a través de una API sin censura

Modelos open source de LangChain a través de una API sin censura

LangChain funciona con modelos open source a través de cualquier servidor compatible con OpenAI, y una API alojada te ahorra ejecutar GPUs tú mismo. Aquí tienes la configuración en Python y Node, con herramientas, un agente, salida JSON, streaming y un plan de concurrencia.

Actualizado

Enlaces de cadena de vidrio conectando bloques modulares a un cubo de servidor, ilustrando LangChain con una API de modelo de pesos abiertos

Puntos clave

  1. Usa ChatOpenAI con base_url establecido en https://api.uncensoredmodelhub.com/v1 y modelo uncensored.
  2. Las llamadas a herramientas, el modo JSON y el streaming funcionan a través de las interfaces estándar de LangChain.
  3. Limita max_concurrency a 8 en una clave completa y a 2 en una clave de prueba para evitar errores 429.
  4. La tarifa es $0,15 por cada 1M de tokens de entrada y $0,50 por cada 1M de tokens de salida, sin suscripción.

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.

PreguntaServidor localEsta API alojada
Costo inicialHardware o una GPU alquiladaNinguno; crédito prepago desde $20
Costo por tokenNinguno, pero desgaste de energía y hardware$0,15 por 1M de entrada, $0,50 por 1M de salida
Ventana de contextoDepende de la memoria que tengas100.000 tokens
ConcurrenciaDepende de tu configuración8 en una clave completa
Ubicación de los datosTu máquinaAlojado; 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 entorno OPENAI_API_KEY esté anulando silenciosamente lo que querías pasar.
  • Modelo no encontrado: el ID del modelo es exactamente uncensored. Llama a GET /v1/models para 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 seed y 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á.

Preguntas y respuestas

¿Qué clase de LangChain uso para esta API?

Usa ChatOpenAI de langchain-openai en Python o @langchain/openai en JavaScript. Establece el modelo a uncensored y apunta base_url a https://api.uncensoredmodelhub.com/v1.

¿Soporta agentes y llamadas a herramientas?

Sí. Las llamadas a herramientas usan el formato de herramientas al estilo de OpenAI, por lo que bind_tools y los agentes de LangGraph funcionan. Valida los argumentos de las herramientas tú mismo, ya que el modelo los devuelve como texto.

¿Cuál es la ventana de contexto para las cadenas de LangChain?

100.000 tokens, compartidos por prompt y respuesta. Los buffers de memoria larga y muchos fragmentos recuperados los consumen, así que recorta el historial en tu cadena.

¿Hay embeddings disponibles para mi vector store?

No. La API es solo de chat de texto, sin embeddings, imágenes, audio ni ajuste fino. Usa un proveedor de embeddings separado para la recuperación y esta API para el paso de generación.

Tu clave está a un solo formulario de distancia

Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.

Obtener clave de API