Iris

Iris — Schluss mit Agenten nach Bauchgefühl

Iris bewertet jeden Agentenlauf nach Qualität, Sicherheit und Kosten – auf deinem Rechner, ohne SDK und ohne Konto. Die meisten Agent-Projekte prüfen die Qualität, indem sie ein paar gespeicherte Prompts ausführen und die Ausgabe überfliegen. Iris ersetzt das durch Zahlen, die du prüfen kannst: Die Läufe deines Agenten landen in einer SQLite-Datenbank auf deiner Festplatte, 25 eingebaute Regeln bewerten sie deterministisch – PII, Prompt-Injection, Halluzinationsmarker, Kostenschwellen und die eigenen Tool-Aufrufe des Agenten – kostenlos, ohne LLM-Aufrufe, und ein optionaler LLM-Richter mit einer harten Kostenobergrenze pro Bewertung übernimmt die semantischen Fragen. Jede Regel ist einsehbar und bearbeitbar, denn ein Richter, den du nicht prüfen kannst, ist nur Bauchgefühl mit einer Zahl darauf. MIT-lizenziert, keine Telemetrie. Nichts verlässt deinen Rechner, es sei denn, du aktivierst eine dieser Optionen: einen OpenTelemetry-Endpunkt (IRIS_OTEL_ENDPOINT), der Traces an den von dir benannten Collector exportiert; den LLM-Richter mit deinem eigenen Schlüssel, der den zu bewertenden Text an diesen Anbieter sendet und dessen Zitatprüfung die Seiten abruft, die eine Ausgabe zitiert; oder einen Webhook, der IDs, das Urteil und Regelnamen – niemals den Text – an die von dir festgelegte Adresse sendet.

Erfordert Node.js 22.13 oder neuer. Überprüfen mit node --version.

_{Die Demo-Datenbank, aufgezeichnet von scripts/demo-media.mts; die Quelle ist demo.mp4. Ein Standbild: dashboard-overview.png.}

Ein Fehler in 60 Sekunden auf dem Bildschirm

Keine Agent-Verdrahtung, keine Konfiguration – ein Befehl:

npx @iris-eval/mcp-server --demo

Dies erzeugt eine Demo-Datenbank – fünf kleine Agenten, zwei Wochen Läufe, jedes Urteil von der Engine selbst – und stellt das Dashboard dagegen unter http://localhost:6920 (dein Browser öffnet sich beim ersten Lauf automatisch). Das Dashboard landet auf Failures: Was fehlgeschlagen ist, zuerst die schlimmsten und neuesten, jede Karte nennt die Regel und ihre Belege. Es lohnt sich, hineinzuklicken – ein PII-Leck, das von den Sicherheitsregeln erfasst wurde, eine versteckte Anweisung in einem Forenbeitrag, der der Zusammenfasser befolgt hat, eine Zahl, die das Quelldokument nie genannt hat, zwei Läufe mit denselben zwölf Fragen, verglichen mit einem Intervall (Runs), eine bereitgestellte benutzerdefinierte Regel und eine pausierte mit ihren Prüfzeilen sowie eine fehlgeschlagene LLM-Richter-Bewertung mit ihrer Begründung.

Die Demo-Daten leben in einer eigenen Datenbank (demo.db in deinem Iris-Home-Verzeichnis – ~/.iris auf macOS/Linux, %USERPROFILE%\.iris auf Windows) und vermischen sich nie mit deinen echten Traces. Entferne alles mit einem Befehl:

npx @iris-eval/mcp-server --demo-clear

Schließe deinen eigenen Agenten an

Prüfe zuerst, ob die Installation auf diesem Rechner funktioniert – sie läuft offline und öffnet nichts von dir:

npx @iris-eval/mcp-server --self-test   # exit 0 = healthy

Füge dann Iris zu deinem MCP-Client hinzu. Ein Befehl schreibt die eigene Konfigurationsdatei des Clients, behält jeden anderen Server darin und pinnt die Version, die du ausgeführt hast:

npx -y @iris-eval/mcp-server install claude-code

Die Clients: claude-code, claude-desktop, cursor, windsurf, continue, vscode, cline, zed, codex, gemini. install --list zeigt die auf diesem Rechner gefundenen, das Iris, das jeder ausführt, und die Datei, die er liest; install <client> --uninstall entfernt Iris wieder. Alle Clients teilen sich eine Datenbank, also verschiebe sie nach einem Upgrade alle auf einmal mit install --upgrade (Aktualisieren). Starte den Client neu, um ihn zu laden.

Claude Desktop: ein Klick. Jedes Release ab 0.20.0 enthält iris-eval.mcpb, ein MCP-Bundle: Lade das neueste herunter, öffne es, und Claude Desktop zeigt einen Installationsdialog. Nichts davon ist erforderlich – ein Anthropic- oder OpenAI-Schlüssel für den LLM-Richter ist optional, und das Dashboard ist ein Schalter, der ausgeschaltet startet. Das Bundle enthält das npm-Paket und seine Abhängigkeiten, sodass nichts anderes installiert werden muss: Claude Desktop führt es unter dem mitgelieferten Node aus, wenn dieser Node 22.13 oder neuer ist (Claude Desktop 1.1.6679 enthält 24.13), und Iris speichert Traces mit dem integrierten SQLite von Node, im selben ~/.iris, das jede andere Installation verwendet. Die Release-Notizen zeigen, wie du seine Signatur und Build-Attestierung überprüfen kannst.

