Verantwortungsvoller Betrieb eines Adult-Chatbot-Produkts: Eine Checkliste für Entwickler

Wer ist für was verantwortlich

Stell dir den Stack in zwei Schichten vor. Die API liefert rechtmäßigen Adult-Content, Fiktion und kontroverse Themen, ohne sie abzulehnen, für Nutzer ab 18 Jahren. Alles rund um das Modell, die Personen, die darauf zugreifen können, die Regeln, denen sie zustimmen, und was passiert, wenn etwas schiefgeht, ist deine Sache. Diese Trennung ist befreiend, aber nur, wenn du deinen Teil ernst nimmst.

Hier ist eine kurze Verantwortungstabelle, die du dir an die Wand hängen kannst.

Betreff	Plattform	Deine App
Sexuelle Inhalte mit Minderjährigen	Immer blockiert (403)	Erkläre es, beende die Szene, verhindere Umgehung
Alter deiner Nutzer	Nur Erwachsene laut AGB	Prüfung und Verifikation an deinem Eingang
Hausregeln über das Gesetz hinaus	Nicht angewendet	Schreibe, veröffentliche und setze sie durch
Pro-Nutzer-Missbrauch	300 Anfragen pro Minute pro Schlüssel	Pro-Nutzer- und Tageslimits
Geheimer Schlüssel	Stellt ihn aus	Halte ihn auf deinem Server

Dies ist technische Anleitung, keine Rechtsberatung; Regeln unterscheiden sich je nach Ort, also prüfe die Anforderungen dort, wo deine Nutzer leben.

Altersprüfung, die tatsächlich sperrt

Ein Banner mit einem "Ich bin 18"-Button ist das Minimum, und ein bestimmter Minderjähriger kann darauf klicken. Es ist dennoch wichtig, weil es eine affirmative Aussage protokolliert und deine Richtlinie ehrlich hält. Der Schlüssel liegt darin, wo du es durchsetzt. Wenn die Prüfung den Chat nur im Browser ausblendet, kann jeder direkt deinen Endpunkt aufrufen. Lass den Server die Unterhaltung verweigern, bis ein signierter Marker existiert.

Copyimport crypto from "node:crypto";

// Minimal 18+ gate: the user must confirm before the chat routes work.
// Replace the confirmation with a real verification step when your market requires it.
const SECRET = process.env.GATE_SECRET;   // random string kept on the server

function sign(value) {
  return crypto.createHmac("sha256", SECRET).update(value).digest("hex");
}

export function issueAdultCookie(res, userId) {
  const stamp = String(Date.now());
  const payload = `${userId}.${stamp}`;
  res.cookie("adult_ok", `${payload}.${sign(payload)}`, {
    httpOnly: true, sameSite: "strict", secure: true, maxAge: 30 * 24 * 3600 * 1000,
  });
}

export function requireAdult(req, res, next) {
  const raw = req.cookies?.adult_ok || "";
  const [userId, stamp, sig] = raw.split(".");
  if (!sig || sign(`${userId}.${stamp}`) !== sig) {
    return res.status(403).json({ state: "age_required" });
  }
  req.userId = userId;
  next();
}

Füge requireAdult vor jeder Chat-Route ein. Füge eine stärkere Überprüfung hinzu, wenn dein Markt oder dein Risikoniveau dies erfordert, z. B. eine Altersprüfung durch einen Drittanbieter, und halte den Marker kurzlebig genug, damit du den Prompt erneut senden kannst. Richte dein Marketing niemals an Schüler oder Schulen aus, und platziere die Sperrung, bevor Erwachsener Inhalt angezeigt wird, einschließlich Vorschauen und Beispielkonversationen.

Schreiben deiner eigenen Content-Richtlinie

Das Modell lehnt legales Adult-Material nicht ab, also entscheidest du, was dein Produkt erlaubt. Eine einseitige Richtlinie reicht aus. Decke ab, was willkommen ist, was in deiner Community auch bei Legalität nicht erlaubt ist (z. B. Belästigung realer Personen oder Doxxing), wie Nutzer Probleme melden können und welche Maßnahmen du ergreifst: Warnungen, temporäre Stumm schaltungen, Sperren.

1. Veröffentliche sie dort, wo sich Nutzer anmelden, in klarer Sprache.
2. Spiegle sie in deinem System-Prompt. Eine Zeile wie "Alle Charaktere sind erwachsen; beende jede Szene, die nicht einvernehmlich wird oder echte, namentlich genannte Personen betrifft" hält den Bot an deine Regeln gebunden.
3. Mach die Durchsetzung langweilig. Lege Schwellenwerte im Voraus fest, damit Moderatoren nicht improvisieren.
4. Überprüfe die Richtlinie jedes Quartal, wenn sich dein Produkt weiterentwickelt.

