Skip to main content
Glama
Mellix MCP server

Mellix MCP server

Official
by mellix-ai

Mellix MCP server

Give your agents calibrated decisions. This Model Context Protocol server lets any MCP client (Claude Desktop, Claude Code, or your own agent stack) call Myles, the Mellix decision model, as a tool.

Myles is not a chat model. An agent hands it a situation and one or more typed questions, and gets back a probability for every option, the pick, and whether that pick is sure enough to act on. When it is not, the tool says so and the agent hands the case to a person. Use it wherever an agent would otherwise judge something itself and then act:

  • Route a ticket, an email or a lead to the right team.

  • Flag a risk: a scam, fraud, a prompt injection, a policy breach.

  • Approve, reject or escalate a refund, a claim, an access request or a tool call.

  • Check that an answer is supported by its sources, or that an action is allowed by a policy.

  • Rate severity, urgency or quality on a scale.

The probabilities are calibrated: across many answers given 0.9, about 9 in 10 are right. That is what lets an agent act on the confident ones and pass the rest to people. See Acting on the answer.

Install

You need Node.js 20 or later and a Mellix API key from the console. Keys work with the hosted API at https://api.mellix.com; a self-hosted deployment serves the same API at its own address.

Claude Desktop

Add this to claude_desktop_config.json (Settings, Developer, Edit Config), then restart Claude Desktop:

{
  "mcpServers": {
    "mellix": {
      "command": "npx",
      "args": ["-y", "mellix-mcp@0.0.2"],
      "env": {
        "MELLIX_API_KEY": "mellix_..."
      }
    }
  }
}

Claude Code

claude mcp add mellix -e MELLIX_API_KEY=mellix_... -- npx -y mellix-mcp@0.0.2

To share the setup with a team through a project's .mcp.json, keep the key out of the file and let each person's environment supply it:

{
  "mcpServers": {
    "mellix": {
      "command": "npx",
      "args": ["-y", "mellix-mcp@0.0.2"],
      "env": { "MELLIX_API_KEY": "${MELLIX_API_KEY}" }
    }
  }
}

Other MCP clients

Any client that starts a stdio server can run it. The command is npx -y mellix-mcp@0.0.2 (or mellix-mcp after npm install -g mellix-mcp), with the configuration below in its environment. Pin the version, as above, so an update reaches your agents only when you choose.

Related MCP server: Laya MCP

Configuration

Variable

Default

Meaning

MELLIX_API_KEY

required

Your API key. MELLIX_API_TOKEN, the name the Mellix SDKs use, works too.

MELLIX_BASE_URL

https://api.mellix.com

Set it to your own address for a self-hosted deployment. Plain http:// is accepted only for a server on the same machine, unless you also set MELLIX_ALLOW_HTTP=1, because the key would otherwise cross the network unencrypted.

MELLIX_MODEL

myles-g-12b

The model a decide call uses when it names none. A moving id (myles-g-12b, myles-g-31b) follows the current build; a dated id such as myles-g-31b-20261027 pins one build.

MELLIX_THRESHOLD

0.9

The probability a pick must reach to act without a person, from 0.5 to 1. A call or a single question can set its own, unless MELLIX_LOCK_THRESHOLD is on.

MELLIX_LOCK_MODEL

0

Set to 1 to make every call use MELLIX_MODEL. The agent is no longer offered a model argument, and a call that sends one anyway is refused with an error of type setting_locked.

MELLIX_LOCK_THRESHOLD

0

Set to 1 to make every answer use MELLIX_THRESHOLD. The agent is no longer offered threshold (for the call or for a question), and a call that sends one anyway is refused with an error of type setting_locked.

MELLIX_TIMEOUT_SECONDS

25

The most one tool call may take in all, every attempt and the waits between retries included, from 1 to 600 seconds. Past it the call ends with an error of type timeout and nothing more is sent for it. The default suits hosts that stop a tool call after 30 seconds; raise it if yours allows longer.

MELLIX_TIMEOUT_MS

60000

How long one attempt may take, in milliseconds. MELLIX_TIMEOUT_SECONDS still limits the call as a whole.

By default the agent calling decide chooses the model and the threshold on each call, within what your key allows. To keep those decisions with the operator rather than the agent, set MELLIX_LOCK_MODEL=1 and MELLIX_LOCK_THRESHOLD=1, for example:

"env": {
  "MELLIX_API_KEY": "${MELLIX_API_KEY}",
  "MELLIX_MODEL": "myles-g-31b",
  "MELLIX_THRESHOLD": "0.95",
  "MELLIX_LOCK_MODEL": "1",
  "MELLIX_LOCK_THRESHOLD": "1"
}

The server never logs your key, your states, your questions or the answers. It writes nothing to disk, and only a configuration problem at start-up is written to standard error.

