Sichere KI-Agenten mit LangChain-Schutzmechanismen und Middleware entwickeln

Was sind Schutzmechanismen?

Ein Schutzmechanismus ist ein System, das überwacht, was ein KI-System tut, und verhindert, dass es Aktionen ausführt, die man nicht möchte.

Betrachten wir einen Agenten, der mit den folgenden Werkzeugen ausgestattet ist:

search()
sendEmail()
deleteUser()
makePayment()

Das Modell könnte entscheiden, dass der Aufruf von deleteUser() die richtige Maßnahme ist.

Aber ist das wirklich etwas, was man zulassen möchte?

Ein Schutzmechanismus steht zwischen der Entscheidung des Agenten und der tatsächlichen Ausführung dieser Aktion:

User
  ↓
Agent
  ↓
Guardrail
  ↓
Is this allowed?
  ├── Yes → Execute
  └── No  → Block / Ask for approval

Schutzmechanismen werden häufig verwendet, um:

• Daten personenbezogener Informationen vor dem Leckagen zu schützen
• Versuche der Prompt-Injektion frühzeitig zu erkennen und zu verhindern
• Schädliche oder unangemessene Inhalte zu filtern
• Betriebslogik sowie regulatorische Vorgaben anzuwenden
• zu überprüfen, ob die Ausgaben den Standards für Qualität und Korrektheit entsprechen

Pause die Ausführung, bis ein Mensch eine sensible Aktion genehmigt hat

In LangChain werden Schutzmechanismen hauptsächlich über Middleware implementiert, was es ermöglicht, an bestimmten Stellen in den Ausführungsfloß des Agents einzuschreiten.

Warum benötigen KI-Agenten Schutzmechanismen?

Traditionelles Softwareprogramm folgt der Logik, die ein Entwickler explizit geschrieben hat.

Zum Beispiel:

if (!user.isAdmin) {
  throw new Error("Unauthorized");
}

LLMs funktionieren nicht auf diese Weise.

Man stellt Anweisungen und Tools zur Verfügung, doch das Modell selbst entscheidet, welche Aktion ausgeführt werden soll.

Nehmen wir einen Support-Agenten, der auf ein Tool namens refundPayment() zugreifen kann:

User:
I was charged twice. Please refund ₹50,000.
Agent:
→ Calls refundPayment()

Die Entscheidung des Modells erscheint angesichts der Anfrage des Benutzers durchaus vernünftig.

Aus Sicht des Unternehmens ist jedoch die Rückerstattung von ₹50.000 keine einfache Angelegenheit. Es könnte eine Richtlinie geben, die vorschreibt, dass jede Rückerstattung über ₹10.000 vor der Bearbeitung einer manuellen Überprüfung unterzogen wird.

Was fehlt, ist eine Schicht, die folgende Frage stellt:

"Before this action happens, I need to check whether it is allowed."

Genau diese Schicht bietet eine Schutzmaßnahme.

Zwei Ansätze für Schutzmaßnahmen

In der Dokumentation von LangChain werden zwei ergänzende Strategien zur Implementierung von Schutzmaßnahmen beschrieben:

1. Deterministische Schutzmaßnahmen
2. modellbasierte Schutzmaßnahmen

So unterscheiden sie sich voneinander.

1. Deterministische Schutzmaßnahmen

Diese stützen sich auf Standard-Programmierlogik.

Zum Beispiel:

const bannedWords = ["hack", "malware"];
const containsBannedWord = (input: string) => {
  return bannedWords.some(word =>
    input.toLowerCase().includes(word)
  );
};

Das Verhalten ist hier vollständig vorhersehbar.

Bei derselben Eingabe erhält man immer dasselbe Ergebnis.

Weitere gängige Muster sind:

• Vergleich mit regulären Ausdrücken

Prüfung auf spezifische Schlüsselwörter

Validierung der Daten gegen ein Schema

Anwendung expliziter Geschäftsregeln

