Iris

Iris — एजेंटों को अटकलों पर शिप करना बंद करें

Iris हर एजेंट रन को गुणवत्ता, सुरक्षा और लागत के लिए स्कोर करता है — आपकी मशीन पर, बिना किसी SDK और बिना किसी खाते के। अधिकांश एजेंट प्रोजेक्ट कुछ याद किए गए प्रॉम्प्ट चलाकर और आउटपुट को देखकर गुणवत्ता की जाँच करते हैं। Iris उसे उन संख्याओं से बदल देता है जिन्हें आप ऑडिट कर सकते हैं: आपके एजेंट के रन आपकी डिस्क पर एक SQLite डेटाबेस में जमा होते हैं, 25 अंतर्निहित नियम उन्हें निर्धारित रूप से स्कोर करते हैं — PII, प्रॉम्प्ट इंजेक्शन, भ्रम के मार्कर, लागत सीमाएँ, और एजेंट के अपने टूल कॉल — मुफ्त, बिना किसी LLM कॉल के, और एक वैकल्पिक LLM जज जिसकी प्रति-मूल्यांकन लागत की कठोर सीमा है, शब्दार्थ संबंधी प्रश्नों को संभालता है। हर नियम निरीक्षण योग्य और संपादन योग्य है, क्योंकि एक जज जिसे आप ऑडिट नहीं कर सकते, वह सिर्फ एक संख्या के साथ अटकलें हैं। MIT लाइसेंस, कोई टेलीमेट्री नहीं। जब तक आप इनमें से किसी एक को चालू नहीं करते, आपकी मशीन से कुछ भी बाहर नहीं जाता: एक OpenTelemetry एंडपॉइंट (IRIS_OTEL_ENDPOINT), जो आपके नामित कलेक्टर को ट्रेस निर्यात करता है; आपकी अपनी कुंजी के साथ LLM जज, जो अपने द्वारा निर्णय किए गए टेक्स्ट को उस प्रदाता को भेजता है, और जिसकी उद्धरण जाँच उन पृष्ठों को लाती है जिन्हें एक आउटपुट उद्धृत करता है; या एक वेबहुक, जो आपके द्वारा निर्धारित पते पर आईडी, निर्णय और नियम के नाम पोस्ट करता है, कभी भी टेक्स्ट नहीं।

Node.js 22.13 या उससे नए की आवश्यकता है। node --version से जाँचें।

_{डेमो डेटाबेस, scripts/demo-media.mts द्वारा रिकॉर्ड किया गया; स्रोत demo.mp4 है। एक स्थिर छवि: dashboard-overview.png।}

60 सेकंड में स्क्रीन पर एक विफलता

कोई एजेंट वायरिंग नहीं, कोई कॉन्फ़िग नहीं — एक कमांड:

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

यह एक डेमो डेटाबेस सीड करता है — पाँच छोटे एजेंट, दो सप्ताह के रन, हर निर्णय इंजन का अपना — और उसके खिलाफ डैशबोर्ड को http://localhost:6920 पर परोसता है (आपका ब्राउज़र पहले रन पर स्वचालित रूप से खुलता है)। डैशबोर्ड Failures पर उतरता है: क्या विफल हुआ, सबसे खराब और सबसे नया पहले, प्रत्येक कार्ड नियम और उसके साक्ष्य का नाम देता है। इसमें क्लिक करने लायक है — सुरक्षा नियमों द्वारा पकड़ा गया एक PII रिसाव, एक फोरम पोस्ट में एक छिपा निर्देश जिसका सारांशकर्ता ने पालन किया, एक संख्या जो स्रोत दस्तावेज़ ने कभी नहीं कही, एक अंतराल के साथ समान बारह प्रश्नों पर दो रन (Runs), एक तैनात कस्टम नियम और एक रोका गया नियम उनकी ऑडिट पंक्तियों के साथ, और एक विफल LLM-जज स्कोर उसके तर्क के साथ।

डेमो डेटा अपने स्वयं के डेटाबेस में रहता है (आपके Iris होम निर्देशिका में demo.db — macOS/Linux पर ~/.iris, Windows पर %USERPROFILE%\.iris) और आपके वास्तविक ट्रेस के साथ कभी मिश्रित नहीं होता। इसे एक कमांड से पूरी तरह हटाएँ:

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

अपना खुद का एजेंट जोड़ें

पहले, साबित करें कि इंस्टॉल इस मशीन पर काम करता है — यह ऑफ़लाइन चलता है और आपकी कोई चीज़ नहीं खोलता:

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

फिर अपने MCP क्लाइंट में Iris जोड़ें। एक कमांड क्लाइंट की अपनी कॉन्फ़िग फ़ाइल लिखता है, उसमें हर दूसरे सर्वर को रखता है, और आपके द्वारा चलाए गए संस्करण को पिन करता है:

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

क्लाइंट: claude-code, claude-desktop, cursor, windsurf, continue, vscode, cline, zed, codex, gemini। install --list इस मशीन पर पाए गए क्लाइंट, प्रत्येक द्वारा चलाया गया Iris और उसके द्वारा पढ़ी गई फ़ाइल दिखाता है; install <client> --uninstall Iris को फिर से बाहर निकालता है। हर क्लाइंट एक डेटाबेस साझा करता है, इसलिए अपग्रेड के बाद उन सभी को एक साथ install --upgrade से स्थानांतरित करें (अपडेट करना)। इसे लोड करने के लिए क्लाइंट को पुनरारंभ करें।

