The MCP Server Start Guide

🚧
This documentation contains references to third party software or websites. N-able has no control over third party software or content and is not responsible for the availability, security, or operation, of any third-party software. If you decide to utilize a release involving third-party software, you do so entirely at your own risk and subject to the applicable third party’s terms and conditions of the use of such software. No information obtained by you from N-able or this documentation shall create any warranty for such software.

Head Nerd Created Adlumin MCP Setup

THIS IS A HEAD NERD CREATED MCP SERVER AND IS NOT SUPPORTED BY N-ABLE. IF SUPPORT IF REQUIRED REACH OUT TO JOE FERLA [email protected].

Connect your AI assistant to the Adlumin security platform for real-time threat intelligence and SOC workflows. This guide walks through configuring the Adlumin MCP server in Claude Desktop, ChatGPT, and GitHub Copilot for VS Code.

Please note that we have updated the MCP server to Version 3.0 as of October 29, 2026.

Download the MCP Server and Documentation HERE

Prerequisites

Before starting, make sure you have the following:

Adlumin API key — Obtain an API key from your Adlumin platform admin. The server sends it as the X-API-KEY header to https://api.adlumin.com/v1.
Tenant ID — Obtain the Tenant ID from the Adlumin Platform. It is optional for the local Python server (it sets the default tenant).
A self-hosted MCP server — Required only for the remote proxy method and the VS Code HTTP setup. An administrator sets it up once (see "Hosting the server yourself") and shares its URL and an access token. Not needed for the local Python method.
Node.js v18+ — Required only for the remote proxy method in Claude Desktop. Download it from nodejs.org. Verify your version:
```
node --version
```
Python 3.10+ — Required only if you run the server locally. Verify your version:
```
python3 --version
```

shield
Keep your API key private. Never commit it to git or share it in screenshots.

Option 1: Claude Desktop

There are two ways to connect Claude Desktop to Adlumin:

Remote proxy — Recommended for teams. Users need no Python, but an administrator must first host the MCP server (see "Hosting the server yourself").
Local Python server — Use this if you need to modify the server or work in a restricted network environment.

Method A: Remote proxy

This method uses mcp-remote, an npm package that bridges Claude Desktop's stdio transport to an Adlumin MCP server over HTTP. That server must already be running: your administrator hosts it by following "Hosting the server yourself" below, and gives you its URL and an access token.

Open Claude Desktop.
Go to Settings → Developer → Edit Config to open claude_desktop_config.json.

File locations:
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json
Add the following block inside the mcpServers object. Create the object if it does not exist:
```
{
  "mcpServers": {
    "adlumin-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "<ADLUMIN_MCP_SERVER_URL>",
        "--header",
        "Authorization:${MCP_AUTH}"
      ],
      "env": {
        "MCP_AUTH": "Bearer <YOUR_ACCESS_TOKEN>"
      }
    }
  }
}
```
The access token is the one your administrator issued for the hosted server (see "Hosting the server yourself"). It goes in env and is referenced as ${MCP_AUTH}; it is not the Adlumin API key. Keep no space after the colon in the header value; spaces inside args break parsing on Windows.
Replace <ADLUMIN_MCP_SERVER_URL> and <YOUR_ACCESS_TOKEN> with the values from your administrator.
Save the file.
Fully quit and reopen Claude Desktop (quit from the system tray or menu bar, not just the window).
Verify the connection. In a new chat, click the tools icon or type /. You should see Adlumin tools listed, such as get_detections and get_firewall_events.

If tools do not appear, check the Claude Desktop logs:

macOS: ~/Library/Logs/Claude/mcp-server-adlumin-mcp.log
Windows: %APPDATA%\Claude\logs\mcp-server-adlumin-mcp.log

Method B: Local Python server

Run the server directly from the Python source. Use this method if you need to modify the server or work in a restricted network environment. The server runs on your machine over stdio and calls the Adlumin API directly.

Unzip the downloaded MCP server package to a known location, for example:
```
~/tools/adlumin-mcp-python/
```
Install dependencies:
```
cd ~/tools/adlumin-mcp-python
pip install -r requirements.txt
```
Use the same Python you will put in command below.

