RAG-spezifische KI-Governance für LlamaIndex — automatische Policy-Checks für jeden LLM-Aufruf, jede Tool-Nutzung und (einzigartig) jeden abgerufenen Dokument-Chunk vor der Synthese.

LlamaIndex Integration

Fügen Sie einen Callback-Handler hinzu. Jeder LLM-Aufruf, jede Tool-Nutzung und einzigartig für RAG: jeder abgerufene Dokument-Chunk wird gegen Ihre Palveron-Policies geprüft. PII in einem Quelldokument gelangt nie still in das Kontextfenster Ihres Modells.

Installation

pip install palveron-llamaindex

Schnellstart

from llama_index.core import VectorStoreIndex, Settings, SimpleDirectoryReader
from llama_index.core.callbacks import CallbackManager
from palveron_llamaindex import PalveronCallbackHandler

handler = PalveronCallbackHandler(api_key="pv_live_xxx")
Settings.callback_manager = CallbackManager([handler])

documents = SimpleDirectoryReader("./kundendateien").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()

# PII in jedem abgerufenen Chunk → PalveronGovernanceError vor der Synthese
response = query_engine.query("Fasse die Kundendatei zusammen")

Was geprüft wird

Event	Wann	Was	Warum es wichtig ist
`LLM`	Vor jedem LLM-Aufruf	Prompt + Chat-Verlauf	Fängt Prompt-Injection / PII an der Modell-Grenze ab
`RETRIEVE`	Nach jedem Retrieval	Jeden abgerufenen Chunk einzeln	RAG-spezifisch: erkennt PII in Quelldokumenten vor der Synthese
`FUNCTION_CALL`	Vor jedem Tool-Aufruf	Tool-Name + Argumente	Verhindert, dass Agenten Tools mit sensiblen Argumenten aufrufen
`AGENT_STEP`	Jeder Agent-Reasoning-Schritt (opt-in)	Schritt-Inhalt	Audit-grade Nachvollziehbarkeit für ReActAgent / function-calling-Agenten

Die Retrieval-Prüfung ist das Alleinstellungsmerkmal. Alle anderen Adapter governieren LLM-I/O; LlamaIndex-Pipelines rufen aus einem Vektor-Index ab, der PII enthalten kann, die nie bereinigt wurde. Wir prüfen sie zum spätesten sicheren Zeitpunkt — nach dem Retrieval, vor der Synthese.

Konfiguration

handler = PalveronCallbackHandler(
    api_key="pv_live_xxx",
    base_url="https://gateway.internal.firma.de:8080",  # on-prem
    check_llm=True,              # LLM-Prompts prüfen (Standard)
    check_retrievals=True,       # abgerufene Chunks prüfen — RAG-spezifisch (Standard)
    check_tools=True,            # Tool-Inputs prüfen (Standard)
    check_agent_steps=False,     # Agent-Schritte prüfen (opt-in)
    fail_open=False,             # Bei Gateway-Ausfall blockieren (Enterprise-Standard)
    metadata={"team": "support", "index": "customer_kb"},
)

Retrieval-Postprocessor (Alternative)

Wenn Sie nur Governance auf Retrievals wollen (keine LLM-seitigen Checks), nutzen Sie den Postprocessor direkt auf einer Query Engine:

from palveron_llamaindex import PalveronNodePostprocessor

query_engine = index.as_query_engine(
    node_postprocessors=[PalveronNodePostprocessor(api_key="pv_live_xxx")],
)

# Oder Chunks, die modifiziert werden müssten, verwerfen statt eine Exception zu werfen
query_engine = index.as_query_engine(
    node_postprocessors=[
        PalveronNodePostprocessor(api_key="pv_live_xxx", drop_modified=True),
    ],
)

Agent-Tool

Registrieren Sie Palveron als explizites Tool, sodass ein ReActAgent Inhalte während des Reasonings verifizieren kann:

from llama_index.core.agent import ReActAgent
from palveron_llamaindex import palveron_verify_tool

agent = ReActAgent.from_tools(
    [
        palveron_verify_tool("pv_live_xxx"),
        search_tool,
        email_tool,
    ],
    verbose=True,
)

response = agent.chat("Entwirf eine Antwort an Max, dann verifiziere sie vor dem Senden")

Verhalten bei Entscheidungen

Entscheidung	Verhalten
`ALLOWED` / `PASSED`	Aufruf läuft weiter
`MODIFIED`	Aufruf läuft weiter; PII-Redaktion wird geloggt. (Für Retrievals bleibt der Original-Chunk erhalten — setzen Sie `drop_modified=True` zum Filtern.)
`FLAGGED`	Aufruf läuft weiter; Policy-Treffer wird geloggt
`BLOCKED`	Wirft `PalveronGovernanceError`
`PENDING_APPROVAL`	Wirft `PalveronGovernanceError` (zur menschlichen Freigabe eingereiht)
`RATE_LIMITED`	Wirft `PalveronGovernanceError` (Quota erreicht)

Governance-Records

print(f"Blockiert: {handler.blocked_count}")
print(f"Trace IDs: {handler.trace_ids}")

for record in handler.records:
    print(f"{record.event} [{record.surface}]: {record.decision} ({record.latency_ms:.0f}ms)")

Fehlerbehandlung

from palveron_llamaindex import PalveronCallbackHandler, PalveronGovernanceError

handler = PalveronCallbackHandler(api_key="pv_live_xxx")
Settings.callback_manager = CallbackManager([handler])

try:
    response = query_engine.query("Finde die Datei zur SSN 123-45-6789")
except PalveronGovernanceError as e:
    print(e.decision)   # "BLOCKED"
    print(e.trace_id)   # "trc_abc123"
    print(e.reason)     # "PII erkannt im abgerufenen Chunk customer_2024_03.txt"

Quellcode

Open Source (MIT): github.com/palveron/adapter-llamaindex.

Nächste Schritte

Eigene Policies erstellen für Ihre RAG-Pipelines
Google ADK Integration für multimodale Agenten
Pydantic AI Integration für typsichere Agent-Governance

LlamaIndex

On this page