Claude Desktop: एक क्लिक। 0.20.0 से प्रत्येक रिलीज़ iris-eval.mcpb, एक MCP बंडल संलग्न करता है: नवीनतम डाउनलोड करें, इसे खोलें, और Claude Desktop एक इंस्टॉल डायलॉग दिखाता है। इस पर कुछ भी आवश्यक नहीं है — LLM जज के लिए एक Anthropic या OpenAI कुंजी वैकल्पिक है, और डैशबोर्ड एक स्विच है जो बंद शुरू होता है। बंडल में npm पैकेज और उसकी निर्भरताएँ हैं, इसलिए कुछ और स्थापित करने की आवश्यकता नहीं है: Claude Desktop इसे उस Node के तहत चलाता है जो वह भेजता है जब वह Node 22.13 या नया होता है (Claude Desktop 1.1.6679 24.13 भेजता है), और Iris ट्रेस को Node के अंतर्निहित SQLite के साथ, उसी ~/.iris में संग्रहीत करता है जो हर दूसरा इंस्टॉल उपयोग करता है। रिलीज़ नोट्स दिखाते हैं कि इसके हस्ताक्षर और बिल्ड प्रमाणन को कैसे सत्यापित किया जाए।

यह किसी भी MCP क्लाइंट में चलता है, और इसके द्वारा नामित हर क्लाइंट के पास वास्तव में जाँच की गई चीज़ों के साथ एक पंक्ति है। हर CI रन पर सत्यापित: Claude Code, Gemini CLI — वास्तविक क्लाइंट इंस्टॉलर द्वारा लिखे गए कॉन्फ़िग से Iris शुरू करता है और रिपोर्ट करता है कि यह जुड़ा हुआ है (claude mcp list, gemini mcp list), Linux, macOS और Windows पर; Claude Code के कैप्चर प्लगइन हुक भी वास्तविक स्क्रिप्ट के माध्यम से संचालित होते हैं। प्रत्येक क्लाइंट के अपने MCP दस्तावेज़ीकरण से दावा किया गया — इंस्टॉलर क्लाइंट द्वारा प्रलेखित कॉन्फ़िगरेशन आकार लिखता है, और वह लेखक आकार पर परीक्षण किया जाता है; Iris पक्ष पर किसी ने इसे जुड़ा हुआ नहीं देखा है: Claude Desktop, Cursor, Devin Desktop (Windsurf), Continue, VS Code, Cline, Zed, OpenAI Codex CLI। हर पंक्ति उसके स्रोत और पढ़ने की तारीख के साथ: https://iris-eval.com/clients. हाथ से इसके बजाय, एक ब्लॉक, डैशबोर्ड सहित:

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

आपका क्लाइंट कनेक्ट होने पर Iris के बारह टूल सूचीबद्ध करता है, और डैशबोर्ड http://localhost:6920. पर परोसता है। अब इसे अपने एजेंट पर पेस्ट करें:

उस अंतिम कार्य को Iris में लॉग करें और आउटपुट का मूल्यांकन करें।

ट्रेस अपने स्कोर के साथ डैशबोर्ड पर उतरता है। हेडलेस MCP सर्वर पसंद करते हैं? तर्कों से --dashboard हटाएँ — आप किसी भी समय npx @iris-eval/mcp-server --dashboard के साथ वही डैशबोर्ड खोल सकते हैं।

पहले से जानने लायक एक बात: MCP टूल तब कहलाते हैं जब मॉडल उन्हें कॉल करने का निर्णय लेता है। Iris आपके एजेंट को इंटरसेप्ट नहीं करता, इसलिए ट्रेस तब लॉग होते हैं जब आपका एजेंट उन्हें लॉग करने के लिए कहता है — या तो क्योंकि आपने उसे बताया, या क्योंकि आपका कोड सीधे टूल को कॉल करता है। अपने एजेंट से "इसे Iris में लॉग करें और मूल्यांकन करें" कहें और यह करेगा। यदि आप ऐसा कैप्चर चाहते हैं जो मॉडल की पसंद पर निर्भर नहीं करता, POST /api/v1/traces बिल्कुल वही करता है — आपका कोड सादे HTTP पर ट्रेस भेजता है, लूप में कोई मॉडल नहीं (देखें docs/http-ingest.md)। रोडमैप पर CLI और होस्ट हुक उसी एंडपॉइंट पर पतले क्लाइंट होंगे।

HTTP पर कैप्चर (लूप में कोई मॉडल नहीं)

