MCP server

Prism for C/AL runs a Model Context Protocol (MCP) server. An AI agent connected to it searches your exported C/AL objects through Prism's symbol index: it finds objects and members, reads their code, follows references, calls and object dependencies, and checks that an edited object still parses. The server only reads your objects; it never changes them.

An agent reaches the server in one of two ways:

Use HTTP while you work in Prism; use stdio when the agent works on its own.

Connect an agent

Start a server, add an entry for it to your agent's MCP configuration, and tell the agent to use it. The MCP Server page writes the entry for you.

Start the server in the workspace window

Use this to serve the object store you have open in Prism.

1. Open the object store in Prism for C/AL: a file store, a folder store or a mirror.
2. In the workspace window, select MCP Server in the navigation rail.
3. Check the Port card. It shows Port is available for the port Prism will use, 47821 unless you chose another. If it shows Port is in use, select Find free.
4. Select Start.

The Status card shows Running, and the endpoint shows http://localhost:47821. Select Heartbeat to check that the server answers. The server runs until you select Stop or close the workspace window.

Start the server from the command line

Use this to serve an object store over HTTP without a Prism window, for example on a build machine.

1. Open a command prompt.
2. Run StaticalPrismCALCmd.exe mcp-server-http with the path of the object text file or folder. Add --encoding and the filter options when your Prism settings use them, so the agent sees the same objects as your workspace window.
3. Leave the window open while agents use the server; press Ctrl+C to stop it.

StaticalPrismCALCmd.exe mcp-server-http "C:\NAV\Cronus" --port 47821
StaticalPrismCALCmd.exe mcp-server-http "C:\NAV\Cronus" --port-search 47821..47920 --encoding 850 --file-include-filter "*.txt"

The server prints “MCP server is running on http://localhost:47821” and builds the symbol index. The Command Line section of the MCP Server page shows this command with the path of the open store filled in. All options are on the Command line page.

Connect GitHub Copilot in Visual Studio Code

Use this to give GitHub Copilot in Visual Studio Code (agent mode) the Prism tools. For HTTP, start the server first in the workspace window or from the command line.

1. On the MCP Server page, select Show mcp.json….
2. In Client, select Visual Studio Code (Copilot).
3. Select HTTP (this window), or stdio (own process) to let Visual Studio Code start its own server.
4. If the folder Visual Studio Code has open has no .vscode/mcp.json, select Copy whole file and save it as .vscode/mcp.json at the root of that folder. Otherwise select Copy entry and paste it inside the file's "servers" block, separated from the entry before it by a comma.
5. Start a new chat in agent mode and ask a question that names a C/AL object.

1 2 3 4

{
  "servers": {
    "prism-cronus-3f9a1c": {
      "type": "http",
      "url": "http://localhost:47821"
    }
  }
}

The entry for stdio holds a command instead of a URL:

{
  "servers": {
    "prism-cronus-3f9a1c": {
      "type": "stdio",
      "command": "StaticalPrismCALCmd.exe",
      "args": [
        "mcp-server-stdio",
        "C:\\NAV\\Cronus"
      ]
    }
  }
}

When Visual Studio Code has a .code-workspace file open, add the "servers" block under "settings" › "mcp" in that file instead: a .vscode/mcp.json beside it is never read. GitHub Copilot does not read MCP resources; it uses the tools list_resources and read_resource instead.

Connect Claude Code

Use this to give Claude Code, in the command line or in the Code tab of the desktop app, the Prism tools. For HTTP, start the server first.

1. On the MCP Server page, select Show mcp.json….
2. In Client, select Claude Code.
3. Select HTTP (this window) or stdio (own process).
4. If the repository has no .mcp.json at its root, select Copy whole file and save it there. Otherwise select Copy entry and paste it inside the file's "mcpServers" block, separated from the entry before it by a comma.
5. Start a new Claude Code session in the repository and ask a question that names a C/AL object.

{
  "mcpServers": {
    "prism-cronus-3f9a1c": {
      "type": "http",
      "url": "http://localhost:47821"
    }
  }
}

{
  "mcpServers": {
    "prism-cronus-3f9a1c": {
      "type": "stdio",
      "command": "StaticalPrismCALCmd.exe",
      "args": [
        "mcp-server-stdio",
        "C:\\NAV\\Cronus"
      ]
    }
  }
}

Connect another MCP client

Use this for any other agent that reads an MCP configuration file.

1. On the MCP Server page, select Show mcp.json….
2. In Client, select Other / generic, then the transport.
3. Copy the entry into your client's MCP configuration, per project if your client has such a file.
4. Start a new session and ask a question that names a C/AL object.