Ein Meldekanal, den Nutzer finden können

Gib jeder Nachricht eine kleine Meldesteuerung und lass sie ohne Login-Umweg funktionieren. Wenn jemand eine Antwort meldet, erfasse das Minimum, das du zum Handeln brauchst: die Benutzer-ID, die Nachrichten-ID, einen kurzen Grund und einen Zeitstempel. Leite es in eine Warteschlange, die deine Moderatoren beobachten.

Copyapp.post("/api/report", requireAdult, express.json(), (req, res) => {
  const { messageId, reason } = req.body;
  // Store only what you need to act on: who, which message, why, when.
  queueForModerator({ userId: req.userId, messageId, reason: String(reason).slice(0, 500), at: Date.now() });
  res.json({ ok: true });
});

Halte deine Versprechen eng. Sag Nutzern genau, was eine Meldung auslöst, und speichere nur, was deine eigene Richtlinie und geltende Vorschriften erfordern. Überprüfe, wie lange du Meldungen aufbewahrst, und lösche sie nach Zeitplan. Bestätige jede Meldung an die Person, die sie eingereicht hat, auch mit einem einzeiligen Dank, weil Nutzer aufhören zu melden, wenn nichts zu geschehen scheint. Verfolge, wie schnell deine Moderatoren Fälle schließen, und setze ein Ziel, das du tatsächlich erreichen kannst.

Gestaltung für die 403-Sperre für Minderjährige

Sexuelle Inhalte mit Minderjährigen werden immer blockiert, auch in Fiktion und Rollenspiel. Die API antwortet mit einem 403 und dem Code content_blocked. Wiederhole die Anfrage nicht und versuche nicht, sie im Namen des Nutzers umzuformulieren. Behandle es stattdessen als Produktmoment, das ein klares Design verdient.

• Übersetze es auf dem Server in einen Zustand, den deine UI kennt, damit roher Upstream-Text niemals den Bildschirm erreicht.
• Sag, was passiert ist in einem ruhigen Satz und nenne die Regel.
• Beende oder setze die Szene zurück. Die Option "Trotzdem fortfahren" verfehlt den Punkt.
• Logge das Ereignis mit der Benutzer-ID, damit wiederholte Versuche deine eigene Durchsetzung auslösen können.
• Rate nicht bei der Intention. Einige Sperren beruhen auf mehrdeutigen Formulierungen; die neutrale Nachricht funktioniert in beiden Fällen.

Copy// server: translate upstream outcomes into states your UI understands
if (upstream.status === 403) {
  return res.status(403).json({
    state: "content_blocked",
    message: "That request breaks our rules, so we can't continue this scene.",
  });
}
if (upstream.status === 402) return res.status(503).json({ state: "paused" });
if (upstream.status === 503) return res.status(503).json({ state: "busy" });

Copy// browser: show a calm, specific message for each state
const MESSAGES = {
  content_blocked: "This scene can't continue. Sexual content involving minors is never allowed. Start a new chat any time.",
  age_required: "Please confirm you are 18 or older to use the chat.",
  slow_down: "You're sending messages quickly. Give it a few seconds.",
  daily_limit: "You've reached today's message allowance. Come back tomorrow.",
  paused: "Chat is briefly unavailable. We're on it.",
  busy: "The service is busy. Try again in a moment.",
};

async function send(messages) {
  const res = await fetch("/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ messages }),
  });
  if (!res.ok) {
    const info = await res.json().catch(() => ({}));
    showBanner(MESSAGES[info.state] || "Something went wrong.");
    if (info.state === "content_blocked") endCurrentScene();
    return null;
  }
  return res;
}

Pro-Benutzer-Betrugs- und Ratenkontrollen

Dein einzelner API-Schlüssel erlaubt insgesamt 300 Anfragen pro Minute, geteilt von allen Nutzern. Ein skriptbasiertes Konto kann alle anderen aushungern, also setze faire Nutzungsgrenzen selbst durch, deutlich unter dieser Decke. Das Beispiel begrenzt jeden Nutzer auf 12 Nachrichten pro Minute und weist jedem ein tägliches Token-Budget zu, gemessen an der usage-Zahl im letzten Stream-Chunk.

Copyconst WINDOW_MS = 60_000;
const PER_USER_PER_MIN = 12;       // your product rule, far below the key's 300
const DAILY_TOKEN_BUDGET = 60_000; // per user, tracked from the usage chunk