इन्जेस्ट एंडपॉइंट डैशबोर्ड पोर्ट पर रहता है — डिफ़ॉल्ट रूप से 6920, MCP ट्रांसपोर्ट पोर्ट नहीं — और यह केवल तब मौजूद होता है जब डैशबोर्ड चल रहा हो। --dashboard पास करें (या IRIS_DASHBOARD=true सेट करें); अकेले --transport http इसे शुरू नहीं करता, और ट्रांसपोर्ट पोर्ट पर एक अनुरोध 404 लौटाता है। डैशबोर्ड ऊपर होने पर, कोई भी चीज़ जो HTTP अनुरोध भेज सकती है, एक ट्रेस लॉग कर सकती है — और वैकल्पिक रूप से उसी अनुरोध में निर्धारक मूल्यांकन चला सकती है। उसी पोर्ट पर GET /api/v1/capabilities बताता है कि यह सर्वर क्या निर्णय कर सकता है, प्रत्येक नियम को क्या चाहिए, जज की स्थिति उन चरणों के साथ जो इसे सक्षम करते हैं, और सीमाएँ — वही ऑब्जेक्ट जो MCP संसाधन iris://capabilities परोसता है — ताकि एक HTTP कॉलर के पास वह ढाँचा हो जो एक MCP क्लाइंट को initialize पर मिलता है:

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"
  }'

संग्रहीत trace_id और मूल्यांकन परिणाम के साथ 201 लौटाता है (--demo मोड में एंडपॉइंट 403 के साथ लेखन को अस्वीकार करता है, ताकि डेमो डेटा आपके साथ कभी मिश्रित न हो)। एंडपॉइंट log_trace टूल के समान बॉडी स्वीकार करता है और डैशबोर्ड के बाकी हिस्सों के समान मिडलवेयर स्टैक के पीछे बैठता है: डिफ़ॉल्ट रूप से लूपबैक बाइंड और DNS-रीबाइंडिंग गार्ड, साथ ही जब आप एक सेट करते हैं तो Bearer प्रमाणीकरण। इसके बारे में दो सादे तथ्य: यह बिना प्रमाणीकरण के लेखन स्वीकार करता है जब तक कि Iris --api-key (या IRIS_API_KEY) के साथ शुरू नहीं किया गया था — लूपबैक बाइंड ही इसे डिफ़ॉल्ट रूप से आपकी मशीन तक रखता है, इसलिए लूपबैक से परे बाइंड करने से पहले एक कुंजी सेट करें; और यह जो संग्रहीत करता है वह शब्दशः है — input और output iris.db में बिल्कुल भेजे गए अनुसार उतरते हैं, जिसमें कोई भी टेक्स्ट शामिल है जिसे no_pii आगे फ्लैग करता है। पूर्ण अनुबंध, फ़ील्ड संदर्भ, और त्रुटि शब्दार्थ: docs/http-ingest.md।

हर Claude Code टर्न कैप्चर करें (वैकल्पिक)

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

एक दूसरा, अलग से स्थापित प्लगइन: तीन हुक प्रत्येक टर्न के प्रॉम्प्ट, टूल कॉल और अंतिम उत्तर रिकॉर्ड करते हैं और उन्हें iris-eval ingest को सौंपते हैं, अलग किए गए, संग्रहीत मूल्यांकन टेक्स्ट में महत्वपूर्ण स्पैन रेडैक्टेड के साथ — कैप्चर जो मॉडल के टूल कॉल करने के निर्णय पर निर्भर नहीं करता। यह कभी भी उस टर्न को लॉग नहीं करता जिसे मॉडल पहले ही लॉग कर चुका है, कभी प्रिंट नहीं करता, कभी ब्लॉक नहीं करता, कभी कहीं कुछ नहीं भेजता। अकेले iris-eval स्थापित करना आपके टर्न लूप के बारे में कुछ नहीं बदलता। सीमाएँ और निष्कासन: 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": []}

सर्वर 0.16.0 और उसके बाद के HTTP API पर एक पतला क्लाइंट, अपने आप संस्करणित — iris_eval.__version__ और PyPI पृष्ठ इसकी संख्या रखते हैं, जो सर्वर की नहीं है: log_trace(), evaluate_output(), get_traces(), get_trace(), health(), capabilities(), sync और async, टाइप किए गए उत्तर, अस्वीकृति पर सर्वर का अपना वाक्य — और एक pytest प्लगइन: एक iris फिक्स्चर और assert_iris(output, expect="pass") जो निर्णय की स्थिति पर जोर देता है। packages/python/README.md।

हर OpenAI और Anthropic कॉल रिकॉर्ड करें

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' });

प्रदाता क्लाइंट को एक बार लपेटें और प्रत्येक मॉडल कॉल एक OpenTelemetry GenAI स्पैन बन जाता है जो OTLP दरवाजे पर भेजा जाता है, उसके इनपुट, आउटपुट, टोकन उपयोग और टूल कॉल के साथ संग्रहीत किया जाता है, और स्कोर किया जाता है: कैप्चर जो मॉडल के टूल कॉल करने पर निर्भर नहीं करता। Python क्लाइंट में wrap_openai / wrap_anthropic; @iris-eval/sdk में Vercel AI SDK के लिए wrapOpenAI, wrapAnthropic और irisMiddleware। दोनों अभी तक प्रकाशित नहीं हैं (अगला iris-eval PyPI पर रिलीज़; @iris-eval/sdk अपने पहले npm रिलीज़ तक स्रोत से बनाया गया है)। स्ट्रीम, SDK के स्ट्रीम हेल्पर और टूल कॉल शामिल हैं, मूल क्लाइंट नहीं बदला गया है, और Iris के डाउन होने से कभी कॉल नहीं टूटती — packages/sdk/README.md, packages/python/README.md।

हर LangChain और LangGraph रन स्कोर करें

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