The generic entry has the shape of the Claude Code one, with an explicit "type" on both transports. If the server does not appear, your client probably uses another key than "mcpServers"; its documentation names it.

Tell your agent to use Prism

Use this when the agent searches the object text files instead of calling Prism. A text match misses usages through record variables, Rec and WITH blocks, and matches same-named fields and procedures of other objects; Prism's index does not.

1. Save the skill below as prism-for-cal/SKILL.md in the agent's skills folder (see the table).
2. If your agent does not read skills, add the short text after the table to the file it reads at the start of every session, such as AGENTS.md.
3. Start a new session.

---
name: prism-for-cal
description: Use for any question about this repository's C/AL code (Dynamics NAV objects) — where a field, procedure or table is used or written, what a procedure calls, which objects depend on an object, whether an edited object still parses. Load this before searching text or reading the exported object files; text search gives wrong answers for C/AL.
---

# Prism for C/AL

This repository's C/AL objects are indexed by the **Prism for C/AL** MCP server,
which resolves each reference to the declaration it binds to — through record
variables, `Rec` and `WITH` blocks, where a text match misses usages and matches
same-named fields and procedures of other objects.

If your client defers the server's tools, load them with one tool search, then
start from `find_symbols` and pass the `prismPathUri` it returns to the other
tools unchanged. After the objects are exported or edited again, call
`reload_workspace` before you trust the answers.

This repository's C/AL objects are indexed by the Prism for C/AL MCP server. For any question
about where C/AL code is used or written, what a procedure calls or which objects depend on an
object, use its tools before text search; text search gives wrong answers for C/AL.

Ask your first questions

These prompts show what the index answers that a text search cannot, each with the tools the agent calls. Use names from your own objects.

• Where is field Credit Limit (LCY) of table Customer written?

  1. find_symbols
  2. find_references

  Only the lines that assign the field, VALIDATE among them, grouped by object and trigger.

• Which objects use codeunit Sales-Post?

  1. find_symbols
  2. find_object_dependencies

  The objects that depend on it, each with how: a variable, a parameter, a property or a call by name or number.

• What does PostCustomerEntry in codeunit Sales-Post call, three levels down? Show me the code of anything that posts to the G/L.

  1. find_symbols
  2. find_callees
  3. get_source_code

• How does page Sales Order end up depending on codeunit Gen. Jnl.-Post Line?

  1. find_symbols
  2. find_dependency_paths

  The routes between the two objects, shortest first, each hop with the kind of dependency.

• I changed this object. Is it still valid C/AL before I import it?

  1. check_object_source

  A syntax check of the object text, with the line and column of the first error.

• Which of our objects from 50000 to 99999 subscribe to events?

  1. find_symbols

The declarations an agent names are Prism Paths. Paste one into Universal Search to open the declaration in Prism and check the answer yourself.

MCP Server page

The MCP Server page of a Workspace window runs an HTTP server for the object store that window has open, and writes the configuration your agent needs.

Opening it

• Select MCP Server in the workspace window's navigation rail, below Reports. Its tooltip reads AI assistant connectivity.

1 2 3 4 5 6 7 8 9

Port, status and heartbeat

1 2 3 4

The page also shows, when they apply:

• Error banner: why the server failed, Failed to start: or Failed to stop: and the reason.
• Heartbeat result: OK — the server's name and version, the number of tools and the round-trip time; or Failed after a number of milliseconds and the reason. It fades after a while.

Open in browser opens http://localhost:47821/info, a page with the server's version and endpoint, the number of tools and resources, the MCP Inspector command and a sample configuration. The MCP endpoint itself is the root address, which answers MCP clients only.

The mcp.json popup

Show mcp.json… opens a popup with the configuration entry for this object store, ready to paste into your agent's MCP configuration file.

1 2 3 4 5 6

Every entry has "type" "http" or "stdio". Prism names the entry prism-, the store's name and six characters derived from its full path, such as prism-cronus-3f9a1c, so entries for two object stores never overwrite each other. With no object store open, the path in a stdio entry is the placeholder <workspace path>; replace it before use.

Capabilities, command lines and tools

Below the controls, the page lists what the server offers and how to run it without the window.

1 2 3

Below them, the Tools section lists the tools by category; see Tools. The Resources section at the end lists each resource with its title, URI and type. The MCP Inspector remembers the last server address it used; if it shows another address than the page, correct it before you connect.

Prism Paths