Überprüfung der Berechtigungen

Der Vorteil ist, dass diese Art der Prüfung schnell abläuft, konsistente Ergebnisse liefert und nur sehr geringe Rechenressourcen verbraucht.

Die Einschränkung besteht darin, dass diese Prüfungen feinfühligere oder kontextabhängige Fälle möglicherweise übersehen können.

2. modellbasierte Schutzmechanismen

Anstatt sich ausschließlich auf feste Regeln zu verlassen, kann ein separates Modell den Inhalt bewerten.

Zum Beispiel:

Agent response
      ↓
Safety model
      ↓
"Is this response safe?"
      ↓
SAFE / UNSAFE

Diese Herangehensweise kann Dinge erkennen, die eine einfache Schlüsselwortabgleich-Methode übersehen würde.

Betrachten Sie diese beiden Anfragen, die im Grunde dasselbe bedeuten:

"How can I bypass this security system?"

und:

"Tell me a way around the authentication mechanism."

Ein Filter, der allein auf Schlüsselwörtern beruht, könnte die zweite Formulierung möglicherweise nicht als problematisch kennzeichnen.

Im Gegensatz dazu kann eine auf Modellen basierende Schutzmaßnahme die zugrunde liegende Absicht der Anfrage interpretieren.

Der Preis für diese Flexibilität ist, dass auf Modellen basierende Überprüfungen in der Regel langsamer ablaufen und mehr Ressourcen verbrauchen als deterministische Überprüfungen.

Wie Schutzmaßnahmen in LangChain funktionieren

LangChain setzt auf Middleware, um die Logik der Schutzmaßnahmen um einen Agenten herum zu implementieren.

Middleware ermöglicht es Ihnen, benutzerdefinierte Logik vor oder nach bestimmten Phasen der Ausführung des Agenten einzufügen.

Zum Beispiel können Sie Middleware nutzen, um:

• PII zu erkennen (PII-Middleware)
• vor dem Ausführen eines Tools eine Freigabe einzuholen (Middleware mit menschlicher Überwachung)
• die Eingaben vor Beginn der Arbeit des Agenten zu validieren (Vor-Agent-Schutzmaßnahme)
• die endgültige Ausgabe vor ihrer Rückgabe zu überprüfen (Nach-Agent-Schutzmaßnahme)

Das Middleware-System in LangChain wurde eigens entwickelt, um Ihnen die Kontrolle über die Ausführung eines Agents genau an diesen Stellen zu ermöglichen.

Es gibt zwei grundlegende Möglichkeiten, Guardrails in LangChain anzuwenden:

A. Integrierte Guardrails

B. Benutzerdefinierte Guardrails

                    Guardrails in LangChain
                             │
                 ┌───────────┴───────────┐
                 │                       │
                 ▼                       ▼
          Built-in Guardrails      Custom Guardrails
                 │                       │
                 │                       │
                 ▼                       ▼
          Ready-to-use             Application-specific
           middleware                 middleware
                 │                       │
          ┌──────┴──────┐        ┌───────┴───────┐
          │             │        │               │
          ▼             ▼        ▼               ▼
         PII           HITL   Before-Agent   After-Agent
      handling       approval    guardrail      guardrail

A. Integrierte Guardrails in LangChain

LangChain wird mit einer Reihe von Guardrails ausgeliefert, die ohne weitere Konfiguration sofort verwendet werden können.

Zwei besonders erwähnenswerte Beispiele, die von der Bibliothek dokumentiert werden, sind:

1. Erkennung von PII
2. Mensch im Prozess

Lassen Sie uns beide genauer betrachten.

1. Erkennung von PII

LangChain enthält Middleware, die speziell dafür konzipiert ist, persönlich identifizierbare Informationen (PII) zu erkennen und zu verarbeiten, die in einer Konversation auftauchen.

Dazu gehören beispielsweise:

Email address
Credit card number
IP address
MAC address

