# jevcore-mcp [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/PerryLink/jevcore  
**GitHub Stars:** 102  
**npm Downloads (last month):** 1906  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/jevcore-mcp

## Description
TypeSafe Jev over the Model Context Protocol: typed judgments (ask, rank, check) that return calibrated probabilities instead of prose.

## Tools
Capabilities this server exposes over MCP:

- **jev_ask** — Ask TypeSafe Jev one or more typed questions about a single piece of state. Jev does not generate text: it returns a selected option and calibrated probabilities. Use it for judgments the rest of the work branches on — routing, classifying, scoring, triaging. Do NOT use it to write prose, explain, summarize, or generate code.

Question types: "noul" is yes/no and returns the probability of true; "choice" picks one of the criteria keys you declare; "score" places the state on an ordered scale whose levels you declare in ascending order. A noul may also declare "boundary" — what true means and what false means — which is worth supplying whenever the line between them is not obvious.

Batch related questions into one call: they are answered against the same state in one round-trip. A score question answers with a numeric "score" that may fall between levels, a "legend" mapping each level index to its description, and probabilities per level. This tool returns probabilities, not decisions — apply your own confidence threshold before acting, and treat a low-confidence answer as unknown rather than picking for it.
- **jev_rank** — Rank a list of candidates by how well each satisfies one stated criterion. Returns every candidate with an independent relevance probability, sorted. Use it to order search hits, triage a backlog, or find the one item that answers a question.

The probabilities are independent per-candidate judgments, NOT a distribution that sums to 1. A flat set of scores means "none of these stands out", not a fine-grained ordering.

What you send is capped, and the two caps behave differently. The candidate list is truncated at 16,000 characters, and the reply carries `truncated: true` when that happens — check for it, because a cut list is still ranked and the scores then describe what Jev actually read rather than what you sent. The generated questions are refused at 4,000 characters instead: exceeding that gives you an error asking for fewer or smaller items, never a silent best-N, so retrying the same call cannot help. Because the criterion is repeated into every candidate's question, that second cap is what bounds the candidate count — measured, an ordinary criterion fits 20 candidates and a 400-character criterion fits 7, while candidate length does not change the count at all and only starts truncating the list past roughly 1,600 characters per candidate.
- **jev_check** — Check whether a piece of evidence supports a specific claim. Returns "supported", "contradicted", "conflicted", "insufficient", or "unknown", with the underlying probabilities. The distinction between "not supported" and "contradicted" is the reason to use this rather than reading the evidence yourself.

It judges one claim against the evidence you give it. It does not search for evidence, and it cannot detect that you omitted the decisive passage.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "jevcore-mcp": {
    "command": "npx",
    "args": ["-y","jevcore-mcp"]
  }
}
```

## Documentation

## What the jevcore-mcp MCP server does

The jevcore-mcp MCP server makes Jev's decision primitives available to MCP hosts that are not running DeepSeek Harness. It provides three typed operations: asking a yes/no-style question, ranking alternatives, and checking a claim against evidence. Results are calibrated probabilities and structured answers, not generated explanations or general-purpose prose.

The MCP package is a thin adapter around the shared `jevcore` decision layer. This keeps the judgment types, provider selection, policy, redaction, and egress behavior consistent with the project's other adapters. The package requires Node.js 20 or newer.

## How it works

Start the server as a stdio process with `npx -y jevcore-mcp`. MCP messages use stdout as the protocol channel, while startup and egress status are written to stderr. The host can then invoke `jev_ask`, `jev_rank`, or `jev_check` when an agent chooses to use them.

Without provider credentials, the process uses an offline mock. This path makes no network calls and produces synthetic answers. A live provider is selected through environment settings and resolves its credential once during startup. The available routes are TypeSafe directly or OpenRouter when a TypeSafe key is not selected.

Each enabled transmission is reported at startup. Tool calls send the arguments supplied by the model after redaction; ranking includes the query and candidates, while checking includes the claim and evidence. Redaction removes values under recognized sensitive field names and matches several known secret formats before live transmission.

## Setup and configuration

The basic setup requires an MCP host that can launch a stdio server and this command:

```sh
npx -y jevcore-mcp
```

The provider environment can be controlled with `JEV_PROVIDER`, using `mock`, `live`, or `openrouter`. `TYPESAFE_API_KEY` selects the TypeSafe route, and `OPENROUTER_API_KEY` selects OpenRouter when no TypeSafe key is present. `TYPESAFE_MODEL` and `OPENROUTER_MODEL` choose model identifiers; the corresponding `*_BASE_URL` variables change the API root.

No key is needed for the default mock mode. If `JEV_PROVIDER=live` is set without a resolvable credential, startup fails rather than silently changing behavior. When embedding the process in DeepSeek Harness, pass credentials through the MCP client's explicit environment map because the harness removes credential-shaped variables from a spawned server environment before merging configured values back in.

## Tools and capabilities

The jevcore-mcp MCP server exposes:

- `jev_ask` for typed questions using the Jev question surface.
- `jev_rank` for comparing a query against candidate options.
- `jev_check` for evaluating a claim with supporting evidence.

The tools run only when called by the model. Optional safety and context gates belong to the broader plugin design and are not automatically enabled for MCP use. The MCP transport itself is stdio rather than an HTTP endpoint.

## Limitations and notes

Jev is not a conversational model. It is intended for typed judgments, so requests for prose are outside the provided decision surface. The default mock provider is synthetic and should not be treated as a live assessment.

Live use can transmit state and tool inputs to the selected provider. Redaction is best effort: recognized field names and known secret patterns are handled, but an unrecognized secret in free text may pass through. Do not enable the live provider if that residual risk is unacceptable.

The server reports its egress contract on stderr so protocol output remains valid. The tools' transmissions are visible when invoked, but any broader gate behavior should be considered separately because gates can inspect matching tool calls and are opt-in in the project design.

_Full upstream README: https://allmcps.com/mcp/jevcore-mcp/readme_