Every tool names an object or declaration by its Prism Path, the same path Copy Prism Path to Clipboard copies in Prism. A path starts with prism:, then the object type and the object's name, then one step per member. These paths name a codeunit, a procedure in it, and the OnValidate trigger of a field:

prism:Codeunit/Sales-Post
prism:Codeunit/Sales-Post/Procedure/PostCustomerEntry
prism:Table/Customer/Field/City/Trigger/OnValidate

The object step carries the object's name, not its number. Spaces and other special characters are escaped as in a web address, such as %20 for a space. Paths also reach the controls, actions and data items of pages, forms and reports, report sections, XMLport elements and request forms.

An agent never writes a path itself: it finds the object or member with find_symbols, takes the prismPathUri from the answer and passes it on unchanged. The server's instructions tell it so.

Tools

1 2 3

The server has 11 tools in five categories. Every tool is listed in every session, whatever your license; six of them need a licensed feature, as each tool's entry says.

These rules hold for every tool:

• Request. The parameters go inside a request object: { "request": { ... } }. Parameters sent without it are rejected.
• Patterns. A pattern parameter is an RE2 regular expression, case-insensitive and not anchored: Cust matches anywhere in a name, ^Sales at its start and ^Customer$ the whole name. Escape metacharacters to match them literally, as in Sales-Post \(Yes/No\). Backreferences and lookarounds are not supported.
• Paging. A tool with a paging parameter takes limit (1 to 500) and offset (0 or more, default 0). The default limit is 200 unless the tool says otherwise. The answer's pagination holds totalCount, limit, offset and hasMore.
• Answer. Lines and columns in answers count from 0. A tool answers a failure as described under Errors, and a success in this shape:

  {
    "result": {
      "kind": "success",
      "data": { ... }
    }
  }

{
  "request": {
    "queryRegex": "^Credit Limit \\(LCY\\)$",
    "kinds": [ "field" ],
    "objectsRegex": "^Customer$"
  }
}

Parameters that take fixed values list them below. The resource mcp://tools/input-enumerations lists them all with their meaning.

find_symbols

Searches objects and their members (procedures, triggers, fields, keys and more) by name, and returns each with its Prism Path, sorted by object ID. Use it first: the other tools take the paths it returns. Needs no license.

All filters apply together. Returns pagination, results and, when the query may not do what it reads like, a hint. Each result has prismPathUri, objectKind, objectName, objectId, kind and name; a field also has dataType and, for a FlowField or FlowFilter, fieldClass; a publisher or subscriber has eventRoles. Fails with invalid_pattern, invalid_request or missing_required_property.

find_references

Finds every place an object or declaration is used. For a declaration it returns the code lines, grouped by object and by the declaration that hosts each reference; for an object it returns the objects that reference it. An [EventSubscriber] binding counts as a reference to its publisher. Needs the Find References license feature: not available without a license.

Returns pagination and objects: each with objectKind, objectName, objectId, prismPathUri and its declarations, each with its code lines (lineNo, lineText). A reference can carry codeUsageFlags: AssignmentTarget, FieldTransfer, MessageParameter, Clear, RecordTemporary or ParameterByReference. unfilteredCount appears when the filters removed references, skippedObjects lists objects that could not be searched, and a declaration summary adds referenceCount. Fails with invalid_path, cal_object_not_found, invalid_pattern or invalid_request, the last for a filter that needs a declaration path.

find_callees

Lists the procedures and triggers that a procedure or trigger calls, and optionally the system functions, grouped by the object called. It can follow the calls further down. Needs the Find References license feature: not available without a license.

Returns pagination and objects; with includeUnresolved, unresolved (name, lineNo, lineText, reason; at most 500); with a maxDepth above 1, reachability (reachableCount, maxDepthReached, cycleCount). Fails with invalid_path, cal_object_not_found or invalid_request.

find_object_dependencies

Lists the objects an object depends on, or the objects that depend on it, each with the kinds of dependency. Objects missing from the store appear with their ID and an empty name. Needs the Find References license feature: not available without a license.

Returns pagination, direction and dependencies, each with objectKind, objectName, objectId, prismPathUri and dependencyTypes; with a maxDepth above 1, also reachability, and the kinds add up along all paths. Fails with invalid_path, cal_object_not_found or invalid_request.

find_dependency_paths

Finds the dependency paths between two objects, shortest first, each hop with its kinds of dependency. No object repeats within a path. Use find_object_dependencies for everything an object reaches, and this tool for the route between two. Needs the Find References license feature: not available without a license.

