Next.js mit KI-Sicherheit in 30 Zeilen Code absichern – so geht’s

Die Integration von KI-Modellen in Next.js-Anwendungen birgt Risiken: Prompt-Injection, ungewollte Datenweitergabe oder sogar die Übernahme der KI-Ziele durch Angreifer. Doch mit einem externen Validierungsdienst lässt sich dieses Problem elegant lösen – ohne komplexe Filterlogik oder teure Infrastruktur. Lakera Guard bietet eine solche Lösung als SaaS-Dienst an, der bereits in der Entwicklungsumgebung von Next.js eingesetzt werden kann.

Vier kritische Angriffsvektoren – und wie Lakera Guard sie blockiert

Bevor eine KI eine Eingabe verarbeitet, prüft Lakera Guard die Anfrage auf vier Hauptgefahren. Das System liefert für jede Kategorie einen Risikowert zwischen 0,0 und 1,0. Standardmäßig werden alle Anfragen mit einem Score ab 0,5 automatisch blockiert.

• Prompt-Injection: Versuche, die vordefinierten Anweisungen der KI zu überschreiben oder das Ziel der KI zu ändern – klassifiziert nach OWASP ASI01 (Goal Hijack).
• Jailbreak-Versuche: Typische Formulierungen wie „Ignoriere alle vorherigen Anweisungen“ oder spezifische „DAN“-Szenarien, die ebenfalls unter ASI01 fallen.
• Erkennung persönlicher Daten: Automatische Identifikation von E-Mail-Adressen, Telefonnummern, Sozialversicherungsnummern oder Kreditkartendaten – abgedeckt durch ASI02 (Memory Poisoning).
• Verstoß gegen Inhaltsrichtlinien: Erkennung von Gewalt, Hassrede, Selbstverletzung oder expliziten Inhalten – zugeordnet zu ASI05 (Cascading Hallucination).

Die kostenlose Version des Dienstes bietet bis zu 10.000 Anfragen pro Monat, ideal für Prototypen oder kleinere Projekte vor dem Scale-up.

In fünf Minuten einsatzbereit: API-Key, Umgebungsvariable und ein 14-Zeilen-Helper

Der erste Schritt besteht darin, einen API-Schlüssel über das Lakera-Dashboard zu generieren. Diese Schlüssel beginnen stets mit dem Präfix lak_. Anschließend wird der Schlüssel in der lokalen .env.local-Datei hinterlegt und an den Hosting-Anbieter (z. B. Vercel) weitergegeben.

# .env.local
LAKERA_GUARD_API_KEY=lak_dein_schlüssel_hier

Nachfolgend wird ein 14-Zeilen-Helfermodul in /lib/lakera.ts eingefügt. Das Modul nutzt die native fetch-Funktion und funktioniert sowohl im Node- als auch Edge-Runtime-Bereich ohne zusätzliche Abhängigkeiten.

// lib/lakera.ts
type GuardCategory =
  | "prompt_injection"
  | "jailbreak"
  | "pii"
  | "moderation";

type GuardResult = {
  flagged: boolean;
  categories: Record<GuardCategory, number>;
};

export async function lakeraGuard(input: string): Promise<GuardResult> {
  const res = await fetch(" {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.LAKERA_GUARD_API_KEY}`,
    },
    body: JSON.stringify({ messages: [{ role: "user", content: input }] }),
  });
  if (!res.ok) throw new Error(`Lakera Guard Fehler: ${res.status}`);
  return res.json() as Promise<GuardResult>;
}

Dieses Modul dient als zentrale Sicherheitsprüfung und kann in allen Routen-Handlern wiederverwendet werden, die mit einem KI-Modell interagieren.

Ein 30-Zeilen-Chat-Endpoint, der riskante Eingaben sofort blockiert

Ein einfacher POST-Endpoint für einen Chat-Dienst integriert die Sicherheitsprüfung nahtlos: Eingabe → Lakera Guard → bei Erfolg KI-Aufruf → bei Blockierung 422-Statuscode.

// app/api/chat/route.ts
import { NextResponse } from "next/server";
import { generateText } from "ai";
import { lakeraGuard } from "@/lib/lakera";

export const runtime = "edge";

export async function POST(req: Request): Promise<Response> {
  const { message } = (await req.json()) as { message: string };
  const guard = await lakeraGuard(message);

  if (guard.flagged) {
    return NextResponse.json(
      { error: "Eingabe durch Sicherheitsprüfung blockiert" },
      { status: 422 }
    );
  }

  const { text } = await generateText({
    model: "openai/gpt-5.4",
    prompt: message,
  });

  return NextResponse.json({ reply: text });
}

Der entscheidende Vorteil: Die Überprüfung erfolgt vor dem Aufruf der KI. Selbst wenn ein Angreifer versucht, schädliche Eingaben zu senden, wird die Ressource des KI-Anbieters nicht belastet. Der Modell-String ("openai/gpt-5.4") bleibt provider-unabhängig, sodass Vercels AI Gateway die Routing- und Authentifizierungslogik übernimmt – ohne dass Provider-Schlüssel im Code sichtbar werden.

Streaming-Chats sicher umsetzen – ohne Sicherheitslücken in Echtzeit

Echtzeit-Chat-Interfaces benötigen Streaming-Antworten, doch die Sicherheitsprüfung muss vor dem Start des Streams abgeschlossen sein. Nachgelagerte Prüfungen sollten in einer separaten Schicht nach Abschluss des Streams erfolgen.

// app/api/chat-stream/route.ts
import { streamText, convertToModelMessages, type UIMessage } from "ai";
import { lakeraGuard } from "@/lib/lakera";

export const runtime = "edge";

export async function POST(req: Request): Promise<Response> {
  const { messages } = (await req.json()) as { messages: UIMessage[] };
  const lastUser = messages.filter((m) => m.role === "user").pop();
  const lastUserText = lastUser?.parts
    .filter((p) => p.type === "text")
    .map((p) => p.text)
    .join("\n");

  if (!lastUserText) {
    return new Response("Kein Benutzereingabetext gefunden", { status: 400 });
  }

  const guard = await lakeraGuard(lastUserText);
  if (guard.flagged) {
    return new Response(
      JSON.stringify({ error: "Eingabe blockiert" }),
      { status: 422, headers: { "Content-Type": "application/json" } }
    );
  }

  const result = streamText({
    model: "openai/gpt-5.4",
    messages: convertToModelMessages(messages),
  });

  return result.toUIMessageStreamResponse();
}

Zwei Details aus dem AI SDK v6 erleichtern diese Integration: Der Client sendet UIMessage[], wobei der Textinhalt in parts gespeichert ist. Die Methode toUIMessageStreamResponse stellt zudem die Kompatibilität mit der useChat-Hook auf der Frontend-Seite sicher. Ein Abbruch des Streams während des Prozesses wäre sowohl technisch aufwendig als auch kostspielig – daher gilt: Sicherheitsprüfung immer vor dem Start des Streams durchführen.

Fazit: Sicherheit priorisieren – bevor das Projekt wächst

Die Integration von Lakera Guard in Next.js erfordert weniger als 30 Codezeilen und vermeidet die Notwendigkeit komplexer SDKs oder proprietärer Filterlösungen. Der Dienst fungiert als kritische Schicht zwischen Benutzereingaben und KI-Modell und blockiert Prompt-Injection, Datenlecks und Missbrauchsversuche, bevor sie das Modell erreichen. Mit der kostenlosen Version lässt sich die Lösung zunächst testen, bevor bei steigendem Traffic die Schwellenwerte angepasst werden. Separate Ausgangsprüfungen sorgen zudem dafür, dass Streaming-Funktionen nicht unterbrochen werden. So bleibt die KI sicher – von der ersten Zeile Code bis zum Scale-up.