The NinjaOne MCP server lets you manage NinjaOne IT ticketing from any MCP-compatible client using your own OAuth credentials.
Ticket Management
Search tickets – List tickets from a board with pagination and filtering
Get ticket – Retrieve full details of a single ticket by ID
Create ticket – Create new tickets with subject, description, type, status, priority, severity, organization, and assignee
Update ticket – Modify existing tickets (status, priority, severity, assignee, subject)
Add comment – Post public responses or private/internal notes to tickets
Discovery & Lookup
List boards – Return the default board ID
List statuses – Retrieve all available ticket statuses with their IDs
List organizations – Browse NinjaOne client/organization records (paginated)
List technicians – Enumerate app users with their numeric IDs for ticket assignment
Authentication
Get auth URL – Generate a NinjaOne OAuth authorization URL to begin the manual login flow
Exchange code – Trade an OAuth authorization code for a refresh token to enable write operations
Read operations work with client credentials only; write operations require user-context auth (refresh token or session key). The server runs locally over stdio with no third-party service involved.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@NinjaOne MCP Search for high priority tickets from last week"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A local Model Context Protocol server for NinjaOne ticketing. It lets any MCP client (Claude Desktop, Claude Code, and others) search, read, create, update, and comment on NinjaOne tickets.
Runs locally over stdio using your own NinjaOne OAuth credentials. No third-party service sits in the middle.
Tool | Description |
| List tickets from a board (paginated) |
| Get a single ticket by ID |
| Create a ticket |
| Update a ticket (status, priority, severity, assignee, subject) |
| Add a public response or private note to a ticket |
| List ticket statuses with IDs |
| List organizations (clients) |
| List technicians with their numeric IDs |
| Return the default board ID |
| Manual OAuth flow to obtain a user refresh token |
Related MCP server: jitbit-helpdesk-mcp
Node.js 18+
A NinjaOne API OAuth client (NinjaOne > Administration > Apps > API):
Client ID and Client Secret
Scopes: monitoring (reads) and management (ticket writes)
For user-context writes (comments authored as you), enable the Authorization Code grant and the offline_access scope, and register a redirect URI (http://localhost:3846/ for the built-in flow, or https://localhost if you use get-refresh-token.js).
git clone https://github.com/cyberkoder/ninjaone-mcp.git
cd ninjaone-mcp
npm installAll configuration is via environment variables (see .env.example):
Variable | Required | Notes |
| yes | Your region's host, e.g. |
| yes | OAuth client ID |
| yes | OAuth client secret |
| no | Defaults to |
| for writes | User-context refresh token (preferred). See below. |
| alt | NinjaOne web session cookie value (expires with the browser session) |
| no | Default org ID for |
| no | Port for the one-time interactive login (default |
Reads (search_tickets, get_ticket, list tools) work with just the client ID/secret via client_credentials. Writes require user context (a refresh token or session key). If neither is set, the first write opens a browser once to authenticate you and captures a refresh token for the session.
NINJA_CLIENT_ID=... NINJA_CLIENT_SECRET=... node get-refresh-token.jsFollow the prompts, then set the printed value as NINJA_REFRESH_TOKEN.
Add to claude_desktop_config.json:
{
"mcpServers": {
"ninjaone": {
"command": "node",
"args": ["/absolute/path/to/ninjaone-mcp/index.js"],
"env": {
"NINJA_BASE_URL": "https://app.ninjarmm.com",
"NINJA_CLIENT_ID": "your-client-id",
"NINJA_CLIENT_SECRET": "your-client-secret",
"NINJA_REFRESH_TOKEN": "your-refresh-token"
}
}
}
}claude mcp add ninjaone -- node /absolute/path/to/ninjaone-mcp/index.jsThen set the NINJA_* environment variables for the server (via the config file's env block or your shell).
These reflect how NinjaOne's ticketing API actually behaves, so you know what to expect:
Reads vs. writes need different auth. client_credentials (client ID + secret) is read-only. Creating, updating, or commenting on tickets requires user context - a refresh token, a session key, or the one-time browser login. With reads-only auth, write tools return an auth error.
Authorization Code grant must be enabled. Older NinjaOne OAuth clients only expose the "Refresh Token" grant and return unauthorized_client for the authorization-code flow. Enable Authorization Code (and the offline_access scope) on the API client, or the interactive/get-refresh-token.js flows won't work.
Comments must be multipart/form-data. The /comment endpoint rejects application/json with HTTP 415. This server already posts the correct form encoding - noted so forks don't regress it.
Refresh tokens rotate. NinjaOne may issue a new refresh token on use. The server logs the rotated value to stderr, but it only persists for the process lifetime - copy it back into NINJA_REFRESH_TOKEN to keep it across restarts.
Session keys are short-lived. NINJA_SESSION_KEY is a browser-session cookie and expires when that session ends. Prefer a refresh token for anything long-running.
update_ticket is read-modify-write. It fetches the ticket first to supply the required version and requesterUid, so concurrent edits can hit optimistic-locking conflicts. Some status transitions (e.g. directly to a closed state) are restricted by NinjaOne's workflow.
Interactive login is local-only. The automatic browser flow needs a localhost redirect and a desktop browser; it won't work in headless/CI environments (use a pre-obtained NINJA_REFRESH_TOKEN there).
No "list boards" API. NinjaOne doesn't expose one; board 1 is the default. Use list_organizations and list_technicians to discover IDs.
No built-in rate-limit handling or retries, and the toolset is intentionally scoped to core ticketing (no attachments, custom fields, time entries, or asset/monitoring endpoints yet). PRs welcome.
This is an independent open-source project and is not affiliated with or endorsed by NinjaOne.
MIT
Add a comment to a NinjaOne ticket. Requires write auth (refresh token or session key).
| Name | Required | Description | Default |
|---|---|---|---|
| body | Yes | ||
| ticketId | Yes | ||
| publicEntry | No | true = public response visible to the requester, false = private/internal note (default true) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description carries full burden. It states auth requirement but does not disclose side effects (e.g., notifications, limits) or result format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences covering action and auth. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with 3 parameters, description covers purpose and auth. But lacks output specification (e.g., returns created comment) and error scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 33%; only publicEntry has a description. The description adds no parameter details beyond schema, leaving body and ticketId without extra meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Add a comment to a NinjaOne ticket.' This is a specific verb+resource+target, and it distinguishes from siblings like update_ticket or create_ticket.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly mentions required write auth (refresh token or session key), which is relevant for when to use. However, does not discuss when not to use or compare to alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new NinjaOne ticket. Requires write auth (refresh token or session key).
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | ||
| status | No | Status name: NEW, OPEN, WAITING, PAUSED, RESOLVED (default NEW) | |
| summary | Yes | Ticket subject | |
| clientId | No | Organization ID (use list_organizations). Omit to use the default org. | |
| priority | No | ||
| severity | No | ||
| description | No | Ticket body text | |
| ticketFormId | No | Form ID (default 1) | |
| assignedAppUserId | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It correctly states 'Requires write auth' but fails to mention return value, idempotency, rate limits, or side effects. This is insufficient for a creation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences, front-loaded with the primary action. No unnecessary content, every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 9 parameters, no output schema, and a creation action, the description is too brief. It omits success conditions, return value, and any special behavior, leaving the agent underinformed for reliable invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 56%, meaning several parameters lack schema descriptions. The tool description adds no parameter-specific information beyond the auth note, failing to compensate for the gap or clarify parameter interplay.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create') and the resource ('a new NinjaOne ticket'), which is specific and distinguishes it from sibling tools like update_ticket, get_ticket, and search_tickets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions an auth requirement but does not provide guidance on when to use this tool versus alternatives like update_ticket, nor does it specify prerequisites or exclusions. The agent lacks context for optimal selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Exchange a NinjaOne authorization code for a refresh token. Paste the code from the redirect URL after using get_auth_url. Save the returned refresh_token as NINJA_REFRESH_TOKEN in your MCP client config.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | The authorization code from the redirect URL query parameter 'code' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries full burden. It mentions the returned refresh_token but does not disclose potential errors, rate limits, or side effects. Adequate for a simple exchange but lacks completeness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words. Purpose is front-loaded, and instructions are direct. Ideal conciseness for this tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a single parameter, no output schema, and a simple OAuth flow, the description is complete. It explains the prerequisite (get_auth_url) and post-action (save token). No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a description of 'code'. The description adds valuable context: 'Paste the code from the redirect URL after using get_auth_url', which helps the agent understand where to obtain the parameter value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The verb 'Exchange' and resource 'authorization code for a refresh token' clearly define the action. It distinguishes from sibling tool get_auth_url by indicating it is used after that step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use ('after using get_auth_url') and what to do with the result ('Save the returned refresh_token...'). No explicit when-not, but usage context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a NinjaOne OAuth authorization URL. Open it in a browser to log in as yourself. After authorizing, copy the 'code' parameter from the redirect URL and pass it to exchange_code.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations present, so description carries the burden. It describes a non-destructive, read-only operation (generating URL) and mentions the OAuth flow, but does not explicitly state lack of side effects or security considerations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the core purpose, no wasted words. Efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complete for a simple 0-parameter tool, covering purpose and next step. However, it does not explicitly describe the output format (though implied it's a URL). Minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, schema coverage is 100%. The description adds context about the URL's purpose and usage, going beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates an OAuth authorization URL, using a specific verb and resource. It distinguishes from sibling tools like exchange_code by describing the next step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly explains the workflow: open URL in browser, authorize, copy code, pass to exchange_code. Provides clear when-to-use and sequential guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a single NinjaOne ticket by ID.
| Name | Required | Description | Default |
|---|---|---|---|
| ticketId | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries the burden. Describes a simple read operation with no behavioral quirks, but does not disclose potential error conditions (e.g., ticket not found) or authorization requirements. Adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, front-loaded sentence with no extraneous words. Efficiently communicates the core function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple get-by-ID tool with one required parameter and no output schema, the description provides enough context. Could optionally mention what the returned ticket object includes, but not strictly necessary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%; the description does not explain the ticketId parameter beyond its name. While the parameter is self-explanatory, the description adds no extra meaning or format details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the action ('Get') and resource ('a single NinjaOne ticket by ID'), differentiating it from sibling tools like search_tickets (multiple tickets) and create_ticket.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. For example, does not mention that this tool is for fetching a specific ticket by ID while search_tickets is for filtering or listing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns known NinjaOne board IDs. NinjaOne has no boards listing API.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose behavior. It reveals that NinjaOne lacks a native API for listing boards, hinting at a workaround. However, it does not explain how IDs are obtained, caching, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. Both sentences provide necessary information: what the tool does and a key limitation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description adequately states purpose and a limitation. It could mention output format (e.g., list of strings), but as a simple tool it is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so schema coverage is 100%. The description adds no parameter info because none exist. Baseline for 0 parameters is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns known NinjaOne board IDs. It is specific about the resource (boards) and action (list), and distinguishes from siblings which deal with tickets, organizations, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is given. However, since no sibling tool lists boards, usage context is implied. The description lacks alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List NinjaOne organizations (clients).
| Name | Required | Description | Default |
|---|---|---|---|
| after | No | ||
| pageSize | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose behavioral traits such as pagination (implied by 'after' parameter), authentication needs, rate limits, or return behavior. The agent lacks context on how the tool operates.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise but lacks essential details. It earns its place but is under-informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with two parameters and no output schema, the description should cover pagination, response structure, and any limits. It fails to provide any of that, leaving the agent with incomplete guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description should compensate but does not explain the parameters 'after' and 'pageSize'. No hint of their purpose (e.g., cursor-based pagination or limit).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and the resource 'organizations' (clarified as clients). It distinguishes from sibling list tools like list_boards or list_technicians, but lacks additional context to differentiate further.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like search_tickets or list_boards. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all NinjaOne ticket statuses with IDs.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It does not disclose potential behavioral traits such as authentication requirements, rate limits, or details about the return format. The description is too brief to convey any operational context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no extraneous information. It is appropriately concise and front-loaded, making it easy for an agent to quickly understand the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema, no annotations), the description is minimally adequate but lacks details about the return structure or any nuances. For a straightforward list tool, this may be sufficient, but it could be more complete by specifying the expected output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and schema coverage is 100% (trivially). According to guidelines, 0 parameters have a baseline score of 4. No additional parameter semantics are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool lists all NinjaOne ticket statuses with IDs, which is a specific verb-resource combination. It effectively distinguishes from sibling tools that list other entities (e.g., list_boards, list_organizations) or perform different actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. However, the tool's simplicity (no parameters) implies it is the go-to for retrieving all statuses, and siblings cover different domains or operations, so usage is contextually implied but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List NinjaOne app users (technicians) with their numeric IDs. Use to look up user IDs for ticket assignment.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the tool lists all users with their numeric IDs. For a read-only operation with no parameters, this is adequately transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no waste. First sentence states purpose, second provides usage context. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters, no output schema, and no annotations, the description is complete for the tool's simplicity. It tells what it does and why to use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, and schema description coverage is 100%. With 0 parameters, baseline is 4, and the description need not add parameter meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists NinjaOne app users (technicians) with numeric IDs, specifying the action and resource. It distinguishes from sibling tools dealing with tickets, boards, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use to look up user IDs for ticket assignment,' providing a clear use case. It does not explicitly mention when not to use it or contrast with alternatives, but the context is sufficient for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List tickets from a NinjaOne board. Requires boardId (default: 1). Supports pagination via cursor.
| Name | Required | Description | Default |
|---|---|---|---|
| cursor | No | Pagination cursor (lastCursorId from previous response) | |
| boardId | No | Board ID (default: 1) | |
| filters | No | Optional filter object | |
| pageSize | No | Results per page (default 25) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided. The description implies a read operation (list) but does not explicitly state read-only behavior or disclose any side effects. Pagination support is noted, but overall behavioral disclosure is minimal for a tool without annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only two sentences, with no wasted words. It front-loads the primary action and resource. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 parameters (including a nested filters object), no output schema, and no annotations, the description is somewhat incomplete. It covers boardId and cursor but omits details on filters, pageSize, and the return value (list of tickets). It is adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are already documented. The description adds that boardId is 'required (default: 1)' and 'Supports pagination via cursor,' which slightly clarifies usage but mostly reiterates schema info. No deep parameter semantics added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List tickets from a NinjaOne board,' which clearly identifies the action (list) and the resource (tickets). It distinguishes from sibling 'get_ticket' by implying multiple results, but does not explicitly contrast with other list-like siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions required boardId and pagination support, providing some usage context. However, it does not specify when to use this tool versus alternatives like get_ticket or update_ticket, missing explicit when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update an existing NinjaOne ticket. Requires write auth (refresh token or session key).
| Name | Required | Description | Default |
|---|---|---|---|
| status | No | Status name: NEW, OPEN, WAITING, PAUSED, RESOLVED | |
| summary | No | ||
| priority | No | ||
| severity | No | ||
| ticketId | Yes | ||
| assignedAppUserId | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With zero annotations, the description bears full responsibility for behavioral disclosure. It only notes that write authentication is required, but fails to disclose side effects (e.g., notification triggers, idempotency, error behavior on missing ticket). The statement 'Update an existing...' implies modification but provides no safety or mutation details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise—one sentence plus an auth note—with no redundant information. It is efficiently structured, though it sacrifices detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (6 parameters, no output schema, no annotations), the description is incomplete. It lacks information about return values, error states, parameter constraints, and interaction with siblings like 'get_ticket'. The agent would need to infer too much from the schema alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 17% (only 'status' has a description). The tool description adds no parameter semantics—it does not explain the meaning or usage of any parameter, leaving the agent to rely on the sparse schema. For a 6-parameter tool, this is insufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and the resource ('existing NinjaOne ticket'), distinguishing it from sibling tools like 'create_ticket' (create) and 'get_ticket' (read). However, it does not specify the scope of updates (e.g., which fields) beyond what the schema implies.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'create_ticket' or 'add_comment'. It only mentions authentication requirements, which is a prerequisite, not a usage guideline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0add_commentcreate_ticketexchange_codeget_auth_urlget_ticketlist_boardslist_organizationslist_statuseslist_technicianssearch_ticketsupdate_ticketTools have distinct purposes, but list_boards has a confusing description stating 'NinjaOne has no boards listing API' which could cause uncertainty. However, all other tools are clearly differentiated.
All tool names follow a consistent verb_noun pattern in snake_case, e.g., create_ticket, search_tickets, update_ticket. No deviations.
11 tools is well-scoped for a ticketing system with OAuth support. It covers authentication, CRUD operations, and utility listings without being excessive.
Covers the main ticket lifecycle (create, read, update, add comment) plus authentication and lookups. Missing delete is likely intentional, but the list_boards limitation indicates a minor gap.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
Personal assistant MCP server with search, execute, packages, jobs, secrets, and integrations.
Remote MCP server for managing Muninx tickets, messages, ticket search, and support analytics.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/cyberkoder/ninjaone-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
