Skip to main content
Glama

jev-mcp

MCP server wrapping TypeSafe's Jev System One models. Instead of prompt-and-parse, agents get typed judgments they can use directly in code: yes/no probabilities, multiple-choice selections with distributions, and rubric-based scores.

Tools

Tool

What it does

Returns

jev_evaluate

Evaluate state against a map of typed questions in one call (they run in parallel)

{model, answers, usage}

jev_noul

Yes/no judgment

{type, noul} — 0 = no … 1 = yes, near 0.5 = uncertain

jev_choice

Pick one option from criteria: {"option": "rubric…"}

{choice, probabilities, confidence}

jev_score

Rate along 2–10 ordered level descriptions

{score, legend, probabilities, confidence}

jev_models

List models your key can use

{models: [{name, …}]}

Every tool takes state (string, object, or array — the content to judge), an optional model (default "jev-latest"), and an optional endpoint ("direct" or "zen", default "direct").

Related MCP server: Jev MCP Proxy

Prerequisites

  • Python 3.10+ and uv (or plain pip)

  • A TypeSafe API key → TYPESAFE_API_KEY

    • Optional: an OpenCode Zen key → OPENCODE_API_KEY, only if you want endpoint="zen" (models jev-1.13 / jev-1.13-free)

Quickstart

git clone https://github.com/rajasekharponakala/jev-mcp.git
cd jev-mcp
cp .env.example .env   # then put your key in .env (never commit it)
uv run --with fastmcp --with httpx server.py

Or with an installed environment:

pip install -e .
export TYPESAFE_API_KEY=...
jev-mcp

Client configuration

OpenCode (~/.config/opencode/opencode.json)

{
  "mcp": {
    "servers": {
      "jev": {
        "type": "local",
        "command": ["uv", "run", "--with", "fastmcp", "--with", "httpx", "server.py"],
        "cwd": "/path/to/jev-mcp",
        "environment": {
          "TYPESAFE_API_KEY": "{env:TYPESAFE_API_KEY}"
        }
      }
    }
  }
}

Claude Code

claude mcp add jev -e TYPESAFE_API_KEY=... -- uv run --with fastmcp --with httpx /path/to/jev-mcp/server.py

Codex CLI (~/.codex/config.toml)

codex mcp add jev --env TYPESAFE_API_KEY=... -- uv run --with fastmcp --with httpx /path/to/jev-mcp/server.py

or manually:

[mcp_servers.jev]
command = "uv"
args = ["run", "--with", "fastmcp", "--with", "httpx", "/path/to/jev-mcp/server.py"]
env = { TYPESAFE_API_KEY = "..." }

Gemini CLI (~/.gemini/settings.json)

{
  "mcpServers": {
    "jev": {
      "command": "uv",
      "args": ["run", "--with", "fastmcp", "--with", "httpx", "/path/to/jev-mcp/server.py"],
      "env": { "TYPESAFE_API_KEY": "..." }
    }
  }
}

Cursor (~/.cursor/mcp.json)

{
  "mcpServers": {
    "jev": {
      "command": "uv",
      "args": ["run", "--with", "fastmcp", "--with", "httpx", "/path/to/jev-mcp/server.py"],
      "env": { "TYPESAFE_API_KEY": "..." }
    }
  }
}

Windsurf (~/.codeium/windsurf/mcp_config.json)

{
  "mcpServers": {
    "jev": {
      "command": "uv",
      "args": ["run", "--with", "fastmcp", "--with", "httpx", "/path/to/jev-mcp/server.py"],
      "env": { "TYPESAFE_API_KEY": "..." }
    }
  }
}

Cline (~/.cline/mcp.json, or cline mcp wizard)

{
  "mcpServers": {
    "jev": {
      "command": "uv",
      "args": ["run", "--with", "fastmcp", "--with", "httpx", "/path/to/jev-mcp/server.py"],
      "env": { "TYPESAFE_API_KEY": "..." },
      "disabled": false
    }
  }
}

Goose (~/.config/goose/config.yaml)

goose session --with-extension "jev:TYPESAFE_API_KEY=... uv run --with fastmcp --with httpx /path/to/jev-mcp/server.py"

or persist in config:

extensions:
  jev:
    name: Jev
    cmd: uv
    args: ["run", "--with", "fastmcp", "--with", "httpx", "/path/to/jev-mcp/server.py"]
    enabled: true
    envs: { "TYPESAFE_API_KEY": "..." }
    type: stdio
    timeout: 300

