# How MCP Prompts Translate into Slash Commands and Resources Map to '@' References in DeepSeek-Reasonix

> Learn how DeepSeek-Reasonix translates MCP prompts to slash commands and maps resources to @ references. Discover standardized namespaces for tool interaction.

- Repository: [YHH/DeepSeek-Reasonix](https://github.com/esengine/DeepSeek-Reasonix)
- Tags: internals
- Published: 2026-06-27

---

**Reasonix converts MCP server prompts into slash commands using the `/mcp__<server>__<prompt>` format and exposes resources via `@<server>:<uri>` syntax, enabling model interaction with external tools through standardized namespaces.**

DeepSeek-Reasonix treats each MCP (Model-Centered Plugin) server as a distinct namespace, transforming advertised capabilities into intuitive command-line interfaces. This architecture allows users to invoke complex prompt templates through slash commands and embed external resources using '@' references. Understanding these mappings is essential for integrating MCP servers effectively into your Reasonix workflows.

## Understanding MCP Prompt to Slash Command Translation

When an MCP server advertises available prompts through the `prompts/list` RPC, Reasonix does not expose these raw names directly to the model. Instead, it constructs a **model-visible tool name** by applying a strict prefixing convention that creates unambiguous slash commands.

### The Namespace Convention

In [`internal/plugin/prompts.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/prompts.go) (line 54), Reasonix assembles tool names using the following pattern:

```go
Name: "mcp__" + normalizeName(c.name) + "__" + normalizeName(p.Name),

```

This generates commands in the format `/mcp__<server>__<prompt>`, where:
- `<server>` represents the configured server name from your `[[plugins]]` definition (either `stdio` or `http` type)
- `<prompt>` corresponds to the original prompt name returned by the server's `prompts/list` RPC

For example, if a server named `docs` advertises a prompt called `summarize`, Reasonix exposes this as `/mcp__docs__summarize`.

### Parsing Slash Command Arguments

The command body—everything following the first space—is parsed into **positional arguments** that map sequentially to the prompt's declared `PromptArg` parameters. This behavior mirrors Claude Code's MCP client implementation.

When you executing a command like:

```text
/mcp__docs__summarize The quickstart guide

```

Reasonix performs the following operations:
1. Parses the command to identify `server="docs"` and `prompt="summarize"`
2. Maps "The quickstart guide" to the prompt's first declared argument
3. Invokes `Prompt.Get` in [`internal/plugin/prompts.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/prompts.go), which calls the MCP RPC `prompts/get`
4. Concatenates the returned messages into a single text block prepended to the model's input

The resolution logic in [`internal/control/input.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/input.go) (line 500) handles this via the `MCPPrompt` function, ensuring arguments align with the server's expected schema.

## How Resources Map to '@' References

Beyond prompts, MCP servers expose resources—files, API schemas, or documents—that Reasonix makes accessible through a concise reference syntax.

### Resource Reference Syntax

Resources use the format `@<server>:<uri>`, where:
- `<server>` identifies the MCP server name defined in your configuration
- `<uri>` represents the canonical resource URI as exposed by the server's `resources/list` endpoint

The `Resource` struct in [`internal/plugin/resources.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/resources.go) (lines 10-12) defines this relationship:

```go
type Resource struct {
    Server      string // owning server name
    URI         string // canonical resource uri
    // …
}

```

### Fetching Resource Content

When the Reasonix UI detects an `@` token in chat input, it triggers `readResource` (line 50 in [`internal/plugin/resources.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/resources.go)). This function executes the MCP RPC `resources/read`, retrieves the resource content, and flattens text data (or notes binary blobs) directly into the conversation context.

For example, entering:

```text
Please review the API spec: @docs:file://api/spec.md

```

Reasonix automatically fetches the markdown content from the `docs` server and inserts it before the model processes your request.

## Practical Implementation Examples

### Invoking MCP Prompts via Slash Commands

To use a prompt advertised by an MCP server:

```text
/mcp__docs__summarize The quickstart guide

```

Here, `docs` is the server name and `summarize` is the prompt. The argument "The quickstart guide" maps to the prompt's declared parameter (e.g., `text`).

### Referencing Resources with '@' Syntax

Embed external resources directly into your queries:

```text
Please review the API spec: @docs:file://api/spec.md

```

Reasonix resolves this by calling `readResource`, fetching the content via `resources/read`, and prepending it to your prompt.

### Programmatic Construction in Go

When building integrations programmatically, construct these strings following the normalization rules:

```go
// Build a slash command for a prompt
cmd := fmt.Sprintf("/mcp__%s__%s %s", server, prompt, strings.Join(args, " "))

// Build an @‑reference for a resource
ref := fmt.Sprintf("@%s:%s", server, uri)

```

These strings work with both the Reasonix CLI and TUI, triggering the same resolution pipelines as manual input.

## Key Implementation Files

The following source files govern MCP integration:

- **[`internal/plugin/prompts.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/prompts.go)**: Defines prompt name generation (`mcp__` prefixing) and `Prompt.Get` logic for RPC calls
- **[`internal/control/input.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/input.go)** (line 500): Contains `MCPPrompt` for slash command resolution
- **[`internal/plugin/resources.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/resources.go)**: Implements `Resource` struct and `readResource` for `@` reference handling
- **[`internal/cli/chat_tui.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/cli/chat_tui.go)** (line 3286): UI detection of `/mcp__` command strings
- **[`cmd/reasonix-plugin-example/main.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/cmd/reasonix-plugin-example/main.go)**: Reference implementation showing server-side prompt and resource registration

## Summary

- **Slash commands** follow the format `/mcp__<server>__<prompt>`, constructed in [`internal/plugin/prompts.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/prompts.go) by prefixing server and prompt names with `mcp__`
- **Command arguments** parse as positional parameters mapped to `PromptArg` declarations, resolved via `MCPPrompt` in [`internal/control/input.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/control/input.go)
- **Resource references** use `@<server>:<uri>` syntax, triggering `readResource` in [`internal/plugin/resources.go`](https://github.com/esengine/DeepSeek-Reasonix/blob/main/internal/plugin/resources.go) to fetch content via the `resources/read` RPC
- Both mechanisms treat MCP servers as namespaces, preventing naming collisions while exposing external capabilities to the model

## Frequently Asked Questions

### What happens if two MCP servers expose prompts with identical names?

Reasonix prevents collisions by namespacing each prompt with its server identifier. Since slash commands follow the `/mcp__<server>__<prompt>` format, identical prompt names from different servers remain unique (e.g., `/mcp__serverA__analyze` vs `/mcp__serverB__analyze`).

### How are arguments passed to MCP prompts when using slash commands?

Arguments provided after the slash command are parsed as positional parameters and mapped in order to the prompt's declared `PromptArg` definitions. For example, `/mcp__docs__summarize "text here"` assigns "text here" to the first argument expected by the `summarize` prompt.

### Can I use multiple '@' references in a single prompt?

Yes. Reasonix scans the entire input for `@<server>:<uri>` tokens and invokes `readResource` for each occurrence. All fetched resources are prepended to the model's context before processing your request, allowing you to combine multiple external sources.

### What is the difference between 'prompts' and 'resources' in the MCP protocol?

**Prompts** are templates that require arguments and generate structured messages via the `prompts/get` RPC, exposed as slash commands. **Resources** are static content (files, schemas, documents) accessed via `resources/read` and referenced using `@` syntax, requiring no additional arguments beyond the URI.