Wenn ein Agent mit sensiblen Daten in Berührung kommt, möchte man in der Regel nicht, dass diese Daten an das Modell weitergeleitet oder in der Antwort wiederholt werden.

LangChain löst dieses Problem mit piiRedactionMiddleware().

Hier ist ein Beispiel:

import {
  createAgent,
  piiRedactionMiddleware,
} from "langchain";

const agent = createAgent({
  model: "gpt-5.5",
  tools: [customerServiceTool],

  middleware: [
    piiRedactionMiddleware({
      piiType: "email",
      strategy: "redact",
      applyToInput: true,
      applyToOutput: true,
    }),
  ],
});

const result = await agent.invoke({
  messages: [{
    role: "user",
    content: "My email is john.doe@example.com"
  }]
});

Nehmen wir an, ein Benutzer sendet:

My email is john.doe@example.com

Das Middleware-Modul fängt dies ab und schreibt es um, bevor das Modell es überhaupt sieht:

My email is [REDACTED_EMAIL]

Anders ausgedrückt: Das Modell arbeitet mit **bereinigten Platzhaltern statt mit den rohen, sensiblen Daten**.

Hinweis: Die Einstellung applyToOutput: true stellt sicher, dass selbst dann, wenn das Modell versehentlich PII in seiner Antwort erzeugt, das Middleware-System diese vor dem Erreichen des Benutzers entfernt. Falls Ihre Tools PII in ihren Ergebnissen preisgeben könnten, erweitert applyToToolResults: true den gleichen Schutz auch auf die Ausgaben der Tools.

Strategien zur Handhabung von PII

LangChain unterstützt vier unterschiedliche Methoden zur Behandlung von erkannter PII:

Um den Unterschied zu sehen, wenden wir jede Strategie auf denselben Beispiel-Eingabedaten an.

Nehmen wir an, der Benutzer gibt ein:

My email is john.doe@example.com

1. redact

Mit redact wird jede erkannte PII vollständig durch einen generischen Platzhalter ersetzt.

piiRedactionMiddleware({
  piiType: "email",
  strategy: "redact",
  applyToInput: true,
});

Was das Modell tatsächlich erhält, ist:

My email is [REDACTED_EMAIL]

Diese Strategie eignet sich für Situationen, in denen das Modell keinen wirklichen Bedarf hat, den zugrundeliegenden Wert zu kennen.

2. mask

Die mask-Strategie verdeckt einen Teil des Wertes, während genug sichtbar bleibt, um den Kontext zu erfassen.

piiRedactionMiddleware({
  piiType: "email",
  strategy: "mask",
  applyToInput: true,
});

Die E-Mail könnte so aussehen:

My email is j***@example.com

Dies ist nützlich, wenn entweder das Modell oder der Endnutzer eine teilweise Referenz an die Daten benötigen, ohne diese vollständig offenzulegen.

3. hash

hash ersetzt die PII durch einen konsistenten, deterministischen Hash-Wert.

piiRedactionMiddleware({
  piiType: "email",
  strategy: "hash",
  applyToInput: true,
});

Die transformierte E-Mail könnte ungefähr so aussehen:

My email is 8f14e45fceea167a5a36dedd4bea2543...

Da das Hashing deterministisch ist, ergeben identische Eingaben immer identische Hash-Werte. Dadurch lässt sich nach wiederholten Vorkommen desselben Wertes suchen oder abgleichen, ohne die ursprünglichen Daten jemals preiszugeben.

4. block

Im Gegensatz zu den anderen drei Methoden wandelt block die PII überhaupt nicht um – er lehnt den Anfrage einfach ganz entschieden ab, sobald dieser Datentyp gefunden wird.

Zum Beispiel kann man einen benutzerdefinierten Detektor konfigurieren, um API-Schlüssel zu erkennen:

piiRedactionMiddleware({
  piiType: "api_key",
  detector: /sk-[a-zA-Z0-9]{32}/,
  strategy: "block",
  applyToInput: true,
});