Claude Desktop / VS Code / other MCP JSON clients

{
  "mcpServers": {
    "jev": {
      "command": "uv",
      "args": ["run", "--with", "fastmcp", "--with", "httpx", "/path/to/jev-mcp/server.py"],
      "env": { "TYPESAFE_API_KEY": "..." }
    }
  }
}

(VS Code: same shape in ~/.vscode/mcp.json.)

FastMCP one-liner

The server object is named mcp, so FastMCP can install it directly:

fastmcp install claude-code /path/to/jev-mcp/server.py

then add TYPESAFE_API_KEY via that client's config.

Example

// tool call: jev_choice
{
  "state": "Help! My payouts have been failing for 3 days.",
  "instructions": "Which team should handle this?",
  "criteria": {
    "billing": "Payments, invoicing, refunds",
    "technical": "Bugs, outages, integrations",
    "sales": "Pricing, upgrades, new accounts"
  }
}
// → {"choice": "billing", "probabilities": {"billing": 0.88, ...}, "confidence": 0.81}

See the TypeSafe docs (source of truth) and the API reference for question design: one narrow judgment per question, batch independent questions, keep policy and thresholds in your code.

Development

uv run --with fastmcp --with httpx python -c "
import asyncio, server
print(sorted(t.name for t in asyncio.run(server.mcp.list_tools())))
"

License

AGPL-3.0-only. Copyright (c) 2026 rajasekharponakala.

Available Tools

5 tools
jev_choiceJev ChoiceB

Pick one option. criteria: {"option": "rubric..."}. Returns choice + probabilities + confidence.

Inputs: state (required), criteria (required), instructions (required), model, +1 more. Returns: object

jev_evaluateJev EvaluateA

Evaluate state against typed questions. Returns {model, answers, usage}.

questions: {"id": {"type": "noul"|"choice"|"score", "instructions": ..., "criteria": {...} or [...]}}. Batch independent questions in one call; they run in parallel. endpoint: "direct" (TYPESAFE_API_KEY) or "zen".

Inputs: state (required), questions (required), model, endpoint. Returns: object

jev_modelsJev ModelsA

List models your key can use (GET /v1/models on direct; static list on zen).

Inputs: endpoint. Returns: object

jev_noulJev NoulC

Yes/no judgment. Returns {type, noul (0=no..1=yes)}. Near 0.5 = uncertain.

Inputs: state (required), instructions (required), model, endpoint, +2 more. Returns: object

jev_scoreJev ScoreC

Rate along ordered levels (2-10 concrete descriptions). Returns score + legend + probabilities.

Inputs: state (required), criteria (required), instructions (required), model, +1 more. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 5 tools

    Disambiguation3/5

    jev_evaluate subsumes the other evaluation tools, creating potential overlap. The descriptions clarify that evaluate is for batched/mixed types while the specialized tools handle single questions, but an agent could still be unsure which to use for a one-off noul or choice query.

    Naming Consistency4/5

    All tools share the 'jev_' prefix in lowercase snake_case, making them easily recognizable as a family. The names mix verbs and nouns (evaluate, models vs noul, choice, score), but the uniform prefix and short, predictable tokens keep the pattern strong.

    Tool Count5/5

    Five tools is a well-scoped size for an evaluation API wrapper. It includes a general evaluator, three specialized question types, and a model discovery utility without unnecessary bloat.

    Completeness4/5

    The toolset covers all declared question types (noul, choice, score) and provides the necessary model listing capability. It lacks history or configuration management, but those are not implied by the server's focused purpose.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Enables frontier coding agents to delegate routine probabilistic judgments to TypeSafe Jev, providing calibrated triage signals for failures, attempts, completion, context ranking, findings, risk, and generic evidence-grounded questions.
      7
      MIT
    • A
      license
      B
      quality
      C
      maintenance
      Enables AI agent skills to route state-evaluation requests to TypeSafe AI's Jev System One model, supporting typed questions, choice classification, binary probabilities, and rubric scoring with calibrated confidence.
      4
      2
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      Enables coding or reasoning agents to request structured judgments from TypeSafe's Jev model at decision points, including choices, scores, claim verification, and code reviews, with probabilities and confidence returned as data.
      5
      13 npm
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables Claude Code agents to perform structured decision-making through TypeSafe Jev, supporting yes/no checks, route selection, scoring, and batched multi-question judgments with confidence values.
      1
      -