Uncensored LLM Hub: Un único endpoint para chat y agentes

Lo que obtienes de un único endpoint

Las personas buscan uncensored llm hub cuando quieren un modelo que responda sin rechazos de contenido para uso adulto legal, pero no quieren ejecutar GPUs. El servicio es una API HTTPS simple. Apuntas un cliente de OpenAI a https://api.uncensoredllmhub.com/v1, envías el ID de modelo uncensored y te autenticas con Authorization: Bearer YOUR_KEY. Existen dos métodos: POST /v1/chat/completions para conversaciones y GET /v1/models para listar.

Ayuda saber qué hay detrás de ese endpoint. Es un único modelo de pesos abiertos, ejecutado por un proveedor independiente y ajustado para omitir los rechazos de contenido. No es la API oficial de ningún gran proveedor, ni es un enrutador que elija entre modelos. Solo maneja texto: sin imágenes, audio, video, embeddings ni ajuste fino. Una regla estricta se aplica sin excepción: no hay contenido sexual que involucre a menores de edad.

Ese alcance limitado es la clave. Un único endpoint estable es fácil de integrar. Las secciones siguientes muestran un backend de chat pequeño, luego un bucle de agente, y luego los límites que necesitas considerar para el diseño.

Paso 1: conectar un cliente existente

Como la API sigue el formato de OpenAI, rara vez escribes código nuevo para el cliente. Abre tu SDK o herramienta, cambia la URL base y la clave, y establece el modelo en uncensored. Primero, regístrate en la página de claves de API (Google, o correo electrónico y contraseña), luego reclama el crédito de prueba de $0.50 con un clic. La prueba no requiere tarjeta, dura 7 días y está limitada a una por persona.

Una petición mínima en Python:

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant for a writing tool."},
        {"role": "user", "content": "Give me three opening lines for a mystery set on a ferry."},
    ],
    temperature=0.9,
    top_p=0.95,
)
print(resp.choices[0].message.content)

Los ajustes de muestreo como temperature, top_p, stop, seed y las penalizaciones de frecuencia y presencia se pasan al modelo, así que las perillas que conoces de otros proveedores se comportan igual. La misma llamada funciona en herramientas que aceptan un endpoint compatible con OpenAI, por ejemplo SillyTavern o Open WebUI: pega la URL base, añade la clave, escribe el ID del modelo a mano.

Paso 2: transmitir respuestas en una interfaz de chat

Las aplicaciones de chat se sienten lentas si el usuario mira una caja vacía hasta que llega la respuesta completa. El streaming soluciona eso. Establece stream: true y la API envía la respuesta como eventos enviados por el servidor, con el uso reportado al final del flujo. Aquí tienes una versión en Node que reenvía los tokens a medida que llegan:

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.uncensoredllmhub.com/v1",
  apiKey: process.env.API_KEY,
});

export async function streamReply(history, onToken, signal) {
  const stream = await client.chat.completions.create(
    { model: "uncensored", messages: history, stream: true },
    { signal }
  );
  let text = "";
  for await (const chunk of stream) {
    const piece = chunk.choices[0]?.delta?.content ?? "";
    if (piece) {
      text += piece;
      onToken(piece);
    }
  }
  return text;
}

Dos hábitos ahorran problemas más adelante. Primero, pasa siempre una señal de aborto y cancéla cuando el usuario cierre la pestaña o presione detener. Una petición en streaming ocupa su ranura de concurrencia hasta que termina el flujo, por lo que los flujos abandonados consumen tu saldo. Segundo, guarda el texto completo que ensamblaste, porque lo añadirás al historial como el mensaje del asistente para el siguiente turno.

Si ves errores vagos en tu interfaz de usuario mientras transmites, nuestra nota sobre diagnóstico de fallos de streaming cubre las causas habituales, como una URL base incorrecta, un proxy que almacena eventos y los dos códigos 429.

Paso 3: usar el contexto largo deliberadamente

La ventana de contexto es de 100.000 tokens, compartida por el prompt y el completado. Para una herramienta de escritura de historias, un chat de personajes o un asistente de documentos, eso es espacio para un historial largo, un prompt de sistema grande y material de referencia al mismo tiempo. No necesitas configurar max_tokens; el completado puede usar lo que quede.