Es läuft in jedem MCP-Client, und jeder Client, den es nennt, hat eine Zeile mit dem, was tatsächlich geprüft wurde. Verifiziert bei jedem CI-Lauf: Claude Code, Gemini CLI – der echte Client startet Iris aus der vom Installer geschriebenen Konfiguration und meldet, dass es verbunden ist (claude mcp list, gemini mcp list), auf Linux, macOS und Windows; die Capture-Plugin-Hooks von Claude Code werden ebenfalls über die echten Skripte gesteuert. Behauptet aus der eigenen MCP-Dokumentation jedes Clients – der Installer schreibt die Konfigurationsform, die der Client dokumentiert, und dieser Writer wird auf der Form getestet; niemand auf der Iris-Seite hat gesehen, wie es sich verbindet: Claude Desktop, Cursor, Devin Desktop (Windsurf), Continue, VS Code, Cline, Zed, OpenAI Codex CLI. Jede Zeile mit ihrer Quelle und dem Datum, an dem sie gelesen wurde: https://iris-eval.com/clients. Stattdessen von Hand, ein Block, Dashboard inklusive:

{
  "mcpServers": {
    "iris-eval": {
      "command": "npx",
      "args": ["-y", "@iris-eval/mcp-server", "--dashboard"]
    }
  }
}

Dein Client listet beim Verbinden die zwölf Tools von Iris auf, und das Dashboard wird unter http://localhost:6920. bereitgestellt. Füge jetzt Folgendes in deinen Agenten ein:

Protokolliere die letzte Aufgabe in Iris und bewerte die Ausgabe.

Der Trace landet mit seinen Bewertungen auf dem Dashboard. Bevorzugst du den MCP-Server ohne Kopf? Entferne --dashboard aus den Argumenten – du kannst dasselbe Dashboard jederzeit mit npx @iris-eval/mcp-server --dashboard öffnen.

Eine Sache, die du vorab wissen solltest: MCP-Tools werden aufgerufen, wenn das Modell entscheidet, sie aufzurufen. Iris greift nicht in deinen Agenten ein, also werden Traces protokolliert, wenn dein Agent darum bittet, sie zu protokollieren – entweder weil du es ihm gesagt hast oder weil dein Code die Tools direkt aufruft. Bitte deinen Agenten, „dies in Iris zu protokollieren und zu bewerten“, und er wird es tun. Wenn du eine Erfassung möchtest, die nicht davon abhängt, dass das Modell sich entscheidet, macht POST /api/v1/traces genau das – dein Code sendet den Trace über einfaches HTTP, ohne Modell in der Schleife (siehe docs/http-ingest.md). Die CLI- und Host-Hooks auf der Roadmap werden dünne Clients über denselben Endpunkt sein.

Erfassung über HTTP (ohne Modell in der Schleife)

Der Ingest-Endpunkt liegt auf dem Dashboard-Port – 6920 standardmäßig, nicht auf dem MCP-Transport-Port – und existiert nur, während das Dashboard läuft. Übergib --dashboard (oder setze IRIS_DASHBOARD=true); --transport http allein startet es nicht, und eine Anfrage an den Transport-Port gibt 404 zurück. Wenn das Dashboard läuft, kann alles, was eine HTTP-Anfrage senden kann, einen Trace protokollieren – und optional die deterministischen Bewertungen in derselben Anfrage ausführen. GET /api/v1/capabilities auf demselben Port sagt, was dieser Server bewerten kann, was jede Regel benötigt, den Richterstatus mit den Schritten, die ihn aktivieren, und die Grenzen – dasselbe Objekt, das die MCP-Ressource iris://capabilities bereitstellt –, sodass ein HTTP-Aufrufer den Rahmen erhält, den ein MCP-Client bei der Initialisierung bekommt:

curl -s -X POST "http://127.0.0.1:6920/api/v1/traces" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_name": "support-bot",
    "input": "What is the refund policy?",
    "output": "Refunds are available within 30 days of purchase.",
    "evaluate": true,
    "eval_type": "safety"
  }'

Gibt 201 mit der gespeicherten trace_id und dem Bewertungsergebnis zurück (im --demo-Modus verweigert der Endpunkt Schreibvorgänge mit 403, damit sich Demo-Daten nie mit deinen vermischen). Der Endpunkt akzeptiert denselben Body wie das log_trace-Tool und sitzt hinter demselben Middleware-Stack wie der Rest des Dashboards: Loopback-Bindung und der DNS-Rebinding-Schutz standardmäßig, plus Bearer-Auth, wenn du eine festlegst. Zwei einfache Fakten dazu: Er akzeptiert unauthentifizierte Schreibvorgänge, es sei denn, Iris wurde mit --api-key (oder IRIS_API_KEY) gestartet – die Loopback-Bindung hält ihn standardmäßig auf deinem Rechner, also setze einen Schlüssel, bevor du über Loopback hinaus bindest; und was er speichert, ist wörtlich – input und output landen in iris.db genau wie gesendet, einschließlich jeglichen Textes, den no_pii anschließend markiert. Vollständiger Vertrag, Feldreferenz und Fehlersemantik: docs/http-ingest.md.

