MCP Resources and Prompts

Besides the tools on the Tools Reference, the server offers resources, documents you attach to a conversation yourself, and prompts, ready-made requests you start by name. Clients show them in different places: resources in an attach or @-mention menu, prompts as slash commands or in a prompt picker. In Claude Code, for example, @mind:mind://guide attaches a resource and /mcp__mind__write_mind_code starts a prompt; in VS Code, resources are under Add Context › MCP Resources and prompts appear when you type / in chat. A client that supports neither still reaches every document through the tools.

The whole language in one attachment

Attach mind://guide before asking an agent to write MIND. It holds the language, the compiler and the toolchain on one page, so the agent starts from the real syntax instead of guessing from other languages.

Fixed resources

resources/list returns every fixed resource in one page, with no nextCursor: 46 in the current build.

URI	Content
`mind://guide`	MIND reference for AI agents: the language, compiler and toolchain in one page. Priority 1.0.
`mind://guide/short`	MIND language guide (short): a short overview of MIND with an index of every docs page. Priority 0.8.
`mind://about`	This server and its index: the build id, the docs snapshot date, the `mindc` release, the specification commit, whether the index holds the data for ranking by meaning (`Semantic search: on`; each `search` result's `mode` says how it was ranked), the document, passage, symbol and error-code counts, the privacy note and the setup link.
`mind://docs/<page>`	Each mindlang.dev docs page in the index, such as `mind://docs/determinism` (43 in the current build).

The priority tells a client which resource matters most when it has room for only a few.

Older mindlang:// URIs still work: mindlang://guide/llms-full reads mind://guide, mindlang://guide/llms reads mind://guide/short, and every other mindlang:// URI reads the mind:// URI with the same path. resources/list shows only the mind:// names.

Resource templates

Templates reach every other document in the index. Fill in the part in braces; {+path} may contain slashes.

Template	Content	Example
`mind://docs/{+path}`	A mindlang.dev docs page, as Markdown	`mind://docs/mic/binary`
`mind://std/{module}`	Signatures and doc comments of one standard-library module	`mind://std/string`
`mind://errors/{code}`	Every public reference for one compiler error code, quoted	`mind://errors/E2103`
`mind://examples/{name}`	One example program from the current release, as plain text	`mind://examples/hello_tensor`
`mind://changelog/{version}`	The release notes of one `mindc` release	`mind://changelog/0.10.2`
`mind://spec/{chapter}`	One chapter or grammar of the Core v1 specification	`mind://spec/autodiff`

Argument completion

Every template argument completes: the server returns the values that start with what you typed, ignoring case, at most 100 at a time (total and hasMore say whether there are more). Clients with a resource picker use this to list modules, codes or versions as you type. A completion/complete request for mind://std/{module} with the value s:

{
  "completion": { "values": ["sha256", "sha512", "string"], "total": 3, "hasMore": false }
}

What a read returns

The text starts with the citation URL on its own line, then a blank line, then the document:

Source: <https://mindlang.dev/docs/determinism>

# The Determinism Contract

The MIND determinism contract: every operation is defined, rejected or explicitly marked, …

Documents are Markdown (text/markdown), except example programs and the specification's grammars, which are plain text. A URI that names no document returns the JSON-RPC error -32602 with the message Resource not found: <uri>.

Prompts

Each prompt builds a request for the model and attaches the documents it needs, as embedded resources, so it works even in clients that cannot read resources on their own. Its arguments are checked first: a value that does not fit returns the JSON-RPC error -32602 and names the argument.

Write MIND code

Prompt write_mind_code. Writes MIND code for a task, checked against the docs and the standard library.

Argument	Required	Values
`task`	yes	1 to 2,000 characters: what the code should do

The request asks the model to write the code, to confirm every std function with search and lookup_symbol before using it, and to cite the pages it used. It attaches mind://guide.

Example: task = "Read whitespace-separated integers from standard input and print their sum." In Claude Code: /mcp__mind__write_mind_code "Read whitespace-separated integers from standard input and print their sum."

Explain a MIND compiler error

Prompt explain_mind_error. Explains a compiler error code and how to fix it, from the error reference.

Argument	Required	Values
`code`	yes	An error code such as `E2103` (pattern `^[Ee][1-6][0-9]{3}$`); completes from the documented codes
`output`	no	Up to 8,000 characters: the compiler output, if you have it

The request asks what the error means, why it happens and how to fix it, quoting the error reference and citing its URLs. It attaches mind://docs/errors, and mind://errors/<CODE> when the code is documented.

Example: code = E1001, output = error[parse][E1001]: unexpected `)`, expected an expression.

Port code to MIND

Prompt port_to_mind. Ports code from another language to MIND, using the migration guide.

Argument	Required	Values
`source_language`	yes	`python`, `numpy`, `pytorch`, `jax`, `rust`, `c` or `cpp`; completes as you type
`code`	yes	1 to 16,000 characters: the code to port

The request asks the model to keep the code's behaviour, use MIND's static shapes and standard library, and confirm every API with search and lookup_symbol. It attaches mind://docs/migration and mind://guide.

Example: source_language = numpy, code = def relu(x): return np.maximum(x, 0).

MCP Server: set the server up in your client
Tools Reference: the five tools, their inputs and outputs
Example Workflows: prompts that chain the tools for real tasks
Connect from Code: call the server from an SDK or with curl