Cómo usar un modelo LLM a través de una API, paso a paso
Usar un modelo de lenguaje alojado se reduce a una llamada HTTP con una clave, un nombre de modelo y una lista de mensajes. Este recorrido te lleva desde una carpeta vacía hasta el streaming, la salida en JSON y las llamadas a herramientas.

Puntos clave
- La API es compatible con OpenAI: cambia la base URL y la clave, mantén tu SDK.
- Usa el ID de modelo uncensored con POST /v1/chat/completions.
- El streaming, el modo JSON y las llamadas a herramientas funcionan con los parámetros estándar.
- Un 429 significa que se alcanzó un límite, y el código de error te indica cuál.
Lo que necesitas antes de la primera petición
Si quieres saber cómo usar endpoints de modelos LLM en tu propio código, solo hacen falta tres cosas: una clave, una base URL y un nombre de modelo. No hay cliente especial que instalar. Cualquier SDK o cliente de OpenAI funciona una vez que lo apuntas a una dirección diferente.
- URL base:
https://api.llmmodelsapi.com/v1 - ID de modelo:
uncensored - Autenticación: un encabezado
Authorization: Bearer YOUR_KEY, que los SDKs añaden por ti
Para obtener una clave, regístrate con Google o con correo electrónico y contraseña, luego abre la página de claves de API. Las cuentas nuevas pueden reclamar $0.50 de crédito de prueba allí con un solo clic, sin tarjeta, válido por 7 días. Eso es suficiente para todo en este artículo. El endpoint admite dos métodos: POST /v1/chat/completions para la generación y GET /v1/models para listar lo disponible.
Ayuda saber qué es el modelo, para que tus expectativas sean correctas. Es 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 gran proveedor, y solo maneja texto. No hay generación de imágenes ni de audio, ni embeddings ni ajuste fino.
Paso 1: comprobar la clave con curl
Antes de escribir código de aplicación, confirma que la clave y la ruta de red funcionan. Listar los modelos es la comprobación más barata, porque no genera nada.
export LLM_KEY="paste-your-key-here"
# the list should include the model id: uncensored
curl https://api.llmmodelsapi.com/v1/models -H "Authorization: Bearer $LLM_KEY"
Deberías obtener una lista en JSON que incluya uncensored. Si ves un 401, la clave es incorrecta o le falta la palabra Bearer. Ahora envía una petición de chat real.
curl https://api.llmmodelsapi.com/v1/chat/completions -H "Authorization: Bearer $LLM_KEY" -H "Content-Type: application/json" -d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain what a context window is in two sentences."}
],
"max_tokens": 150
}'
La respuesta contiene una matriz choices, y el texto está en choices[0].message.content. Los encabezados de respuesta llevan X-Request-Id y X-Balance-USD, para que puedas ver tu crédito restante en cada llamada. El campo usage muestra los tokens contados para la facturación.
Paso 2: llamarlo desde Python o Node
En la práctica usarás un SDK. Instala el paquete oficial de OpenAI, luego establece la URL base cuando crees el cliente. Nada más de tu código cambia.
Python
from openai import OpenAI
client = OpenAI(
base_url="https://api.llmmodelsapi.com/v1",
api_key="YOUR_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You answer in plain language."},
{"role": "user", "content": "Give me three names for a fantasy tavern."},
],
temperature=0.9,
max_tokens=200,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
Node
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llmmodelsapi.com/v1",
apiKey: process.env.LLM_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Summarise HTTP caching in one paragraph." }],
});
console.log(resp.choices[0].message.content);
Mantén la clave en una variable de entorno en lugar de en el archivo de origen. Si una clave se filtra, reemplázala en la página de claves y la antigua dejará de funcionar.
Paso 3: dar forma a la salida con parámetros
El modelo es un predictor de texto, así que cómo redactas la petición importa tanto como los parámetros. Algunos hábitos pagan dividendos de inmediato.
- Usa el mensaje del sistema para reglas permanentes. Pon el tono, el formato y el rol allí, y mantén el mensaje del usuario para la tarea real.
- Sé específico con la longitud. Pide "tres viñetas" o "menos de 120 palabras". Es más fiable que solo reducir
max_tokens, que corta el texto a mitad de frase. - Ajusta la temperatura al trabajo. Alrededor de 0.2 se adapta a la extracción y la clasificación. Alrededor de 0.8 a 1.0 se adapta a la ficción y el juego de roles.
- Pasa lo que necesites.
top_p,stop,seedy los penalizadores de frecuencia y presencia se pasan al modelo.
La ventana de contexto es de 100.000 tokens, contando el prompt y la respuesta juntos. No tienes que establecer max_tokens, porque la respuesta puede usar todo el espacio restante. Establecerlo de todos modos es una buena manera de poner un techo al coste.
Una forma práctica de aprender estos ajustes es ejecutar el mismo prompt tres veces a diferentes temperaturas y comparar. Cambia un valor por ejecución y mantén el resto fijo, usando el mismo seed donde puedas. Después de diez minutos de esto sabrás cómo se comporta el modelo para tu tarea mucho mejor que cualquier descripción podría decirte, y el coste del experimento es una fracción de centavo.
La tarifa es de $0.15 por millón de tokens de entrada y $0.50 por millón de tokens de salida. Una petición con 1,500 tokens de entrada y 400 de salida cuesta 1,500 x 0.15 / 1,000,000 = $0.000225 más 400 x 0.50 / 1,000,000 = $0.0002, es decir $0.000425 en total. La página de precios tiene las opciones de recarga.
Paso 4: hacer streaming de la respuesta
Esperar una respuesta completa se siente lento en una aplicación interactiva. Con stream: true el servidor envía tokens como eventos enviados por el servidor, y tu interfaz puede imprimirlos a medida que llegan. El uso se informa al final del streaming.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening 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("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
Una cosa a recordar sobre la concurrencia: una petición con streaming ocupa su espacio hasta que el stream termina. Una clave completa permite 8 peticiones simultáneas, una clave de prueba permite 2. Si abres un stream en el navegador y nunca lo cierras, ese espacio se mantiene ocupado.
Paso 5: modo JSON y llamadas a funciones
Cuando otro programa tiene que leer la respuesta, el texto libre se convierte en un problema. El modo JSON pide al modelo que devuelva un objeto JSON válido.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
{"role": "user", "content": "Describe a post about growing tomatoes on a balcony."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
Describe la forma que quieres en el prompt también, ya que el modo JSON garantiza sintaxis válida y no tus nombres de campo exactos. Envuelve el análisis en un bloque try y reintenta una vez si falla.
Las llamadas a funciones permiten al modelo pedir a tu código que ejecute una función. Describes las herramientas, el modelo responde con una entrada tool_calls, la ejecutas y envías el resultado de vuelta como un mensaje con role: "tool".
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "get_time",
"description": "Return the current time for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]
messages.append(first.choices[0].message)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps({"time": "14:05"}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
En producción, comprueba que tool_calls esté presente antes de indexar en él, porque el modelo puede responder directamente en lugar de llamar a la función. El parámetro tool_choice te permite forzar o prohibir una llamada cuando lo necesites.
Mantener una conversación
La API no tiene memoria entre llamadas. Si quieres que el modelo recuerde lo que se dijo hace dos turnos, envías esos turnos de nuevo. Una aplicación de chat es por tanto una lista que crece: añades el mensaje del usuario, llamas a la API, añades la respuesta del asistente, y repites.
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
history = [{"role": "system", "content": "You are a friendly writing coach."}]
def say(text):
history.append({"role": "user", "content": text})
resp = client.chat.completions.create(model="uncensored", messages=history, max_tokens=300)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(say("Give me a tip for opening a short story."))
print(say("Now apply it to a story about a night train."))
Debido a que cada llamada lleva toda la lista, el coste y la latencia crecen con la conversación. Una vez que el historial es largo, elimina los turnos más antiguos o reemplázalos con un resumen de un párrafo. Tienes mucho espacio, ya que 100.000 tokens es aproximadamente la longitud de una novela corta, pero no hay razón para pagar por tokens que ya no ayudan a la respuesta.
Por la misma razón, mantén el mensaje del sistema corto y estable. Se envía en cada llamada, así que un prompt del sistema de 1.000 tokens en 500 peticiones son 500.000 tokens de entrada, que cuestan 500.000 x 0.15 / 1.000.000 = $0.075 por sí solos.
Errores comunes de principiantes
- Olvidar añadir la respuesta del asistente. El modelo entonces solo ve tus preguntas y pierde el hilo.
- Poner secretos en el front end. Una clave dentro del código del navegador es visible para todos. Llama a la API desde tu servidor y expone tu propio endpoint en su lugar.
- Esperar hechos de un predictor de texto. El modelo puede afirmar detalles incorrectos con confianza. Dale el texto fuente en el prompt cuando la precisión sea importante, y verifica la salida importante.
- Analizar texto libre. Si el código tiene que leer la respuesta, usa el modo JSON o una llamada a función en lugar de expresiones regulares.
Errores, límites y hacia dónde ir a continuación
La mayoría de los problemas entran en una lista corta.
| Síntoma | Causa probable | Solución |
|---|---|---|
| Respuesta 401 | Clave faltante o incorrecta | Comprueba el encabezado Bearer y la clave en la página de claves |
429, código rate_limited | Más de 300 peticiones por minuto (60 en una clave de prueba) | Reduce la velocidad o cola las peticiones |
429, código concurrency | Más de 8 peticiones a la vez (2 en una clave de prueba) | Limita los hilos paralelos, cierra las transmisiones abiertas |
429 con Retry-After: 5 | Sobrecarga temporal | Espera 5 segundos y reintenta |
| Petición demasiado grande | Cuerpo de la solicitud superior a 8 MB | Envía menos texto por llamada |
Un reintento simple con un breve retraso maneja los casos 429. Las solicitudes fallidas no se cobran, por lo que reintentar no tiene coste adicional. Los prompts no se utilizan para entrenamiento.
Desde aquí, la documentación de API lista todos los parámetros, y el resumen de pago por token cubre para quién es el servicio. Una regla se aplica en todas partes: el contenido sexual que involucre a menores de edad nunca está permitido.
Más guías
Preguntas y respuestas
¿Qué ID de modelo envío en la petición?
Usa uncensored como valor del modelo en cada petición. Puedes confirmarlo llamando a GET /v1/models.
¿Necesito un SDK especial?
No. Cualquier SDK o cliente de OpenAI funciona una vez que cambies la URL base a https://api.llmmodelsapi.com/v1 y uses tu propia clave.
¿Puedo usarlo sin tarjeta de crédito?
Sí, para pruebas. Los nuevos usuarios pueden reclamar $0.50 de crédito de prueba con un solo clic después del registro, sin tarjeta, válido por 7 días.
¿Qué tamaño puede tener mi prompt?
La ventana de contexto es de 100,000 tokens para el prompt y la finalización juntos, y el cuerpo de la petición puede ser de hasta 8 MB.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.