Jede Claude-Code-Runde erfassen (optional)

/plugin marketplace add iris-eval/mcp-server
/plugin install iris-eval-capture@iris-eval

Ein zweites, separat installiertes Plugin: Drei Hooks zeichnen den Prompt, die Tool-Aufrufe und die endgültige Antwort jeder Runde auf und übergeben sie an iris-eval ingest, abgetrennt, mit kritischen Spannen im gespeicherten Bewertungstext geschwärzt – Erfassung, die nicht davon abhängt, dass das Modell sich entscheidet, ein Tool aufzurufen. Es protokolliert nie eine Runde, die das Modell bereits protokolliert hat, druckt nie, blockiert nie, sendet nie etwas irgendwohin. Die Installation von iris-eval allein ändert nichts an deiner Runden-Schleife. Grenzen und Entfernung: claude-plugin-capture/README.md.

Python

pip install iris-eval

from iris_eval import IrisClient
iris = IrisClient()                       # IRIS_URL, or the running dashboard's runtime.json
iris.evaluate_output("…", input="…", agent_name="support-bot")["verdict"]   # {"state": "pass", "basis": "clean", "by": []}

Ein dünner Client über die HTTP-API von Server 0.16.0 und später, eigenständig versioniert – iris_eval.__version__ und die PyPI-Seite tragen seine Nummer, die nicht die des Servers ist: log_trace(), evaluate_output(), get_traces(), get_trace(), health(), capabilities(), synchron und asynchron, typisierte Antworten, der eigene Satz des Servers bei einer Ablehnung – und ein pytest-Plugin: eine iris-Fixture und assert_iris(output, expect="pass"), das auf den Zustand des Urteils prüft. packages/python/README.md.

Jeden OpenAI- und Anthropic-Aufruf aufzeichnen

from iris_eval import wrap_openai
client = wrap_openai(OpenAI(), agent_name="support-bot")   # every call: a GenAI span to POST /v1/traces, scored

import { wrapOpenAI } from '@iris-eval/sdk';
const openai = wrapOpenAI(new OpenAI(), { agentName: 'support-bot' });

Umschließe den Provider-Client einmal, und jeder Modellaufruf wird zu einem OpenTelemetry-GenAI-Span, der an die OTLP-Tür gesendet, mit Eingabe, Ausgabe, Token-Nutzung und Tool-Aufrufen gespeichert und bewertet wird: Erfassung, die nicht davon abhängt, dass das Modell ein Tool aufruft. wrap_openai / wrap_anthropic im Python-Client; wrapOpenAI, wrapAnthropic und irisMiddleware für das Vercel AI SDK in @iris-eval/sdk. Beide sind noch nicht veröffentlicht (das nächste iris-eval-Release auf PyPI; @iris-eval/sdk wird aus dem Quellcode gebaut, bis sein erstes npm-Release). Streams, die Stream-Helfer der SDKs und Tool-Aufrufe sind abgedeckt, der ursprüngliche Client wird nicht geändert, und ein Ausfall von Iris unterbricht nie einen Aufruf – packages/sdk/README.md, packages/python/README.md.

Jeden LangChain- und LangGraph-Lauf bewerten

from iris_eval.langchain import IrisCallbackHandler
graph.invoke(inputs, config={"callbacks": [IrisCallbackHandler(agent_name="support-bot")]})

Jeder Top-Level-Lauf wird zu einem Trace (der Lauf, seine Modellaufrufe, seine Tool-Aufrufe und seine Graph-Knoten als GenAI-Spans) mit Eingabe, Ausgabe, Tool-Aufrufen, Token-Nutzung und einem Urteil. Python im Client (nächstes Release, noch nicht auf PyPI veröffentlicht), JavaScript als @iris-eval/langchain (noch nicht auf npm veröffentlicht). Beide sind in CI gegen eine echte LangGraph-App mit einem skriptgesteuerten Modell bewiesen; der eigene OpenTelemetry-Export von LangSmith ist auf dieselbe Weise bewiesen – docs/otel-recipes.md.

Ein CI-Gate, kein Server nötig

npx -y @iris-eval/mcp-server ingest --file traces.ndjson --evaluate --fail-on detector_veto