प्रत्येक शीर्ष-स्तरीय रन एक ट्रेस बन जाता है (रन, उसके मॉडल कॉल, उसके टूल कॉल और उसके ग्राफ नोड GenAI स्पैन के रूप में) उसके इनपुट, आउटपुट, टूल कॉल, टोकन उपयोग और एक निर्णय के साथ। क्लाइंट में Python (अगली रिलीज़, अभी तक PyPI पर प्रकाशित नहीं), JavaScript @iris-eval/langchain के रूप में (अभी तक npm पर प्रकाशित नहीं)। दोनों CI में एक स्क्रिप्टेड मॉडल के साथ एक वास्तविक LangGraph ऐप के खिलाफ सिद्ध हैं; LangSmith का अपना OpenTelemetry निर्यात उसी तरह सिद्ध है — docs/otel-recipes.md।

एक CI गेट, कोई सर्वर आवश्यक नहीं

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

या GitHub Action (0.16.0), जो आपके नामित निर्णयों पर जॉब को विफल करता है, रसीद को जॉब सारांश में लिखता है और इसे एक पुल-रिक्वेस्ट टिप्पणी के रूप में पोस्ट करता है जो जगह पर अपडेट होती है: uses: iris-eval/mcp-server/.github/actions/gate@v0.19.0 के साथ traces: traces.ndjson — docs/ci-gate.md। चौथा द्वार (0.15.0): POST /v1/traces डैशबोर्ड पोर्ट पर OTLP/HTTP JSON या protobuf लेता है जो आपका OpenTelemetry इंस्ट्रुमेंटेशन पहले से उत्सर्जित करता है (Python SDK का एक्सपोर्टर केवल protobuf बोलता है, इसलिए यह Python द्वार भी है), और प्रत्येक OTLP ट्रेस अपने स्पैन के साथ एक Iris ट्रेस बन जाता है — docs/otel-integration.md; प्रत्येक फ्रेमवर्क के लिए एक रेसिपी (Pydantic AI, Google ADK, LangGraph via LangSmith, CrewAI, OpenAI Agents SDK Python और JavaScript में, LlamaIndex, AutoGen, Microsoft Agent Framework, Semantic Kernel, Vercel AI SDK और Mastra), प्रत्येक एक फिक्स्चर द्वारा सिद्ध, docs/otel-recipes.md में। ingest stdin या एक फ़ाइल से एक JSON ट्रेस (या NDJSON, प्रति पंक्ति एक) पढ़ता है, उसे संग्रहीत करता है, उसे ठीक उन्हीं नियमों के अंतर्गत मूल्यांकित करता है जिन्हें evaluate_output चलाता है, प्रति ट्रेस एक JSON पंक्ति फैसले और उसके आधार के साथ प्रिंट करता है, और जब कोई फैसला --fail-on से मेल खाता है तो 1 से बाहर निकलता है। --dataset <id|label> उस गेट को डेटासेट में केस कुंजियों तक सीमित करता है (POST /api/v1/datasets एक रन की केस कुंजियों को एक में बढ़ावा देता है), इसलिए कोई जॉब केवल उन मामलों पर विफल होता है जिन्हें आपने चुना है। पूरी रेसिपी, निकास कोड और आठ आधार docs/ci-gate.md में हैं।

एक नियम को कोड के रूप में लिखें

eval.plugins में config.json आपके द्वारा लिखे गए नियमों को लोड करता है — एक ES मॉड्यूल जिसका डिफ़ॉल्ट निर्यात { name, kind, mechanism, version, needs, evaluate(ctx) } है — फ़ाइल के sha256 द्वारा पिन किया गया, इसलिए एक फ़ाइल जो पिन करने के बाद बदल गई है वह चलने के बजाय स्टार्टअप से इनकार करती है। एक लोड किया गया प्लगइन अंतर्निहित की तरह फायर करता है और plugins के अंतर्गत list_rules पर दिखता है। अनुबंध, हैश रेसिपी और एक प्लगइन क्या लौटा सकता है: docs/plugins.md।

अपनी स्वयं की प्रक्रिया में इंजन का उपयोग करें

मूल्यांकन इंजन आयात योग्य है — कोई सर्वर नहीं, कोई डेटाबेस नहीं, कोई मॉडल नहीं:

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

वही इंजन, वही नियम और वही कंपोज़र जो सर्वर चलाता है; builtInRules(), createCustomRule(), compose() और प्रकाशित-सटीकता रीडर इसके बगल में निर्यात किए गए हैं।

HTTP रूट के लिए एक टाइप किया गया क्लाइंट

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

हर द्वार पर एक बॉडी: यह वही है जो log_trace और iris-eval ingest स्वीकार करते हैं। एक इनकार IrisClientError को सर्वर के अपने वाक्य और स्थिति के साथ फेंकता है। दोनों उपपथ हर बिल्ड पर एक पैक किए गए टारबॉल से जांचे जाते हैं।