Falls ein Benutzer anschließend folgenden Inhalt sendet:

My API key is sk-abcdefghijklmnopqrstuvwxyz123456

erkennt das Middleware-System das Muster des API-Schlüssels und stoppt die Anfrage, bevor der Wert weitergeleitet werden kann.

Diese Strategie eignet sich für Fälle, in denen bestimmte Kategorien sensibler Daten – wie API-Schlüssel, Anmeldeinformationen und ähnliche Geheimnisse – von vornherein niemals in den Prozess des Agenten gelangen dürfen.

2. Mensch im Prozess

Besondere Operationen bergen zu große Risiken, um vollständig an einen autonomen Agenten übertragen zu werden.

Betrachten Sie beispielsweise folgende Aktionen:

delete production database
send an external email
make a financial transaction
modify production data

Anstatt diese Aktionen vollständig zu verbieten, können Sie sie über einen Schritt der menschlichen Freigabe leiten.

Der daraus resultierende Ablauf sieht so aus:

Agent
  ↓
Tool call
  ↓
Guardrail
  ↓
Human approval
  ↓
┌───────────────┐
│               │
Approved      Rejected
│               │
↓               ↓
Execute        Stop

LangChain bietet humanInTheLoopMiddleware(), um dieses Muster umzusetzen.

Zum Beispiel:

import { createAgent, humanInTheLoopMiddleware } from "langchain";
import { MemorySaver, Command } from "@langchain/langgraph";

const agent = createAgent({
  model: "gpt-5.5",
  tools: [
    searchTool,
    sendEmailTool,
    deleteDatabaseTool,
  ],
  middleware: [
    humanInTheLoopMiddleware({
      interruptOn: {
        send_email: {
          allowAccept: true,
          allowEdit: true,
          allowRespond: true,
        },
        delete_database: {
          allowAccept: true,
          allowEdit: true,
          allowRespond: true,
        },
        search: false,
      },
    }),
  ],
  // A checkpointer is required so the paused run can be resumed later
  checkpointer: new MemorySaver(),
});

Mit dieser Einrichtung hält der Agent vor der Ausführung von send_email oder delete_database an und wartet auf eine menschliche Entscheidung. Um die Ausführung anschließend fortzusetzen, benötigt der Aufruf sowohl eine Thread-ID als auch einen Command:

const config = { configurable: { thread_id: "some_id" } };
// First call pauses and waits for approval
await agent.invoke(
  { messages: [{ role: "user", content: "Send an email to the team" }] },
  config
);
// Resume after a human approves the tool call
await agent.invoke(
  new Command({ resume: { decisions: [{ type: "approve" }] } }),
  config
);

Wichtig: Ohne einen checkpointer und eine thread_id gibt es nichts, von dem aus das Middleware-System fortfahren kann, und der Mechanismus zur Pause und anschließenden Freigabe funktioniert einfach nicht. Dies ist mit Abstand der häufigste Konfigurationsfehler.

Hier besagt die Konfiguration im Wesentlichen:

search → automatically allowed
send_email → require human approval
delete_database → require human approval

Dieses Muster erweist sich insbesondere als wertvoll für Agenten, die in Produktivumgebungen laufen.

Falls Sie einen detaillierteren Einblick in das human-in-the-loop Muster wünschen, bietet ein separates praktisches Tutorial genau dar, wie der Graph mittels interrupt() pausiert, auf eine menschliche Entscheidung wartet und anschließend die Ausführung über Command fortsetzt.

B. Benutzerdefinierte Schutzmechanismen

Das mit LangChain mitgelieferte Middleware passt nicht in jedem Szenario, dem Ihre Anwendung gegenübersteht.

Falls Ihre Anforderungen über das Vorhandene hinausgehen, ermöglicht LangChain es Ihnen, eigene Middleware zu schreiben und benutzerdefiniertes Verhalten für Schutzmechanismen einzubinden.