Oder die GitHub Action (0.16.0), die den Job bei den von dir benannten Urteilen fehlschlagen lässt, die Quittung in die Job-Zusammenfassung schreibt und sie als einen an Ort und Stelle aktualisierten Pull-Request-Kommentar postet: uses: iris-eval/mcp-server/.github/actions/gate@v0.19.0 mit traces: traces.ndjson – docs/ci-gate.md. Eine vierte Tür (0.15.0): POST /v1/traces auf dem Dashboard-Port nimmt das OTLP/HTTP-JSON oder -Protobuf entgegen, das Ihre OpenTelemetry-Instrumentierung bereits emittiert (der Exporter des Python-SDK spricht nur Protobuf, also ist dies auch die Python-Tür), und jede OTLP-Spur wird zu einer Iris-Spur mit ihren Spans — docs/otel-integration.md; ein Rezept pro Framework (Pydantic AI, Google ADK, LangGraph über LangSmith, CrewAI, das OpenAI Agents SDK in Python und JavaScript, LlamaIndex, AutoGen, Microsoft Agent Framework, Semantic Kernel, das Vercel AI SDK und Mastra), jedes durch eine Fixture belegt, in docs/otel-recipes.md. ingest liest eine JSON-Spur (oder NDJSON, eine pro Zeile) von stdin oder einer Datei, speichert sie, bewertet sie unter genau den Regeln, die evaluate_output ausführt, gibt eine JSON-Zeile pro Spur mit dem Urteil und seiner Grundlage aus und beendet sich mit 1, wenn ein Urteil mit --fail-on übereinstimmt. --dataset <id|label> beschränkt dieses Tor auf die Fallschlüssel in einem Datensatz (POST /api/v1/datasets befördert die Fallschlüssel eines Laufs in einen), sodass ein Job nur bei den von Ihnen gewählten Fällen fehlschlägt. Das vollständige Rezept, die Exit-Codes und die acht Grundlagen finden Sie in docs/ci-gate.md.

Eine Regel als Code schreiben

eval.plugins in config.json lädt Regeln, die Sie geschrieben haben — ein ES-Modul, dessen Standardexport { name, kind, mechanism, version, needs, evaluate(ctx) } ist — fixiert durch den sha256 der Datei, sodass eine Datei, die sich seit der Fixierung geändert hat, den Start verweigert, anstatt zu laufen. Ein geladenes Plugin feuert wie ein eingebautes und erscheint auf list_rules unter plugins. Der Vertrag, das Hash-Rezept und was ein Plugin zurückgeben darf: docs/plugins.md.

Die Engine im eigenen Prozess verwenden

Die Bewertungs-Engine ist importierbar — kein Server, keine Datenbank, kein Modell:

import { EvalEngine, defaultConfig } from '@iris-eval/mcp-server/engine';

const engine = new EvalEngine(defaultConfig.eval.defaultThreshold, defaultConfig.eval.ruleThresholds, defaultConfig.eval);
const result = await engine.evaluateAll({ output: answer, input: prompt, toolCalls, costUsd });
result.verdict.state;       // 'pass' | 'fail' | 'unknown', with result.verdict.basis and result.interpretations

Dieselbe Engine, dieselben Regeln und derselbe Composer, den der Server ausführt; builtInRules(), createCustomRule(), compose() und die Leser für die veröffentlichte Genauigkeit werden daneben exportiert.

Ein typisierter Client für die HTTP-Route

import { createClient } from '@iris-eval/mcp-server/client';

const iris = createClient({ baseUrl: 'http://127.0.0.1:6920', apiKey: process.env.IRIS_API_KEY });
const { trace_id, evaluation } = await iris.logTrace({ agent_name: 'support-bot', input, output, tool_calls, evaluate: true });
evaluation?.verdict?.state;  // the same object evaluate_output returns

Ein Body auf jeder Tür: Es ist das, was log_trace und iris-eval ingest akzeptieren. Eine Ablehnung wirft IrisClientError mit dem eigenen Satz und Status des Servers. Beide Unterpfade werden bei jedem Build aus einem gepackten Tarball geprüft.

Ihre Installation verifizieren

npx @iris-eval/mcp-server --self-test   # offline diagnostic; exit 0 = healthy, 1 = a check failed
npx @iris-eval/mcp-server --version     # prints the bare version, e.g. 1.2.3

--self-test erstellt zuerst Ihr Iris-Home, falls es fehlt, und prüft, ob es beschreibbar ist (Exit 1, mit Nennung des Pfads, wenn nicht), meldet, wo sich der Suchindex Ihrer Datenbank befindet (vollständig, wie viele Spuren ein Hintergrund-Build bisher indexiert hat, oder kein FTS5 auf diesem SQLite), liest das Schema Ihrer Datenbank (Exit 1, mit der Lösung, wenn diese Version oder ein MCP-Client, der auf eine ältere Version fixiert ist, sie nicht öffnen kann), und führt dann seine Prüfungen aus — Speicher-Roundtrip, eine gepflanzte SSN und eine gepflanzte Injektion, die von den Sicherheitsregeln erkannt werden, Dashboard-Start, der DNS-Rebinding-Schutz — in einem isolierten temporären Home. Ihre echte Datenbank wird nur gelesen, nie geändert. Alles, was Iris schreibt, lebt unter einem Verzeichnis, Ihrem Iris-Home: ~/.iris standardmäßig (%USERPROFILE%\.iris unter Windows) oder wo auch immer IRIS_HOME zeigt. Dort liegen iris.db, config.json, custom-rules.json, audit.log, preferences.json und die Demo-Dateien; zeigen Sie IRIS_HOME auf ein Scratch-Verzeichnis, um Iris auszuprobieren, ohne Ihre echten Daten anzufassen.

