ES ▾
Obtener clave de API

LLM Inference APIGuía

LLM Inference API: streaming, herramientas y modo JSON

Una API de inferencia LLM te permite enviar un prompt por HTTPS y recibir texto generado, sin necesidad de GPU en tu lado. Esta página muestra una configuración funcional contra un endpoint compatible con OpenAI, desde la primera petición hasta streaming, herramientas, modo JSON y límites.

Actualizado:

Ilustración isométrica de paquetes de datos fluyendo desde una terminal hacia una puerta de enlace en la nube, representando una llamada a una API de inferencia

Puntos clave

  1. Apunta cualquier SDK de OpenAI a https://api.llminferenceapi.com/v1, usa el ID de modelo uncensored y envía tu clave como token Bearer.
  2. Hay dos endpoints disponibles: POST /v1/chat/completions y GET /v1/models.
  3. El streaming, las llamadas a funciones y el modo JSON funcionan a través de los campos de petición estándar.
  4. Una clave completa permite 8 peticiones concurrentes y 300 por minuto; una respuesta 429 te dice qué límite has alcanzado.

Lo que necesitas antes de la primera llamada

Necesitas tres cosas: una base URL, una clave y un nombre de modelo. La base URL es https://api.llminferenceapi.com/v1, el ID de modelo es uncensored, y la clave se obtiene desde la página de clave de API después de registrarte con Google o con correo electrónico y contraseña. Los nuevos usuarios pueden reclamar $0.50 de crédito de prueba con un solo clic. No requiere tarjeta, dura 7 días y está limitado a uno por persona.

El servicio es solo de texto. Expone POST /v1/chat/completions y GET /v1/models. No hay ruta de embeddings, ni generación de imágenes ni de audio, ni fine-tuning. Ejecuta un único modelo de pesos abiertos, operado 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. Hay una regla estricta: no se permite el contenido que sexualice a menores de edad.

Mantén la clave en una variable de entorno en lugar de en el código fuente. Los ejemplos siguientes la leen desde API_KEY donde el lenguaje lo permite.

Tu primera petición

Empieza con curl, porque muestra exactamente lo que va por la red.

curl https://api.llminferenceapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "List three uses of a message queue."}
    ],
    "temperature": 0.7
  }'

La respuesta es el objeto chat completion habitual: choices[0].message.content contiene el texto y usage contiene los recuentos de tokens. También puedes listar modelos con GET /v1/models, que es una forma rápida de confirmar que la clave y la URL son correctas antes de depurar cualquier otra cosa.

En Python con el SDK oficial de OpenAI, solo cambia el constructor:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.llminferenceapi.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List three uses of a message queue."}],
)
print(resp.choices[0].message.content)

Y en Node:

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "List three uses of a message queue." }],
});
console.log(resp.choices[0].message.content);

La completión puede usar lo que quede de la ventana de 100.000 tokens después de tu prompt, por lo que max_tokens es opcional. Establecerlo de todos modos cuando quieras un techo estricto en el costo o la longitud. Los controles de muestreo como temperature, top_p, stop, seed y las penalizaciones de frecuencia y presencia se pasan a través.

Dos configuraciones vale la pena conocer desde el inicio. seed hace que el muestreo sea repetible para pruebas, lo que ayuda cuando comparas dos versiones de un prompt y quieres que la diferencia provenga del prompt y no del azar. stop toma una o más cadenas que finalizan la generación tan pronto como el modelo las escribe, una forma barata de cortar una respuesta en un delimitador y evitar pagar por tokens que desecharías.

Respuestas en streaming

Con stream: true el servidor responde mediante eventos enviados por el servidor y envía el texto en pequeños deltas. Los usuarios ven las primeras palabras rápidamente, lo cual es importante en interfaces de chat. Las cifras de uso llegan al final del streaming.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem about a lighthouse."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Dos puntos son fáciles de pasar por alto. Primero, el último fragmento puede contener uso y una lista choices vacía, así que verifica que choices no esté vacía antes de indexarla. Segundo, una petición en streaming mantiene su slot de concurrencia hasta que termina el streaming. Si un cliente abre un streaming y nunca lo lee hasta el final, ese slot permanece ocupado y tus peticiones posteriores pueden alcanzar un error de concurrency. Cierra o consume completamente los streaming siempre.

Llamadas a funciones

Las llamadas a herramientas permiten que el modelo solicite a tu código ejecutar una función y usar el resultado. Describes las funciones en tools, diriges opcionalmente la elección con tool_choice, ejecutas lo que el modelo solicite y envías la salida de vuelta como un mensaje con role: "tool".

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its id.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1043?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"order_id": args["order_id"], "status": "shipped"}
        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)

Analiza siempre function.arguments de forma defensiva. Es una cadena JSON producida por un modelo de lenguaje y, en casos raros, puede estar malformada o contener un campo que no definiste. Valídala antes de actuar sobre ella, especialmente cuando la función cambia datos. Las llamadas a herramientas también funcionan con streaming, en cuyo caso los tool_calls llegan como fragmentos que debes unir por índice antes de analizar.

Gestión del historial de conversaciones

La API es sin estado. No recuerda las peticiones anteriores, por lo que un chat de múltiples turnos funciona solo porque tu código envía los turnos anteriores cada vez. Mantén una lista de mensajes, añade el nuevo mensaje del usuario, llama al endpoint y luego añade la respuesta del asistente antes del siguiente turno.

history = [{"role": "system", "content": "You are a patient writing coach."}]

