IT ▾
Uncensored Chatbot APIAccesso API diretto a un LLM senza censuraOttieni la chiave API

Uncensored Chatbot APISicurezza

Integrazione API Chatbot: Collega un endpoint chat alla tua app

Un'integrazione API chatbot ha una regola che non puoi saltare: il browser non tiene mai la chiave API. Inserisci un piccolo proxy backend nel mezzo, invia lo streaming delle risposte attraverso di esso e il resto è sviluppo web ordinario.

Aggiornato

Condotto trasparente che collega un cubo browser e un cubo server attraverso un cancello chiuso, che mostra un proxy chat backend

Punti chiave

  • Il browser parla con il tuo server; il tuo server parla con l'API chat con la chiave.
  • Usa lo streaming con eventi server-sent così le risposte appaiono parola per parola.
  • Limita la cronologia, imposta limiti per utente e gestisci le risposte 429 con una breve attesa.
  • L'endpoint è compatibile con OpenAI, quindi l'SDK ufficiale funziona dopo un cambio del base URL.

Il pattern in un'immagine

Ogni integrazione chatbot api sicura appare uguale dall'alto. Una pagina nel browser invia il messaggio dell'utente al tuo endpoint. Il tuo server aggiunge il system prompt, riduce la cronologia, attacca la chiave API e inoltra la richiesta. La risposta torna in streaming nello stesso modo.

Browser  --POST /api/chat-->  Your server  --POST /v1/chat/completions-->  Chat API
Browser  <--SSE stream------  Your server  <--SSE stream-----------------  Chat API

Il proxy esiste per quattro motivi: nasconde la chiave, ti permette di verificare chi sta chiamando, ti permette di limitare il costo per utente e ti dà un unico punto dove cambiare le impostazioni del modello in seguito. Una chiave messa nel JavaScript front-end è pubblica nel momento in cui la pagina si carica, e qualcun altro spenderebbe il tuo credito prepagato.

L'API segue il formato OpenAI. L'URL di base è https://api.uncensoredchatbotapi.com/v1, il modello è uncensored, e l'autenticazione è Authorization: Bearer YOUR_KEY. Ottieni una chiave nella pagina delle chiavi.

Passo 1: il proxy server

Questo server Express accetta una conversazione, aggiunge un system prompt, chiama l'API con streaming e inoltra il testo. Installa le dipendenze con npm i express openai e imposta CHAT_API_KEY nell'ambiente.

import express from "express";
import OpenAI from "openai";

const app = express();
app.use(express.json({ limit: "200kb" }));
app.use(express.static("public"));

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

const SYSTEM = "You are a helpful companion for adults. Keep replies under 150 words.";

app.post("/api/chat", async (req, res) => {
  const incoming = Array.isArray(req.body.messages) ? req.body.messages : [];
  const clean = incoming
    .filter((m) => ["user", "assistant"].includes(m.role) && typeof m.content === "string")
    .slice(-20)
    .map((m) => ({ role: m.role, content: m.content.slice(0, 4000) }));

  res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" });
  try {
    const stream = await client.chat.completions.create({
      model: "uncensored",
      messages: [{ role: "system", content: SYSTEM }, ...clean],
      stream: true,
    });
    for await (const part of stream) {
      const t = part.choices[0]?.delta?.content;
      if (t) res.write(`data: ${JSON.stringify(t)}\n\n`);
    }
    res.write("data: [DONE]\n\n");
  } catch (e) {
    res.write(`event: error\ndata: ${JSON.stringify(e.status === 429 ? "busy" : "failed")}\n\n`);
  }
  res.end();
});

app.listen(3000);

Nota il filtro. Il client può inviare qualsiasi cosa, quindi il server mantiene solo i messaggi user e assistant, li tronca e ignora qualsiasi messaggio system che il browser cerca di iniettare. Il system prompt viene sempre dal tuo codice.

Passo 2: lato browser

Il browser legge lo streaming con fetch e aggiunge il testo man mano che arriva. Non serve alcuna libreria.

const messages = [];

async function send(text, out) {
  messages.push({ role: "user", content: text });
  const res = await fetch("/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ messages }),
  });

  const reader = res.body.getReader();
  const dec = new TextDecoder();
  let reply = "", buf = "";

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buf += dec.decode(value, { stream: true });
    const events = buf.split("\n\n");
    buf = events.pop();
    for (const ev of events) {
      if (ev === "data: [DONE]") break;
      if (ev.startsWith("data: ")) {
        reply += JSON.parse(ev.slice(6));
        out.textContent = reply;
      }
    }
  }
  messages.push({ role: "assistant", content: reply });
}

Il buffer è importante. I chunk di rete non si allineano ai confini degli eventi, quindi dividi sulla riga vuota e tieni la coda incompleta per la lettura successiva. Per una guida alla pagina stessa, vedi la guida alla chat web, e per il quadro più ampio dell'aggiunta di un bot a un sito, come implementare un chatbot in un sito web.

Limiti, errori e retry

