A
security-
licenseA
qualityA server that enables LLMs to programmatically interact with Logseq knowledge graphs, allowing creation and management of pages and blocks.
Last updated -
10
24
MIT License
The PagerDuty MCP Server provides programmatic access for LLMs to interact with the PagerDuty API, enabling management of various PagerDuty resources including:
Incidents: List, show details, and filter by status, service IDs, team IDs, or date range
Services: List and show details with optional filtering by query or team IDs
Teams: List and show details with optional query filtering
Users: List, show details, and access the current user's profile information
Escalation policies: List and show details with filtering options
Schedules: List and show details with optional query or date range filtering
On-call entries: List with filtering by schedule IDs, user IDs, policy IDs, or date range
Provides tools for interacting with the PagerDuty API, enabling operations on incidents, services, teams, and users. Supports listing, filtering, and managing PagerDuty resources with automatic context-based filtering.
PagerDuty MCP Server
A server that exposes PagerDuty API functionality to LLMs. This server is designed to be used programmatically, with structured inputs and outputs.
Overview
The PagerDuty MCP Server provides a set of tools for interacting with the PagerDuty API. These tools are designed to be used by LLMs to perform various operations on PagerDuty resources such as incidents, services, teams, and users.
Installation
From PyPI
pip install pagerduty-mcp-server
From Source
# Clone the repository
git clone https://github.com/wpfleger96/pagerduty-mcp-server.git
cd pagerduty-mcp-server
# Install dependencies
brew install uv
uv sync
Requirements
Python 3.13 or higher
PagerDuty API key
Configuration
The PagerDuty MCP Server requires a PagerDuty API key to be set in the environment:
PAGERDUTY_API_KEY=your_api_key_here
Usage
As Goose Extension
{
"type": "stdio",
"enabled": true,
"args": [
"run",
"python",
"-m",
"pagerduty_mcp_server"
],
"commandInput": "uv run python -m pagerduty_mcp_server",
"timeout": 300,
"id": "pagerduty-mcp-server",
"name": "pagerduty-mcp-server",
"description": "pagerduty-mcp-server",
"env_keys": [
"PAGERDUTY_API_KEY"
],
"cmd": "uv"
}
As Standalone Server
uv run python -m pagerduty_mcp_server
Response Format
All API responses follow a consistent format:
{
"metadata": {
"count": <int>, // Number of results
"description": "<str>" // A short summary of the results
},
<resource_type>: [ // Always pluralized for consistency, even if one result is returned
{
...
},
...
],
"error": { // Only present if there's an error
"message": "<str>", // Human-readable error description
"code": "<str>" // Machine-readable error code
}
}
Error Handling
When an error occurs, the response will include an error object with the following structure:
{
"metadata": {
"count": 0,
"description": "Error occurred while processing request"
},
"error": {
"message": "Invalid user ID provided",
"code": "INVALID_USER_ID"
}
}
Common error scenarios include:
Invalid resource IDs (e.g., user_id, team_id, service_id)
Missing required parameters
Invalid parameter values
API request failures
Response processing errors
Parameter Validation
All ID parameters must be valid PagerDuty resource IDs
Date parameters must be valid ISO8601 timestamps
List parameters (e.g.,
statuses,team_ids) must contain valid valuesInvalid values in list parameters will be ignored
Required parameters cannot be
Noneor empty stringsFor
statusesinlist_incidents, onlytriggered,acknowledged, andresolvedare valid valuesFor
urgencyin incidents, onlyhighandloware valid valuesThe
limitparameter can be used to restrict the number of results returned by list operations
Rate Limiting and Pagination
The server respects PagerDuty's rate limits
The server automatically handles pagination for you
The
limitparameter can be used to control the number of results returned by list operationsIf no limit is specified, the server will return up to {pagerduty_mcp_server.utils.RESPONSE_LIMIT} results by default
Example Usage
from pagerduty_mcp_server import incidents
from pagerduty_mcp_server.utils import RESPONSE_LIMIT
# List all incidents (including resolved) for the current user's teams
incidents_list = incidents.list_incidents()
# List only active incidents
active_incidents = incidents.list_incidents(statuses=['triggered', 'acknowledged'])
# List incidents for specific services
service_incidents = incidents.list_incidents(service_ids=['SERVICE-1', 'SERVICE-2'])
# List incidents for specific teams
team_incidents = incidents.list_incidents(team_ids=['TEAM-1', 'TEAM-2'])
# List incidents within a date range
date_range_incidents = incidents.list_incidents(
since='2024-03-01T00:00:00Z',
until='2024-03-14T23:59:59Z'
)
# List incidents with a limit on the number of results
limited_incidents = incidents.list_incidents(limit=10)
# List incidents with the default limit
default_limit_incidents = incidents.list_incidents(limit=RESPONSE_LIMIT)
User Context
Many functions accept a current_user_context parameter (defaults to True) which automatically filters results based on this context. When current_user_context is True, you cannot use certain filter parameters as they would conflict with the automatic filtering:
For all resource types:
user_idscannot be used withcurrent_user_context=True
For incidents:
team_idsandservice_idscannot be used withcurrent_user_context=True
For services:
team_idscannot be used withcurrent_user_context=True
For escalation policies:
team_idscannot be used withcurrent_user_context=True
For on-calls:
user_idscannot be used withcurrent_user_context=Trueschedule_idscan still be used to filter by specific schedulesThe query will show on-calls for all escalation policies associated with the current user's teams
This is useful for answering questions like "who is currently on-call for my team?"
The current user's ID is not used as a filter, so you'll see all team members who are on-call
Development
Running Tests
Note that most tests require a real connection to PagerDuty API, so you'll need to set PAGERDUTY_API_KEY in the environment before running the full test suite.
uv run pytest
To run only unit tests (i.e. tests that don't require PAGERDUTY_API_KEY set in the environment):
uv run pytest -m unit
To run only integration tests:
uv run pytest -m integration
To run only parser tests:
uv run pytest -m parsers
To run only tests related to a specific submodule:
uv run pytest -m <client|escalation_policies|...>
Debug Server with MCP Inspector
npx @modelcontextprotocol/inspector uv run python -m pagerduty_mcp_server
Contributions
Releases
This project uses Conventional Commits for automated releases. Commit messages determine version bumps:
feat:→ minor version (1.0.0 → 1.1.0)fix:→ patch version (1.0.0 → 1.0.1)BREAKING CHANGE:→ major version (1.0.0 → 2.0.0)
The CHANGELOG.md, GitHub releases, and PyPI packages are updated automatically.
Documentation
Tool Documentation - Detailed information about available tools including parameters, return types, and example queries
Conventions
All API responses follow the standard format with metadata, resource list, and optional error
Resource names in responses are always pluralized for consistency
All functions that return a single item still return a list with one element
Error responses include both a message and a code
All timestamps are in ISO8601 format
Tests are marked with pytest markers to indicate their type (unit/integration), the resource they test (incidents, teams, etc.), and whether they test parsing functionality ("parsers" marker)
remote-capable server
The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.
Tools
A server that exposes PagerDuty API functionality to LLMs with structured inputs and outputs, enabling management of incidents, services, teams, and users.
- Overview
- Installation
- Requirements
- Configuration
- Usage
- Response Format
- User Context
- Development
- Contributions
Related Resources
Related MCP Servers
- -security-license-qualityA server that enables LLMs to interact with Lark/Feishu services, currently supporting employee information queries via Lark's Contact API.Last updated -33
- -security-license-qualityA specialized server that enables LLMs to gather specific information through sequential questioning, implementing the MCP standard for seamless integration with LLM clients.Last updated -1
- -security-license-qualityEnables LLMs to interact with Todoist task management platform through its API, supporting all features from the official Todoist TypeScript Client.Last updated -90MIT License