claude mcp add --transport stdio iris-eval -- npx -y @iris-eval/mcp-server

{
  "servers": {
    "iris-eval": {
      "command": "npx",
      "args": ["-y", "@iris-eval/mcp-server"]
    }
  }
}

{
  "context_servers": {
    "iris-eval": {
      "command": "npx",
      "args": ["-y", "@iris-eval/mcp-server"],
      "env": {}
    }
  }
}

[mcp_servers.iris-eval]
command = "npx"
args = ["-y", "@iris-eval/mcp-server"]

Andere Installationsmethoden

# Global install (recommended for persistent data and faster startup)
npm install -g @iris-eval/mcp-server
iris-eval --dashboard

# Docker — two servers, two ports: 3000 = MCP HTTP transport,
# 6920 = dashboard (which also serves the POST /api/v1/traces ingest endpoint).
# The image binds 0.0.0.0 inside the container, so a key is required (see Production).
# The volume is the Iris home: the database, deployed rules and audit log persist in it.
docker run -p 3000:3000 -p 6920:6920 -v iris-data:/data \
  -e IRIS_API_KEY="$(openssl rand -hex 32)" ghcr.io/iris-eval/mcp-server

Tipp: Globale Installation (npm install -g) speichert Spuren dauerhaft unter ~/.iris/iris.db. Mit npx bleiben Spuren am selben Ort erhalten, aber der Start ist aufgrund der Paketauflösung langsamer.

Was Sie erhalten

Wohin das als Nächstes geht: die Fähigkeitskarte — jede Frage, die Iris zu jedem Thema gestellt werden kann, mit dem, was es hat und was ihm fehlt — und die drei Spuren.

Gemessen, nicht behauptet

Jede eingebaute Regel hat eine veröffentlichte Präzision, einen Recall und einen F1-Wert mit 95%-Konfidenzintervallen, gemessen an einem beschrifteten Korpus, der in diesem Repository liegt (proof/corpus/) und mit einem einzigen Befehl — npm run proof — offline neu generiert wird, ohne Schlüssel und ohne Modell im Prozess. Diese Zahlen sind von zwei verschiedenen Arten, und die Seite addiert sie nie: Einige Regeln werden gegen Beschriftungen gemessen, die ein Modell durch das Lesen des Fehlers selbst vergeben hat, was die Erkennung misst; die übrigen werden gegen ihre eigene dokumentierte Definition geprüft, die unabhängig angewendet wird, was zeigt, dass der Code seine Formel implementiert, aber nichts darüber aussagt, ob die Formel den Fehler erfasst. proof/RESULTS.md und die Beweisseite markieren jede Regel. CI führt die Messung bei jedem Pull-Request erneut aus und schlägt fehl, wenn die festgeschriebenen Zahlen von dem abweichen, was der Code produziert, sodass eine Regel sich nicht ändern kann, ohne dass sich ihre Zahlen mitändern. Die Zahlen stehen auf iris-eval.com/proof und in proof/RESULTS.md; wie der Korpus erstellt wurde, was er nicht ist und wie man ein Intervall liest, steht in docs/proof.md. Der Korpus ist synthetisch und modellbeschriftet — eine menschliche Blindbeschriftung steht aus, und die Seite sagt das; node proof/blind-sample.mjs zieht die reproduzierbare Stichprobe, die das klären wird.

MCP-Tools

Iris registriert zwölf Tools, die jeder MCP-kompatible Agent aufrufen kann — Trace- und Regel-Lebenszyklus, Vergleich über Läufe hinweg, LLM-als-Richter und semantische Zitatprüfung:

• log_trace — Protokolliert eine Agent-Ausführung mit Spans, Tool-Aufrufen, Token-Nutzung und Kosten; übergebe evaluate: true, um sie im selben Aufruf zu bewerten
• evaluate_output — Bewertet die Ausgabequalität anhand von Vollständigkeits-, Relevanz-, Sicherheits- und Kostenregeln (heuristisch, deterministisch, kostenlos)
• get_traces — Fragt gespeicherte Traces mit Filtern, Paginierung und Zeitbereichsunterstützung ab und findet den Lauf, in dem der Agent etwas mit q gesagt hat: Volltextsuche über Eingabe, Ausgabe, Tool-Aufrufwerte und Metadaten, sortiert, mit markierten Treffern
• list_rules — Listet bereitgestellte benutzerdefinierte Bewertungsregeln auf (schreibgeschützt)
• deploy_rule — Registriert eine neue benutzerdefinierte Bewertungsregel, sodass sie bei jedem evaluate_output dieser Kategorie ausgelöst wird
• delete_rule — Entfernt eine bereitgestellte benutzerdefinierte Regel (destruktiv, idempotent)
• delete_trace — Entfernt einen einzelnen gespeicherten Trace anhand der ID (destruktiv, mandantenbezogen)
• evaluate_with_llm_judge — Semantische Bewertung über LLM (Anthropic oder OpenAI). Sieben Vorlagen: Genauigkeit, Hilfsbereitschaft, Sicherheit, Korrektheit, Treue, Aufgabe_abgeschlossen, Relevanz. Kostenobergrenze, Preise pro Bewertung offengelegt. Eigenen API-Schlüssel mitbringen (IRIS_ANTHROPIC_API_KEY oder IRIS_OPENAI_API_KEY) — Iris leitet LLM-Aufrufe weder weiter noch vermittelt sie sie.
• verify_citations — Extrahiert Zitate aus der Ausgabe (nummeriert, Autor-Jahr, URLs, DOIs), ruft Quellen über einen SSRF-geschützten und domain-zugelassenen Resolver ab und nutzt einen LLM-Richter, um zu prüfen, ob jede Quelle die zitierte Behauptung tatsächlich stützt. Opt-in ausgehender HTTP-Verkehr. Gleiche BYOK-Anforderung wie evaluate_with_llm_judge.
• compare_runs — Hat eine Änderung den Agenten verschlechtert? Vergleicht zwei Läufe gespeicherter Bewertungen: ein gepaarter exakter Test, wenn die Läufe Fallschlüssel teilen, ein Intervall für die Differenz sonst, ein ehrliches „kann nicht sagen“ mit der Anzahl der Fälle, die es bräuchte, oder „äquivalent innerhalb einer Marge“. Jede Regel trägt ihren eigenen einseitigen Test, gemeinsam korrigiert (Benjamini–Hochberg), sodass zwanzig Regeln keine Regression erzeugen können
• compare_traces — Wie zuverlässig beantwortet der Agent dieselbe Frage? Fallweise Bestehensquoten mit Intervallen, instabile Fälle zuerst, und eine Gesamtquote, die Wiederholungen berücksichtigt
• evaluate_runs — Bewertet jeden Trace in einem Lauf unter den heutigen Regeln in einem neuen Lauf neu, sodass eine Regeländerung nie als Agentenänderung gelesen wird

LLM-Richter aktivieren (optional; die deterministischen Regeln brauchen ihn nie)

1. Besorge einen API-Schlüssel von Anthropic oder OpenAI.
2. Lege ihn in der Umgebung des Prozesses ab, der Iris ausführt, nicht nur in deiner Shell. Claude Code, Claude Desktop, Cursor und die meisten MCP-Clients: der „env“-Block des iris-eval-Eintrags in deiner MCP-Konfiguration — „iris-eval“: { „command“: „npx“, „args“: [„-y“, „@iris-eval/mcp-server“], „env“: { „IRIS_ANTHROPIC_API_KEY“: „sk-ant-...“ } } (IRIS_OPENAI_API_KEY für einen OpenAI-Schlüssel). Docker: -e IRIS_ANTHROPIC_API_KEY=... im run-Befehl. HTTP oder CI: exportiere ihn, bevor du iris-eval startest.
3. Starte die MCP-Sitzung neu. Ein laufender Prozess sieht nie eine Variable, die nach seinem Start gesetzt wurde.
4. Bestätige aus deinem Client heraus: lies iris://capabilities — judge.enabled muss dort true sein. Ein in deiner Shell exportierter Schlüssel wird nicht an den Prozess übergeben, den dein Client startet, es sei denn, seine Konfiguration listet ihn. Auf einem Rechner gibt npx @iris-eval/mcp-server --self-test die Richterzeile für diese Shell aus, und GET /api/v1/health meldet judge.enabled auf einem laufenden Dashboard.
5. Ausgabenschutz: Jeder Aufruf ist durch IRIS_LLM_JUDGE_MAX_COST_USD_PER_EVAL begrenzt (Standard 0,25 USD) und wird vor jeder Ausgabe verweigert, wenn der schlechteste Fall ihn überschreiten würde. Iris ruft den Anbieter direkt mit deinem Schlüssel auf und leitet ihn nie weiter.
6. Optional: Setze IRIS_RELEVANCE_JUDGE_MODEL auf eine bepreiste Modell-ID (z. B. claude-haiku-4-5), damit answers_the_ask den Richter fragt, ob jede Antwort ihre Frage adressiert, und eine themenfremde Antwort durchfällt. Das ist ein Richteraufruf pro Bewertung mit Eingabe, auf deinem Schlüssel und unter der obigen Obergrenze; der Schlüssel allein aktiviert das nie. Jeder Aufruf sendet diese Eingabe und Ausgabe an den Anbieter des Modells, wobei die persönlichen Daten und Anmeldedaten der no_pii-Flags zuerst ersetzt werden (IRIS_RELEVANCE_JUDGE_REDACT=off sendet sie unverändert). Es gibt höchstens IRIS_RELEVANCE_JUDGE_DAILY_BUDGET_USD pro UTC-Tag aus (Standard 1 USD) und macht höchstens IRIS_RELEVANCE_JUDGE_MAX_CALLS_PER_REQUEST Aufrufe pro Anfrage (Standard 20); danach liest answers_the_ask die Frage lexikalisch und sagt warum.

Wenn IRIS_OTEL_ENDPOINT konfiguriert ist, geben log_trace-Aufrufe auch einen Best-Effort-OTLP/HTTP-JSON-Export an jeden OpenTelemetry-Kollektor aus (Jaeger, Grafana Tempo, Datadog OTLP, Honeycomb usw.). Siehe docs/otel-integration.md.