const hits = new Map();            // userId -> array of timestamps
const spent = new Map();           // userId -> tokens used today

export function userLimit(req, res, next) {
  const now = Date.now();
  const recent = (hits.get(req.userId) || []).filter((t) => now - t < WINDOW_MS);
  if (recent.length >= PER_USER_PER_MIN) {
    return res.status(429).json({ state: "slow_down" });
  }
  if ((spent.get(req.userId) || 0) >= DAILY_TOKEN_BUDGET) {
    return res.status(429).json({ state: "daily_limit" });
  }
  recent.push(now);
  hits.set(req.userId, recent);
  next();
}

export function recordUsage(userId, totalTokens) {
  spent.set(userId, (spent.get(userId) || 0) + totalTokens);
}

Speichere Zähler für die Produktion in einem gemeinsamen Speicher statt im Prozessspeicher, damit Limits Neustarts überdauern und auf mehreren Servern funktionieren. Füge eine moderate max_tokens-Begrenzung bei jeder Anfrage hinzu, um den Worst Case zu begrenzen, und achte auf 402 auf deinem eigenen Guthaben. Ein kostenloses Testguthaben von $0,50 für 7 Tage ist eine gute Möglichkeit, diese Kontrollen zu testen, bevor echter Datenverkehr eintrifft.

Bewahre den Schlüssel auf dem Server auf

Gib den Schlüssel niemals in Frontend-Bundles, mobilen Apps oder öffentlichen Repositories frei. Speichere ihn als Umgebungsvariable oder in einem Secret Manager, lade ihn nur in deinem Backend und schließe ihn aus Logs und Fehlerberichten aus. Wenn du einen Verlust vermutest, generiere ihn aus deinem Konto neu; der alte Schlüssel funktioniert sofort nicht mehr, also halte eine Bereitstellung bereit. Denke daran, dass es einen Schlüssel pro Konto gibt, was eine saubere Proxy-Schicht noch wertvoller macht. Das Web-Chat-Tutorial zeigt das Muster von Anfang bis Ende, und die Dokumentation listet die Fehlercodes auf, die dein Wrapper abbilden sollte.

Checkliste vor dem Start

Gehe diese Liste am Tag vor deinem Start durch. Jeder Punkt dauert nur Minuten und verhindert eine Fehlerklasse, die schmerzhaft zu beheben ist, sobald Nutzer da sind.

1. Versuche, die Sperre zu knacken. Rufe deine Chat-Route mit curl und ohne Cookie auf. Sie muss 403 mit age_required antworten, niemals eine Modellantwort.
2. Löse jeden Zustand aus. Simuliere den Upstream, um nacheinander 402, 403, 429 und 503 zurückzugeben, und bestätige, dass jeder den richtigen Banner zeigt und niemals rohen Fehlertext durchsickern lässt.
3. Lies deine eigene Richtlinie laut vor. Wenn ein Moderator einen Fall nicht innerhalb einer Minute daraus entscheiden kann, schärfe die Formulierung.
4. Teste die Melde-Taste auf einem Smartphone-Bildschirm. Eine Steuerung, die schwer zu erreichen ist, zählt nicht als Meldekanal.
5. Durchsuche dein Repository nach dem Schlüssel. Schau in Frontend-Ordner, Build-Ausgaben, Beispielkonfigurationen und Commit-Verlauf. Generiere ihn neu, wenn du ihn irgendwo öffentlich findest.
6. Richte Warnungen ein. Pinge dich selbst bei einem 402, bei einem Anstieg von 403-Blockierungen durch einen einzelnen Nutzer und bei einem Anstieg im täglichen Tokenverbrauch.
7. Bereite den Pause-Schalter vor. Ein einzelnes Flag, das den Chat sauber beendet, ist bei einem Vorfall von unschätzbarem Wert.

Sicherheit ist nie abgeschlossen, und das Gleiche gilt für die Liste; füge jedes Mal Elemente hinzu, wenn ein Vorfall dir etwas Neues lehrt, und teile sie mit jedem, der deinem Team beitritt. Überprüfe die Liste erneut, wenn du Funktionen wie Bilduploads in deiner eigenen Benutzeroberfläche, Gruppenräume oder die öffentliche Charakterfreigabe hinzufügst, da jede davon neue Missbrauchsmöglichkeiten eröffnet. Lies für Hilfe bei der Gestaltung der Charaktere selbst den Persona-Design-Leitfaden, und halte die Grundlagen deiner Integrationsnotizen in den Dokumentationen griffbereit, während dein Team wächst.