Morpheus Inference
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., "@Morpheus InferenceList the available models."
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.
morpheus-grok-mcp
Grok / Cursor Marketplace MCP that routes OpenAI-compatible inference to Morpheus:
Public (default):
https://api.mor.org/api/v1Custom: your Uplink base
https://<host>/v1(auto-normalized; never invent/apion 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-mcpConfigure 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_mcpRelated MCP server: GPT-MCP Bridge
Configure (variable names only)
Variable | Meaning |
|
|
| Custom Uplink URL when |
|
|
| Shared Bearer key |
| Discrete per-bot secrets ( |
| JSON map escape hatch slot → key |
| Slot id when |
| Exact model id when |
| Prefer MoE via |
| Native only if operator names exception |
| On down → native + |
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 |
|
|
|
|
|
|
Not shipped: morpheus_usage (deferred).
Skills
skills/morpheus-setup— endpoint/key modes, smoke test, secrets UXskills/use-morpheus-model— MoE default policy; native only on named exception or down+flag
Public vs custom bases
Mode | Base |
public |
|
custom | Your host normalized to |
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/
/usagesemantics
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 pytestLicense
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 toolsmorpheus_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.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | ||
| tools | No | ||
| messages | Yes | ||
| max_tokens | No | ||
| temperature | No | ||
| tool_choice | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
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. 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.
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.
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.
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.
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.
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).
| Name | Required | Description | Default |
|---|---|---|---|
| input | Yes | ||
| model | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
3 tool updates
v0.1.0- First observed
morpheus_chat - First observed
morpheus_embed - First observed
morpheus_list_models
TDQS
Scored across 3 tools
Each tool targets a distinct operation: chat completions, embeddings, and model listing. There is no overlap or ambiguity between them.
All tools share the 'morpheus_' prefix and use a consistent verb-based naming pattern (chat, list_models, embed). The convention is uniform and predictable.
Three tools are well-scoped for an inference server providing chat and embedding endpoints plus model discovery. Each tool earns its place without bloat.
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
Related MCP Connectors
Synap (pool.linkrra.com/v1), Linkrra's OpenAI-compatible LLM API, as an MCP server.
- QuallaaOAuthcom.quallaa
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
17-model LLM gateway + 350+ data/KYB/sanctions tools. Pay-per-call USDC via x402, no API key.
OpenAI-compatible LLM MCP (7 tools); chat via balance key or x402 USDC on Base
Related MCP Servers
- AlicenseCqualityDmaintenanceEnables integration with OpenAI models through the MCP protocol, supporting concise and detailed responses for use with Claude Desktop.13MIT
- FlicenseNot gradedqualityNot gradedmaintenanceEnables 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-
- -licenseCqualityNot gradedmaintenanceEnables 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-
- AlicenseAqualityBmaintenanceIntegrates OpenAI APIs into MCP-compatible clients, providing tools for text generation, chat completions, model discovery, image creation/editing, audio transcription, speech synthesis, embeddings, and content moderation.9120 npmMIT