IT ▾

unfilteredaiapi.comhttps://api.unfilteredaiapi.com/v1

Unfiltered AI

API LLM grezza e senza censura per gli sviluppatori.

Unfiltered AIOttieni la chiave API

API AI Node JS: streaming, strumenti ed errori in Express

Questo tutorial Node JS AI API ti guida da una cartella vuota a un endpoint Express che effettua lo streaming delle risposte chat, chiama una funzione e gestisce gli errori di limite di richieste. Devi solo modificare il baseURL e la chiave nel pacchetto ufficiale OpenAI, quindi inviare il modello uncensored.

Ingranaggio esagonale collegato a un rack server che trasmette particelle di luce a una finestra del browser

Punti chiave

  • Installa il pacchetto openai e imposta baseURL su https://api.unfilteredaiapi.com/v1.
  • Effettua lo streaming con stream: true e inoltra i chunk al browser come eventi server-sent.
  • Le chiamate agli strumenti arrivano come tool_calls; restituisci i risultati con role tool.
  • 429 indica rate_limited, richieste parallele o sovraccarico temporaneo; riprova dopo il ritardo Retry-After.

Configurazione: installa e invia la prima richiesta

Ti serve Node 18 o versione successiva. Crea un progetto, installa l'SDK ed Express, e passa ai moduli 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"

Ottieni una chiave dalla pagina chiave API. I nuovi account possono richiedere $0.50 di credito di prova gratuito con un solo clic, valido per 7 giorni. Poi 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);

Eseguilo con node client.js. Ogni snippet definisce di nuovo il client in modo che possa essere eseguito autonomamente. Questa è l'intera migrazione se usi già il pacchetto OpenAI: un diverso baseURL, la tua chiave e l'ID del modello. Il servizio è compatibile con OpenAI e solo testo, con una finestra di contesto di 100.000 token. Consulta la documentazione per ogni metodo supportato.

Attiva lo streaming della risposta

Lo streaming invia i token man mano che vengono prodotti, così gli utenti vedono il testo immediatamente. Imposta stream: true e itera sui chunk:

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);
}

L'utilizzo arriva nell'ultimo chunk, il che ti permette di registrare i conteggi reali dei token per richiesta. Tieni a mente un fatto: una richiesta in streaming occupa il suo slot di concorrenza fino alla fine dello streaming. Se il client si disconnette, interrompi la chiamata upstream in modo che lo slot si liberi rapidamente.

Un route Express che effettua lo streaming al browser

Ecco un piccolo server con un endpoint POST /chat. Inoltra lo streaming come eventi SSE e annulla la richiesta upstream quando il browser chiude la connessione.

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"));

Non mettere mai la chiave nel codice del browser. Il route sopra la mantiene sul server, dove dovrebbe stare. Lo stesso pattern è mostrato in Python nell'articolo backend chatbot FastAPI.

Chiama uno strumento

La chiamata di funzioni segue il formato OpenAI: descrivi le funzioni in tools, il modello risponde con tool_calls, esegui la funzione e invia il risultato di nuovo come messaggio 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);
}

Analizza sempre arguments all'interno di un blocco try nel codice reale, poiché i modelli possono restituire occasionalmente JSON non validi. Per l'output strutturato senza strumenti, imposta response_format: { type: "json_object" } e menziona JSON nel tuo prompt. Le scene di gioco che chiamano funzioni per i dadi o l'inventario sono trattate in costruzione di NPC di gioco e narrativa interattiva.

Gestisci errori e limiti di frequenza

L'API restituisce HTTP 429 in tre situazioni. Il codice di errore rate_limited significa troppe richieste al minuto: 300 per una chiave completa, 60 per una chiave di prova. Il codice concurrency significa troppe richieste simultanee: 8 per una chiave completa, 2 per una chiave di prova. In caso di sovraccarico temporaneo ricevi anche 429 con un'intestazione Retry-After: 5. L'SDK espone lo stato nell'errore lanciato, quindi un piccolo wrapper gestisce tutti e tre i casi:

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;
    }
  }
}

Il wrapper attende il ritardo richiesto dal server e passa al backoff esponenziale. Nota che il pacchetto OpenAI tenta anche automaticamente il retry di alcuni errori; imposta maxRetries sul client se vuoi controllare questo comportamento. Altri codici di stato, come 401 per una chiave errata, non dovrebbero essere ritentati. Una panoramica più approfondita sui limiti è disponibile nella FAQ.

Esegui e testa il route

Avvia il server con node server.js e testalo da un secondo terminale. Il flag -N disabilita il buffering di curl così vedi gli eventi arrivare uno alla volta:

# 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."}]}'

Nel browser, leggi lo streaming con fetch e un reader, o con una piccola libreria helper SSE. Poiché l'endpoint è un POST, l'oggetto nativo EventSource non è adatto, quindi usa fetch e decodifica i chunk tu stesso.

Abitudini di produzione

  • Tieni la chiave in una variabile d'ambiente o in un archivio segreti, mai nel repository.
  • Limita il corpo della richiesta. L'API accetta fino a 8 MB, ma il tuo route dovrebbe accettare molto meno.
  • Limita la cronologia che invii. Taglia i turni vecchi prima che ti costino denaro o riempiano la finestra da 100.000 token.
  • Accoda o rifiuta il lavoro extra quando hai già 8 stream aperti, invece di lasciare che l'API risponda 429 ai tuoi utenti.
  • Registra l'intestazione di risposta X-Request-Id, così il supporto può tracciare una singola richiesta.

Verifica il tuo saldo e i costi

Ogni risposta include un'intestazione X-Balance-USD, e GET /v1/balance restituisce il saldo direttamente. I prezzi sono $0,15 per 1M token di input e $0,50 per 1M token di output, addebitati dal credito prepagato, e le richieste fallite o rifiutate sono gratuite. Un turno di chat con 800 token di input e 250 di output costa $0,000245, quindi 10.000 turni costano $2,45. Registra usage da ogni risposta e puoi prevedere la tua fattura entro pochi centesimi. La pagina dei prezzi elenca le ricariche da $20 a $500.

Domande e risposte

Quale pacchetto npm dovrei usare?

Il pacchetto openai ufficiale funziona. Imposta baseURL su https://api.unfilteredaiapi.com/v1, passa la tua chiave e usa l'ID del modello uncensored.

Posso effettuare lo streaming delle risposte da Node?

Sì. Passa stream: true e itera con for await. Aggiungi stream_options con include_usage per ottenere i conteggi dei token nell'ultimo frammento.

L'API supporta la chiamata di funzioni?

Sì. Invia tools e tool_choice, leggi tool_calls dalla risposta e restituisci i risultati come messaggi con role tool.

Cosa dovrebbe fare il mio server in caso di HTTP 429?

Attendi il valore Retry-After se presente, altrimenti applica un backoff esponenziale e riprova alcune volte. Riduci le richieste parallele se il codice di errore è concorrenza.

La tua chiave è a un modulo di distanza

Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.

Ottieni chiave APILeggi i documenti