Skip to main content
Glama
absgrafx
by absgrafx

morpheus-grok-mcp

Grok / Cursor Marketplace MCP that routes OpenAI-compatible inference to Morpheus:

  • Public (default): https://api.mor.org/api/v1

  • Custom: your Uplink base https://<host>/v1 (auto-normalized; never invent /api on Uplink)

Name: Morpheus Inference (morpheus-inference)
Maintainer (public): NomadicRogue / ABSGrafx
License: MIT — see LICENSE
Status: v0 implementation (this PR) — stdio MCP + setup/policy skills

GitHub: absgrafx/morpheus-grok-mcp · Python package / CLI: morpheus-mcp (python -m morpheus_mcp)

Accepted product design lives in this repo under docs/ (not a private eng tree).

Install

Marketplace / uvx (preferred)

mcp.json runs:

uvx --from git+https://github.com/absgrafx/morpheus-grok-mcp.git morpheus-mcp

Configure secrets via Plugins → Configure (or vault inject). Values are never committed.

Local development

git clone https://github.com/absgrafx/morpheus-grok-mcp.git
cd morpheus-mcp
uv sync --all-extras
uv run morpheus-mcp
# or: uv run python -m morpheus_mcp

Related MCP server: GPT-MCP Bridge

Configure (variable names only)

Variable

Meaning

MORPHEUS_ENDPOINT_MODE

public | custom (default public)

MORPHEUS_BASE_URL

Custom Uplink URL when custom → normalized to …/v1

MORPHEUS_KEY_MODE

shared | per_bot (default shared)

MORPHEUS_API_KEY

Shared Bearer key

MORPHEUS_API_KEY_<SLOT>

Discrete per-bot secrets (COS, CTO, CISO, CIO, COO, CMO, CFO)

MORPHEUS_API_KEYS_JSON

JSON map escape hatch slot → key

MORPHEUS_AGENT_SLOT / MORPHEUS_AGENT

Slot id when per_bot

MORPHEUS_MODEL_DEFAULT

Exact model id when morpheus_chat omits model

MORPHEUS_POLICY_MOE_DEFAULT

Prefer MoE via morpheus_chat

MORPHEUS_POLICY_CURSOR_EXCEPTION

Native only if operator names exception

MORPHEUS_POLICY_FALLBACK_ON_DOWN

On down → native + Morpheus didn’t work: <reason>

Slot ids are lowercase role keys (cos, cto, ciso, cio, coo, cmo, cfo) matching those roles. The JSON-map escape accepts arbitrary slot keys when needed. Master / usage-only keys are refused for chat, embeddings, and list_models.

See plugin.json for titles/descriptions and skills/morpheus-setup/SKILL.md for the guided setup.

Tools (v0)

Tool

Upstream

morpheus_chat

POST {base}/chat/completions

morpheus_list_models

GET {base}/models

morpheus_embed

POST {base}/embeddings

Not shipped: morpheus_usage (deferred).

Skills

  • skills/morpheus-setup — endpoint/key modes, smoke test, secrets UX

  • skills/use-morpheus-model — MoE default policy; native only on named exception or down+flag

Public vs custom bases

Mode

Base

public

https://api.mor.org/api/v1 (forced)

custom

Your host normalized to https://<host>/v1

Wrong prefix (/api/v1 on Uplink, or bare /v1 on APIGW) → 404. The connector warns on custom normalize; it does not invent /api for Uplink.

Non-goals (v0)

  • Not shipping any staff CLI / bridge to Marketplace users

  • Not embedding Uplink / Lumerin / C-Node

  • Not re-shipping staff allowlist tools as MCP tools

  • No secrets in this repo (plugin variables / secure install UI only)

  • No master key for inference

  • Not claiming APIGW and Uplink share identical billing//usage semantics

Dogfood note

Crews can sideload this listing with endpoint_mode=custom + per-bot slot secrets to exercise the same MoE path the staff bridge used historically. Host-native tools stay for repo/gh work. Full bridge retirement needs the dogfood checklist in docs/DESIGN.md (including a possible host custom-provider hook as P1 — not a v0 publish blocker).

Design

See docs/DESIGN.md — Conceptual / Logical / Physical, Marketplace fields, and accepted Q1–Q5 locks.

Tests

uv sync --all-extras
uv run pytest

License

MIT — Copyright (c) 2026 ABSGrafx LLC.

CI

Pull requests and pushes to main run unit tests via GitHub Actions (uv sync --extra dev then uv run pytest). No live API calls and no secrets in CI.

Available Tools

3 tools
morpheus_chatA

Call Morpheus OpenAI-compatible chat/completions.

Pass messages (OpenAI shape). Model defaults to MORPHEUS_MODEL_DEFAULT when omitted. Optional tools / tool_choice for models that support tool_calls. Returns JSON with assistant content and tool_calls if any.

ParametersJSON Schema
NameRequiredDescriptionDefault
modelNo
toolsNo
messagesYes
max_tokensNo
temperatureNo
tool_choiceNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.4/5.0
Behavior4/5

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. It states key behaviors: OpenAI-compatible request shape, default model fallback, optional tools/tool_choice, and JSON response containing assistant content and tool_calls. It does not mention auth, rate limits, or error behavior, but the core behavior is clearly disclosed.

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 compact and front-loaded with the core purpose. Every sentence adds useful information: call type, message shape, model default, optional tool parameters, and return format. No wasted wording.

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?