Zwei Lebenszyklus-Hooks sind zu diesem Zweck besonders nützlich:

beforeAgent
afterAgent

Diese Hooks bieten Ihnen die Möglichkeit, Schutzmechanismen zu bestimmten Zeitpunkten während des Laufs eines Agenten einzubringen.

1. Schutzmechanismen vor dem Agenten

Ein beforeAgent-Hook wird zu Beginn jeder Agentenaufrufung ausgelöst. Sie können ihn nutzen, um einen Schutzmechanismus vor dem Agenten zu erstellen, der eine eingehende Anfrage überprüft oder filtert, bevor der Agent überhaupt mit ihrer Verarbeitung beginnt.

Typische Anwendungsfälle sind:

• Authentifizierung
• Rate Limiting
• Eingabefilterung
• Ablehnen unangemessener Anfragen
• Prüfungen, die auf einer Sitzung beschränkt sind

Hier ist eine Veranschaulichung:

import { createMiddleware, AIMessage } from "langchain";

const sensitiveDataFilterMiddleware = (sensitiveKeywords: string[]) => {
  const keywords = sensitiveKeywords.map((kw) => kw.toLowerCase());

  return createMiddleware({
    name: "SensitiveDataFilterMiddleware",

    beforeAgent: {
      hook: (state) => {
        // Check if messages exist
        if (!state.messages || state.messages.length === 0) {
          return;
        }

        // Get the first user message
        const firstMessage = state.messages[0];

        // Make sure the message is from the user
        if (firstMessage._getType() !== "human") {
          return;
        }

        const content = firstMessage.content.toString().toLowerCase();

        // Check for sensitive keywords
        for (const keyword of keywords) {
          if (content.includes(keyword)) {
            // Stop the agent before it starts processing
            return {
              messages: [
                new AIMessage(
                  "I cannot process requests containing sensitive information. " +
                  "Please remove passwords, API keys, or secrets and try again."
                ),
              ],
              jumpTo: "end",
            };
          }
        }

        // No sensitive content found
        return;
      },

      canJumpTo: ["end"],
    },
  });
};


// Create the agent
import { createAgent } from "langchain";

const agent = createAgent({
  model: "gpt-5.5",
  tools: [searchTool, calculatorTool],

  middleware: [
    sensitiveDataFilterMiddleware([
      "password",
      "api_key",
      "secret",
      "private_key",
    ]),
  ],
});


// This request will be blocked
const result = await agent.invoke({
  messages: [
    {
      role: "user",
      content: "Show me how to store my production password securely.",
    },
  ],
});

console.log(result);

Ablauf:

                         User Request
                              │
                              ▼
                  ┌──────────────────────┐
                  │   beforeAgent Hook   │
                  │                      │
                  │ Check user message   │
                  │ for sensitive words │
                  └──────────┬───────────┘
                             │
                             ▼
                    ┌─────────────────┐
                    │ Sensitive       │
                    │ keyword found?  │
                    └───────┬─────────┘
                            │
                   ┌────────┴────────┐
                   │                 │
                  YES                NO
                   │                 │
                   ▼                 ▼
        ┌──────────────────┐   ┌──────────────┐
        │ Return blocked   │   │ Continue to  │
        │ AIMessage        │   │ the agent    │
        └────────┬─────────┘   └───────┬──────┘
                 │                     │
                 ▼                     ▼
          jumpTo: "end"          Agent executes
                 │                     │
                 ▼                     ▼
           Final Response        Final Response

Wenn dieser Hook aktiv ist, wird eine problematische Anfrage gestoppt, bevor der Agent die Möglichkeit hat, Tools auszuführen oder aufzurufen.

2. Schutzmechanismen nach dem Agenten

Ein afterAgent-Hook wird ausgelöst, nachdem der Agent seine Arbeit abgeschlossen hat. Er ermöglicht es Ihnen, einen Schutzmechanismus nach dem Agenten zu implementieren, der die endgültige Antwort des Agents überprüft oder filtert, bevor sie beim Benutzer ankommt.