Wie passed entschieden wird

evaluate_output gibt sowohl ein score als auch ein passed-Flag zurück — sie beantworten verschiedene Fragen:

• score (0..1) ist der gewichtete Durchschnitt über die Regeln, die liefen — ein Qualitätsgradient.
• passed ist das Verdict „ausliefern/nicht ausliefern“, und die Punktzahl wird dafür nie herangezogen. Ein Komponist liest jede Regel nach der Art ihrer Behauptung: eine Richtlinie, die du konfiguriert hast, blockt; ein kritischer Detektor legt ein Veto ein; eine kritische Prüfung, die angefragt wurde und nicht antworten konnte, macht das Verdict unbekannt (passed: false) statt sauber; jede verbleibende Detektorregel kombiniert sich zu einer Wahrscheinlichkeit, dass die Ausgabe schlecht ist, abgewogen gegen das Verlustverhältnis, das du in eval.falsePassCost angibst (Standard 1, also liegt der Schnitt bei 0,5). verdict.basis nennt die Ebene, die entschieden hat, und verdict.by die Regeln, und verdict.also listet jede spätere Ebene, die ebenfalls entschieden hätte; interpretations[] sagt, warum eine fehlgeschlagene Regel nicht entschieden hat und welche Einstellung das ändern würde, und nennt jede Frage, die nicht beurteilt wurde, und die Eingabe, die das ermöglichen würde.

Echte Sicherheitsverletzungen scheitern hart. Standardmäßig sind no_pii, no_injection_patterns und no_blocklist_words kritische Regeln: Wenn eine fehlschlägt, meldet die Bewertung passed: false, egal wie gut die anderen Regeln abschneiden, und die Antwort nennt die Verursacher in critical_failures. Ein durchgesickertes SSN kann nicht weggemittelt werden. Welche eingebauten Regeln kritisch sind, ist eine Bereitstellungseinstellung (eval.criticalRules / eval.nonCriticalRules); jedes Regelergebnis trägt das effektive critical-Flag und criticalSource, und list_rules meldet die Liste, die dieser Server anwendet. Benutzerdefinierte Regeln, die mit severity: "high" oder "critical" bereitgestellt werden, scheitern auf dieselbe Weise hart; die Schweregrade low/medium wirken sich nur auf die Punktzahl aus. Eine Grenze, die man kennen sollte, auf jeder Oberfläche gleich formuliert: Eine kritische Regel, die übersprungen wurde (fehlender Kontext, eine defekte Definition oder ein Regex, der im Sandbox-Budget abgebrochen wurde), hat die Ausgabe nicht beurteilt und legt kein Veto ein — jede solche Regel wird in critical_skipped genannt. Ein Gate, das fail-closed sein muss, behandelt ein nicht-leeres critical_skipped als unbekannt, nicht als sauber, und kann jeden budgetExceeded-Skip in rule_results genauso behandeln.

Für CI-Gates: Wenn du eval_type weglässt, läuft jedes Bündel — Vollständigkeit, Relevanz, Sicherheit, Kosten und alle benutzerdefinierten Regeln — und die Antwort sagt eval_type: "all" mit einem note, dass der Standard lief, plus einer categories-Karte pro Bündel. Ein Bündel ohne zu Beurteilendes (Kosten ohne cost_usd, Relevanz ohne input) meldet dort passed: null — nicht bewertet, nicht fehlgeschlagen — und zählt nie zum Verdict. Die Antwort gibt immer das eval_type zurück, das lief, damit dein Gate die Abdeckung prüfen kann; orientiere dich für das Verdict an passed und nenne ein Bündel nur, wenn du einen engeren Lauf willst.

Eine benutzerdefinierte Regel erstellen

Zwei Wege, eine Regel hinzuzufügen. Inline-Regeln fahren auf einem evaluate_output-Aufruf mit (custom_rules, bis zu 10 pro Aufruf); sie feuern neben dem eval_type-Bündel deiner Wahl oder allein mit eval_type: "custom". Bereitgestellte Regeln werden einmal mit deploy_rule registriert, bleiben in custom-rules.json unter deinem Iris-Home erhalten und feuern bei jedem zukünftigen evaluate_output ihres evalType. Die Definition hat in beiden Fällen dieselbe Form:

deploy_rule umhüllt die Definition mit name, einem optionalen description, evalType (completeness · relevance · safety · cost · custom) und severity. Der Schweregrad sagt, was ein Fehlschlag bedeutet: low/medium senken nur die Punktzahl; high/critical lassen die Bewertung hart fehlschlagen — passed: false, die Regel in critical_failures genannt — egal was die gewichtete Punktzahl sagt. Eine Regel, die überspringt (eine cost_threshold-Regel ohne cost_usd oder ein Regex, der im 100-ms-Sandbox-Budget abgebrochen wurde), hat die Ausgabe nicht beurteilt und wird stattdessen in critical_skipped aufgelistet. Stelle eine kritische Regel bereit, die interne Hostnamen in allem verbietet, was der Agent sagt:

{
  "name": "no_internal_hostnames",
  "description": "Output must not mention internal hostnames.",
  "evalType": "safety",
  "severity": "critical",
  "definition": {
    "name": "no_internal_hostnames",
    "type": "regex_no_match",
    "config": { "pattern": "\\b[a-z0-9-]+\\.internal\\.example\\b", "flags": "i" }
  }
}

Die Antwort ist die gespeicherte Regel — behalte die id für delete_rule:

{ "rule": { "id": "rule-588823d0", "name": "no_internal_hostnames", "evalType": "safety", "severity": "critical", "enabled": true, "version": 1, "definition": { "…": "…" } } }

Ab dem allerersten evaluate_output mit eval_type: "safety" kommt eine Ausgabe, die db-primary.internal.example erwähnt, als passed: false mit critical_failures: ["no_internal_hostnames"] zurück — obwohl alle fünf eingebauten Sicherheitsregeln bestanden haben und die gewichtete Punktzahl 0,895 beträgt. Regex-Muster müssen beim Bereitstellen einen ReDoS-Check bestehen und laufen immer in einem Sandbox-Worker unter einer harten 100-ms-Frist. list_rules zeigt, was bereitgestellt ist; der Regel-Komponist des Dashboards baut dieselbe Form aus einem Fehler, auf den du geklickt hast. Vollständige Referenz, Bewertung pro Typ und ausgearbeitete Beispiele: docs/custom-rules.md.

Vollständige Tool-Schemas und Konfiguration: iris-eval.com

Gehostete Funktionen

Iris läuft heute vollständig auf deinem Rechner, und alles, was es tut, ist kostenlos und MIT-lizenziert, ohne Limits und ohne Konto. Gehosteter Speicher, gemeinsamer Team-Verlauf und Benachrichtigungen sind in Prüfung, nicht im Bau. Es gibt keine Preisgestaltung und nichts zu kaufen. Wenn ein gemeinsamer Verlauf für Sie nützlich wäre, erfahren wir über die Warteliste, ob sich der Aufbau lohnt – sie verpflichtet Sie zu nichts.

Zwei Zusagen gelten unabhängig davon: nichts, was heute kostenlos ist, wird hinter eine Bezahlschranke verschoben, und keine Compliance-Zertifizierung wird beansprucht, bevor sie erworben wurde.

Beispiele

• Claude-Desktop-Einrichtung — MCP-Konfiguration für Stdio- und HTTP-Modi
• TypeScript — MCP-SDK-Client — Tools verbinden und aufrufen
• HTTP-Transport (TS + Python) — vollständiger Client-Code für REST-artige Integration
• Ein LangGraph-Agent, Lauf für Lauf bewertet (Python) — IrisCallbackHandler in den Callbacks des Graphen; CI führt denselben Graphen mit einem skriptgesteuerten Modell aus
• Eine CrewAI-Crew über OpenTelemetry (Python) — der OpenInference-Instrumentor direkt an Iris' OTLP-Tür, das CrewAI-Rezept als Skript
• Ein OpenAI-Agents-SDK-Agent über OpenTelemetry (Python) und (JavaScript), sowie ein LlamaIndex-Agent — jedes Rezept als das Skript, das CI gegen einen echten Iris-Server ausführt

Community

• GitHub-Issues — Fehlerberichte und Feature-Anfragen
• GitHub-Diskussionen — Fragen und Ideen
• Beitragsleitfaden — So tragen Sie bei
• HTTP-Ingest — Deterministische Trace-Erfassung über POST /api/v1/traces
• Fähigkeitsübersicht — Jede Frage, die Iris gestellt werden kann, und was ihm fehlt
• Versionierungsrichtlinie — Was jede Versionsnummer verspricht und was vor 1.0 wahr sein muss

# Production deployment
iris-eval --transport http --port 3000 --api-key "$(openssl rand -hex 32)" --dashboard

# The image: pass a key
docker run -p 3000:3000 -p 6920:6920 -v iris-data:/data \
  -e IRIS_API_KEY="$(openssl rand -hex 32)" ghcr.io/iris-eval/mcp-server

# Compose: the file requires the variable and refuses before the container starts
IRIS_API_KEY="$(openssl rand -hex 32)" docker compose up

# A network you have already fenced some other way: run open, on purpose
IRIS_ALLOW_UNAUTHENTICATED=1 iris-eval --transport http --dashboard

npx @iris-eval/mcp-server --self-test

npx --yes @iris-eval/mcp-server@latest

npm install -g @iris-eval/mcp-server@latest

npm rebuild better-sqlite3
# for a global install:
npm rebuild -g better-sqlite3

npx @iris-eval/mcp-server --version

npx -y @iris-eval/mcp-server@latest install --upgrade

node --version  # Must be v22.13.0 or newer

# Correct
claude mcp add --transport stdio iris-eval -- npx -y @iris-eval/mcp-server

# Wrong (causes /c to be parsed as a path)
claude mcp add --transport stdio iris-eval -- cmd /c "npx -y @iris-eval/mcp-server"

Wenn Iris für Sie nützlich ist, erwägen Sie, das Repo zu starren — es hilft anderen, es zu finden.

MIT-lizenziert.