jev-mcp-server
This server is an MCP bridge to Jev (TypeSafe System One), letting AI clients make fast, cheap, calibrated structured decisions without an LLM.
choice: pick one of 2–100 options and get probabilities over all options for triage, routing, or tie-breakingscore: grade on an ordered 2–8 level rubric and return a fractional score plus confidence for risk/severity/qualitynoul: answer a yes/no question with a 0–1 degree for binary checks like breaking-change gatesclassify: batch-classify up to 100 items against one shared category set, with aggregated countssetup: verify a TypeSafe API key once and store it locally with 0600 permissions so no env var is neededREADME also highlights
compare(A/B winner with probability split) andverify(support of a claim against supplied evidence)
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-mcp-server Which of these log lines is most likely the root cause?"
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-mcp-server
MCP server for Jev, TypeSafe's System One model. It exposes the three official question types (choice, score, noul) plus compare, verify, batch classify, and a one-command installer that writes your client config for you.
What is Jev
Jev is a hosted decision model from TypeSafe. You send a structured question with enumerated options; it returns a typed answer with calibrated probabilities and a confidence value. It does not write prose and it does not explain itself. A single call costs roughly $0.00002 to $0.0001 and returns in about half a second, which is what makes it practical for the small, repeated judgments (triage, routing, grading, gating) that a frontier model is too slow and too expensive to run on every item.
You need a TypeSafe API key. There is no local model, no second LLM, and nothing else to install.
Related MCP server: jev-judge-mcp
Quickstart
# 1. Get a key: https://console.typesafe.ai/settings/keys
# 2. Install into your client (config is written for you):
uvx jev-mcp-server install claude-code # or: pi | cursor | opencode | codex
# 3. Restart the client if it is running, then ask:
# "Which of these rollout plans is safest? Show me the probability split."No uv yet? curl -LsSf https://astral.sh/uv/install.sh | sh, or brew install uv, or pip install uv. A plain pip install jev-mcp-server works too; the installer subcommand is the same either way.
Most stdio MCP clients take this shape:
{
"mcpServers": {
"jev": {
"command": "uvx",
"args": ["jev-mcp-server"],
"env": { "TYPESAFE_API_KEY": "apikey_xxx" }
}
}
}Codex (~/.codex/config.toml):
[mcp_servers.jev]
command = "uvx"
args = ["jev-mcp-server"]
[mcp_servers.jev.env]
TYPESAFE_API_KEY = "apikey_xxx"OpenCode (opencode.json, "mcp" section): {"jev": {"type": "local", "command": ["uvx", "jev-mcp-server"], "env": {"TYPESAFE_API_KEY": "apikey_xxx"}}}
Prefer not to put the key in config at all? Skip the env block and call the setup tool once from your agent. It verifies the key live and stores it with 0600 permissions.
Tools
Tool | Official type | What it does | Typical use |
|
| Pick 1 of 2-100 options; probabilities over all options, so near-ties are visible | Triage, routing, tie-breaking |
|
| Grade on an ordered 2-8 level rubric; fractional index (1.88 = between levels 1 and 2, leaning to 2) | Risk / severity / quality grading |
|
| Yes/no question with a 0-1 degree | "Is this change breaking?" |
|
| Which of two candidates wins, with the visible probability split | Titles, plans, messages |
|
| Support degree of ONE claim against evidence you supply | Fact-check lines, log-vs-symptom |
|
| Up to 100 items against one shared category set, aggregated | Labeling queues, sorting inboxes |
| (none) | Verify a key once, store it locally (0600) | Onboarding without env config |
Examples
Real calls; responses quoted as returned (only usage and model trimmed).
choice: which change is most likely a breaking change for API consumers? Options: rename an existing config key, add an optional response field, change the log format.
{"choice": "rename_config_key", "confidence": 1.0,
"probabilities": {"rename_config_key": 1.0, "add_optional_field": 0.0, "change_log_format": 0.0}}score: regression risk of rewriting an auth middleware in place, no tests written yet, on a minor/moderate/severe rubric:
{"score": 1.98, "nearest_level": "severe", "confidence": 0.96}verify: claim "all tests in the latest CI run passed", evidence "the CI log shows 3 failed tests out of 250":
{"noul": 0.01, "verdict": "not supported"}When to use it
Good fit:
Enumerated options: triage, routing, tie-breaks, A/B calls
Rubric grading: risk, severity, review triage
Binary checks at volume: breaking-change gates, claim-vs-evidence checks
Batch labeling: 100 items against one label set for about $0.007
Poor fit:
Open-ended reasoning or long-context analysis
Anything that needs an explanation attached. Jev returns numbers; any "reason" your assistant adds is its own reading of those numbers, not output from the model
Cost and latency (measured)
Single calls, indicative only; cost at $42 per 1B input tokens.
Call | Latency | Input tokens | Cost |
| ~0.6-0.7s | ~1.7k | ≈ $0.00007 |
| ~0.4-0.6s | ~0.3-0.5k | ≈ $0.00002 |
| ~1 min sequential | ~100× a single call | ≈ $0.007 |
Configuration
Variable | Meaning | Default |
| API key; env var beats the file stored by | required |
| API endpoint override (experiment with relays) |
|
| Model name |
|
|
| off |
| Relocate cache / key storage |
|
With JEVMCP_CACHE=1, identical question payloads are answered from disk at zero cost (usage.cached: true); classify deduplicates repeated items automatically.
FAQ
Why does Jev never explain its choice? By design; "decisions, not strings" is the product. The probability distribution is the output. Explanations would cost the latency and tokens this model exists to avoid.
Do I need another LLM or a local Jev install? No. Jev is a cloud API; there is no local model and no helper LLM. Your agent's main model decides when to call these tools and reads the numbers.
Why not just ask my main LLM? You can, and for one-off questions you probably should. The difference shows up in loops: an LLM's stated confidence is not calibrated, a call costs 100× more, and it takes seconds instead of milliseconds. Per item across a batch, that gap compounds.
Is there another Jev MCP? Yes. jkudish/jev-mcp (Node/npm) offers ten workflow-shaped tools, and a Go server exists. This one is the Python/uvx side: faithful official question types, one-command install, bilingual docs, MIT.
License
Available Tools
5 toolschoiceA
Ask Jev (TypeSafe System One) to pick ONE of 2-100 mutually exclusive options, with calibrated probabilities.
The official choice question type — for fast, cheap structured decisions:
triage, routing, classification, prioritization, tie-breaking among enumerated
candidates. Returns probabilities over ALL options (not just the winner), so
near-ties are visible. NOT for open-ended generation or multi-step reasoning —
use an LLM for those.
Args: question: The decision, e.g. "Which error class is most likely the root cause?" options: Mapping of short unique id -> one-line description. 2-100 options. context: Optional background facts that inform the decision. Keep it short.
Returns: JSON string: {choice, confidence, probabilities (sorted desc), runner_up, model, latency_ms, usage}
Inputs: options (required), question (required), context. Returns: result
classifyA
Batch-classify up to 100 items against ONE shared set of categories using Jev.
Runs the official choice question type once per item and aggregates the
results — routing support tickets, labeling log lines, triaging inbox items
against your own label set. Much cheaper and faster than an LLM for
mechanical labeling.
Args: items: 1-100 non-empty strings to classify. options: Mapping of short unique id -> one-line category description. 2-100 options. question: Per-item question; the item itself is appended automatically. context: Optional background facts shared by all items.
Returns: JSON string: {results: [{item, choice, confidence, probabilities}], summary (counts per choice, sorted desc), model, total_latency_ms, usage: {input_tokens, output_tokens, calls, cached_calls}}
Inputs: items (required), options (required), context, question. Returns: result
noulA
Ask Jev (TypeSafe System One) a yes/no question; returns a 0-1 degree (>= 0.5 leans yes).
The official noul question type — fast, cheap binary checks: "is this change
breaking?", "does this log line match the reported symptom?". No probability
list, just the degree. NOT for questions that need multi-step reasoning — use
an LLM for those.
Args: question: A yes/no question, e.g. "Is renaming a public config key a breaking change?" context: Optional background facts. Keep it short.
Returns: JSON string: {noul, verdict, model, latency_ms, usage}
Inputs: question (required), context. Returns: result
scoreA
Ask Jev (TypeSafe System One) to grade something on an ORDERED scale of 2-8 levels.
The official score question type — risk/severity/quality rubrics, e.g.
levels ["minor", "moderate", "severe", "critical"]. Returns a fractional
0-based index into levels (1.88 = between levels[1] and levels[2], leaning
to levels[2]), plus confidence and per-level probabilities.
Args: question: What to grade, e.g. "Regression risk of renaming public config key X". levels: 2-8 unique ordered scale points, low to high. context: Optional background facts. Keep it short.
Returns: JSON string: {score, nearest_level, confidence, probabilities (sorted desc), model, latency_ms, usage}
Inputs: levels (required), question (required), context. Returns: result
setupA
One-time onboarding: verify a TypeSafe API key with a live call, then store it locally.
Use when TYPESAFE_API_KEY is not set in the server environment: pass your key once (get one at https://console.typesafe.ai/settings/keys). It is verified against the live API, then saved to ~/.config/jev-mcp/key (permissions 0600) and never echoed back. An existing TYPESAFE_API_KEY env var always takes precedence over the stored file.
Args: api_key: Your TypeSafe API key (from console.typesafe.ai/settings/keys).
Returns: JSON string: {ok, stored_path, verified}
Inputs: api_key (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool has a clearly distinct purpose: setup handles key onboarding, while noul, choice, score, and classify map to different question types (binary, single-choice, ordered-scale, batch). The descriptions explicitly call out boundaries, such as noul being for yes/no only and classify being a batched version of choice.
Tool names are all single lowercase words with no mixed conventions, which keeps them readable and predictable. The slight deviation is that setup describes an action while noul, choice, score, and classify follow the official TypeSafe question-type naming, but this is minor and does not cause confusion.
Five tools is well-scoped for a focused Jev/TypeSafe MCP server: one setup tool plus four distinct query/question types. Each tool maps to a clear capability and none feel redundant or missing.
The tool surface covers the full apparent lifecycle of using Jev: setup for authentication and noul/choice/score/classify for the available question types. There are no obvious dead ends—setup returns verification, every query tool returns structured results, and classify aggregates batch outputs.
Related MCP Connectors
Independent statistical feature evaluation for machine learning and forecasting. ML Referee tests up to 1,000 candidate features in one run against a declared baseline, helping researchers and AI agents decide which inputs to pursue, which bounded feature repairs merit further testing, and where more evidence is needed—without a separate ablation run for every feature. Use the MCP tools to discover input schemas, check access and credits, preflight a dataset, obtain a quote, submit an authorized evaluation, and retrieve structured results and reports. Results are scoped to the submitted evidence and evaluation design; they do not guarantee future model performance. Invite-only beta with manual approval. Public tool discovery requires no authentication; account and evaluation tools require OAuth through approved client connections and available evaluation credits. Connect directly to https://api.mlreferee.com/mcp. Website: https://mlreferee.com Request beta access: https://mlreferee.com/beta Agent setup and documentation: https://mlreferee.com/agents
A paid remote MCP for Skybridge, built to return verdicts, receipts, usage logs, and audit-ready JSO
MCP server providing access to the Scorecard API to evaluate and optimize LLM systems.
A paid remote MCP for HyperFrames, built to return verdicts, receipts, usage logs, and audit-ready J
Related MCP Servers
- AlicenseAqualityCmaintenanceEnables MCP clients to call TypeSafe's JEV classifier and receive structured, typed judgments with probabilities for binary, choice, and scoring questions.18MIT
- AlicenseNot gradedqualityCmaintenanceEnables MCP clients to consult TypeSafe's Jev through a judge tool, answering narrow typed questions with calibrated probabilities instead of prose.24 npm1MIT

Jev MCPofficial
AlicenseNot gradedqualityBmaintenanceProvides MCP clients with typed, probabilistic decisions (choices, probabilities, scores) from TypeSafe's System One model, offering validated outputs and flexible provider support.3Apache 2.0- AlicenseNot gradedqualityCmaintenanceEnables MCP clients to get machine-readable yes/no, choice, and score decisions from TypeSafe Jev, bridging fast classification to Cursor and other clients.MIT