jev-eval-mcp
Click on "Deploy 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., "@jev-eval-mcpeval my support-tickets.jsonl with the plain and detailed variants"
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.
jev-eval-mcp
An eval-first MCP server for TypeSafe's Jev, a System One model that
returns typed judgments (noul, choice, score) with probabilities instead of generated text.
Most Jev integrations expose "ask the model a question". The hard part in practice is not asking — it is knowing whether a question works and where to put the threshold. This server is built around that:
tool | use it for |
| prototype a question against one state and see the full probability distribution |
| run a question set over many items, get one compact row each, filter/sort/save |
| measure question variants against labeled examples: accuracy, calibration, threshold sweep, worst misses |
jev_map exists because the expensive part of triaging 500 files, findings, or tickets is reading
them into the agent's context. jev_eval exists because a threshold picked by vibes is the usual
reason a classifier gate misbehaves in production.
Install
Requires Node 20+ and a TypeSafe API key from https://console.typesafe.ai/settings/keys.
Register the server with your MCP client. Claude Code:
claude mcp add jev -e TYPESAFE_API_KEY=sk-... -- npx -y jev-eval-mcpOr in a mcp.json-style config:
{
"mcpServers": {
"jev": {
"command": "npx",
"args": ["-y", "jev-eval-mcp"],
"env": { "TYPESAFE_API_KEY": "sk-..." }
}
}
}For opencode, in ~/.config/opencode/opencode.json (or a
project-level opencode.json):
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"jev": {
"type": "local",
"command": ["npx", "-y", "jev-eval-mcp"],
"enabled": true,
"environment": { "TYPESAFE_API_KEY": "{env:TYPESAFE_API_KEY}" }
}
}
}From a clone, build first (npm install && npm run build) and point the client at
node /path/to/jev-mcp/dist/index.js instead.
Environment: TYPESAFE_API_KEY (required), JEV_MODEL (default jev-latest),
TYPESAFE_BASE_URL (default https://api.typesafe.ai).
Related MCP server: jev-mcp
Questions
A question is one of three types, matching the Jev API:
{ "type": "noul", "instructions": "Is this ticket urgent?" }
{ "type": "score", "instructions": "How severe is this?", "criteria": ["trivial", "minor", "major", "critical"] }
{ "type": "choice", "instructions": "Which team owns this?", "criteria": { "billing": "payments", "platform": "availability" } }Questions are keyed by an id you choose; ids are not sent to the model, so the meaning belongs in
instructions. All questions in one call are answered independently against the same state in a
single request, so asking several at once costs one round trip.
Typical loop
jev_ask— try two or three wordings on a state you understand.jev_eval— run the promising ones over labeled examples (inline, or a.jsonl/.jsonfile of{ id?, state, label? }). Read the threshold sweep and the worst misses; pick a threshold from the table, not from intuition.jev_map— apply the question you measured to the real workload, sorting or filtering by the answer and usingsave_pathto keep the bulk out of context.
> jev_eval dataset_path=examples/support-tickets.jsonl variants={plain, detailed}
16 labeled items · 2 variant(s) · jev-1.13.0 · 268 ms · 4987 input tokens
| variant | headline metrics |
| plain | best F1 1.000 @ threshold 0.50 · AUC 1.000 · Brier 0.012 · ECE 0.097 |
| detailed | best F1 1.000 @ threshold 0.50 · AUC 1.000 · Brier 0.021 · ECE 0.095 |Labels are coerced to the question type: booleans/yes/no/1/0 for noul, the option key for
choice, and either a level name or its index for score.
Thresholds are only as good as the dataset behind them, and they are tied to a model version —
jev_eval reports the resolved version so a rerun after an upgrade is comparable.
Development
npm run typecheck && npm run lint && npm test # metrics unit tests, no network
npm run build && npm run smoke # live end-to-end over stdio, needs TYPESAFE_API_KEY
node scripts/call.ts jev_ask '{"state": "...", "questions": {}}' # drive one tool by handThe tool descriptions in this server are themselves measured with jev_eval: examples/tool-routing.jsonl
holds labeled requests and scripts/routing-eval.json compares the shipped descriptions against a terse
variant, so a reworded description can be checked for routing regressions instead of argued about.
node scripts/call.ts jev_eval - < scripts/routing-eval.jsonMIT licensed.
Available Tools
3 toolsjev_askAsk Jev typed questions about one stateARead-only
Run a question set once against a single state and see the typed answers with their probability distributions. Use it to prototype question wording before committing it to code or to jev_eval. Questions over the same state are answered independently in one request, so ask several at once.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Model id or alias. Defaults to jev-latest. | |
| state | Yes | The content to judge: a string, or an object/array when it has several named parts. | |
| questions | Yes | Map of your question id to a question. Ids are not sent to the model, so put the full meaning in instructions. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, and the description adds useful behavioral detail: questions are 'answered independently in one request' and the tool returns probability distributions, which goes beyond what annotations state. There is no contradiction with the annotations.
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?
Three sentences, with the core action front-loaded and the use case and batching note following naturally. Every sentence earns its place with no wasted words.
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?
For a read-only prototyping tool with three well-documented parameters, the description covers the essential decision factors: what it runs, what it returns, and when to prefer it over jev_eval. The absence of an output schema is offset by the explicit mention of typed answers and probability distributions.
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 description coverage is 100%, so the schema fully documents model, state, and questions. The description adds the batching behavior of questions but no additional parameter syntax or format details, matching the baseline for well-covered schemas.
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 states a specific verb ('Run'), a resource ('a single state'), and an output ('typed answers with their probability distributions'), making the tool's purpose concrete. It also distinguishes itself from jev_eval by framing the use case as prototyping, so an agent can tell them apart without opening the schema.
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?
The description explicitly says to use it 'to prototype question wording before committing it to code or to jev_eval,' which gives a clear when-to-use context and implies when not to use it (final evaluation). It also advises batching several questions per request. It doesn't explicitly mention jev_map, but the guidance is strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jev_evalMeasure question variants against labeled examplesARead-only
Score one or more wordings of a question against labeled items and report accuracy, calibration (Brier, ECE, AUC), a full threshold sweep for noul questions, an abstention curve for choice and score questions, and the worst misses. Run this before hard-coding any threshold, and rerun it after changing wording or model version. Variants are asked in the same request, so comparing several is nearly free.
| Name | Required | Description | Default |
|---|---|---|---|
| items | No | Inline items: { id?, state, label? }. Use dataset_path instead for large sets. | |
| model | No | Model id or alias. Defaults to jev-latest. | |
| variants | Yes | Candidate questions keyed by variant name. Pass several wordings of the same judgment to compare them head to head on identical inputs. | |
| save_path | No | Write the full per-item results as JSON here, to keep them out of context. | |
| max_errors | No | Worst misses to list per variant. Default 8. | |
| concurrency | No | Requests in flight. Default 8. | |
| dataset_path | No | Path to a .jsonl (one object per line) or .json file of items. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds no extra behavioral traits such as rate limits, auth needs, or side effects; the 'nearly free' remark hints at cost but is not a full disclosure. With annotations present, a 3 is appropriate because the description does not contradict and offers only marginal extra context.
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 three sentences, each with a distinct purpose: the first enumerates the output metrics, the second gives usage timing, and the third explains the efficiency of passing multiple variants. There is no filler, and the core action is front-loaded.
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 the tool has no output schema, the description appropriately enumerates the main output components (accuracy, Brier, ECE, AUC, threshold sweep, abstention curve, worst misses). It also covers the key workflow hint about evaluating before thresholding. However, it does not explain the distinction between inline items and dataset_path or the meaning of noul/choice/score types—though those are covered by the schema, so the description remains largely complete.
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 description coverage is 100%, so the input schema already explains each parameter fully. The description adds a high-level tie to 'one or more wordings' (variants) and 'labeled items' (items/dataset_path) but does not provide any new parameter-specific semantics. Baseline 3 is correct.
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 states a specific action (score question variants against labeled items) and enumerates the outputs (accuracy, calibration, threshold sweep, abstention curve, worst misses), so the purpose is unambiguous. However, it does not explicitly distinguish this tool from siblings jev_map and jev_ask, so it earns 4 rather than 5.
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?
The description gives clear usage timing: 'Run this before hard-coding any threshold, and rerun it after changing wording or model version.' It also notes that passing multiple variants is 'nearly free,' implying a best practice. It does not mention when NOT to use the tool or point to alternatives, which prevents a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jev_mapRun a question set over many itemsARead-only
Judge every item in a list and get back one compact row per item, plus per-question aggregates. Built for triage and ranking at a scale where reading each item into context is the expensive part: filter, sort, or write the full results to disk and only pull back what matters.
| Name | Required | Description | Default |
|---|---|---|---|
| items | No | Inline items: { id?, state, label? }. Use dataset_path instead for large sets. | |
| model | No | Model id or alias. Defaults to jev-latest. | |
| order | No | Sort direction. Default desc. | |
| filter | No | Keep rows whose answer is in a numeric range, or equals a choice option. | |
| sort_by | No | Question id to sort by: noul value, score, or choice confidence. | |
| max_rows | No | Rows to include in the table. Default 50. | |
| questions | Yes | Questions applied to every item. | |
| save_path | No | Write the full per-item results as JSON here, to keep them out of context. | |
| concurrency | No | Requests in flight. Default 8. | |
| dataset_path | No | Path to a .jsonl (one object per line) or .json file of items. | |
| include_rows | No | Set false for aggregates only. Default true. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint; the description adds useful operational context beyond those: batch judging, per-item compact rows, per-question aggregates, and the ability to write full results to disk while only pulling back what matters. No contradiction with annotations.
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?
Two sentences, front-loaded with the core behavior, and each clause earns its place. It explains what the tool returns, why it exists, and what workflow it supports without any filler.
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?
For an 11-parameter tool with nested question schemas and no output schema, the description plus fully documented schema covers the main invocation and selection needs. It does not spell out the exact row layout or default behaviors, but those are largely covered by the schema.
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 description coverage is 100%, so the baseline is 3. The description maps at a high level to filter/sort/save_path/include_rows concepts but does not add parameter-specific meaning beyond what the input schema already provides.
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?
States a specific behavior: 'Judge every item in a list' and defines the return shape ('one compact row per item, plus per-question aggregates'). It clearly differentiates from single-item siblings like jev_eval and jev_ask by emphasizing multi-item mapping and scale.
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?
Gives clear context for when this tool is the right choice: 'triage and ranking at a scale where reading each item into context is the expensive part', with filter/sort/disk-write options to avoid pulling everything into context. It does not explicitly name when-not or alternative tools, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
jev_ask - First observed
jev_eval - First observed
jev_map
TDQS
Scored across 3 tools
Each tool has a clearly distinct purpose: jev_map judges items in a list, jev_eval evaluates question wordings against labeled data, and jev_ask runs questions to see answers. There is no overlap or ambiguity in their intended use cases.
All tools share the 'jev_' prefix and use a consistent verb_noun pattern: map, eval, ask. The naming is predictable and clearly indicates the action each tool performs.
With only 3 tools, the server is on the low end of the appropriate range, but each tool covers a distinct phase of the evaluation workflow (prototype, evaluate, triage). The count is reasonable for the narrow domain and does not feel artificially padded.
The tools cover the core lifecycle for question evaluation: jev_ask for prototyping, jev_eval for validating wording, and jev_map for applying judgments at scale. Minor gaps exist (e.g., no tool for managing question sets or exporting results), but these are not blocking for the primary workflow.
Maintenance
Related MCP Connectors
Prediction market data and crowd-sourced probability forecasts
Read-only game, setup, place, evidence and travel decision tools with explicit provenance.
- memoricOAuthio.memoric
Provenance-first database for teams and agents: every value carries sources, rules and coverage.
1 Sealed prediction-market verdicts, graded in public across Polymarket and Kalshi. No auth required.
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables typed, calibrated judgment calls through classify, score, check, and batched ask tools, each returning full probability distributions for programmatic decisions.51MIT
- AlicenseNot gradedqualityCmaintenanceEnables MCP clients to call TypeSafe's JEV classifier and receive structured, typed judgments with probabilities for binary, choice, and scoring questions.MIT
- AlicenseAqualityBmaintenanceProvides coding agents and CI with a typed decision layer that sends bounded state and questions to Jev, then returns deterministic actions for review, risk assessment, requirement checks, and verification.9MIT
- AlicenseNot gradedqualityBmaintenanceEnables natural-language interaction with TypeSafe's Jev decision API, supporting mixed question calls, batch evaluation, model listing, and confidence or composite-score gates over stdio.3MIT