Übliche Anwendungen sind:

• Sicherheitsprüfungen
• Überprüfung der Ausgabqualität
• Konformitätsprüfungen
• Filtern der Ausgabe
• Bewertung durch ein anderes Modell

Zum Beispiel könnte man die Antwort durch ein zweites Modell leiten, dessen einzige Aufgabe es ist, sie zu bewerten:

import {
  createMiddleware,
  AIMessage,
  initChatModel,
} from "langchain";

const toxicityGuardrailMiddleware = () => {
  // Model used only for toxicity evaluation
  const evaluatorModel = initChatModel("gpt-5.4-mini");

  return createMiddleware({
    name: "ToxicityGuardrailMiddleware",

    afterAgent: {
      hook: async (state) => {
        // Get the final AI response
        if (!state.messages || state.messages.length === 0) {
          return;
        }

        const lastMessage =
          state.messages[state.messages.length - 1];

        if (lastMessage._getType() !== "ai") {
          return;
        }

        const response = lastMessage.content.toString();

        // Ask the evaluator model to check for toxicity
        const evaluationPrompt = `
You are a toxicity detection system.

Analyze the following AI response and determine
whether it contains toxic, abusive, hateful, or
harassing language.

Respond with ONLY:
SAFE
or
TOXIC

AI response:
${response}
`;

        const evaluation = await evaluatorModel.invoke([          {            role: "user",            content: evaluationPrompt,          },        ]);

        const result = evaluation.content
          .toString()
          .trim()
          .toUpperCase();

        // Replace the response if it is toxic
        if (result === "TOXIC") {
          return {
            messages: [
              new AIMessage(
                "I'm unable to provide that response because it contains inappropriate language."
              ),
            ],
            jumpTo: "end",
          };
        }

        return;
      },

      canJumpTo: ["end"],
    },
  });
};


// Create the agent
import { createAgent } from "langchain";

const agent = createAgent({
  model: "gpt-5.5",

  tools: [
    searchTool,
    calculatorTool,
  ],

  middleware: [
    toxicityGuardrailMiddleware(),
  ],
});


// Invoke the agent
const result = await agent.invoke({
  messages: [
    {
      role: "user",
      content: "Give me a response to this angry customer.",
    },
  ],
});

console.log(result);

User
 ↓
Main Agent (GPT-5.5)
 ↓
Generates response
 ↓
afterAgent hook
 ↓
Evaluator Model (GPT-5.4-mini)
 ↓
┌───────────────┐
│ Is it toxic?  │
└───────┬───────┘
        │
    ┌───┴───┐
    ↓       ↓
  SAFE     TOXIC
    ↓       ↓
Return    Replace
response  response

Die wichtigste Erkenntnis hier ist, dass man der Ausgabe des Agenten niemals automatisch vertrauen sollte. Stattdessen sendet man die erzeugte Antwort an ein Bewertungsmodell, dessen Aufgabe es ist, sie vor der Rückgabe an den Benutzer gegen Ihre Sicherheitskriterien zu überprüfen.

Kombination mehrerer Schutzmechanismen

In der Praxis reicht ein einziger Schutzmechanismus selten aus für eine Anwendung in der realen Welt.

Verschiedene Phasen der Ausführung eines Agenten erfordern unterschiedliche Arten von Schutzmaßnahmen. Betrachten Sie diese Abfolge:

1. Input filtering
2. PII protection
3. Tool approval
4. Output safety check

LangChain ermöglicht es, mehrere Middleware-Komponenten gleichzeitig an einen einzigen Agenten anzuhängen.

Hier ist ein Beispiel:

