jev-netlify-mcp
Provides a key-locked proxy deployed on Netlify that forwards TypeSafe Jev API calls through Netlify AI Gateway, enabling Jev access using Netlify free-plan credits.
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-netlify-mcpAsk Jev whether this support email is urgent and which team should handle it."
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-netlify-mcp
Use TypeSafe's Jev (a System One decision model) from Claude Code, Codex CLI, Claude Desktop or any MCP client, paid for by your free Netlify credits and locked with a key only you have.
It has two parts:
A key-locked Netlify proxy (
proxy/). One small function that exposes the TypeSafe API routes (POST /v1/systemone,GET /v1/models) and forwards calls through Netlify AI Gateway. Netlify injects the gateway credentials, so you never create a TypeSafe API key. Requests without your key get401and never reach the model.An MCP server (
src/jev_netlify_mcp/). Two tools,jev_evaluateandjev_models, plus instructions that teach the agent how to ask Jev good questions (atomic questions, the three question types, translating non-English input to English and reporting back in the user's language, flagging low-confidence answers).
The MCP server also works directly against the TypeSafe API if you already have a key.
Why
There are many Jev MCP servers already. This one exists for the part they do not cover: getting private Jev access without a TypeSafe balance, by using the Netlify free plan (300 credits per month). In our measurement 18,000 Jev tokens cost 0.11 credits. The larger cost is deploying: each production deploy uses 15 credits, so deploy once and leave it.
Related MCP server: jev-bridge
Requirements
Python 3.10+
A Netlify account (the free plan is enough) with AI features left enabled
Node.js 20+ only if you want to run the proxy tests
Setup
git clone <this repo URL>
cd jev-netlify-mcp
pip install . # installs the jev-netlify-mcp command
python scripts/setup.py new-key # creates your key, builds dist/jev-proxy.zipSign in to Netlify, then deploy dist/jev-proxy.zip with Netlify Drop
(drag the zip or the dist/site folder). Without signing in, Drop sites expire. Netlify Drop sites are production deploys, which is what activates
AI Gateway. Then save the site address and check it:
python scripts/setup.py set-url https://<your-site>.netlify.app
python scripts/setup.py check # expects 401 without key and 200 with key
python scripts/setup.py check --live # also asks Jev one question (tiny credit use)The key is stored in your user config file (%APPDATA%\jev-netlify-mcp\config.env on Windows,
~/.config/jev-netlify-mcp/config.env elsewhere) and, on Windows, in your user environment
variables. Only its SHA-256 hash is put into the function. setup.py never prints the key unless
you run show-key.
If you would rather keep the hash out of the deployed file, set a Netlify environment variable named
JEV_PROXY_KEY_SHA256 to the hash and redeploy. Do not name it TYPESAFE_*: if you set those
yourself, Netlify stops injecting the AI Gateway credentials.
Connect your agent
Claude Code
claude mcp add --scope user jev -- jev-netlify-mcpCodex CLI (~/.codex/config.toml)
[mcp_servers.jev]
command = "jev-netlify-mcp"
# optional: let `codex exec` call the tools without asking
[mcp_servers.jev.tools.jev_evaluate]
approval_mode = "approve"
[mcp_servers.jev.tools.jev_models]
approval_mode = "approve"Claude Desktop (claude_desktop_config.json)
{
"mcpServers": {
"jev": { "command": "jev-netlify-mcp" }
}
}If the command is not on your PATH, use the full path to your Python and
["-m", "jev_netlify_mcp"] as arguments.
Then just ask, for example: "Use Jev: is this support email urgent, and which team should get it: sales, logistics or tech support?"
Configuration
Variable | Meaning |
| Your Netlify site address |
| Your proxy key |
| Fallbacks, so the server also works with the TypeSafe API directly |
Each value is looked up in the process environment, then (Windows) the user registry environment,
then the config file. The registry step matters because some MCP clients do not pass environment
variables to the server. Set JEV_NETLIFY_MCP_NO_REGISTRY=1 to skip the registry.
The official TypeSafe SDKs also work with the proxy: point TYPESAFE_BASE_URL at your site and set
TYPESAFE_API_KEY to your proxy key (python scripts/setup.py show-key).
Tools
jev_evaluate(state, questions, model="jev-latest"): one call per text, as many questions as you like. Question types:noul(yes/no, returns a probability),choice(one of named options) andscore(ordered levels, up to 10). State and questions share about 32k tokens.jev_models(): lists the models on the endpoint.
Security notes
Keep your site address and key to yourself. Anyone with both can spend your credits.
If the key leaks:
python scripts/setup.py new-key --force, then deploydist/again.Free plan AI Gateway limit is 90 credits per minute. When credits run out the site stops until the next month; there are no overage charges on the free plan.
Tests
node --test tests/*.test.mjs # proxy function, offline
python -m pytest tests -q # MCP server over stdio (fake Jev) plus setup.pyDisclaimer
Not affiliated with TypeSafe or Netlify. Jev, TypeSafe and Netlify are their owners' trademarks. Check the current Netlify and TypeSafe terms before relying on this.
License
MIT
Available Tools
2 toolsjev_evaluateB
Evaluate one text (state) against typed questions with Jev and return calibrated answers. state: string or JSON object (English works best). questions: {name: {type: 'noul'|'choice'|'score', instructions: str, criteria?: ...}}. noul criteria optional {true, false}; choice criteria {option: description}; score criteria [level0, level1, ...] from low to high. model defaults to jev-latest.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | jev-latest | |
| state | Yes | ||
| questions | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It notes that English works best and that model defaults to jev-latest, but does not state whether the tool is read-only, what permissions or costs apply, how errors are handled, or what side effects exist.
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 dense but front-loaded, starting with the core action before detailing parameters. Every sentence carries relevant information, though the compact single-paragraph format could be structured more readably for complex nested types.
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 lack of annotations, output schema, and any schema descriptions, the description adequately covers input parameters but does not explain the return shape of 'calibrated answers' or provide usage context. It is sufficient for forming a call but leaves gaps around output interpretation and tool selection.
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 0%, so the description must compensate, and it does substantially. It defines state as string or JSON, explains the questions object with question names, type options (noul, choice, score), instructions, and criteria formats, and states the model default. Some nested criteria semantics remain slightly cryptic, but the coverage is strong.
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 and resource: evaluate one text (state) against typed questions with Jev and return calibrated answers. It is clear what the tool does and how it differs from the sibling jev_models, though it does not explicitly name or contrast the sibling.
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 explains input structure but gives no explicit guidance on when to use this tool versus alternatives, nor any when-not conditions or prerequisites. Usage is only implied by the evaluation purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jev_modelsB
List the Jev models and aliases available on this endpoint.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure, and it discloses almost nothing: no confirmation that it is a read-only/non-mutating call, no auth requirements, no pagination or result-size behavior. The only hint is the word 'List', which weakly implies a safe read.
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?
A single front-loaded sentence with no filler; every word earns its place and the resource is named before the qualifier.
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 simple no-argument list tool this is close to sufficient, but with no output schema and no annotations the description could reasonably state what the returned items look like (model names, aliases) or how they are consumed by jev_evaluate. It is adequate but leaves a small gap.
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?
The schema declares zero parameters at 100% coverage, so there is nothing for the description to compensate for; the baseline for a no-parameter tool applies.
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?
Specific verb (List) plus resource (Jev models and aliases) with a scoping qualifier ('available on this endpoint'), so an agent can immediately tell what the tool returns. It does not, however, differentiate itself from the sibling jev_evaluate or state what a 'model' means in this context.
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?
No guidance on when to call this versus jev_evaluate, no prerequisites, and no statement of typical workflow (e.g., list models first, then evaluate). Usage is only inferable from the verb 'List'.
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.
2 tool updates
v0.1.0- First observed
jev_evaluate - First observed
jev_models
TDQS
Scored across 2 tools
The two tools are clearly distinct: one evaluates text against typed questions, while the other lists available models. There is no overlap in purpose or parameters that would cause misselection.
Both names use a consistent jev_ prefix and snake_case, but jev_evaluate is action-oriented while jev_models is a resource listing. This is a minor deviation from a pure verb_noun pattern.
Two tools is thin for a server, though each tool has a valid role in a minimal evaluation API wrapper. It is borderline rather than clearly well-scoped or severely mismatched.
The core evaluation workflow and model discovery are covered, but there are minor gaps such as no batch evaluation, validation, or result-retrieval tooling. These are workable omissions for a thin MCP wrapper.
Maintenance
Related MCP Connectors
Build, validate, deploy — HTTP APIs, cron jobs, webhooks and MCP tools — from your AI client.
- QuallaaOAuthcom.quallaa
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
A paid remote MCP for OpenAI Codex agent coordination MCP, built to return verdicts, receipts, usage
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceEnables MCP hosts to query Jev's typed decision model—yes/no, choice, and score—with calibrated probabilities, while defaulting to an offline mock and disclosing all egress unless explicitly enabled.106Apache 2.0
- AlicenseNot gradedqualityAmaintenanceEnables Claude Code or any MCP client to ask TypeSafe's Jev for calibrated, typed judgments (probabilities, choices, scores) instead of prose, with local caching and cost tracking.1MIT
- AlicenseAqualityCmaintenanceEnables running Jev AI typed decisions from any MCP client, returning choices, scores, or yes/no with calibrated probabilities.316 npmMIT
- AlicenseAqualityBmaintenanceEnables AI coding agents to offload yes/no, multiple-choice, and scoring questions to TypeSafe's Jev, returning compact confidence-scored answers to save tokens and improve speed.1MIT