← Back to blog

Claude MCP Servers for MSPs: How to Connect Your Entire Stack

8 min read

If you’ve been experimenting with Claude for your MSP — summarizing tickets, writing scripts, drafting SOPs — you’ve probably hit the wall where it stops being useful because it can’t see your actual data. Claude MCP servers are how you fix that. MCP (Model Context Protocol) lets Claude connect directly to ConnectWise, NinjaOne, ITGlue, M365, and the rest of your stack so it can read real tickets, pull real device data, and take real action. This post covers what that looks like, how to set it up, and where the DIY approach breaks down for MSPs.

If you’re new to MCP itself, start with our explainer on what MCP is and why MSPs should care. This post assumes you understand the basics and want to get practical.

What Are Claude MCP Servers?

An MCP server is a lightweight service that exposes a tool’s API to an AI model using a standardized protocol. When you configure MCP servers for Claude — whether in Claude Desktop, Claude Code, or through the API — Claude gains the ability to call tools, query data, and execute actions through those servers.

Each server handles one integration. A ConnectWise MCP server knows how to search tickets, read configurations, and update statuses — we cover the full ConnectWise API surface for automation in a separate post. A NinjaOne MCP server knows how to query device health, run scripts, and pull patch compliance. Claude talks to all of them using the same protocol. It doesn’t need to know the underlying API details — it just sees the tools each server exposes.

For MSPs, this matters because your workflow crosses a dozen tools every time a ticket comes in. MCP is the mechanism that lets Claude cross those same boundaries.

Setting Up Claude MCP Servers: The Config

If you’re running Claude Desktop or Claude Code, MCP servers are configured in a JSON file. Here’s what a basic MSP setup looks like:

{
  "mcpServers": {
    "connectwise-psa": {
      "command": "node",
      "args": ["./mcp-servers/connectwise/index.js"],
      "env": {
        "CW_COMPANY_ID": "yourcompany",
        "CW_PUBLIC_KEY": "your-public-key",
        "CW_PRIVATE_KEY": "your-private-key",
        "CW_BASE_URL": "https://api-na.myconnectwise.net"
      }
    },
    "ninjaone": {
      "command": "python",
      "args": ["./mcp-servers/ninjaone/server.py"],
      "env": {
        "NINJA_CLIENT_ID": "your-client-id",
        "NINJA_CLIENT_SECRET": "your-client-secret",
        "NINJA_INSTANCE": "app.ninjarmm.com"
      }
    },
    "itglue": {
      "command": "node",
      "args": ["./mcp-servers/itglue/index.js"],
      "env": {
        "ITGLUE_API_KEY": "your-api-key",
        "ITGLUE_SUBDOMAIN": "yourcompany"
      }
    },
    "microsoft-graph": {
      "command": "node",
      "args": ["./mcp-servers/msgraph/index.js"],
      "env": {
        "AZURE_TENANT_ID": "your-tenant-id",
        "AZURE_CLIENT_ID": "your-client-id",
        "AZURE_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

For Claude Desktop, this goes in ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows. For Claude Code, you configure servers in your project’s .mcp.json or via claude mcp add.

Each server runs as a separate process. Claude discovers the available tools at startup and can call them during conversations. You ask “What’s the status of ticket #48291?” and Claude calls the ConnectWise server’s get_ticket tool, reads the response, and answers with real data.

What MCP Servers Exist for MSP Tools?

Here’s the reality: the open-source MCP ecosystem is growing fast, but MSP-specific coverage is thin. As of mid-2026:

Community/open-source servers that exist:

  • Microsoft Graph (M365 users, mail, calendar, SharePoint) — several mature options
  • Generic REST API servers that can be pointed at any API
  • Database servers (PostgreSQL, MySQL) for direct data queries

Servers you’ll likely need to build yourself:

  • ConnectWise PSA (Manage) — no widely-adopted open-source server
  • NinjaOne — no public MCP server
  • ITGlue / Hudu — no public MCP server
  • Sophos / SentinelOne — no public MCP server
  • Pax8 — has an official MCP server with Claude Desktop support and end-to-end encryption
  • Auvik / Meraki — no public MCP server
  • Halo PSA / Autotask — limited or no public servers

The gap between “MCP servers that exist” and “MCP servers MSPs need” is significant. Which brings us to the build-it-yourself path.

Building Your Own MCP Server: Claude Code MCP

If you want to build MCP servers for your stack, Claude Code is actually a solid tool for the job. You can use Claude Code MCP capabilities to scaffold a server, define tool schemas, and test against your APIs.

Here’s what a basic MCP tool definition looks like for a ConnectWise ticket lookup:

server.registerTool(
  "get_ticket",
  {
    description: "Retrieve a ConnectWise PSA ticket by ID",
    inputSchema: { ticket_id: z.number().describe("The ConnectWise ticket ID") }
  },
  async ({ ticket_id }) => {
    const response = await fetch(
      `${baseUrl}/v4_6_release/apis/3.0/service/tickets/${ticket_id}`,
      {
        headers: {
          "Authorization": `Basic ${credentials}`,
          "clientId": clientId,
          "Content-Type": "application/json"
        }
      }
    );
    const ticket = await response.json();
    return {
      content: [{
        type: "text",
        text: JSON.stringify(ticket, null, 2)
      }]
    };
  }
);

And a NinjaOne device query:

server.registerTool(
  "get_device",
  {
    description: "Get device details from NinjaOne by device ID",
    inputSchema: { device_id: z.number().describe("The NinjaOne device ID") }
  },
  async ({ device_id }) => {
    const token = await getAccessToken();
    const response = await fetch(
      `https://${instance}/api/v2/device/${device_id}`,
      {
        headers: { "Authorization": `Bearer ${token}` }
      }
    );
    const device = await response.json();
    return {
      content: [{
        type: "text",
        text: JSON.stringify(device, null, 2)
      }]
    };
  }
);

You can use the MCP SDK (@modelcontextprotocol/sdk for TypeScript, mcp for Python) to build these. Each server registers its tools, and Claude discovers them when it connects. You can build a working read-only server for one tool in a few hours.

The problem isn’t building one server. It’s building ten, and keeping them running. (This is the exact problem Junto solves with pre-built integrations — but if you want to understand the DIY path first, here’s where it gets real.)

Where the DIY Approach Breaks Down

Every MSP that’s gone down the “build my own Claude MCP servers” path hits the same walls. They’re not technical limitations of MCP — they’re operational realities of running an MSP.

Multi-tenancy

This is the big one. You manage 30, 50, 100 clients. When Claude queries ConnectWise, it needs to scope results to the right client. When it pulls M365 data, it needs to hit the right tenant. When it reads ITGlue documentation, it needs to filter by organization.

In a single-user Claude Desktop setup, you’re typically authenticated as yourself with access to everything. There’s no tenant isolation. If you ask “show me recent tickets,” you get tickets across all clients. Building proper multi-tenant scoping into each MCP server — where every query is filtered to the correct client context — is a significant engineering project.

Authentication management

Each tool has its own auth model. ConnectWise uses API keys with member-level permissions. NinjaOne uses OAuth with refresh tokens. ITGlue uses API keys scoped by organization. M365 requires app registrations per tenant or a partner-level delegated admin setup. Sophos Central uses a different OAuth flow than NinjaOne.

In the JSON config above, those credentials are environment variables. For a single tech experimenting on their laptop, that’s fine. For a team of 15 techs across 80 clients, you need credential management, rotation, and per-client auth — which MCP’s config model wasn’t designed for.

Maintenance and reliability

APIs change. ConnectWise releases API updates that break field names. NinjaOne adds rate limits. ITGlue deprecates endpoints. M365 Graph API versions evolve. Each MCP server you build is a service you maintain. When the NinjaOne server breaks at 2 AM because their API changed, your AI workflow stops working until someone fixes it.

For MSPs already stretched thin on engineering resources, maintaining a fleet of custom MCP servers is a real operational burden.

Write operations and safety

Read access is straightforward. Write access — updating tickets, running scripts, resetting passwords, modifying configurations — requires guardrails. You need approval workflows, audit logging, rollback capabilities, and the confidence that Claude won’t execute a destructive action without human review.

Building those safety mechanisms into each individual MCP server, consistently across your entire stack, is where the effort multiplies.

Claude Cowork MSP: What People Are Actually Searching For

If you’ve searched “claude cowork msp” or “claude cowork connectwise,” you’re looking for ways to use Claude alongside your MSP tools — querying ConnectWise tickets, pulling NinjaOne device data, searching ITGlue documentation, all from Claude’s interface via MCP servers. That’s exactly what the setup described above enables. Claude connects to your tools through MCP servers, and you interact with your entire stack through one conversation.

The gap between “Claude with a few MCP servers” and “production-ready MSP automation” is everything discussed above: multi-tenancy, auth management, write safety, and reliability across 50+ client environments.

What Junto Provides Instead

Junto took the “build MCP servers for MSP tools” problem and productized it. Here’s a real example: a password reset ticket comes in. Junto’s AI reads the ticket, queries ConnectWise for the contact record, checks M365 for the user’s account status, pulls the client’s password policy from ITGlue, generates a compliant temporary password, and drafts the reset — all before your tech opens the ticket. That’s five MCP-style tool calls across four systems, multi-tenant scoped, in under 30 seconds.

Instead of configuring individual servers in a JSON file and managing credentials on your machine, Junto provides 19+ pre-built integrations that handle the entire stack:

PSA: ConnectWise PSA, Halo PSA, Autotask RMM: NinjaOne, Datto RMM, ConnectWise Automate Documentation: ITGlue, Hudu Identity & Productivity: Microsoft 365, Google Workspace Security: Sophos, SentinelOne Licensing & Billing: Pax8 Networking: Auvik, Meraki Communication: Slack, Teams

Each integration is multi-tenant by design — every query is scoped to the correct client. Authentication is managed through OAuth at the platform level, not API keys in a config file. And when ConnectWise changes their API, Junto’s engineering team fixes it — not yours.

But the real difference isn’t the integrations themselves. It’s what’s built on top of them. Junto runs an 18-processor triage pipeline on every incoming ticket — classifying intent, pulling cross-tool context, matching runbooks, and posting enriched internal notes to your PSA. Runbooks execute multi-step resolutions with tech approval. The intelligence engine identifies automation opportunities from your actual ticket patterns.

MCP servers are plumbing. Junto is the product built on top of that plumbing.

When DIY Makes Sense (and When It Doesn’t)

Build your own Claude MCP servers if:

  • You have dedicated engineering resources and enjoy the build
  • You’re connecting 1-2 tools for personal productivity (not team-wide)
  • You’re prototyping a specific workflow before committing to a platform
  • You manage a small number of clients where multi-tenancy isn’t critical

Use a platform like Junto if:

  • You need multi-tenant isolation across dozens of clients
  • Your team (not just you) needs AI-assisted triage and resolution
  • You want to connect 5+ tools and don’t want to maintain 5+ MCP servers
  • You’d rather spend time on service delivery than infrastructure

Most MSPs we talk to started with the DIY approach — got a ConnectWise MCP server working in Claude Desktop, maybe added M365 — and realized that scaling it to their full stack and full team was a different problem entirely.

Getting Started

If you want to experiment with Claude MCP servers today, start with one tool. Pick your PSA or your RMM, build a read-only MCP server using the SDK, and connect it to Claude Desktop. See what it feels like to ask Claude a question and get an answer from your real data. That experience is what makes the value click.

When you’re ready to move beyond the experiment — multi-tenant, multi-tool, team-wide, with automation — book a 15-minute demo. We’ll connect to your ConnectWise instance and show you AI triage pulling context from your actual stack on your actual tickets. No MCP servers to build.

See Junto in action

15-minute demo. We'll show you AI triage working on your actual tickets.

Book a Demo