Connect ManageEngine Endpoint Central to ChatGPT: Monitor Fleet Health

If you need to connect ManageEngine Endpoint Central to ChatGPT to monitor fleet health, audit software inventory, or run patch compliance checks via natural language, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and ManageEngine's specific REST APIs. You can either build, host, and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting ManageEngine Endpoint Central to Claude or explore our broader architectural overview on connecting ManageEngine Endpoint Central to AI Agents.

Giving a Large Language Model (LLM) read and write access to an endpoint management platform is an engineering challenge. You have to handle complex nested hardware summaries, undocumented query parameters, and specific rate limit behaviors. Every time your IT operations require a new API endpoint, custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for ManageEngine Endpoint Central, connect it natively to ChatGPT, and execute complex IT automation workflows using natural language.

The Engineering Reality of the ManageEngine Endpoint Central API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against ManageEngine's API surface introduces specific integration friction points. If you build a custom MCP server, you own the entire API lifecycle and have to solve these problems from scratch.

The "toolID" Magic Numbers

ManageEngine Endpoint Central's API relies heavily on specific, sometimes poorly documented magic numbers to route requests. For instance, querying the software inventory across the fleet requires passing toolID=2121. Querying the overall inventory scan status requires passing toolID=2131. If an LLM attempts to hit these endpoints without these exact query parameters, the request will fail. Building a custom MCP server means manually hardcoding these requirements into JSON Schemas so the LLM knows to include them. Truto's auto-generated tools automatically inject these requirements into the tool's query_schema, forcing the LLM to pass the correct ID without hallucinating.

Highly Nested Summary Payloads

When an LLM asks for a computer's summary, the API does not return a flat record. Instead, get_summary returns five distinct objects in one payload: osSummary, hardwareSummary, generalSummary, assetSummary, and diskUsageSummary. Processing these requires the LLM to navigate deep JSON trees. If your MCP server does not accurately pass the response schema definitions, the LLM will struggle to parse the nested hardware specifications. Truto handles this mapping dynamically derived from documentation records.

Strict Rate Limiting (No Automatic Retries)

ManageEngine Endpoint Central strictly throttles requests to prevent database exhaustion. When building an MCP server, you must handle these limits. It is critical to note: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream ManageEngine API returns an HTTP 429, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. The caller (your AI agent or application) is strictly responsible for implementing its own retry and backoff logic. Do not assume the integration layer will absorb rate limit spikes.

How to Create the ManageEngine Endpoint Central MCP Server

Truto dynamically generates MCP tools by reading the integration's resource definitions and mapping them to JSON-RPC 2.0 endpoints. You can create a scoped MCP server for your ManageEngine instance in two ways: via the UI or programmatically via the API.

Method 1: Via the Truto UI

If you are setting this up for internal team use, the dashboard is the fastest route:

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected ManageEngine Endpoint Central account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration. You can restrict the server to only read operations or filter by tags (e.g., inventory, patches).
6. Click Save and copy the generated MCP server URL.

This URL contains a hashed token that securely identifies the account and configuration. Treat it like a secret.

Method 2: Via the Truto API

If you are building an AI product and need to generate MCP servers dynamically for your customers, use the REST API. You will need the integrated_account_id for the specific ManageEngine connection.

Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ManageEngine Fleet Monitor",
    "config": {
      "methods": ["read"],
      "tags": ["inventory", "patches", "security"]
    }
  }'

The API will return a database record including the tokenized URL:

{
  "id": "abc-123",
  "name": "ManageEngine Fleet Monitor",
  "config": { "methods": ["read"], "tags": ["inventory", "patches", "security"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to ChatGPT

Once you have the url from the steps above, you must connect it to ChatGPT so the model can discover and execute the ManageEngine tools.

Method A: Via the ChatGPT UI

If you are using ChatGPT directly (requires a Pro, Plus, Business, Enterprise, or Education account):

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on.
3. Under the custom connectors or MCP servers section, click to add a new server.
4. Enter a name (e.g., "ManageEngine Fleet Data").
5. Paste the Truto MCP URL into the Server URL field.
6. Save the configuration. ChatGPT will immediately perform an MCP handshake (initialize), request tools/list, and load the IT tools into its context window.

Method B: Via Manual Config File (Local Agents / Claude Desktop equivalent)

If you are running a local agent environment, LangGraph, or testing via an MCP client configuration file, you connect to the remote Truto server using the SSE (Server-Sent Events) transport.

Add the following to your MCP configuration file (e.g., mcp-settings.json):

{
  "mcpServers": {
    "manageengine_endpoint_central": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_TOKEN_HERE"
      ]
    }
  }
}

Your agent will now proxy tool execution through the secure token URL directly to the ManageEngine API.

Hero Tools for ManageEngine Endpoint Central

Truto automatically exposes the ManageEngine endpoints as well-documented MCP tools. Here are six high-leverage tools available for your AI agents.

1. List Managed Computers

Tool name: list_all_manage_engine_endpoint_central_computers

This is the starting point for most workflows. It returns the fleet of computers managed in Endpoint Central, including their resource_id, OS details, IP addresses, MAC addresses, and agent contact status. You need this to get the computer_id for deeper investigations.

"Get a list of all managed computers in Endpoint Central that have an installation status of failed or offline."

2. Get Hardware Summary

Tool name: manage_engine_endpoint_central_computers_get_summary

Retrieves the primary inventory summary of a specific machine. It outputs highly nested JSON containing osSummary, hardwareSummary, generalSummary, assetSummary, and diskUsageSummary. The LLM can parse this to tell you exactly what OS version or hardware is running.

"Pull the hardware and OS summary for computer ID 1042. Tell me how much disk space is left on the primary drive."

3. Audit Installed Software

Tool name: manage_engine_endpoint_central_computers_get_software

Requires a computer_id. Returns an array of installed software records, including the manufacturer, installation date, and version. Crucial for shadow IT discovery and compliance auditing.

"List all the software installed on computer ID 2055. Flag any applications manufactured by BitTorrent or unauthorized VPN providers."

4. Check Firewall Status

Tool name: manage_engine_endpoint_central_computers_get_firewall

Requires a computer_id. Returns external firewall details (third-party products) and native Windows Firewall configurations per network profile. Use this to verify endpoint security posture.

"Check the firewall status for computer ID 4091. Is the Windows Firewall active on the public network profile?"

5. Fleet Scan Status

Tool name: list_all_manage_engine_endpoint_central_inventory_computers

Requires toolID: 2131. This returns per-computer scan records with FQDN, IP, MAC, and scan_status. It is essential for verifying that the agent is actively reporting back to the management server.

"Check the inventory scan status for the entire fleet using tool ID 2131. Which machines have not successfully scanned in the last 7 days?"

6. System Patch Health

Tool name: list_all_manage_engine_endpoint_central_patch_systems

Retrieves the patch systems report, detailing the health of machines across the network. Returns total patches, missing patches, and installed patches per system.

"Run a patch health report across the fleet. Give me a table of all systems that have more than 5 missing OS patches."

To view the complete inventory of available tools, schemas, and resource mappings, visit the ManageEngine Endpoint Central integration page.

Workflows in Action

When you connect an LLM to an MCP server, you move beyond isolated API calls into autonomous workflows. Here are two concrete scenarios showing how ChatGPT orchestrates ManageEngine tools.

Scenario 1: Triage a Compromised Endpoint

An IT admin receives an alert about suspicious activity on a specific laptop and uses ChatGPT to immediately build a threat context profile.

"A security alert fired for the machine 'LAPTOP-DEV-09'. Find this computer in Endpoint Central, check if its firewall is active, and list any software installed in the last 48 hours."

Step-by-step Execution:

1. ChatGPT calls list_all_manage_engine_endpoint_central_computers with a search filter to find the resource_id for 'LAPTOP-DEV-09' (e.g., ID 405).
2. It calls manage_engine_endpoint_central_computers_get_firewall passing computer_id: 405 to verify network defenses.
3. It calls manage_engine_endpoint_central_computers_get_software to pull the software array, using Python in its sandbox to filter for installed_date within the last two days.

The Output: ChatGPT replies with a concise summary stating that the machine's public firewall profile is inexplicably disabled, and an unauthorized remote desktop utility was installed yesterday afternoon.

sequenceDiagram
    participant User as User Prompt
    participant GPT as ChatGPT Agent
    participant Truto as Truto MCP Server
    participant ManageEngine as ManageEngine API

    User->>GPT: "Check LAPTOP-DEV-09 firewall and new software"
    GPT->>Truto: call tools/list_all_manage_engine_endpoint_central_computers
    Truto->>ManageEngine: GET /api/1.4/mdm/computers
    ManageEngine-->>GPT: Returns resource_id: 405
    
    GPT->>Truto: call tools/manage_engine_endpoint_central_computers_get_firewall
    Truto->>ManageEngine: GET /api/1.4/mdm/computers/405/firewall
    ManageEngine-->>GPT: Returns firewall disabled
    
    GPT->>Truto: call tools/manage_engine_endpoint_central_computers_get_software
    Truto->>ManageEngine: GET /api/1.4/mdm/computers/405/software
    ManageEngine-->>GPT: Returns software array
    
    GPT-->>User: Delivers compromised endpoint report

Scenario 2: Pre-Audit Patch Compliance Report

Before a compliance audit, the DevOps team needs to identify which servers are lagging behind on critical patches without logging into the clunky ManageEngine dashboard.

"I need a patch compliance audit. Run the system health report to find any machines missing patches. For the worst offender, pull its full hardware summary and list what OS it is running."

Step-by-step Execution:

1. ChatGPT calls list_all_manage_engine_endpoint_central_patch_systems to retrieve the fleet's patch posture.
2. It analyzes the JSON array, sorting by MissingPatches to identify the machine with the highest count (e.g., resource_id: 812).
3. It calls manage_engine_endpoint_central_computers_get_summary with computer_id: 812.
4. It parses the osSummary block to extract the exact Windows Server version and build number.

The Output: ChatGPT provides a markdown table of the top 5 most vulnerable systems, highlighting that the worst offender is a legacy Windows Server 2016 box running out of disk space, preventing patch installations.

Security and Access Control

Giving an AI agent access to endpoint management tools requires strict governance. Truto provides several mechanisms to secure your ManageEngine MCP server:

• Method Filtering: Configure the MCP token with config.methods: ["read"]. This ensures the AI can run get and list operations (like pulling reports) but strictly denies create, update, or delete actions, preventing accidental device wipes or configuration changes.
• Tag Filtering: Use config.tags: ["inventory"] to restrict the LLM's visibility strictly to hardware and software lists, hiding sensitive patching or administrative endpoints.
• Expiration: Set an expires_at timestamp when generating the server via the API. This creates a short-lived server (e.g., valid for 2 hours) for temporary auditing tasks, which automatically self-destructs when time runs out.
• Dual Authentication: By enabling require_api_token_auth: true, possession of the MCP URL is no longer enough. The client must also pass a valid Truto API token in the Authorization header, adding a second layer of defense against URL leakage.

Orchestrating Fleet Health with AI

Connecting ManageEngine Endpoint Central to ChatGPT transforms endpoint management from a point-and-click chore into an interactive, conversational workflow. Instead of writing custom integration scripts to unpack complex hardware summaries or remembering obscure toolID query parameters, you can rely on Truto's auto-generated, dynamically mapped MCP tools.

Whether you are triaging a compromised laptop, hunting for shadow IT, or generating patch compliance reports for an auditor, deploying an MCP server bridges the gap between your IT data and the reasoning capabilities of an LLM.