Given that an output schema exists, the return value details are covered elsewhere. The description addresses the main invocation requirements: messages are required, model has a default, and optional tools/tool_choice are supported. It lacks explicit usage guidance for max_tokens and temperature, but overall an agent can correctly invoke the tool with this definition.

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?

Schema description coverage is 0%, so the description must compensate. It adds useful meaning for messages ('OpenAI shape'), model ('defaults to MORPHEUS_MODEL_DEFAULT when omitted'), and tools/tool_choice ('for models that support tool_calls'). However, max_tokens and temperature are not explicitly described, though their names are self-explanatory.

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?

Description uses a specific verb and resource ('Call Morpheus OpenAI-compatible chat/completions') that immediately clarifies the tool's function. This clearly differentiates it from siblings morpheus_list_models and morpheus_embed, which are distinct operations.

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?

The description clearly establishes context: use this for OpenAI-compatible chat completions with messages, model selection, and optional tool calling. It does not explicitly name alternatives or state when not to use it, but the sibling names make the intended use obvious.

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

morpheus_embedC

Call Morpheus OpenAI-compatible embeddings (POST {base}/embeddings).

ParametersJSON Schema
NameRequiredDescriptionDefault
inputYes
modelYes

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

C2.9/5.0
Behavior2/5

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It reveals the HTTP method and OpenAI compatibility, but omits side effects, authorization requirements, rate limits, or whether this is a read-only inference operation. For a tool with no annotations, this is too thin.

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 a single sentence with no filler, front-loading the core operation and endpoint. Every word contributes information, making it easy to parse quickly.

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

Completeness3/5

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

The output schema covers return shape, and the two required parameters are simple. However, the absence of annotations and lack of usage guidance leave gaps in safety and tool-selection context. It is minimally adequate for an agent already familiar with embeddings APIs, but not complete on its own.

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

Parameters2/5

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

Schema description coverage is 0%, and the description does not explain the parameters. The names 'Input' and 'Model' are somewhat intuitive, and 'OpenAI-compatible' hints at the expected shape, but the description adds almost no explicit meaning beyond what the bare schema already shows.

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 operation—calling Morpheus embeddings—and identifies the exact endpoint (POST {base}/embeddings). This distinguishes it from the sibling tools morpheus_chat and morpheus_list_models by resource. It does not elaborate on what an embedding is or returns, but the resource name is clear enough in the ML context.

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

Usage Guidelines2/5

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

The description gives no guidance on when to use this tool versus alternatives. It never mentions morpheus_chat or morpheus_list_models, nor does it describe conditions that would favor this tool. The only usage signal is implicit: 'embeddings' implies tasks needing vector representations.

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

morpheus_list_modelsA

List models from GET {base}/models (install smoke + model picker).

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.3/5.0
Behavior3/5

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

With no annotations provided, the description carries the behavioral disclosure burden. It indicates an HTTP GET, which implies a read-only operation with no side effects, and the list use case suggests non-destructive behavior. However, it does not explicitly state the read-only nature, nor does it address auth, rate limits, or other behavioral traits that could affect an agent's invocation.

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?

Single sentence with no filler; it states the operation, the endpoint, and two concrete use cases. The parenthetical adds useful context without bloating the description.

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?

Given the tool has no parameters, an output schema exists to define return values, and the implementation is a simple list operation, the description is complete. It gives the endpoint and use cases, so an agent can invoke it correctly. It does not need to explain return structure since the output schema is available.

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 has zero parameters, and the schema confirms an empty object, so the baseline for parameter semantics is 4. The description adds no parameter-level detail, but none is needed since there are no parameters to document.

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 description uses a specific verb ('List') and resource ('models') and names the exact endpoint GET {base}/models. It clearly distinguishes this from the sibling tools morpheus_chat and morpheus_embed, which serve different purposes.

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?

The parenthetical '(install smoke + model picker)' gives concrete contexts where this tool should be used. It does not explicitly mention alternatives or when not to use it, but with only chat and embed as siblings, the usage boundary is clear enough.

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.1.0
    • First observedmorpheus_chat
    • First observedmorpheus_embed
    • First observedmorpheus_list_models

TDQS

A4/5.0

Scored across 3 tools

Disambiguation5/5

Each tool targets a distinct operation: chat completions, embeddings, and model listing. There is no overlap or ambiguity between them.

Naming Consistency5/5

All tools share the 'morpheus_' prefix and use a consistent verb-based naming pattern (chat, list_models, embed). The convention is uniform and predictable.

Tool Count5/5

Three tools are well-scoped for an inference server providing chat and embedding endpoints plus model discovery. Each tool earns its place without bloat.

Completeness5/5

The set covers the core OpenAI-compatible inference surface: chat completions, embeddings, and model listing. No obvious dead ends or missing essential operations for this domain.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    C
    quality
    D
    maintenance
    Enables integration with OpenAI models through the MCP protocol, supporting concise and detailed responses for use with Claude Desktop.
    1
    3
    MIT
  • F
    license
    Not graded
    quality
    Not graded
    maintenance
    Enables Claude and other MCP-compatible tools to communicate with OpenAI's GPT models (GPT-5, GPT-5-mini, o3) with conversation history and session management. Features advanced controls like reasoning effort settings, token tracking, and parallel conversation sessions for efficient AI workflows.
    4 npm
    -
  • -
    license
    C
    quality
    Not graded
    maintenance
    Enables interaction with OpenAI-compatible APIs (like Ollama) through MCP tools. Provides access to chat completions, model listings, and embeddings generation from local or remote OpenAI-style endpoints.
    3
    -