Skip to main content
Glama
BYK
by BYK

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

jev_ask

prototype a question against one state and see the full probability distribution

jev_map

run a question set over many items, get one compact row each, filter/sort/save

jev_eval

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-mcp

Or 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

  1. jev_ask — try two or three wordings on a state you understand.

  2. jev_eval — run the promising ones over labeled examples (inline, or a .jsonl/.json file of { id?, state, label? }). Read the threshold sweep and the worst misses; pick a threshold from the table, not from intuition.

  3. jev_map — apply the question you measured to the real workload, sorting or filtering by the answer and using save_path to 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 hand

The 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.json

MIT licensed.

Available Tools

3 tools
jev_askAsk Jev typed questions about one stateA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
modelNoModel id or alias. Defaults to jev-latest.
stateYesThe content to judge: a string, or an object/array when it has several named parts.
questionsYesMap of your question id to a question. Ids are not sent to the model, so put the full meaning in instructions.

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 examplesA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
itemsNoInline items: { id?, state, label? }. Use dataset_path instead for large sets.
modelNoModel id or alias. Defaults to jev-latest.
variantsYesCandidate questions keyed by variant name. Pass several wordings of the same judgment to compare them head to head on identical inputs.
save_pathNoWrite the full per-item results as JSON here, to keep them out of context.
max_errorsNoWorst misses to list per variant. Default 8.
concurrencyNoRequests in flight. Default 8.
dataset_pathNoPath to a .jsonl (one object per line) or .json file of items.

TDQS

A3.8/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines4/5

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 itemsA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
itemsNoInline items: { id?, state, label? }. Use dataset_path instead for large sets.
modelNoModel id or alias. Defaults to jev-latest.
orderNoSort direction. Default desc.
filterNoKeep rows whose answer is in a numeric range, or equals a choice option.
sort_byNoQuestion id to sort by: noul value, score, or choice confidence.
max_rowsNoRows to include in the table. Default 50.
questionsYesQuestions applied to every item.
save_pathNoWrite the full per-item results as JSON here, to keep them out of context.
concurrencyNoRequests in flight. Default 8.
dataset_pathNoPath to a .jsonl (one object per line) or .json file of items.
include_rowsNoSet false for aggregates only. Default true.

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 3 tool updatesv0.1.0
    • First observedjev_ask
    • First observedjev_eval
    • First observedjev_map

TDQS

A4.1/5.0

Scored across 3 tools

Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count4/5

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.

Completeness4/5

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

ActivityMaintained
ResponsivenessUnresponsive

Related MCP Connectors

Related MCP Servers

  • A
    license
    A
    quality
    C
    maintenance
    Enables typed, calibrated judgment calls through classify, score, check, and batched ask tools, each returning full probability distributions for programmatic decisions.
    5
    1
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables MCP clients to call TypeSafe's JEV classifier and receive structured, typed judgments with probabilities for binary, choice, and scoring questions.
    MIT
  • A
    license
    A
    quality
    B
    maintenance
    Provides 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.
    9
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    Enables 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.
    3
    MIT