Una chiave completa consente 8 richieste concorrenti e 300 al minuto. Una chiave di prova ne consente 2 e 60. Una richiesta in streaming occupa la sua slot fino alla fine dello streaming, quindi con 8 slot puoi servire al massimo 8 risposte live contemporaneamente. Se il tuo sito ha più utenti simultanei di questo, accoda le richieste nel tuo server e rispondi "un momento" invece di restituire un errore.

  • 429 con concurrency: troppe richieste in corso. Accoda e riprova.
  • 429 con rate_limited: troppe richieste al minuto. Rallenta.
  • 429 con un'intestazione Retry-After: 5: sovraccarico temporaneo. Attendi 5 secondi e riprova.
  • 401: chiave errata o mancante.
  • Corpo sopra 8 MB: rifiutato, quindi riduci ciò che invii.

Aggiungi un piccolo contatore in memoria così il tuo server non apre mai più di 8 stream upstream:

let active = 0;
const MAX = 8;

app.use("/api/chat", (req, res, next) => {
  if (active >= MAX) return res.status(503).json({ error: "busy" });
  active++;
  res.on("close", () => { active--; });
  next();
});

Registra questo middleware prima della route chat. L'evento close si attiva quando la risposta termina o l'utente se ne va, così il contatore non causa perdite.

Controlla il costo di ogni conversazione

Il prezzo è $0,15 per 1M input token e $0,50 per 1M output token. Poiché ogni turno rispedisce la cronologia, il limite sulla cronologia è la tua leva principale. Con gli ultimi 20 messaggi a circa 60 token ciascuno più un system prompt da 100 token, una richiesta trasporta circa 1.300 input token. Una risposta da 150 token aggiunge output.

Costo per turno: 1.300 / 1.000.000 x $0,15 = $0,000195, più 150 / 1.000.000 x $0,50 = $0,000075, quindi $0,00027. Una sessione da 30 turni di queste dimensioni costa al massimo $0,0081, poiché i turni iniziali sono più brevi. Limiti giornalieri per utente, ad esempio 100 messaggi, delimitano il tuo caso peggiore a 100 x $0,00027 = $0,027 per utente al giorno. Per di più sulla tariffazione di un bot sito, leggi la pagina su chatbot su costo sito web, e usa la documentazione per parametri come max_tokens.

Chi sta chiamando il tuo proxy

Il proxy protegge la chiave, ma diventa anche un endpoint chat gratuito per chiunque trovi l'URL. Decidi chi può usarlo prima di rilasciare.

Per un sito pubblico, un cookie di sessione firmato impostato al login è la risposta usuale. Verificalo all'inizio della route e restituisci 401 quando è mancante. Per un prototipo veloce, un limite per IP con un pacchetto come express-rate-limit è meglio di niente, anche se le reti condivise rendono i limiti IP imprecisi. Qualunque cosa tu scelga, conta i messaggi per utente, non per connessione, e memorizza il conteggio dove un riavvio non può resettarlo.

Mantieni la cronologia delle conversazioni sul server quando l'app cresce. Inviare l'intera cronologia dal browser a ogni turno è facile da implementare, ma gli utenti possono modificarla. Memorizza i messaggi in un database associandoli a un ID conversazione, carica gli ultimi 20 a ogni richiesta e aggiungi la risposta dopo la fine dello streaming. Questo permette anche a un utente di chiudere la scheda e tornare alla stessa chat.

Prima del lancio

Una breve checklist mantiene tranquillo il giorno del lancio.

  1. La chiave vive solo in una variabile d'ambiente sul server, e il repository non la contiene.
  2. Il server ignora qualsiasi messaggio system dal client.
  3. Ogni utente ha un limite di messaggi al giorno e un limite di lunghezza dei messaggi.
  4. Gli errori mostrano un messaggio amichevole e non stampano mai dettagli interni.
  5. Registra gli ID delle richieste dall'intestazione X-Request-Id e i conteggi token, non il testo completo.
  6. Monitori X-Balance-USD e ricevi un avviso quando il credito è basso.
  7. I tuoi termini dichiarano il pubblico solo adulti, e il bot non produce mai contenuti sessuali che coinvolgono i minorenni.

L'ultimo punto è condiviso con le indicazioni sulla sicurezza dei chatbot per adulti. Il modello alla base di questa API è ottimizzato per rispondere senza rifiuti per un uso adulto legale, il che rende le tue regole di verifica dell'età e moderazione più importanti, non meno. Le ricariche qui sono solo in cripto (USDT su TRC20 o USDC su Base), da $20 a $500, e i nuovi utenti possono richiedere prima un credito di prova di $0,50.

Domande e risposte

Perché non posso chiamare l'API direttamente da JavaScript nel browser?

Perché la chiave sarebbe visibile a chiunque apra il monitor di rete. Un proxy backend tiene la chiave sul tuo server e ti permette di aggiungere limiti per utente.

L'API supporta lo streaming?

Sì. Imposta stream a true e l'API invia eventi server-sent, con i dettagli di utilizzo alla fine. Il tuo proxy può inoltrare questi eventi al browser.

Quale SDK devo usare?

Funziona qualsiasi SDK OpenAI o client HTTP. Cambia l'URL di base in https://api.uncensoredchatbotapi.com/v1, usa la tua chiave e imposta il modello su uncensored.

Cosa succede se troppi utenti chattano contemporaneamente?

Una chiave completa permette 8 richieste concorrenti. Oltre questo limite l'API restituisce 429 con il codice concurrency, quindi accoda le richieste extra nel tuo server e riprova a breve.

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 la documentazione