Add this block to claude_desktop_config.json:

{
  "mcpServers": {
    "adlumin-mcp": {
      "command": "<PATH_TO_PYTHON>",
      "args": [
        "<PATH_TO_server.py>"
      ],
      "env": {
        "ADLUMIN_API_KEY": "<YOUR_API_KEY>",
        "TENANT_ID": "<YOUR_TENANT_ID>"
      }
    }
  }
}

Replace the placeholders:
- <PATH_TO_PYTHON> — for example python3 on macOS/Linux, or C:\\Python312\\python.exe on Windows.
- <PATH_TO_server.py> — the full path to server.py from step 1. On Windows use double backslashes.
- <YOUR_API_KEY> and <YOUR_TENANT_ID> — the values from your Adlumin admin.
Save the file.
Fully quit and reopen Claude Desktop.
Verify that the Adlumin tools appear in Claude Desktop.

Hosting the server yourself (for Method A and VS Code)

Method A and the VS Code HTTP setup both connect to an MCP server over HTTP. server.py speaks stdio by default, so an administrator hosts it once on a server, and users then connect with no Python on their machines.

shield
A hosted server calls Adlumin with one API key (and optional default tenant) set on the host. The server has no built-in login, so anyone who can reach it can read that tenant's data and run acknowledge_detections. Put it behind TLS and an authenticating reverse proxy or gateway, and restrict who can reach it.

On the host

Install Python 3.10+ and the dependencies from the downloaded package:
```
pip install -r requirements.txt
```

Next to server.py, create server_http.py:

import server

server.mcp.run("streamable-http", host="127.0.0.1", port=8000)

Set the environment variables and start it:
```
export ADLUMIN_API_KEY="<YOUR_API_KEY>"
export TENANT_ID="<YOUR_TENANT_ID>"
python server_http.py
```
On Windows PowerShell, use $env:ADLUMIN_API_KEY = "<YOUR_API_KEY>" instead of export.

The endpoint is http://127.0.0.1:8000/mcp. It binds to localhost on purpose.
Publish it with a reverse proxy (nginx, IIS, a cloud gateway) that terminates HTTPS and requires a token you issue. The public address, for example https://adlumin-mcp.example.com/mcp, is your <ADLUMIN_MCP_SERVER_URL>.
Run it as a service (systemd, NSSM, a container) so it restarts, and keep the API key in the service's secret store, not in a file in git.

What to give your users

The proxy URL and the token you issued. In Method A, the --header carries your gateway token (for example Authorization:${MCP_AUTH}, with MCP_AUTH in env set to Bearer <token>), not the Adlumin API key. Users don't need Adlumin credentials or Python.

Option 2: ChatGPT

Native MCP support in ChatGPT is limited, so the steps below use the Custom GPT and Actions method, which works with OpenAI plans that include GPT Builder access.

This method does not use the MCP server. The GPT calls the Adlumin REST API directly, and can only use the endpoints you define in the OpenAPI schema.

Go to chatgpt.com → Explore GPTs → Create.
Click Configure → Add actions → Create new action.

In the Schema field, paste an OpenAPI 3.1 definition for the Adlumin endpoints you want to expose.

Example for get_detections:

openapi: 3.1.0
info:
  title: Adlumin API
  version: "1"
servers:
  - url: https://api.adlumin.com/v1
paths:
  /detections:
    get:
      operationId: get_detections
      summary: List security detections
      parameters:
        - name: severity
          in: query
          schema:
            type: string
        - name: status
          in: query
          schema:
            type: string
      responses:
        "200":
          description: Detection list

Under Authentication, choose API Key.
Set the auth type to Custom, enter X-API-KEY as the header name, and paste your Adlumin API key.
Click Save and Publish. Choose Only me to keep it private.
Test the GPT with:
```
Show me the latest critical detections.
```

If OpenAI adds native MCP support to your account, you can skip the OpenAPI schema and connect the MCP server URL directly in Connectors settings.

