API de IA en Node JS: streaming, herramientas y errores en Express
Este tutorial de API de IA en node js te lleva desde una carpeta vacía hasta una ruta de Express que transmite respuestas de chat, llama a una herramienta y maneja errores de límite de peticiones. Solo cambias la baseURL y la clave en el paquete oficial de OpenAI, luego envías el modelo uncensored.
ActualizadoUnfiltered AI

Puntos clave
- Instala el paquete openai y establece baseURL en https://api.unfilteredaiapi.com/v1.
- Transmite con stream: true y reenvía los fragmentos al navegador como eventos enviados por el servidor.
- Las llamadas a herramientas llegan como tool_calls; devuelve los resultados con role tool.
- 429 significa rate_limited, concurrencia o sobrecarga temporal; reintenta tras el retraso de Retry-After.
Configuración: instala y envía la primera petición
Necesitas Node 18 o superior. Crea un proyecto, instala el SDK y Express, y cambia a módulos ES.
mkdir ai-node && cd ai-node
npm init -y
npm pkg set type=module
npm install openai express
# base URL: https://api.unfilteredaiapi.com/v1 model: uncensored
export AI_API_KEY="YOUR_KEY"
Obtén una clave desde la página de clave de API. Las cuentas nuevas pueden reclamar $0.50 de crédito de prueba con un clic, válido por 7 días. Luego crea client.js:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.unfilteredaiapi.com/v1",
apiKey: process.env.AI_API_KEY,
});
const res = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Give me three names for a tavern keeper." }],
});
console.log(res.choices[0].message.content);
Ejecútalo con node client.js. Cada fragmento define el cliente de nuevo para que se ejecute por sí solo. Esa es toda la migración si ya usas el paquete de OpenAI: una baseURL diferente, tu clave y el ID del modelo. El servicio es compatible con OpenAI y solo texto, con una ventana de contexto de 100.000 tokens. Consulta la documentación para todos los métodos compatibles.
Transmite la respuesta
El streaming envía tokens a medida que se producen, para que los usuarios vean texto inmediatamente. Establece stream: true e itera sobre los fragmentos:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.unfilteredaiapi.com/v1",
apiKey: process.env.AI_API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Describe a rainy harbor town." }],
stream: true,
stream_options: { include_usage: true },
});
for await (const chunk of stream) {
const delta = chunk.choices[0]?.delta?.content;
if (delta) process.stdout.write(delta);
if (chunk.usage) console.log("\nusage:", chunk.usage);
}
El uso llega en el último fragmento, lo que te permite registrar recuentos reales de tokens por petición. Ten en cuenta un hecho: una petición en streaming ocupa su espacio de concurrencia hasta que finalice la transmisión. Si el cliente se desconecta, aborta la llamada upstream para liberar el espacio rápidamente.
Una ruta de Express que transmite al navegador
Aquí tienes un servidor pequeño con una ruta POST /chat. Reenvía el stream como eventos enviados por el servidor y cancela la llamada upstream cuando el navegador cierra la conexión.
import express from "express";
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.unfilteredaiapi.com/v1",
apiKey: process.env.AI_API_KEY,
});
const app = express();
app.use(express.json({ limit: "1mb" }));
app.post("/chat", async (req, res) => {
const { messages } = req.body;
if (Array.isArray(messages) === false) return res.status(400).json({ error: "messages required" });
res.set({
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache",
Connection: "keep-alive",
});
const controller = new AbortController();
req.on("close", () => controller.abort());
try {
const stream = await client.chat.completions.create(
{ model: "uncensored", messages, stream: true },
{ signal: controller.signal }
);
for await (const chunk of stream) {
const delta = chunk.choices[0]?.delta?.content;
if (delta) res.write("data: " + JSON.stringify({ delta }) + "\n\n");
}
res.write("data: [DONE]\n\n");
} catch (err) {
res.write("data: " + JSON.stringify({ error: err.status || 500 }) + "\n\n");
} finally {
res.end();
}
});
app.listen(3000, () => console.log("listening on 3000"));
Nunca pongas la clave en el código del navegador. La ruta anterior la mantiene en el servidor, donde corresponde. El mismo patrón se muestra en Python en el artículo de backend de chatbot FastAPI.
Llamar a una herramienta
Las llamadas a funciones siguen el formato OpenAI: describes funciones en tools, el modelo responde con tool_calls, ejecutas la función y envías el resultado como mensaje con role: "tool".
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.unfilteredaiapi.com/v1",
apiKey: process.env.AI_API_KEY,
});
const tools = [{
type: "function",
function: {
name: "roll_dice",
description: "Roll a die with the given number of sides",
parameters: {
type: "object",
properties: { sides: { type: "integer" } },
required: ["sides"],
},
},
}];
const messages = [{ role: "user", content: "Roll a d20 for my attack." }];
const first = await client.chat.completions.create({
model: "uncensored", messages, tools, tool_choice: "auto",
});
const msg = first.choices[0].message;
if (msg.tool_calls) {
messages.push(msg);
for (const call of msg.tool_calls) {
const { sides } = JSON.parse(call.function.arguments);
const result = 1 + Math.floor(Math.random() * sides);
messages.push({ role: "tool", tool_call_id: call.id, content: String(result) });
}
const second = await client.chat.completions.create({ model: "uncensored", messages, tools });
console.log(second.choices[0].message.content);
}
Analiza siempre arguments dentro de un bloque try en código real, ya que los modelos pueden devolver JSON malformado de vez en cuando. Para salida estructurada sin herramientas, establece response_format: { type: "json_object" } y menciona JSON en tu prompt. Las escenas de juegos que llaman a funciones de dados o inventario se cubren en creación de NPCs de juegos y ficción interactiva.
Manejar errores y límites de velocidad
La API devuelve HTTP 429 en tres casos. El código de error rate_limited indica demasiadas peticiones por minuto: 300 para clave completa, 60 para prueba. El código concurrency indica demasiadas peticiones simultáneas: 8 para clave completa, 2 para prueba. En sobrecarga temporal recibes 429 con la cabecera Retry-After: 5. El SDK expone el estado en el error lanzado, así un pequeño envoltorio maneja los tres:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.unfilteredaiapi.com/v1",
apiKey: process.env.AI_API_KEY,
});
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
export async function chatWithRetry(params, tries = 4) {
for (let i = 0; i < tries; i++) {
try {
return await client.chat.completions.create({ model: "uncensored", ...params });
} catch (err) {
if (err.status === 429 && i < tries - 1) {
const wait = Number(err.headers?.["retry-after"]) || 2 ** i;
await sleep(wait * 1000);
continue;
}
throw err;
}
}
}
El wrapper espera el retraso que pide el servidor y recurre a retroceso exponencial. Ten en cuenta que el paquete de OpenAI también reintenta algunos errores por sí mismo; establece maxRetries en el cliente si quieres controlar esto. Otros estados, como 401 para una clave incorrecta, no deben reintentarse. Una mirada más profunda a los límites está en la FAQ.
Ejecuta y prueba la ruta
Inicia el servidor con node server.js y pruébalo desde una segunda terminal. La bandera -N desactiva el buffering de curl para que veas los eventos llegar uno por uno:
# the server calls https://api.unfilteredaiapi.com/v1 with model uncensored
curl -N http://localhost:3000/chat -H "Content-Type: application/json" -d '{"messages":[{"role":"user","content":"Write a two-line riddle."}]}'
En el navegador, lee el streaming con fetch y un reader, o con una librería SSE. Como la ruta es POST, el objeto nativo EventSource no sirve, usa fetch y decodifica los fragmentos tú mismo.
Hábitos de producción
- Mantén la clave en una variable de entorno o en un almacén de secretos, nunca en el repositorio.
- Limita el cuerpo de la petición. La API acepta hasta 8 MB, pero tu propia ruta debería aceptar mucho menos.
- Limita el historial que envías. Recorta turnos antiguos antes de que te cuesten dinero o llenen la ventana de 100.000 tokens.
- Cola o rechaza trabajo extra cuando ya tienes 8 streaming abiertos, en lugar de dejar que la API responda 429 a tus usuarios.
- Registra la cabecera de respuesta
X-Request-Idpara que soporte rastree una petición.
Verifica tu saldo y coste
Toda respuesta incluye la cabecera X-Balance-USD, y GET /v1/balance devuelve el saldo directamente. Precios: $0.15 por 1M tokens de entrada y $0.50 por 1M de salida, cobrados del crédito prepago; las peticiones fallidas o rechazadas son gratis. Una vuelta de chat con 800 tokens de entrada y 250 de salida cuesta $0.000245, así 10.000 vueltas cuestan $2.45. Registra usage de cada respuesta y puedes predecir tu factura con un margen de unos pocos centavos. La página de precios muestra recargas de $20 a $500.
Más guías
Preguntas y respuestas
¿Qué paquete npm debo usar?
El paquete oficial de openai funciona. Establece baseURL en https://api.unfilteredaiapi.com/v1, pasa tu clave y usa el ID de modelo uncensored.
¿Puedo transmitir respuestas desde Node?
Sí. Pasa stream: true e itera con for await. Añade stream_options con include_usage para obtener recuentos de tokens en el último fragmento.
¿La API admite llamadas a funciones?
Sí. Envía tools y tool_choice, lee tool_calls de la respuesta y devuelve resultados como mensajes con role tool.
¿Qué debe hacer mi servidor ante un HTTP 429?
Espera el valor de Retry-After si está presente; de lo contrario, aplica backoff exponencial y reintenta unas pocas veces. Reduce las peticiones simultáneas si el código de error es de concurrencia.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.