Matrix42 MCP Server: Ask Your Service Desk in Plain Language

Alexander Schnabl
Alexander Schnabl ·

Ask an AI assistant about Matrix42 today and it will guess. It does not know which web services your instance offers, what your data definitions are called or which values a field can take. So it invents URLs, attribute names and filters. The answer sounds right until someone tries it.

The Matrix42 MCP Server closes that gap. It is an open-source server that connects AI assistants such as Claude, GitHub Copilot or Cursor with your Matrix42 instance. The assistant looks things up in your system instead of guessing. It only reads unless you allow more.

What the Model Context Protocol is

The Model Context Protocol (MCP) is an open standard for connecting AI assistants to tools and data. An MCP server describes what it can do as a set of tools. The assistant decides when to call one. The client shows you which tool it uses with which input.

For Matrix42 this means: you ask a question in plain language, the assistant calls the tools of the server and the server talks to the Matrix42 API on its behalf.

The diagram shows how the parts connect.

The Matrix42 MCP server runs next to the AI client, offers it six tools over MCP and keeps the credentials for the Matrix42 REST API

The AI client starts the server on your machine and talks to it over MCP through stdio. The server offers six tools: five that read and ticket_actions, which only exists when writing is allowed. It holds the API token, exchanges it for a short-lived access token for the Matrix42 REST API and never hands the credentials to the assistant.

Why an assistant needs it for Matrix42

A typical Matrix42 instance exposes about 190 web services with some 1,100 operations plus a data model of around 800 data definitions and 240 configuration items. Every company adds its own on top. No language model can know what exists in your instance.

The server gives the assistant a way to find out:

  • It searches the web services and reads the exact contract of an operation before anyone writes integration code.
  • It reads the real data model: data definitions, configuration items, attributes, relations and the values a pickup field can take.
  • It checks every column against the live schema of your instance before a query runs. A field your instance does not have is reported instead of sent.
  • It brings four written guides along, on the data model, the schema, the ASQL filter language and the conventions of the REST API.

A question in plain language

Ask "Which open hardware tickets are past their service level?" and the assistant works it out on its own. It searches the tickets by category and state, checks the service level of each one as Matrix42 itself computes it and builds a link into the Matrix42 web interface for the ticket at risk. You do not look up a single ID and nothing is written.

Behind the answer are three tool calls:

A question about open hardware tickets answered through the Matrix42 MCP server in three tool calls: search, service level check and link

First service_desk searches the tickets by category and state with search_tickets. Then sla_for_ticket checks the service level of each ticket. Last data_query builds the link for the ticket at risk with deep_link. Each call only reads.

Other questions it answers the same way:

  • Which contracts end this quarter?
  • Where is the cost center of an asset stored? Which values can it take?
  • What does the journal of this incident say?
  • Which operation of the API creates a service request? Write me a script that calls it.

What it can do

The server offers six tools. Five of them only read:

Tool What it does
server_info Shows which instance is connected and checks that the credentials work
webservice_discovery Finds web services and operations and reads their contracts
schema_discovery Explores data definitions, configuration items, attributes and pickup values
data_query Runs ASQL queries with paging, saved views, journals, attachments and links into the web interface
service_desk Searches tickets of every kind, answers service level questions and browses assets, contracts, catalog services and knowledge articles
ticket_actions Creates, closes, takes over, forwards, pauses and reopens tickets, sets deadlines and books time. Only there when writing is switched on

Safe by default

Giving an AI assistant access to the service desk needs clear limits. The server sets them by default:

  • It only reads. The tools that change data are not even offered to the assistant unless M42_ALLOW_WRITES=1 is set.
  • Every write shows a preview first: the exact request it would send. Only a second call with a confirmation sends it. The preview is the same object that is executed.
  • The credentials stay in the server. They are never logged and never returned to the assistant.
  • Tickets created through the server get an internal note that says so. Notification emails are off, journal entries stay internal and closing related incidents has to be asked for.

This is how a change travels from the assistant to Matrix42:

How the Matrix42 MCP server handles a write: only when allowed, first a preview, then the confirmed request, with safe defaults

Without M42_ALLOW_WRITES=1 the assistant can only read. With it, the first call of a write returns a preview of the exact request and changes nothing. Only the second call with a confirmation sends that same request to Matrix42, under the defaults listed above.

The server can reach whatever the configured account can read. Use an account with the rights the assistant needs and no more. M42_TOOLS limits the server to the tools you want.

Setting it up

You need Node.js 22.19 or later and an API token, created in the Matrix42 administration for the account the assistant should act as. The server runs over stdio: your AI client starts it with npx, nothing has to be installed first.

In Claude Code:

claude mcp add matrix42 \
  --env M42_HOST=https://matrix42.example.com \
  --env M42_API_TOKEN=your-api-token \
  -- npx -y matrix42-mcp

In Claude Desktop, add the server to claude_desktop_config.json:

{
  "mcpServers": {
    "matrix42": {
      "command": "npx",
      "args": ["-y", "matrix42-mcp"],
      "env": {
        "M42_HOST": "https://matrix42.example.com",
        "M42_API_TOKEN": "your-api-token"
      }
    }
  }
}

Cursor, VS Code with GitHub Copilot and other MCP clients use the same command in their own configuration file; the README on GitHub has an example for each. To check the connection, ask the assistant to call server_info.

Where it fits

The MCP server is for people who work with an assistant. For automation that runs without one, our Matrix42 node for n8n, verified by n8n, brings the same instance into n8n workflows. Both together are the base of our AI agents for the service desk: agents that sort, summarize and route tickets, with people keeping the final decision.

Good to know

The server is listed in the official MCP Registry as io.github.sus-tech-gmbh/matrix42-mcp, where MCP clients and directories find it.

The server is an early release and an independent community project under the MIT license. It is not affiliated with or supported by Matrix42, so please do not contact Matrix42 support about it. Questions and bug reports go to the issues on GitHub; the package is on npm.

Do you want to use it with your own Matrix42 instance? Or connect Matrix42 with AI agents? Talk to us.

Related solutions

  • AI Agents for the Service Desk

    Agents that sort, summarise and route tickets and draft answers, connected to Matrix42, Jira or ServiceNow through n8n.

  • Matrix42 MCP Server

    Lets AI assistants like Claude, Cursor or Copilot explore and query a Matrix42 instance. Read-only by default.

Keep reading