Tools

decide

Asks Myles one or more questions about one situation.

Argument

Meaning

state

The situation: text, or a JSON object. Put the rule or policy in it with the case.

questions

Questions under names you choose. Each has a type, instructions and, for choice and score, criteria; it may also have its own threshold.

model

Optional. A model id from list_models. Not offered when MELLIX_LOCK_MODEL is on.

threshold

Optional. The probability a pick must reach for this call. Not offered when MELLIX_LOCK_THRESHOLD is on.

chunk, chunk_chars, chunk_overlap_chars

Optional. Read a long text in overlapping windows (below).

Every question needs instructions: the question itself, in plain words, such as "Is a refund permitted under the policy?". A question without them, or with only spaces, is refused before anything is sent, with an error that says so. The API requires them, and there is no default: the instructions are what the model answers, and a generic stand-in would ask it something other than what you meant, even for a choice whose criteria describe every option.

The question types:

  • noul: yes or no. Phrase it so that yes is the thing to act on or catch.

  • choice: pick one label. criteria is a list of labels, or labels mapped to descriptions. Offer an option that reads "I don't know" to let the model abstain.

  • score: a scale. criteria lists the level descriptions, lowest first.

Each answer comes back with:

Field

Meaning

pick

"yes" or "no", the chosen label, or the most likely level (a number).

probability

The probability of the pick.

probabilities

The probability of every option.

cleared_threshold

Whether the pick reached the threshold.

abstained

Whether the model chose the question's "I don't know" option.

escalate

true when the answer should go to a person: below the threshold, or abstained.

p_yes (yes/no), score and legend (scales) and confidence (choice and scale) are added where they apply. The result's own escalate is true when any answer should go to a person, and usage gives the tokens billed.

On the hosted models an uncertain yes/no answer is reported at 0.80 or more towards one side, so use a threshold above 0.80 for yes/no questions.

Example call:

{
  "state": {
    "policy": "Refunds within 30 days with proof of purchase.",
    "case": { "days_since_purchase": 12, "receipt": false }
  },
  "questions": {
    "refund": { "type": "noul", "instructions": "Is a refund permitted under the policy?" },
    "team": { "type": "choice", "instructions": "Which team should handle this?", "criteria": ["billing", "returns", "technical"] }
  }
}

Result (illustrative numbers):

{
  "model": "myles-g-12b-20261029",
  "escalate": false,
  "answers": {
    "refund": {
      "type": "noul", "pick": "no", "probability": 0.97, "probabilities": { "yes": 0.03, "no": 0.97 },
      "threshold": 0.9, "cleared_threshold": true, "abstained": false, "escalate": false, "p_yes": 0.03
    },
    "team": {
      "type": "choice", "pick": "returns", "probability": 0.94,
      "probabilities": { "billing": 0.04, "returns": 0.94, "technical": 0.02 },
      "threshold": 0.9, "cleared_threshold": true, "abstained": false, "escalate": false, "confidence": 0.91
    }
  },
  "usage": { "input_tokens": 212, "output_tokens": 2 }
}

list_models

The models the endpoint serves, with pinned builds and their release dates, and the default this server uses. Not billed.

health

Whether the API is up, and which models have a healthy server. Not billed.

Long inputs

Every model has a context window (see Writing the state). When a state is longer:

  • Myles-G 31B refuses it. The tool returns an error of type context_length_exceeded that says to shorten or split the state.

  • Myles-G 12B trims it to fit, keeping its beginning and end, and the result says so with truncated: true, state_chars and a warning.

