Skip to main content
Glama
servicenow-mcp

servicenow-mcp

by siddhardhan

servicenow-mcp

An MCP server for managing ServiceNow incidents via the Table API. Exposes tools to create, read, update, search, comment on, and resolve incidents.

Setup

  1. Install dependencies:

    uv sync
  2. Copy .env.example to .env and fill in your credentials:

    cp .env.example .env
    • SERVICENOW_INSTANCE: the instance name only (e.g. dev12345 for dev12345.service-now.com)

    • SERVICENOW_USERNAME / SERVICENOW_PASSWORD: basic auth credentials for a user with access to the incident table (read/write via the Table API)

  3. Run the server directly to sanity-check it starts:

    uv run servicenow-mcp

Related MCP server: servicenow-api

Using with Claude Desktop / Claude Code

There are two ways to connect, depending on whether you want everyone using the server to share one ServiceNow service account, or each person to authenticate as themselves. See Authentication below for the full picture.

Option A — stdio, shared service account

The client launches the server itself as a subprocess; every tool call uses the SERVICENOW_USERNAME / SERVICENOW_PASSWORD passed in via env.

{
  "mcpServers": {
    "servicenow": {
      "command": "uv",
      "args": ["--directory", "/absolute/path/to/servicenow-mcp", "run", "servicenow-mcp"],
      "env": {
        "SERVICENOW_INSTANCE": "your-instance",
        "SERVICENOW_USERNAME": "your-username",
        "SERVICENOW_PASSWORD": "your-password"
      }
    }
  }
}

Option B — HTTP, per-client credentials

Start the server once as a long-running HTTP process (it only needs SERVICENOW_INSTANCE, plus SERVICENOW_USERNAME/PASSWORD as a fallback for requests with no auth header):

uv run servicenow-mcp --transport streamable-http --host 127.0.0.1 --port 8003

Then point .mcp.json at it and send your own ServiceNow login as an HTTP Basic Auth header — this is what makes the connection "client level": the credentials live in your client config, not the server's:

{
  "mcpServers": {
    "servicenow": {
      "type": "http",
      "url": "http://127.0.0.1:8003/mcp",
      "headers": {
        "Authorization": "Basic <base64 of your-username:your-password>"
      }
    }
  }
}

Generate the base64 value from a terminal (note the leading space, which -n on echo avoids):

echo -n "your-username:your-password" | base64

.mcp.json isn't covered by .gitignore the way .env is — don't commit real credentials into it if this directory ever becomes a shared/git repo.

Tools

  • create_incident — create a new incident

  • get_incident — fetch by number (e.g. INC0010023) or sys_id

  • update_incident — update arbitrary fields

  • search_incidents — search with a ServiceNow encoded query (sysparm_query)

  • add_comment — add a customer-visible comment or internal work note

  • resolve_incident — set state to Resolved with close notes/code

Authentication

Auth is basic auth (username/password). Where those credentials come from depends on transport:

  • stdio: always uses the shared SERVICENOW_USERNAME / SERVICENOW_PASSWORD from .env.

  • HTTP (sse / streamable-http): each request can authenticate as its own ServiceNow user by sending a standard HTTP Basic Auth header:

    Authorization: Basic base64(username:password)

    SERVICENOW_INSTANCE stays server-side (it's one instance for all clients), but the username/password are per-client — so search_incidents results, caller_id resolution, etc. reflect that individual user's ServiceNow permissions instead of one shared service account. If a request has no Authorization header, it falls back to the shared SERVICENOW_USERNAME / SERVICENOW_PASSWORD from .env.

If you need OAuth 2.0 later, swap the requests.Session.auth setup in src/servicenow_mcp/client.py for a token-based flow — the rest of the client is auth-agnostic.

Notes

  • The incident table's state field is numeric (e.g. 6 = Resolved, 7 = Closed); values can differ if your instance customizes incident states.

Available Tools

6 tools
add_commentA

Add a customer-visible comment or an internal work note to an incident.

Args: number_or_sys_id: Incident number or sys_id. comment: Text to add. work_note: If True, adds as an internal work note instead of a customer-visible comment.

Inputs: comment (required), number_or_sys_id (required), work_note. Returns: object

create_incidentA

Create a new ServiceNow incident.

Args: short_description: Brief summary of the incident (required). description: Full description of the issue. urgency: "1" (High), "2" (Medium), or "3" (Low). impact: "1" (High), "2" (Medium), or "3" (Low). category: Incident category, e.g. "software", "hardware", "network". assignment_group: Name or sys_id of the assignment group. caller_id: Name or sys_id of the user reporting the incident.

Inputs: short_description (required), impact, urgency, category, +3 more. Returns: object

get_incidentA

Fetch a ServiceNow incident by its number (e.g. INC0010023) or sys_id.

Inputs: number_or_sys_id (required). Returns: object

resolve_incidentB

Resolve an incident by setting its state to Resolved.

Args: number_or_sys_id: Incident number or sys_id. close_notes: Notes describing the resolution. close_code: Resolution code, e.g. "Solved (Permanently)", "Solved (Workaround)".

Inputs: close_notes (required), number_or_sys_id (required), close_code. Returns: object

search_incidentsA

Search incidents using a ServiceNow encoded query.

Args: query: ServiceNow encoded query string (sysparm_query), e.g. "active=true^priority=1" or "assigned_to.nameLIKEJohn". Leave empty to list the most recent incidents. limit: Max number of records to return (default 10). offset: Number of records to skip, for pagination.

Inputs: limit, query, offset. Returns: result

update_incidentA

Update fields on an existing incident.

Args: number_or_sys_id: Incident number (e.g. INC0010023) or sys_id. fields: Field name -> new value, e.g. {"state": "2", "priority": "1"}.

Inputs: fields (required), number_or_sys_id (required). Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a clear, distinct purpose covering the full incident lifecycle: get, create, update, search, add comment, and resolve. There is no overlap or ambiguity between them.

    Naming Consistency4/5

    Tools follow a verb_noun pattern (e.g., get_incident, create_incident). The only minor deviation is 'add_comment' which is still verb_noun but lacks the 'incident' suffix, though it is clearly contextual.

    Tool Count5/5

    Six tools is an ideal size for an incident management MCP server. Each tool serves a necessary operation without being too many or too few, keeping the surface focused and manageable.

    Completeness4/5

    Core incident operations are covered: create, read, update, search, comment, and resolve. Missing an explicit delete tool, but ServiceNow incidents are typically not deleted; update can handle assignment. Minor gap but still robust.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers