LangChain-Agenten mit Execlave in 10 Minuten regieren

Dies ist ein funktionsfähiges Tutorial mit copy-paste-fähigem Code. Am Ende verfügen Sie über Richtliniendurchsetzung, unveränderliche Audit-Trails und Kill Switches für jeden LangChain-Agenten. Python- und TypeScript-Beispiele sind enthalten.

Was Sie aufbauen

Einen LangChain-Agenten, der:

• Jeden LLM-Aufruf, jeden Tool-Aufruf und jeden Retriever-Treffer in einem zentralen Dashboard protokolliert
• Richtlinien vor der Ausführung von Tool-Aufrufen durchsetzt (Allowlists, Kostenlimits, PII-Erkennung)
• Die Ausführung blockiert, wenn ein Richtlinienverstoß erkannt wird
• Compliance-fähige Audit-Trails mit kryptografischer Verifikation erstellt
• Per Fernzugriff über Dashboard oder Slack pausiert oder gestoppt werden kann

All das geschieht in der Callback-Schicht — Ihre bestehende Chain-Logik bleibt unverändert.

Voraussetzungen

• Ein Execlave-Konto mit einem API-Key (kostenloser Tarif verfügbar)
• Ein registrierter Agent in Execlave (erstellen Sie einen in Dashboard → Agents)
• LangChain >=0.3 (Python) oder @langchain/core >=0.3 (JS)

Schritt 1: SDK mit LangChain-Extra installieren (2 Minuten)

Die LangChain-Integration ist ein optionales Extra, sodass das Standard-SDK LangChain nicht als transitive Abhängigkeit einbindet.

Python

pip install 'execlave-sdk[langchain]'

TypeScript

npm install @execlave/sdk @langchain/core

Fügen Sie Ihren API-Key zur Umgebung hinzu:

# .env
EXECLAVE_API_KEY=exe_live_...

Schritt 2: Callback-Handler erstellen (2 Minuten)

Ein Handler verbindet Execlave mit jedem Callback, den LangChain ausgibt. Erstellen Sie ihn einmal beim App-Start und verwenden Sie ihn über Anfragen hinweg wieder.

Python

from execlave import Execlave
from execlave.integrations.langchain import ExeclaveCallbackHandler
import os

exe = Execlave(api_key=os.environ["EXECLAVE_API_KEY"])
handler = ExeclaveCallbackHandler(exe, agent_id="support-bot")

TypeScript

import { Execlave } from '@execlave/sdk';
import { ExeclaveCallbackHandler } from '@execlave/sdk/integrations/langchain';

const exe = new Execlave({ apiKey: process.env.EXECLAVE_API_KEY! });
const handler = new ExeclaveCallbackHandler(exe, { agentId: 'support-bot' });

Wichtig: Verwenden Sie die agent_id / agentId aus Ihrem Execlave-Dashboard, nicht die Rolle oder den Namen des LangChain-Agenten.

Schritt 3: An Ihre Chain anhängen (1 Minute)

Übergeben Sie den Handler über das Feld callbacks, wenn Sie aufrufen oder streamen. Wenn Sie bereits Callbacks haben, fügen Sie den Execlave-Handler hinzu — ersetzen Sie die bestehenden nicht.

Python

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([("user", "{question}")])
llm = ChatOpenAI(model="gpt-4o-mini")
chain = prompt | llm

# Durchsetzung läuft beim Chain-Start und bei jedem Tool-Aufruf
answer = chain.invoke(
    {"question": "Summarize our Q3 pipeline"},
    config={"callbacks": [handler]},
)

TypeScript

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';

const prompt = ChatPromptTemplate.fromMessages([['user', '{question}']]);
const chain = prompt.pipe(new ChatOpenAI({ model: 'gpt-4o-mini' }));

const answer = await chain.invoke(
  { question: 'Summarize our Q3 pipeline' },
  { callbacks: [handler] },
);

Das war es. Jeder LLM-Aufruf, jeder Tool-Aufruf und jede Retriever-Abfrage wird ab sofort verfolgt und durchgesetzt.

Schritt 4: Erste Richtlinie erstellen (3 Minuten)

Erstellen Sie im Execlave-Dashboard eine Richtlinie, um zu steuern, was Ihr Agent tun darf. Hier ist eine Tool-Allowlist, die nur bestimmte Tools erlaubt:

{
  "name": "Support Bot Tool Allowlist",
  "policyType": "tool_allowlist",
  "config": {
    "allowedTools": ["search_knowledge_base", "create_ticket"]
  },
  "enforcementMode": "block",
  "severity": "high"
}

Wenn der Agent versucht, ein anderes Tool aufzurufen, löst die Chain einen PolicyBlockedError aus, bevor das Tool ausgeführt wird.

Schritt 5: Richtlinienblockierungen behandeln (2 Minuten)

Wrappen Sie Ihren Chain-Aufruf in try/catch, um Richtlinienverstöße elegant zu behandeln:

Python

from execlave.errors import PolicyBlockedError

try:
    answer = chain.invoke({"question": user_input}, config={"callbacks": [handler]})
except PolicyBlockedError as exc:
    # exc.violations enthält die gematchten Richtlinien
    return {
        "error": "Diese Aktion wurde durch eine Richtlinie blockiert",
        "violations": exc.violations
    }

TypeScript

import { PolicyBlockedError } from '@execlave/sdk';

try {
  const answer = await chain.invoke({ question: userInput }, { callbacks: [handler] });
} catch (err) {
  if (err instanceof PolicyBlockedError) {
    return {
      error: 'Diese Aktion wurde durch eine Richtlinie blockiert',
      violations: err.violations,
    };
  }
  throw err;
}

Was Sie gerade aufgebaut haben

In unter 10 Minuten haben Sie hinzugefügt:

• Vollständige Ausführungs-Traces: Jeder LLM-Aufruf, jeder Tool-Aufruf, jeder Agenten-Schritt und jede Retriever-Abfrage protokolliert mit Eingabe, Ausgabe, Latenz und Kosten
• Runtime-Richtliniendurchsetzung: Tool-Allowlists, Kostenbudgets, PII-Erkennung und Prompt-Injection-Scanning — alles vor der Ausführung ausgewertet
• Compliance-fähiger Audit-Trail: Append-only, kryptografisch signierte Logs, die für 1+ Jahre aufbewahrt werden
• Kill Switches: Jeden Agenten vom Dashboard oder Slack aus pausieren oder stoppen

Und das alles, ohne eine einzige Zeile Ihrer Chain-Logik zu ändern — Sie haben lediglich einen Callback-Handler hinzugefügt.

Nächste Schritte

• Weitere Richtlinientypen hinzufügen: Kostenlimits, Rate-Kontrollen, Content-Filterung, zeitbasierte Einschränkungen (Richtlinien-Referenz)
• Freigabe-Workflows einrichten: Risikoreiche Aktionen durch Human-in-the-Loop-Gates leiten (require_approval Modus)
• Compliance-Berichte exportieren: Signierte Audit-Pakete für SOC 2, EU AI Act oder ISO 27001 erstellen (Compliance-Seite)
• Alerts an Slack weiterleiten: Benachrichtigt werden, wenn Richtlinien verletzt oder Budgets überschritten werden (Dokumentation)

Häufige Fragen

Verlangsamt das meinen Agenten?

Nein. Die Richtlinienauswertung läuft in <20 ms p50 (sub-Millisekunde für gecachte Entscheidungen). Der Callback-Handler ist asynchron, sodass das Tracing Ihre Chain nicht blockiert.

Was passiert, wenn Execlave ausfällt?

Das SDK versagt standardmäßig auf „offen“ (fail open) — wenn die Enforcement-API nicht erreichbar ist, läuft Ihre Chain weiter und protokolliert eine Warnung. Sie können den Fail-Closed-Modus konfigurieren, wenn Sie das bevorzugen.

Kann ich das mit Agenten verwenden, die Tools haben?

Ja. Der Callback-Handler erkennt automatisch Tool-Aufrufe und setzt Richtlinien vor jedem Tool-Aufruf durch. Das ist der primäre Anwendungsfall.

Funktioniert das mit LangGraph?

Ja. LangGraph basiert auf LangChain-Callbacks, sodass derselbe Handler funktioniert. Jeder Knoten in Ihrem Graphen wird zu einem Span im Trace.

Vollständiges Arbeitsbeispiel

Ein vollständig ausführbares Beispiel mit einem Tool-aufrufenden Agenten finden Sie in der LangChain-Integrationsdokumentation.