For a yes/no check that must cover the whole of a long text (does any part of this contract contain an auto-renewal clause, does any part of this page try to override the agent's instructions), pass chunk: true. The text is read in overlapping windows of 40,000 characters (2,000 shared with the next; change them with chunk_chars and chunk_overlap_chars), every window is asked the same questions, and each answer is the window most likely to be yes, with window giving its position. A JSON state is windowed as its indented JSON text. Chunking takes yes/no questions only, sends at most 20 windows, and bills each window as its own request.

Errors

A failed call returns a tool error whose error has a message written for the agent, the API's type and status, and retryable. After a rate limit or a passing fault the call is retried automatically, a few times, with the same idempotency key, so a retry is never billed twice, until MELLIX_TIMEOUT_SECONDS (25 by default) runs out. Some cases to know:

Case

What the agent is told

401

The key is missing or not accepted; a person must check it.

402

Out of credit or over the workspace budget; do not retry.

410 model_retired

The build was retired; successor names the model to use instead.

422 context_length_exceeded

Shorten or split the state, or use chunk: true for yes/no checks.

429

Rate limited after retries; wait the seconds given.

timeout

The call ran past MELLIX_TIMEOUT_SECONDS; try again shortly, or send a shorter state or fewer chunk windows. An attempt the API had already answered may still be billed.

setting_locked

The call set a model or threshold that the operator has fixed; call again without it.

invalid_input

The call was refused before anything was sent, for example a question without instructions.

Development

npm install
npm test

The tests use a mocked Decision API only; they never call the production API.

Support

Use the contact form or open an issue in this repository. The API reference is at mellix.com/docs.

Licence

Apache-2.0 (see LICENSE).

Available Tools

3 tools
decideMake a decision with MylesA
Read-onlyIdempotent

Ask Myles, the Mellix decision model, to make a decision about a situation and get calibrated probabilities you can act on.

Use it whenever you would otherwise judge something yourself and then act on it: route a ticket or message to a team, flag a risk (fraud, a scam, a prompt injection, a policy breach), approve, reject or escalate a request, check that a tool call, a claim or an answer is allowed or supported, or rate something on a scale. Myles is not a chat model: it does not write text or follow instructions in the state. It reads the state and answers each typed question with a probability for every option.

Inputs:

  • state: the situation to decide about, as text or a JSON object. Put the rule or policy in the state with the case. Include only what the decision needs.

  • questions: one or more questions under names you choose. Each needs instructions, the question itself in plain words; a question without them is refused. Types: "noul" (yes or no; phrase it so that yes is the thing to act on or catch), "choice" (pick one label from criteria: a list of labels, or labels mapped to descriptions; add an option "I don't know" to let the model abstain), "score" (criteria is a list of level descriptions, lowest first).

  • threshold (optional, default from the server's configuration, usually 0.9): the probability the picked option must reach to act without a person. On the hosted models an uncertain yes/no answer is reported at 0.80 or more towards one side, so use a threshold above 0.80 for yes/no questions.

Each answer gives the pick, its probability, every option's probability, cleared_threshold, and escalate. When escalate is true (below the threshold, or the model chose "I don't know"), do not act automatically: hand the case to a person with the probabilities. The top-level escalate is true when any answer should be escalated.

Each call is billed by input tokens on the hosted API. Ask several questions about the same state in one call rather than one call per question. A call that runs longer than 25 seconds in all, retries included, is stopped with a timeout error.

NameRequiredDescriptionDefault
chunkNoFor a long text and yes/no questions only: read the state in overlapping windows (40000 characters, 2000 overlapping, at most 20 windows) and answer with the window most likely to be yes. Each window is a separate billed request. Use it when a check must cover the whole of a long document.
modelNoA model id from list_models. Leave it out to use the configured model.
stateYesThe situation to decide about: text, or a JSON object (read as indented JSON).
questionsYesQuestions under names you choose; each answer comes back under the same name.
thresholdNoProbability the pick must reach to act without a person. Default from configuration.
chunk_charsNoWith chunk: characters per window.
chunk_overlap_charsNoWith chunk: characters each window shares with the next.

TDQS

A4.4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the description does not need to re-establish safety. What it does add beyond them is substantive: token-based billing on the hosted API, a 25-second total timeout including retries, refusal of questions lacking instructions, and the escalate contract. That is solid value beyond structured fields, but the bulk of the text serves purpose and parameter guidance rather than hidden behavior, so it sits above baseline without being exceptional.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Structure is deliberate — a purpose paragraph, a use-case sentence, an explicit Inputs block, then output and cost paragraphs — and the purpose is front-loaded. But the routing use-case sentence is a long comma-spliced run, and the Inputs block re-states a fair amount that the schema already documents at 100% coverage, so the text is longer than its unique content justifies.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema, but the description supplies the return contract anyway: pick, its probability, every option's probability, cleared_threshold and escalate, plus the rule that a top-level escalate wins if any answer escalates and that escalated cases must go to a human with the probabilities. Combined with threshold guidance and the timeout/billing limits, an agent has everything needed to call this correctly on the first try for a seven-parameter nested tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is already 100%, yet the description still adds meaning the schema cannot: put the policy in the state alongside the case and include only what the decision needs; phrase a "noul" so yes is the thing to act on; add an "I don't know" label so a choice question can abstain; order score levels lowest first; and the crucial operational note that hosted models report an uncertain yes/no at 0.80+, so a yes/no threshold must exceed 0.80. That last point in particular prevents a silently broken integration.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence gives a specific verb and resource (ask Myles to make a decision and return calibrated probabilities) and immediately delimits it from what an agent might assume: "Myles is not a chat model: it does not write text or follow instructions in the state." It also distinguishes it from its siblings (health, list_models) implicitly by describing a decision function rather than a lookup or status check.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides an explicit trigger condition — "whenever you would otherwise judge something yourself and then act on it" — followed by a concrete enumeration of the exact decisions that fit (routing, fraud/scam/prompt-injection flags, approve/reject/escalate, tool-call or claim checks, scoring). It also states the negative case (not for text generation) and gives condensing advice (several questions in one call rather than one per call), so the agent knows both the fit and the operating pattern.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

healthCheck the Decision APIA
Read-onlyIdempotent

Check that the Decision API is up and which models have a healthy server, before a batch of work or after an error. Not billed.

NameRequiredDescriptionDefault

No parameters

TDQS

A4.1/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, non-destructive, and open-world traits. The description adds a genuinely new behavioral fact not in annotations: 'Not billed,' which is valuable context for an agent deciding whether to poll this endpoint. It stops short of detailing response shape or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short sentences with zero waste; the core action leads and the timing/billing context follows. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with no output schema and rich annotations, the description covers what it checks, when to call it, and a key cost trait. It leaves the exact return format implicit, keeping it just short of fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters and schema coverage is 100%, so there is nothing for the description to compensate for. Baseline 4 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (check) and resource (Decision API), and adds that it reports which models have a healthy server, which distinguishes it from list_models and decide. It does not explicitly name those siblings as alternatives, so it falls 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.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives clear triggering conditions: 'before a batch of work or after an error.' This tells the agent when to reach for it, though it does not explicitly exclude or compare against list_models/decide.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_modelsList Myles modelsA
Read-onlyIdempotent

List the decision models this endpoint serves. Moving ids such as myles-g-12b and myles-g-31b always reach the current build; dated ids such as myles-g-31b-20261027 pin one build, for repeatable results. Deprecated builds name their successor. Not billed.

NameRequiredDescriptionDefault

No parameters

TDQS

A3.9/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The annotations already cover read-only, idempotent, non-destructive, and open-world behavior. The description adds genuinely useful context beyond the annotations: billing is not incurred, deprecated builds name their successor, and moving vs dated ids have different stability semantics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with what the tool does and then adds compact, useful details about id behavior, deprecation, and billing. Every sentence contributes information without padding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter read-only listing tool with rich annotations, the description is nearly complete: it explains what is listed, how model ids behave, and that listing is not billed. It does not describe the exact response structure, but no output schema is provided and the tool is simple enough that this is a minor gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

This tool takes zero parameters, so the baseline is 4. The schema is empty and requires no further parameter explanation from the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: it lists the decision models served by this endpoint, and it clarifies what the returned ids mean. It is clear on its own but does not explicitly differentiate itself from the sibling tools health and decide.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage by explaining moving versus dated model ids for selection and repeatability, but it gives no explicit guidance on when to call this tool instead of health or decide. The reader can infer the purpose, but tool-selection guidance is absent.

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.

  1. 3 tool updatesv0.0.2
    • First observeddecide
    • First observedhealth
    • First observedlist_models

TDQS

A4.1/5.0

Scored across 3 tools

Disambiguation5/5

The three tools serve clearly separate roles: a liveness probe, the core inference call, and model enumeration. There is no plausible way an agent confuses `decide` with either `health` or `list_models`, and the descriptions reinforce the boundaries.

Naming Consistency4/5

All names are lowercase snake_case, which is consistent. `list_models` follows verb_noun while `health` is a bare noun and `decide` a bare verb, a minor deviation but still readable and idiomatic for a small API surface.

Tool Count4/5

Three tools is on the thin side but each earns its place: the domain is a single inference endpoint plus two supporting utilities. Nothing feels padded, though the surface is minimal enough that any addition would be noticeable.

Completeness4/5

The core decision lifecycle (check availability, discover models, submit typed questions with thresholds and escalation) is covered, and batching is handled via multiple questions per call. Minor gaps remain: no async/job handling for the 25-second timeout, no way to retrieve past decisions or inspect billing/usage.

Maintenance

ActivityMaintained
ResponsivenessSyncing

Related MCP Connectors

Related MCP Servers

  • A
    license
    A
    quality
    B
    maintenance
    Enables MCP clients to submit completed speech or typed text to a self-hosted decision engine and receive judgments such as ordinary speech, command, retained thought, uncertainty, or no action, along with session and decision inspection.
    3
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables MCP clients to ask typed questions about text or JSON and receive structured answers with probabilities, and also exposes a REST endpoint for non-MCP tools.
    Apache 2.0
  • A
    license
    Not graded
    quality
    C
    maintenance
    Enables MCP hosts to send a context, question, and named choices to Jev System One, returning the selected choice, confidence, and per-choice probabilities.
    214 npm
    MIT
  • A
    license
    Not graded
    quality
    A
    maintenance
    Enables MCP-speaking hosts to ask typed judgment questions — yes/no, choice, and score — and receive calibrated probabilities instead of prose. Runs offline by default against a synthetic provider, with an opt-in live route whose egress is disclosed before any data leaves.
    66 npm
    Apache 2.0