अपनी स्थापना सत्यापित करें

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 पहले आपका Iris होम बनाता है यदि यह गायब है और जांचता है कि यह लिखने योग्य है (यदि नहीं है तो पथ का नाम देते हुए 1 से बाहर निकलता है), रिपोर्ट करता है कि आपके डेटाबेस का खोज सूचकांक कहाँ है (पूरा, एक पृष्ठभूमि बिल्ड ने अब तक कितने ट्रेस अनुक्रमित किए हैं, या इस SQLite पर कोई FTS5 नहीं), आपके डेटाबेस की स्कीमा पढ़ता है (1 से बाहर निकलता है, फिक्स के साथ, जब यह संस्करण या एक MCP क्लाइंट जो पुराने रिलीज़ से पिन किया गया है उसे नहीं खोल सकता), फिर अपनी जांच चलाता है — स्टोरेज राउंड-ट्रिप, एक लगाया गया SSN और एक लगाया गया इंजेक्शन जो सुरक्षा नियमों द्वारा पकड़ा गया, डैशबोर्ड बूट, DNS-रीबाइंडिंग गार्ड — एक अलग अस्थायी होम के अंदर। आपका वास्तविक डेटाबेस केवल पढ़ा जाता है, कभी नहीं बदला जाता। Iris जो कुछ भी लिखता है वह एक निर्देशिका के अंतर्गत रहता है, आपका Iris होम: डिफ़ॉल्ट रूप से ~/.iris (Windows पर %USERPROFILE%\.iris), या जहाँ भी IRIS_HOME इंगित करता है। वहीं iris.db, config.json, custom-rules.json, audit.log, preferences.json और डेमो फ़ाइलें रहती हैं; अपने वास्तविक डेटा को छुए बिना Iris आज़माने के लिए IRIS_HOME को एक स्क्रैच निर्देशिका पर इंगित करें।

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"]

अन्य स्थापना विधियाँ

# 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

टिप: वैश्विक स्थापना (npm install -g) ट्रेस को ~/.iris/iris.db पर स्थायी रूप से संग्रहीत करती है। npx के साथ, ट्रेस उसी स्थान पर बने रहते हैं, लेकिन पैकेज समाधान के कारण स्टार्टअप धीमा होता है।

आपको क्या मिलता है

यह आगे कहाँ जा रहा है: क्षमता मानचित्र — हर प्रश्न जो Iris से हर विषय के बारे में पूछा जा सकता है, उसके पास क्या है और क्या कमी है — और तीन ट्रैक।

मापा गया, दावा नहीं किया गया

हर अंतर्निहित नियम का एक प्रकाशित precision, recall और F1 होता है, जिसमें 95% confidence intervals होते हैं, जो इस रिपॉजिटरी में मौजूद एक लेबल किए गए corpus पर मापे जाते हैं (proof/corpus/) और एक कमांड से पुनर्जीवित होते हैं — npm run proof — ऑफ़लाइन, बिना किसी key और बिना किसी model के। वे संख्याएँ दो अलग-अलग प्रकार की होती हैं, और पृष्ठ उन्हें कभी एक साथ नहीं जोड़ता: कुछ नियम उन लेबलों के विरुद्ध मापे जाते हैं जो एक model ने स्वयं failure को पढ़कर दिए हैं, जो detection को मापता है; बाकी की जाँच उनके अपने प्रलेखित definition के विरुद्ध की जाती है, जिसे स्वतंत्र रूप से लागू किया जाता है, जो दिखाता है कि code अपना formula लागू करता है और यह नहीं बताता कि formula failure को पकड़ता है या नहीं। proof/RESULTS.md और proof पृष्ठ प्रत्येक नियम को चिह्नित करते हैं। CI हर pull request पर माप को फिर से चलाता है और विफल हो जाता है यदि committed संख्याएँ code द्वारा उत्पादित संख्याओं से भिन्न हों, इसलिए कोई नियम बिना उसकी संख्याओं के बदले बदल नहीं सकता। संख्याएँ iris-eval.com/proof और proof/RESULTS.md पर हैं; corpus कैसे बनाया गया, यह क्या नहीं है, और interval कैसे पढ़ें, यह docs/proof.md में है। Corpus सिंथेटिक और model-लेबल किया हुआ है — एक मानव blind label लंबित है, और पृष्ठ ऐसा कहता है; node proof/blind-sample.mjs प्रतिलिपि प्रस्तुत करने योग्य नमूना खींचता है जो इसे तय करेगा।

MCP Tools

Iris बारह उपकरण पंजीकृत करता है जिन्हें कोई भी MCP-संगत agent लागू कर सकता है — trace और rule lifecycle, runs के बीच तुलना, LLM-as-judge और semantic citation verification:

• log_trace — एक agent निष्पादन को spans, tool calls, token usage और cost के साथ लॉग करें; उसी कॉल में इसे स्कोर करने के लिए evaluate: true पास करें
• evaluate_output — completeness, relevance, safety और cost नियमों के विरुद्ध आउटपुट गुणवत्ता को स्कोर करें (heuristic, deterministic, free)
• get_traces — filtering, pagination और time-range समर्थन के साथ संग्रहीत traces को क्वेरी करें, और वह run खोजें जहाँ agent ने q के साथ कुछ कहा: input, output, tool-call values और metadata पर full-text खोज, रैंक किया हुआ, मिलान किए गए शब्दों के साथ चिह्नित
• list_rules — तैनात कस्टम eval नियमों की सूची बनाएं (read-only)
• deploy_rule — एक नया कस्टम eval नियम पंजीकृत करें ताकि यह उस श्रेणी के हर evaluate_output पर सक्रिय हो
• delete_rule — एक तैनात कस्टम नियम हटाएं (destructive, idempotent)
• delete_trace — ID द्वारा एक संग्रहीत trace हटाएं (destructive, tenant-scoped)
• evaluate_with_llm_judge — LLM के माध्यम से Semantic eval (Anthropic या OpenAI)। सात टेम्पलेट: accuracy, helpfulness, safety, correctness, faithfulness, task_completed, relevance। Cost-capped, प्रति-eval मूल्य निर्धारण प्रकट। अपनी API key लाएं (IRIS_ANTHROPIC_API_KEY या IRIS_OPENAI_API_KEY) — Iris LLM कॉल्स को proxy या relay नहीं करता।
• verify_citations — आउटपुट से citations निकालें (numbered, author-year, URLs, DOIs), SSRF-guarded + domain-allowlisted resolver के पीछे स्रोतों को लाएं, और यह जाँचने के लिए LLM judge का उपयोग करें कि प्रत्येक स्रोत वास्तव में उद्धृत दावे का समर्थन करता है या नहीं। Opt-in outbound HTTP। evaluate_with_llm_judge के समान BYOK आवश्यकता।
• compare_runs — क्या किसी बदलाव ने agent को बदतर बना दिया? संग्रहीत evaluations के दो runs की तुलना करता है: एक paired exact test जब runs साझा case keys रखते हैं, अन्यथा अंतर पर एक interval, एक ईमानदार "cannot tell" जिसमें लगने वाले cases की संख्या होती है, या "equivalent within a margin"। प्रत्येक नियम अपना स्वयं का one-sided test रखता है, एक साथ सही किया गया (Benjamini–Hochberg) ताकि बीस नियम regression नहीं बना सकें
• compare_traces — agent एक ही प्रश्न का कितनी विश्वसनीयता से उत्तर देता है? intervals के साथ प्रति-case pass rates, पहले flaky cases, और एक समग्र दर जो repeats का सम्मान करती है
• evaluate_runs — एक run में हर trace को आज के नियमों के तहत एक नए run में फिर से स्कोर करें, ताकि नियमों में बदलाव को agent में बदलाव के रूप में कभी न पढ़ा जाए

LLM judge सक्षम करें (वैकल्पिक; deterministic नियमों को कभी इसकी आवश्यकता नहीं होती)

1. Anthropic या OpenAI से API key प्राप्त करें।
2. इसे Iris चलाने वाली प्रक्रिया के environment में रखें, न कि केवल अपने shell में। Claude Code, Claude Desktop, Cursor और अधिकांश MCP clients: अपने MCP config में iris-eval प्रविष्टि का "env" ब्लॉक — "iris-eval": { "command": "npx", "args": ["-y", "@iris-eval/mcp-server"], "env": { "IRIS_ANTHROPIC_API_KEY": "sk-ant-..." } } (OpenAI key के लिए IRIS_OPENAI_API_KEY)। Docker: run कमांड पर -e IRIS_ANTHROPIC_API_KEY=...। HTTP या CI: iris-eval शुरू करने से पहले इसे export करें।
3. MCP सत्र पुनः आरंभ करें। एक चल रही प्रक्रिया उसके शुरू होने के बाद सेट किया गया variable कभी नहीं देखती।
4. अपने client के अंदर से पुष्टि करें: iris://capabilities पढ़ें — judge.enabled वहाँ true होना चाहिए। आपके shell में export की गई key आपके client द्वारा शुरू की गई प्रक्रिया को नहीं दी जाती जब तक उसका config इसे सूचीबद्ध न करे। एक मशीन पर, npx @iris-eval/mcp-server --self-test उस shell के लिए judge लाइन प्रिंट करता है, और GET /api/v1/health एक चल रहे dashboard पर judge.enabled रिपोर्ट करता है।
5. Spend guard: प्रत्येक कॉल IRIS_LLM_JUDGE_MAX_COST_USD_PER_EVAL (डिफ़ॉल्ट 0.25 USD) द्वारा सीमित है और सबसे खराब स्थिति इसे पार करने पर किसी भी spend से पहले अस्वीकार कर दिया जाता है। Iris आपकी key के साथ सीधे provider को कॉल करता है और इसे कभी proxy नहीं करता।
6. वैकल्पिक: IRIS_RELEVANCE_JUDGE_MODEL को एक मूल्यवान model id (उदाहरण के लिए, claude-haiku-4-5) पर सेट करें ताकि answers_the_ask judge से पूछे कि प्रत्येक उत्तर अपने ask को संबोधित करता है या नहीं, और एक off-topic उत्तर को विफल करे। यह प्रति evaluation एक judge कॉल है जो एक input रखता है, आपकी key पर और उपरोक्त cap के तहत; key अकेले इसे कभी चालू नहीं करती। प्रत्येक कॉल उस input और output को model के provider को भेजता है, पहले no_pii flags के साथ व्यक्तिगत डेटा और credentials को बदलकर (IRIS_RELEVANCE_JUDGE_REDACT=off उन्हें जैसे हैं वैसे भेजता है)। यह प्रति UTC दिन अधिकतम IRIS_RELEVANCE_JUDGE_DAILY_BUDGET_USD (डिफ़ॉल्ट 1 USD) खर्च करता है और प्रति अनुरोध अधिकतम IRIS_RELEVANCE_JUDGE_MAX_CALLS_PER_REQUEST कॉल करता है (डिफ़ॉल्ट 20); इनमें से किसी के पार होने पर, answers_the_ask ask को शाब्दिक रूप से पढ़ता है और कारण बताता है।