El contexto largo es barato de probar a estos precios. Llenar toda la ventana con entrada cuesta 0.1 × $0.15 = $0.015 por 100,000 tokens de entrada. Añade una respuesta de 2,000 tokens (0.002 × $0.50 = $0.001) y una llamada casi completa cuesta $0.016. Todavía querrás gestionar la ventana por tres razones: la latencia crece con el tamaño del prompt, cada turno reenvía el historial por lo que los costos se acumulan durante una sesión, y los historiales muy largos diluyen las instrucciones al principio.

Una política simple funciona bien:

1. Mantén el prompt de sistema y cualquier texto de referencia fijo al inicio.
2. Mantén los turnos más recientes tal cual.
3. Cuando el historial pasa un umbral que elijas, por ejemplo 60,000 tokens, pide al modelo que resuma la parte más antigua en una nota corta y reemplaza esos turnos con ella.
4. Lee usage.prompt_tokens de cada respuesta para saber qué tan grande será la siguiente petición, en lugar de estimar por caracteres.

Paso 4: herramientas y salida estructurada para agentes

Los agentes necesitan dos cosas de un modelo: una forma de llamar a funciones y una salida que puedas analizar. Ambas están soportadas. Las llamadas a funciones usan los parámetros estándar tools y tool_choice, las llamadas a funciones pueden transmitirse y los resultados vuelven como mensajes con role: "tool". Una sola ida y vuelta se ve así:

Copyimport json
from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredllmhub.com/v1",
    api_key="YOUR_API_KEY",
)

tools = [{
    "type": "function",
    "function": {
        "name": "lookup_order",
        "description": "Find an order by its number.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup goes here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Valida siempre los argumentos antes de ejecutar cualquier cosa con efectos secundarios. Un modelo puede producir un valor malformado o inesperado, y tu código es la última línea de defensa.

Para salida estructurada simple sin herramientas, usa el modo JSON con response_format establecido en {"type": "json_object"}. Describe la forma que quieres en el prompt también, y analiza la respuesta dentro de un bloque try para que una respuesta incorrecta active un reintento en lugar de un fallo.

Copycurl https://api.uncensoredllmhub.com/v1/chat/completions   -H "Authorization: Bearer $API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Reply with JSON: {"title": string, "tags": [string]}"},
      {"role": "user", "content": "Describe a noir story set in a rainy port city."}
    ]
  }'

Límites para diseñar alrededor

Una clave completa permite 8 peticiones simultáneas y 300 peticiones por minuto. Una clave de prueba permite 2 y 60. El cuerpo puede tener hasta 8 MB. Cada respuesta lleva X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests y X-RateLimit-Limit-Concurrency, que son útiles para registrar.

Cuando superas un límite, la API devuelve HTTP 429. El código es rate_limited para demasiadas peticiones por minuto y concurrency para demasiadas a la vez. Una sobrecarga temporal también devuelve 429, con Retry-After: 5. Para una aplicación multiusuario, pon una cola pequeña delante de la API: un semáforo dimensionado por debajo del límite de concurrencia y un reintento que respete Retry-After. Para un agente que se ramifica en llamadas a herramientas paralelas, limita la ramificación al mismo número.

La lista completa de parámetros y el formato de error están en la documentación de API.

Costo, recargas y manejo de datos

Los precios son $0.15 por 1M de tokens de entrada y $0.50 por 1M de tokens de salida, desde el crédito prepago. No hay suscripción, el crédito nunca caduca y las peticiones fallidas o rechazadas no se cobran. Un turno de chat de 1,500 tokens de entrada y 500 de salida cuesta 0.0015 × $0.15 + 0.0005 × $0.50 = $0.000225 + $0.00025 = $0.000475, por lo que $20 de crédito cubren aproximadamente 42,000 de estos turnos.

Puedes recargar cualquier cantidad entera desde $20 hasta $500. El bono es +5% desde $50, +10% desde $100 y +15% desde $200. Paga con tarjeta (Visa, Mastercard, Apple Pay, Google Pay) o cripto (USDT en TRC20, USDC en Base). La página de precios tiene la tabla actual.

Sobre los datos: los prompts no se usan para entrenamiento. Lee la política de privacidad para la redacción completa. Tú sigues siendo responsable de lo que construyas con el modelo, y el servicio está destinado solo para uso adulto legal (no para menores de edad).

Más guías

• Error desconocido del flujo LLM: causas y soluciones
• Cómo alojar un LLM tú mismo, o saltarlo con una API
• Modelos Ollama sin censura vs APIs alojadas