Provides CI-friendly quality gates for agent evaluation, enabling integration with GitHub Actions workflows for automated testing and deployment.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@agent-eval-mcp run evaluation suite on my candidate agent outputs"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A dependency-light evaluation platform for RAG/wiki-quality AI agents. It scores agent outputs for faithfulness, retrieval relevance, hallucination risk, latency, and cost; produces CI-friendly quality gates; emits regression/canary reports; and exposes the workflow through a lightweight MCP-style stdio tool server.
JSONL evaluation case format for RAG/wiki workflows.
Deterministic checks for:
faithfulness to retrieved context and reference answer,
retrieval relevance against question and expected keywords,
hallucination risk from unsupported answer content,
latency and cost thresholds.
100+ synthetic case generator.
CI/CD-style suite-level and case-level quality gates.
Markdown and JSON evaluation reports.
Regression report comparing baseline and candidate runs.
Canary promotion policy with traffic ramp decisions.
OpenTelemetry-compatible JSONL traces/metrics.
MCP-style stdio server exposing evaluation tools.
Related MCP server: iris-eval/mcp-server
git clone https://github.com/ad-github1/ENTERPRISE-AI-AGENT-EVALUATION-PLATFORM.git
cd ENTERPRISE-AI-AGENT-EVALUATION-PLATFORM
PYTHONPATH=src python3 -m agent_eval_platform generate-cases --count 120 --out examples/wiki_eval_cases.jsonl
PYTHONPATH=src python3 -m agent_eval_platform evaluate \
--cases examples/wiki_eval_cases.jsonl \
--gate examples/quality_gate.json \
--variant candidate \
--json-out reports/eval_result.json \
--markdown-out reports/eval_report.md \
--traces-out reports/traces.jsonl
PYTHONPATH=src python3 -m unittest discover -s testsRun the test suite:
PYTHONPATH=src python3 -m unittest discover -s testsCurrent local result:
Ran 5 tests in 0.015s
OKAfter installation:
pip install -e .
agent-eval evaluate --cases examples/wiki_eval_cases.jsonl --gate examples/quality_gate.json
agent-eval-mcpEach JSONL row contains one evaluated agent run:
{
"case_id": "case-0001",
"question": "What contribution is Ada Lovelace known for in mathematics?",
"reference_answer": "Ada Lovelace is known for Analytical Engine notes.",
"expected_keywords": ["Ada Lovelace", "Analytical Engine"],
"retrieved_docs": [
{"doc_id": "wiki-1", "title": "Ada Lovelace", "text": "...", "score": 0.94}
],
"agent_answer": "Ada Lovelace is known for Analytical Engine notes.",
"latency_ms": 240.5,
"cost_usd": 0.0031,
"tags": ["wiki", "rag"]
}The evaluator exits non-zero when --fail-on-gate is used and thresholds fail:
PYTHONPATH=src python3 -m agent_eval_platform evaluate \
--cases examples/wiki_eval_cases.jsonl \
--gate examples/quality_gate.json \
--fail-on-gateSee .github/workflows/agent-eval.yml for a GitHub Actions example.
Run:
PYTHONPATH=src python3 -m agent_eval_platform.mcp_serverSupported JSON-RPC methods:
initialize
tools/list
tools/call with:
run_evaluation_suite
compare_regression
decide_canary
This is intentionally stdio and dependency-free. It follows the MCP tool shape closely enough for local agent integration demos without requiring the MCP Python SDK.
PYTHONPATH=src python3 -m agent_eval_platform canary \
--result reports/eval_result.json \
--config examples/canary_config.json \
--json-out reports/canary_decision.jsonThe decision is hold, increase_traffic, or promote based on suite quality and minimum case coverage.
PYTHONPATH=src python3 -m agent_eval_platform evaluate \
--cases examples/wiki_eval_cases.jsonl \
--gate examples/quality_gate.json \
--variant candidate \
--json-out reports/eval_result.json \
--markdown-out reports/eval_report.md \
--traces-out reports/traces.jsonlMetric | Value |
Evaluation cases | 120 |
Pass rate | 82.5% |
Average faithfulness | 0.825 |
Average retrieval relevance | 0.838 |
Average hallucination risk | 0.153 |
p50 latency | 392.58 ms |
p95 latency | 663.40 ms |
p99 latency | 872.87 ms |
Average cost | $0.00393 |
Total cost | $0.47158 |
PYTHONPATH=src python3 -m agent_eval_platform canary \
--result reports/eval_result.json \
--config examples/canary_config.json \
--json-out reports/canary_decision.jsonResult:
{
"action": "hold",
"next_traffic_percent": 10.0,
"reasons": [
"pass_rate 0.825 < 0.900"
]
}The canary policy correctly blocked promotion because the candidate run did not meet the configured 90% pass-rate threshold. This demonstrates how the platform can prevent low-quality agent versions from being promoted automatically.
The evaluation emits OpenTelemetry-style JSONL traces to:
reports/traces.jsonlEach case generates spans for faithfulness, retrieval relevance, hallucination risk, and final case-level pass/fail status, enabling debugging of failed agent responses.
Compare baseline and candidate suite JSON files.
| Name | Required | Description | Default |
|---|---|---|---|
| out | No | ||
| baseline_path | Yes | ||
| candidate_path | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only says 'compare', but doesn't disclose whether it's read-only, what side effects exist, or output format. For a comparison tool, it likely is read-only, but that is not stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (6 words), but lacks structure and essential details. It is under-specified rather than efficiently concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 undocumented parameters, no output schema, and no annotations, the description is far from complete. It does not explain the comparison logic, output format, or parameter usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description does not mention any parameters. It fails to add meaning beyond the schema, leaving three parameters (including required ones) undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it compares two files (baseline and candidate suite JSON files), which is a specific verb+resource. It differentiates from siblings 'decide_canary' (decision) and 'run_evaluation_suite' (executing evaluations).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives. No context on prerequisites or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Apply canary promotion policy to a suite result.
| Name | Required | Description | Default |
|---|---|---|---|
| config_path | Yes | ||
| result_path | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations and the description does not disclose whether the tool is destructive, requires authentication, or has side effects, which is critical for an AI agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short but at the expense of clarity; it lacks the substance needed to be genuinely concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, minimal param info, and no annotations, the description fails to provide a complete picture of the tool's behavior and context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the description does not explain what config_path or result_path refer to, leaving the agent without meaning for the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description says 'Apply canary promotion policy to a suite result,' which gives a vague sense of purpose but lacks specificity on what the policy entails and how it differs from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus siblings like compare_regression or run_evaluation_suite, leaving the agent without decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run RAG/wiki agent evaluation cases and emit JSON, Markdown, and telemetry outputs.
| Name | Required | Description | Default |
|---|---|---|---|
| variant | No | ||
| json_out | No | ||
| gate_path | No | ||
| cases_path | Yes | ||
| traces_out | No | ||
| markdown_out | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only mentions running evaluations and emitting outputs, but fails to describe side effects, destructive actions, auth requirements, or performance implications. For a tool that likely modifies state or consumes resources, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, no wasted words. It is front-loaded with the core action. However, it could benefit from a brief list of parameters or constraints without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters (1 required), no output schema, and no annotations, the description is severely incomplete. It does not explain parameter roles, output structure, error handling, or expected behavior after execution. An agent would likely misuse or misunderstand the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the tool description does not explain any parameter meanings, default values, or constraints. An agent cannot infer semantic intent for parameters like 'variant' or 'gate_path' from the name alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Run') and resource ('RAG/wiki agent evaluation cases'), and specifies the output formats (JSON, Markdown, telemetry). This distinguishes it from sibling tools like 'compare_regression' and 'decide_canary', which have different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, nor any prerequisites or conditions. The description only states functionality, omitting context like when not to use it or comparison to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0compare_regressiondecide_canaryrun_evaluation_suiteEach tool has a distinct purpose: running evaluations, comparing results, and applying deployment policy. There is no overlap.
All tools follow a consistent verb_noun pattern (run_evaluation_suite, compare_regression, decide_canary), making them predictable.
With 3 tools, the server covers the core evaluation workflow without being bloated. Slightly minimal but appropriate for a focused server.
The tools cover the main lifecycle: run suite, compare results, decide promotion. Minor gaps like suite management exist, but the core workflow is complete.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server providing access to the Scorecard API to evaluate and optimize LLM systems.
MCP server for visual regression testing: triage a PR's UI diffs from your coding agent.
Pay-per-call AI evaluation MCP server. Score LLM outputs against benchmark rubrics via Workers AI.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ad-github1/ENTERPRISE-AI-AGENT-EVALUATION-PLATFORM'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