const agent = createAgent({
  model: "gpt-5.5",
  tools: [
    searchTool,
    sendEmailTool,
  ],
  middleware: [
    // 1. Before-agent guardrail for input filtering
    sensitiveDataFilterMiddleware([
      "password",
      "api_key",
      "secret",
      "private_key",
    ]),
    // 2. Built-in PII protection middleware
    piiRedactionMiddleware({
      piiType: "email",
      strategy: "redact",
      applyToInput: true,
      applyToOutput: true,
    }),
    // 3. Built-in Human approval middleware for sensitive tools
    humanInTheLoopMiddleware({
      interruptOn: {
        send_email: {
          allowAccept: true,
          allowEdit: true,
          allowRespond: true,
        },
      },
    }),
    // 4. After-agent guardrail
    toxicityGuardrailMiddleware(),
  ],
});

Jede Middleware-Schicht ist dafür verantwortlich, einen bestimmten Teil des Ausführungspfades des Agenten zu schützen.

Insgesamt sieht der Gesamtfluss so aus:

                         User Request
                              │
                              ▼
                  ┌──────────────────────┐
                  │ Before-agent         │
                  │ guardrail            │
                  │                      │
                  │ Input filtering      │
                  └──────────┬───────────┘
                             │
                             ▼
                  ┌──────────────────────┐
                  │ PII protection       │
                  │                      │
                  │ Redact sensitive     │
                  │ information          │
                  └──────────┬───────────┘
                             │
                             ▼
                         AI Agent
                             │
                             ▼
                       Tool call?
                        /       \
                      No         Yes
                      │           │
                      │           ▼
                      │    ┌───────────────┐
                      │    │ Human approval│
                      │    └───────┬───────┘
                      │            │
                      │       ┌────┴────┐
                      │       │         │
                      │    Approved   Rejected
                      │       │         │
                      │       ▼         ▼
                      │   Execute      Stop
                      │       │
                      └───────┤
                              ▼
                       Agent response
                              │
                              ▼
                  ┌──────────────────────┐
                  │ After-agent          │
                  │ guardrail            │
                  │                      │
                  │ Toxicity check       │
                  │ using evaluator model│
                  └──────────┬───────────┘
                             │
                        ┌────┴────┐
                        │         │
                       SAFE      TOXIC
                        │         │
                        ▼         ▼
                   Return      Replace
                   response    response

Das erzeugt eine schichtweise Verteidigungsstrategie für den Agenten.

Die Kernidee ist, dass jede Schutzmaßnahme für einen anderen Kontrollpunkt zuständig ist:

• Die vor dem Agenten liegende Schutzmaßnahme validiert die eingehende Anfrage.
• Die PII-Middleware schützt sensible Daten.
• Die Überprüfung durch einen Menschen blockiert risikoreiche Tool-Aufrufe, bis eine Person sie genehmigt.
• Die nach dem Agenten liegende Schutzmaßnahme prüft die endgültige Antwort, bevor sie den Benutzer erreicht.

Anstatt sich auf ein einzelnes Sicherheitsmechanismus zu verlassen, werden mehrere Schichten übereinander geschichtet, damit der Agent in jeder Phase umfassender geschützt wird.

Sicherheitsmaßnahmen dienen nicht nur der Sicherheit

Wenn Menschen den Begriff „Sicherheitsmaßnahmen“ hören, stellen sie sich in der Regel das Blockieren schädlichen oder anstößigen Inhalts vor.

In Produktionsystemen dienen Sicherheitsmaßnahmen jedoch auch dazu, Geschäftslogik sowie anwendungsbezogene Richtlinien durchzusetzen.

Zum Beispiel:

Customer support agent

Can:
✓ Search orders
✓ Check delivery status

Cannot:
✗ Refund more than ₹10,000
✗ Delete customer account
✗ Change payment details

Diese Regeln haben nichts mit der Erkennung schädlichen Inhalts zu tun.

Sie stellen Anwendungsrichtlinien dar, die die Grenzen definieren, was der Agent tun darf.

Da ein LLM Entscheidungen zur Laufzeit dynamisch trifft, benötigt man einen zuverlässigen Durchsetzungspunkt für Regeln, die unabhängig von den Entscheidungen des Modells gelten müssen.