जब IRIS_OTEL_ENDPOINT कॉन्फ़िगर किया जाता है, log_trace कॉल्स किसी भी OpenTelemetry collector (Jaeger, Grafana Tempo, Datadog OTLP, Honeycomb, आदि) के लिए एक best-effort OTLP/HTTP JSON export भी उत्सर्जित करते हैं। देखें docs/otel-integration.md।

passed कैसे तय किया जाता है

evaluate_output एक score और एक passed फ़्लैग दोनों लौटाता है — वे अलग-अलग प्रश्नों का उत्तर देते हैं:

• score (0..1) चलाए गए नियमों में भारित औसत है — एक गुणवत्ता gradient।
• passed ship/no-ship निर्णय है, और स्कोर इसके लिए कभी परामर्श नहीं किया जाता। एक composer प्रत्येक नियम को उसके दावे के प्रकार से पढ़ता है: एक policy जिसे आपने कॉन्फ़िगर किया है gates; एक critical detector vetoes; एक critical check जो पूछा गया था और उत्तर नहीं दे सका निर्णय को unknown (passed: false) बनाता है न कि clean; हर शेष detector एक संभावना में जुड़ता है कि आउटपुट खराब है, जिसे आप eval.falsePassCost में बताए गए loss ratio के विरुद्ध तौला जाता है (डिफ़ॉल्ट 1, इसलिए कट 0.5 है)। verdict.basis उस परत का नाम बताता है जिसने निर्णय लिया और verdict.by नियमों का, और verdict.also हर बाद की परत को सूचीबद्ध करता है जिसने इसे भी तय किया होता; interpretations[] बताता है कि एक नियम जो विफल हुआ उसने निर्णय क्यों नहीं लिया और कौन सी सेटिंग इसे बदल देगी, और किसी भी प्रश्न का नाम बताता है जिसे नहीं आंका गया और वह input जो इसे आंकने देगा।

वास्तविक सुरक्षा उल्लंघन hard-fail होते हैं। डिफ़ॉल्ट रूप से no_pii, no_injection_patterns, और no_blocklist_words critical rules हैं: यदि एक विफल होता है, eval passed: false रिपोर्ट करता है चाहे अन्य नियमों ने कितना भी अच्छा स्कोर किया हो, और प्रतिक्रिया critical_failures में दोषियों का नाम बताती है। एक लीक हुआ SSN औसत नहीं किया जा सकता। कौन से अंतर्निहित नियम critical हैं यह एक deployment सेटिंग है (eval.criticalRules / eval.nonCriticalRules); प्रत्येक नियम परिणाम प्रभावी critical फ़्लैग और criticalSource रखता है, और list_rules उस roster की रिपोर्ट करता है जिसे यह सर्वर लागू करता है। severity: "high" या "critical" के साथ तैनात कस्टम नियम उसी तरह hard-fail होते हैं; low/medium गंभीरता केवल स्कोर को प्रभावित करती है। एक सीमा जानने योग्य है, हर सतह पर उसी तरह बताई गई: एक critical rule जो skipped (लापता संदर्भ, एक टूटी हुई परिभाषा, या sandbox बजट पर मारा गया regex) ने आउटपुट का न्याय नहीं किया और veto नहीं करता — ऐसा हर नियम critical_skipped में नामित है। एक gate जिसे fail closed होना चाहिए वह एक गैर-खाली critical_skipped को unknown मानता है, clean नहीं, और rule_results में किसी भी budgetExceeded skip को उसी तरह मान सकता है।

CI gates के लिए: यदि आप eval_type छोड़ देते हैं, हर bundle चलता है — completeness, relevance, safety, cost और कोई भी कस्टम नियम — और प्रतिक्रिया eval_type: "all" कहती है जिसमें note है कि डिफ़ॉल्ट चला, साथ ही एक प्रति-bundle categories मानचित्र। एक bundle जिसके पास न्याय करने के लिए कुछ नहीं है (बिना cost_usd के cost, बिना input के relevance) वहाँ passed: null रिपोर्ट करता है — मूल्यांकित नहीं, विफल नहीं — और कभी निर्णय की ओर नहीं गिना जाता। प्रतिक्रिया हमेशा eval_type को प्रतिध्वनित करती है जो चला, ताकि आपका gate कवरेज सत्यापित कर सके; निर्णय के लिए passed पर कुंजी लगाएं और केवल तभी एक bundle का नाम लें जब आप एक संकीर्ण run चाहते हैं।

एक कस्टम नियम लिखना

एक नियम जोड़ने के दो तरीके। Inline नियम एक evaluate_output कॉल पर सवार होते हैं (custom_rules, प्रति कॉल अधिकतम 10); वे आपके चुने हुए eval_type bundle के साथ, या अकेले eval_type: "custom" के साथ सक्रिय होते हैं। Deployed नियम एक बार deploy_rule के साथ पंजीकृत होते हैं, आपके Iris home के तहत custom-rules.json में बने रहते हैं, और उनके evalType के हर भविष्य के evaluate_output पर सक्रिय होते हैं। परिभाषा किसी भी तरह से समान आकार की है:

deploy_rule परिभाषा को name, एक वैकल्पिक description, evalType (completeness · relevance · safety · cost · custom) और severity के साथ लपेटता है। गंभीरता बताती है कि एक विफलता का क्या अर्थ है: low/medium केवल स्कोर कम करते हैं; high/critical मूल्यांकन को hard-fail करते हैं — passed: false, नियम critical_failures में नामित — चाहे भारित स्कोर कुछ भी कहे। एक नियम जो skip करता है (बिना cost_usd के cost_threshold नियम, या 100 ms sandbox बजट पर मारा गया regex) ने आउटपुट का न्याय नहीं किया है और इसके बजाय critical_skipped में सूचीबद्ध है। एक critical नियम तैनात करें जो agent द्वारा कही गई किसी भी चीज़ में आंतरिक hostnames को प्रतिबंधित करता है:

{
  "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" }
  }
}

प्रतिक्रिया बना रहा नियम है — delete_rule के लिए id रखें:

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

अगले ही evaluate_output से eval_type: "safety" के साथ, एक आउटपुट जो db-primary.internal.example का उल्लेख करता है वह passed: false के साथ critical_failures: ["no_internal_hostnames"] लौटाता है — भले ही सभी पाँच अंतर्निहित सुरक्षा नियम पारित हुए और भारित स्कोर 0.895 है। Regex पैटर्न को तैनाती के समय ReDoS जाँच पास करनी चाहिए और हमेशा एक कठोर 100 ms deadline के तहत sandbox worker में चलना चाहिए। list_rules दिखाता है कि क्या तैनात है; dashboard का rule composer उसी आकार को एक failure से बनाता है जिस पर आपने क्लिक किया। पूर्ण संदर्भ, प्रति प्रकार स्कोरिंग, और काम किए गए उदाहरण: docs/custom-rules.md।

पूर्ण tool schemas और कॉन्फ़िगरेशन: iris-eval.com

Hosted features

Iris आज पूरी तरह से आपकी मशीन पर चलता है, और यह जो कुछ भी करता है वह मुफ्त और MIT लाइसेंस प्राप्त है जिसमें कोई सीमा या खाता नहीं है। होस्टेड स्टोरेज, साझा टीम इतिहास और अलर्टिंग विचाराधीन हैं, निर्माणाधीन नहीं। कोई मूल्य निर्धारण नहीं है, और खरीदने के लिए कुछ भी नहीं है। यदि साझा इतिहास आपके लिए उपयोगी होगा, तो प्रतीक्षा सूची यह पता लगाने का हमारा तरीका है कि क्या इसे बनाना उचित है — यह आपको किसी भी चीज़ के लिए प्रतिबद्ध नहीं करता है।

दो प्रतिबद्धताएँ किसी भी स्थिति में कायम रहती हैं: आज जो मुफ़्त है वह कभी भी पेवॉल के पीछे नहीं जाएगा, और कोई भी अनुपालन प्रमाणन उसके प्राप्त होने से पहले दावा नहीं किया जाएगा।

उदाहरण

• Claude Desktop सेटअप — stdio और HTTP मोड के लिए MCP कॉन्फ़िग
• TypeScript — MCP SDK क्लाइंट — टूल्स से कनेक्ट करें और इनवोक करें
• HTTP ट्रांसपोर्ट (TS + Python) — REST-शैली एकीकरण के लिए पूर्ण क्लाइंट कोड
• एक LangGraph एजेंट, रन दर रन स्कोर किया गया (Python) — IrisCallbackHandler ग्राफ़ के कॉलबैक में; CI एक स्क्रिप्टेड मॉडल के साथ वही ग्राफ़ चलाता है
• OpenTelemetry पर एक CrewAI क्रू (Python) — OpenInference इंस्ट्रूमेंटर सीधे Iris के OTLP द्वार तक, CrewAI रेसिपी एक स्क्रिप्ट के रूप में
• OpenTelemetry पर एक OpenAI Agents SDK एजेंट (Python) और (JavaScript), और एक LlamaIndex एजेंट — प्रत्येक रेसिपी उस स्क्रिप्ट के रूप में जिसे CI एक वास्तविक Iris सर्वर के विरुद्ध चलाता है

समुदाय

• GitHub Issues — बग रिपोर्ट और फीचर अनुरोध
• GitHub Discussions — प्रश्न और विचार
• योगदान गाइड — योगदान कैसे करें
• HTTP इन्जेस्ट — POST /api/v1/traces के माध्यम से निर्धारणात्मक ट्रेस कैप्चर
• क्षमता मानचित्र — हर वह प्रश्न जो Iris से पूछा जा सकता है, और उसमें क्या कमी है
• संस्करण नीति — प्रत्येक संस्करण संख्या क्या वादा करती है, और 1.0 से पहले क्या सत्य होना चाहिए

# 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"

यदि Iris आपके लिए उपयोगी है, रिपो पर स्टार करने पर विचार करें — यह दूसरों को इसे खोजने में मदद करता है।

MIT लाइसेंस प्राप्त।