def chat(user_text):
    history.append({"role": "user", "content": user_text})
    resp = client.chat.completions.create(model="uncensored", messages=history)
    reply = resp.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(chat("Give me a prompt for a ghost story."))
print(chat("Make it set on a ferry."))

Debido a que cada turno reenvía el historial, los tokens de entrada crecen con la longitud del chat. La ventana contiene 100.000 tokens, lo cual es suficiente para la mayoría de las conversaciones, pero el costo aumenta considerablemente antes de alcanzar el límite. Un patrón común es mantener el mensaje del sistema y los últimos varios turnos, y reemplazar los turnos más antiguos con un resumen corto que el modelo mismo escribe. Lee usage.prompt_tokens después de cada llamada para ver qué tamaño ha alcanzado el historial.

Modo JSON

Cuando necesites una salida legible por máquina, establece response_format en {"type": "json_object"} y indica en el prompt que quieres JSON. Describir las claves que esperas hace que el resultado sea mucho más estable.

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only, using the keys title, tags and summary."},
        {"role": "user", "content": "Describe a short story about a lost robot."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

El modo JSON hace que la salida se analice como JSON, pero no aplica tu esquema. Verifica las claves en el código y mantén un plan de respaldo para el caso en que falte un valor. Si la respuesta se corta porque alcanzó un límite de tokens, el JSON estará incompleto, así que no establezcas max_tokens demasiado bajo para la salida estructurada.

Una breve lista de verificación cuando algo falla

La mayoría de los problemas del primer día provienen de un puñado de causas, y puedes descartarlas en orden.

  1. Base URL. Debe terminar en /v1. El SDK añade /chat/completions por sí mismo, por lo que una URL con la ruta ya incluida no funcionará.
  2. Cabecera de clave. La clave va en Authorization: Bearer seguida de la clave. Un espacio o salto de línea sobrante copiado con la clave es una causa frecuente de errores de autenticación.
  3. ID de modelo. Usa uncensored exactamente. Los nombres de modelos de otros proveedores no son válidos aquí.
  4. Tamaño de la petición. El límite del cuerpo es 8 MB, y el prompt más el completado deben caber en 100.000 tokens.
  5. Saldo. Mira el encabezado X-Balance-USD en cualquier respuesta para ver si el problema es el crédito.
  6. Incluye el ID de petición. Si contactas a soporte, incluye el valor X-Request-Id de la respuesta fallida para que la petición pueda encontrarse.

Ten en cuenta que un rechazo no es lo mismo que un error. Debido a que el modelo está ajustado para evitar rechazos de contenido para uso adulto lícito, verás menos de ellos que en servicios con filtros, pero el modelo aún puede negarse o dar una respuesta débil a un prompt vago. Un mensaje del sistema más claro suele arreglar eso mejor que una temperatura más alta.

Límites, encabezados y reintentos

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. Cada respuesta lleva X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests y X-RateLimit-Limit-Concurrency, que son útiles para el registro y para mostrar un saldo en una pantalla de administración.

Cuando excedes un límite, la API devuelve HTTP 429. El código de error rate_limited indica demasiadas peticiones por minuto, y concurrency indica demasiadas a la vez. En sobrecarga temporal también obtienes 429, con una cabecera Retry-After: 5. Un envoltorio de reintento simple cubre los tres casos:

import time
from openai import RateLimitError

def ask(messages, tries=4):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = 5 if attempt == 0 else 5 * (attempt + 1)
            retry_after = getattr(e.response, "headers", {}).get("retry-after")
            time.sleep(int(retry_after) if retry_after else wait)
    raise RuntimeError("still rate limited after retries")

Para un grupo de trabajadores, limita el tamaño del grupo a tu límite de concurrencia en lugar de depender de reintentos. Ocho trabajadores en una clave completa rara vez verán un error de concurrency. Si encuentras errores inesperados, el artículo de solución de problemas recorre las causas comunes.

Cómo pagar

Los cobros son de pago por uso con crédito prepagado: $0.15 por cada 1M de tokens de entrada y $0.50 por cada 1M de tokens de salida, sin suscripción. Las peticiones fallidas o rechazadas no se cobran y el crédito nunca caduca. Una petición con 1.500 tokens de entrada y 400 tokens de salida cuesta 1.500 / 1.000.000 x $0.15 + 400 / 1.000.000 x $0.50 = $0.000225 + $0.0002 = $0.000425.

Las recargas son cualquier cantidad entera desde $20 hasta $500, con un bono del 5% desde $50, 10% desde $100 y 15% desde $200. Puedes pagar con cripto (USDT en TRC20, USDC en Base). Los prompts no se usan para entrenamiento. La página de precios lista los detalles y la guía rápida repite los pasos de configuración en forma corta.

Preguntas y respuestas

¿Puedo usar la librería oficial de OpenAI con esta API?

Sí. Instala el SDK de OpenAI para Python o Node, establece la base URL en https://api.llminferenceapi.com/v1, pasa tu clave y usa el ID de modelo uncensored.

¿La API admite llamadas a funciones?

Sí. Pasa las herramientas y opcionalmente tool_choice, luego devuelve cada resultado como un mensaje con role: tool. También se admiten tool_calls en streaming.

¿Qué significa un error 429 aquí?

Has alcanzado un límite. El código rate_limited significa demasiadas peticiones por minuto, concurrency significa demasiadas al mismo tiempo, y un encabezado Retry-After: 5 marca una sobrecarga temporal. Espera y reintenta.

¿Puedo usarlo para embeddings o imágenes?

No. La API es solo de texto y ofrece completaciones de chat y una lista de modelos.

Tu clave está a un formulario de distancia

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

Obtener clave de API