Hinweis: Das LLM entscheidet selbst, was es tun möchte; die Schutzmechanismen bestimmen hingegen, was die Anwendung ihm tatsächlich erlaubt.

Fazit

Der Aufbau eines KI-Agenten beinhaltet mehr als nur die Verbindung eines LLMs mit einigen Werkzeugen.

Sobald dieser Agent echte Benutzeranfragen bearbeitet und auf reale Systeme zugreift, sind klare Grenzen für sein Verhalten notwendig. Genau diese Rolle übernehmen die Schutzmechanismen.

LangChain stellt dazu mehrere Bausteine zur Verfügung:

• Deterministische Schutzmechanismen für Regeln, die vorhersagbar sein müssen
• modellbasierte Schutzmechanismen für Überprüfungen, die auf Bedeutung und Kontext angewiesen sind
• PII-Middleware zur Handhabung sensibler Informationen
• Middleware mit menschlicher Einmischung für Aktionen mit echten Konsequenzen
• Before-Agent-Middleware für Eingab- und Sitzungsebene-Überprüfungen
• After-Agent-Middleware zur Validierung der endgültigen Ausgabe

Mehrere Middleware-Schichten in Kombination zur tiefen Absicherung

Die wichtigste Lektion aus all dem ist: Verlassen Sie sich nicht allein auf das LLM, um die Regeln Ihrer Anwendung durchzusetzen.

Lassen Sie das Modell für das Denken und Entscheiden zuständig sein, aber bewahren Sie die wirklich wichtigen Grenzen in Code und Middleware auf, wo Sie sie direkt überprüfen und validieren können.

Dadurch wird ein KI-Agent zu etwas Zuverlässigem für eine echte Produktionsumgebung.

Referenzen

• Der offizielle LangChain-Leitfaden zu Guardrail-Konzepten, verfügbar unter https://docs.langchain.com/oss/javascript/langchain/guardrails
• Die offizielle LangChain-Dokumentation, die erklärt, wie Middleware im Allgemeinen funktioniert, verfügbar unter https://docs.langchain.com/oss/javascript/langchain/middleware/overview

Zusätzliche Literatur

• Erstellung eines lokalen Angry Birds-Klons mit Qwen3.8-27B und Pi — Lernen Sie, wie man mithilfe von LM Studio und dem Pi-Agenten einen vollständig lokalen AI-Entwicklungsworkflow einrichtet, um mit Qwen3.8-27B ein spielbares Angry Birds-Niveau zu erstellen.
• Strukturelle Schutzmechanismen für AI-Agenten: Ein Blick in den ResolveFlow-Pipeline — Erklärt, wie ein auf LangGraph basierender Agent durch Prüfungen auf Codeebene statt durch Prompt-Anweisungen eine Trennung zwischen Logikverarbeitung und Ausführung gewährleistet, einschließlich eines auftretenden Abruffehlers im Laufe des Prozesses.

Selbsthostung des LangGraph Agent Servers mit Postgres und Redis — Erfahren Sie, wie Langhost die Persistenzschicht von LangGraph durch Postgres und Redis ersetzt und Teams ermöglicht, den unveränderten Agent Server unter einer MIT-Lizenz selbst zu hosten.

Erstellung einer typsicheren GraphQL-API mit Prisma und Nexus in Node.js — Folgen Sie einer sieben Schritte umfassenden Anleitung zur Erstellung einer Node.js GraphQL-API, die das Datenmodell von Prisma mit von Nexus generierten Typen und Resolvern vereint.

Ein AI-Agent von Grund auf erstellen: Muster, ReAct und LangGraph — Erlernen Sie die grundlegenden Konzepte hinter AI-Agenten – Planung, Werkzeugnutzung, Reflexion sowie das ReAct-Muster – und wie LangChain und LangGraph bei der manuellen Erstellung eines solchen Agenten helfen.