Returns pagination, paths (each a list of edges with from, to and dependencyTypes) and truncated, which is true when maxPaths or a search limit cut the result; a hint then says what to change. Fails with invalid_path, cal_object_not_found or invalid_request.

check_object_source

Parses the C/AL text of one object and reports whether it is valid. It checks syntax only, not references or types, and stops at the first error. Lines may end in CRLF or LF. Needs the Source Code license feature: not available without a license.

Returns valid, the objectDescriptor read from the OBJECT line (objectKind, objectId, objectName) and at most one entry in diagnostics: message, line, column, absoluteOffset, the rejected token and about 200 characters of text near it. Fails with missing_required_property. For the objects of the store that failed to parse, read mcp://workspace/diagnostics/summary.

get_source_code

Returns the C/AL text of a whole object, or of one declaration such as a field or a procedure, exactly as it is in the object store. Needs the Source Code license feature: not available without a license.

Returns source, the object's objectKind, objectName and objectId, for a declaration its memberKind and memberName, the declaration's range within the object, and totalLines, returnedLines, startFromLine, truncated and hasMore. When hasMore is true, call again with startFromLine moved on by returnedLines. Fails with invalid_path, cal_object_not_found, declaration_not_found or source_file_not_found.

reload_workspace

Reads the object store from disk again and rebuilds the symbol index, after objects were exported or edited. The previous index keeps answering while the reload runs. It reloads with the encoding and filters the server started with. Needs no license.

Returns objectCount, builtInObjectCount (Prism's built-in system tables, such as 2000000026 Integer, which no object file declares), objectCountByKind and diff, the change in object counts since the last load. A reload still running after 20 seconds answers workspace_reloading and carries on; the same call made meanwhile waits for that reload. Clients that ask for progress get progress notifications.

list_resources

Lists the server's resources, for agents that cannot read MCP resources themselves, such as GitHub Copilot in Visual Studio Code. It takes no parameters. Needs no license.

Returns count and resources, each with uri, name, title, description and mimeType.

read_resource

Reads one resource, for the same agents. Needs no license.

Returns uri, mimeType and content, the resource as text. Fails with missing_required_property or invalid_request.

submit_mcp_feedback

Sends feedback on a tool, a resource or the server to Statical over the internet: what the agent tried, how it went and what would help. Needs no license.

Returns a thank-you message. A server accepts one submission per 15 seconds, 10 per hour and 50 per session, and refuses a repeat of a recent submission. Fails with missing_required_property or invalid_request, for a limit reached, an unknown subject name or a submission that is too large.

Resources

Resources are reference documents an agent reads on demand. All of them can be read with any license. Agents that cannot read resources use list_resources and read_resource.

While the symbol index is loading or has failed, the workspace and diagnostics resources answer with its status and the URI to check instead of their content.

Errors

A failed call answers with "kind": "failure", an error sentence, an errorDetails text with a hint, a code, and permanent, which says whether retrying the same call can succeed. A failure that clears on its own adds retryAfterSeconds, and pollUri names the resource that reports the condition. Agents act on code, never on the wording.

{
  "result": {
    "kind": "failure",
    "error": "The requested capability is not enabled by the current license.",
    "errorDetails": "Tool 'get_source_code' requires the 'Source Code' feature, which is not enabled by the current license. Read 'mcp://license/status' for the full license status. | Hint: The tool exists but the current license does not enable the feature it belongs to. Read the 'mcp://license/status' resource to see which features are enabled and what each gates; do not retry the call without a license change.",
    "code": "feature_not_licensed",
    "permanent": true,
    "pollUri": "mcp://license/status"
  }
}

License and readiness

The server runs with or without a license and lists every tool. Six tools need a licensed feature, which a license and a trial license enable:

A call to a tool whose feature is not enabled fails with feature_not_licensed. The server reads the license at every call, so a key you install in Prism or with license install takes effect without a restart. See Activate license window.

A server starts answering at once and builds the symbol index in the background. Meanwhile reload_workspace, list_resources, read_resource and submit_mcp_feedback answer at once. Any other call waits up to 20 seconds for the index and then runs, or fails with workspace_reloading and a time to retry after. If the index failed to load, a call fails at once; reload_workspace tries again.

Troubleshooting

For anything else, select Help › Feedback… in Prism, or let the agent call submit_mcp_feedback.

Related

• Command line: every option of the MCP server commands.
• Workspace window: the window that hosts the MCP Server page.
• Universal Search: open a Prism Path an agent gave you.
• Activate license window: enable the licensed tools.
• Settings page: the encoding and filters a command-line server must match.