Summary: This MCP server lets an MCP client evaluate typed questions against any System One backend (Ollama nimble/tev/clef, TypeSafe jev, Kev, Laya) and discover available models.
systemone_evaluate — answer typed choice / score / noul questions about a given state using a System One model.
state accepts a non-empty string, arbitrary object, or array (the situation/context to analyze).
questions is a map of question name → typed question spec:
choice: pick from named criteria (label → description).
score: rate against 2–10 ordered criteria strings.
noul: no-label/boolean-style question with optional true/false criteria text.
instructions on any question can be a string, object, or array.
Optional images array (image strings) for multimodal input.
Optional model (free-form non-empty string, not a fixed enum); falls back to SYSTEMONE_MODEL (default nimble).
Optional keep_alive (string or number) to control backend model lifetime.
systemone_list_models — list the System One models available on the currently configured backend (no inputs).
Backend routing — calls {SYSTEMONE_BASE_URL}/v1/systemone, optionally with Authorization: Bearer <SYSTEMONE_API_KEY> for TypeSafe cloud / Kev / Laya.
Deployment — runs over stdio via npx -y @es11225599/systemone-mcp or bunx, with no local build required.
Provides access to System One models on an Ollama backend, allowing users to evaluate typed choice/score/noul questions and list available System One models.
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., "@system-one-mcp Ask nimble to choice-label 'Checkout 500s since 9am' as billing, bug, or account."
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.
MCP server for any System One backend (Ollama nimble/tev/clef, TypeSafe jev, Kev, Laya).
Exposes two stdio tools:
systemone_evaluate — answer typed choice / score / noul questions with a System One model
systemone_list_models — list available System One models on the configured backend
Thin Zod-validated passthrough: MCP tools -> fetch({baseUrl}/v1/systemone) with optional Bearer key. model is a free-form non-empty string (never a hard-coded enum).
Run it with npx or bunx — see Install.
Variable | Default | Notes |
|
| Must start with |
| (unset) | Optional. TypeSafe cloud / Kev with key / Laya with |
|
| Default model when the tool call omits |
See .env.example for a copy-paste starting point.
Related MCP server: McpHub
No build, no clone, no npm install — the published package ships prebuilt, so npx/bunx fetch a ready-to-run server.
npx -y @es11225599/systemone-mcpbunx @es11225599/systemone-mcpRequires Node >= 20 (or Bun). First run downloads the package; later runs are cached.
Point any MCP client at the runner. Nothing to build or install locally:
{
"mcpServers": {
"system-one": {
"command": "npx",
"args": ["-y", "@es11225599/systemone-mcp"],
"env": {
"SYSTEMONE_BASE_URL": "http://localhost:11434",
"SYSTEMONE_MODEL": "nimble"
}
}
}
}With Bun, swap the command and args:
{
"mcpServers": {
"system-one": {
"command": "bunx",
"args": ["@es11225599/systemone-mcp"],
"env": {
"SYSTEMONE_BASE_URL": "http://localhost:11434",
"SYSTEMONE_MODEL": "nimble"
}
}
}
}Both forward stdio, so the server is fully wired either way. If your client resolves binaries through a shell, npx.cmd / bunx.cmd are the Windows equivalents.
claude mcp add system-one \
-e SYSTEMONE_BASE_URL=http://localhost:11434 \
-e SYSTEMONE_MODEL=nimble \
-- npx -y @es11225599/systemone-mcpnpm install
npm run build
SYSTEMONE_BASE_URL=http://localhost:11434 node dist/index.jsWindows PowerShell:
npm install
npm run build
$env:SYSTEMONE_BASE_URL="http://localhost:11434"; node dist/index.jsnpm run dev (tsx) skips the build for local iteration.
For TypeSafe cloud / Kev / Laya, add "SYSTEMONE_API_KEY": "<key>" to env and point SYSTEMONE_BASE_URL at that backend.
Direct HTTP check against an Ollama backend running nimble (bypasses MCP, same endpoint the server calls):
curl http://localhost:11434/v1/systemone \
-H 'Content-Type: application/json' \
-d '{"model":"nimble","state":"Our checkout has returned 500 errors since 9am.","questions":{"label":{"type":"choice","instructions":"Which label fits?","criteria":{"billing":"Payments","bug":"Errors","account":"Login"}}}}'Expected: JSON with model, answers.label, and usage (input_tokens / output_tokens).
Answer typed choice/score/noul questions with a System One model (jev/nimble/kev/tev/laya).
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | ||
| state | Yes | ||
| images | No | ||
| questions | Yes | ||
| keep_alive | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It says nothing about whether models must be loaded, what state represents, what keep_alive does, latency characteristics, or what the response contains. For a tool with nested question objects and no output schema, this is a significant gap.
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 efficient sentence with no wasted words, and the core verb is front-loaded. It is terse to the point of under-specification, but structurally sound.
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 a complex nested schema (three question-type variants), 5 undocumented parameters, no annotations, and no output schema, the description is far too thin. An agent cannot determine valid state/image formats or how question criteria should be shaped.
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% across 5 parameters. The description maps loosely onto two of them (model names and the 'choice/score/noul' question types), but state, images, and keep_alive are entirely undocumented in both schema and description. It does not compensate for the coverage gap.
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?
States a specific verb+resource: 'Answer typed choice/score/noul questions with a System One model.' It also enumerates the supported models (jev/nimble/kev/tev/laya), which is concrete. However, it does not distinguish itself from the sibling systemone_list_models or clarify what 'noul' means, so it stops short of a 5.
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?
There is no guidance on when to use this tool versus alternatives, and the sibling systemone_list_models (presumably for discovering valid model names) is never mentioned. The model list is embedded but without stating that a call to list_models may be a prerequisite.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List available System One models on the configured backend.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It hints that results depend on a 'configured backend' but says nothing about return format, whether configuration/auth is required first, or error behavior when no backend is set.
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 zero filler. Every word earns its place.
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?
No output schema exists, so the description should convey what a 'model' listing contains (names, IDs, capabilities), but it does not. For a simple no-arg discovery tool this is a moderate gap rather than a fatal one.
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 tool takes zero parameters, so there is nothing to disambiguate; the baseline for a parameterless 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?
States a specific verb and resource (List ... System One models) plus a scoping qualifier ('configured backend'). This is unambiguous, though it does not explicitly contrast itself with the sibling systemone_evaluate, which is a very different action anyway.
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?
Usage is only implied – an agent can infer this is a discovery step preceding an evaluation, but the description never states when to call it, whether it needs prior configuration, or what alternatives exist.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0systemone_evaluatesystemone_list_modelsScored across 2 tools
The two tools serve clearly distinct purposes: one enumerates available models and the other runs an evaluation with a chosen model. There is no overlap in resource or action, so an agent cannot realistically confuse them.
Both names share the 'systemone_' snake_case prefix, which is predictable and readable. The minor deviation is that 'evaluate' is a bare verb without a noun object unlike 'list_models', but the set still feels coherent.
Two tools is thin even for a narrow evaluation-model domain; there is no separate model-detail, configuration, or result-retrieval tool. It is borderline rather than mismatched, since the core discover-then-evaluate flow is present.
The surface covers the minimal loop of listing models and evaluating a question, but lacks supporting operations such as fetching model metadata, setting backend configuration, or retrieving/batching prior evaluations. Agents can work around this only by relying on external configuration.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