Option 3: GitHub Copilot in VS Code

VS Code supports MCP servers from version 1.99. This connects Adlumin tools directly into Copilot's agent mode. It connects over HTTP, so it needs the self-hosted MCP server described in "Hosting the server yourself"; ask your administrator for its URL and access token first.

Make sure you have VS Code 1.99+ and the GitHub Copilot Chat extension installed.
Sign in to GitHub Copilot.
Open the Command Palette:
- macOS: Cmd+Shift+P
- Windows/Linux: Ctrl+Shift+P
Run MCP: Add Server....

If you do not see this command, update VS Code and the Copilot Chat extension.
Choose HTTP (HTTP or Server-Sent Events) as the server type.
Enter the URL of your organisation's self-hosted Adlumin MCP server when prompted:
```
https://<ADLUMIN_MCP_SERVER_URL>/mcp
```

VS Code opens your workspace .vscode/mcp.json file or user settings. Make sure the entry looks like this, adding the authorization header manually:

{
  "servers": {
    "adlumin-mcp": {
      "type": "http",
      "url": "https://<ADLUMIN_MCP_SERVER_URL>/mcp",
      "headers": {
        "Authorization": "Bearer ${input:adlumin-mcp-token}"
      }
    }
  },
  "inputs": [
    {
      "id": "adlumin-mcp-token",
      "type": "promptString",
      "description": "Adlumin MCP access token",
      "password": true
    }
  ]
}

VS Code prompts for the key the first time the server starts, so it is never saved in a file you might commit. Note that VS Code uses servers, not mcpServers.

Save the file.
Open Copilot Chat with Ctrl+Alt+I.
Switch to Agent mode from the dropdown next to the send button.
Verify that Adlumin tools appear in the tools list.

Test with:

Use Adlumin to show me endpoint data for any offline agents.

If the server URL uses plain HTTP, VS Code may warn about insecure connections. Use the HTTPS endpoint if your admin has one configured.

Available tools

Tool	Category	Description
`get_detections`	Detections	List and filter security detections by severity, status, date range, or free text. Max 100 per page.
`acknowledge_detections`	Detections	Acknowledge one or more detections by ID, removing them from the active dashboard. This changes data; keep per-tool approval on.
`get_at_risk_groups`	At-Risk Assets	List Active Directory groups flagged at risk due to overly broad or privileged permissions.
`get_at_risk_shares`	At-Risk Assets	List network shares flagged at risk, such as world-readable shares or shares accessible to privileged groups.
`get_at_risk_systems`	At-Risk Assets	List hosts flagged at risk due to misconfiguration, stale patches, or anomalous activity.
`get_endpoint_data`	Endpoint	List endpoint security agent telemetry for SentinelOne, CrowdStrike, Carbon Black, and Defender.
`get_complete_endpoint_data`	Endpoint	Tenant-wide summary of at-risk counts, sensor health, compliance posture, and network health score.
`get_device_data`	Endpoint	Base device inventory, including hostname, IP, MAC, OS, and domain, regardless of agent status.
`get_network_data`	Network	Network health score from 0–100 and per-metric breakdown, including stale accounts and GPO violations.
`get_compliance_insights`	Compliance	Compliance posture insights for the tenant.
`get_firewall_events`	Firewall	Raw firewall log events with source and destination IPs, geo data, action, and UBA risk score.
`get_firewall_geo_aggregation`	Firewall	Top source and destination countries by firewall event volume.
`get_firewall_blocked_ip_aggregation`	Firewall	Most frequently blocked IP addresses by firewall event volume.

References

Claude Desktop (config file locations, Edit Config, restart, logs): Connect to local MCP servers
mcp-remote (--header, environment variable substitution, Windows spacing workaround, Node.js 18+): mcp-remote on GitHub
VS Code MCP server setup (MCP: Add Server, transport choices): Use MCP servers in VS Code
VS Code mcp.json format (servers, type, url, headers, inputs): MCP configuration reference
ChatGPT Custom GPT Actions (API key authentication): GPT Actions authentication