Which integrations are available for this server?

Provides tools for triaging GitHub Actions CI failures, including fetching PR checks, failed jobs, and log analysis.

How do I use ci-triage-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ci-triage-mcp summarize the failures in PR #42 in owner/repo" 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.

ci-triage-mcp

by aamar-shahzad

Overview Schema Source Related Servers Discussions Admin

JavaScript

Local

ci-triage-mcp

MCP server for GitHub Actions CI failure triage. Wraps the gh CLI to fetch PR checks, failed jobs, and tail/grep failed job logs — with ANSI/timestamp stripping and root-cause extraction. Zero runtime dependencies; stdio JSON-RPC.

Built to turn a 5–10 minute "open the run, find the failed job, scroll the raw log" ritual into a single tool call.

Tools

Tool	Input	Returns
`get_pr_checks`	`repo`, `prNumber`	Aggregated check rollup: failed / pending / success + merge state
`get_failed_jobs`	`repo`, `runId`	Jobs with `conclusion=failure`: name, databaseId, url, timestamps
`get_job_logs_tail`	`repo`, `jobId`, `lines?`	Last N log lines, ANSI + timestamp prefixes stripped
`grep_job_logs`	`repo`, `jobId`, `pattern`, `maxMatches?`	Matching lines + 2 lines context. Use when failure is mid-log (E2E, build errors)
`summarize_pr_failure`	`repo`, `prNumber`	End-to-end: failed checks → failed jobs → log tail → extracted error lines + file:line

All repo inputs validated as owner/repo (alphanumerics, ., -, _). lines capped at 500, maxMatches at 200.

Related MCP server: tai-mcp-github

Install

One-click install

Click a badge → opens the install page → click the button → your IDE prompts to install.

GitHub strips custom protocol schemes (cursor://, vscode://) from markdown links for security, so the badges route through a hosted install page on GitHub Pages with real <a href> buttons. The page also covers Claude Code, Claude Desktop, Cline, Windsurf, Zed, and LM Studio.

The install page registers the server under the name ci-triage via npx -y github:aamar-shahzad/ci-triage-mcp (works now, no npm registry publish needed). After install, restart your IDE if the tools don't appear immediately.

Manual install — per client

The server config is the same everywhere; only the file location differs.

Cursor — ~/.cursor/mcp.json:

{
  "mcpServers": {
    "ci-triage": {
      "command": "npx",
      "args": ["-y", "github:aamar-shahzad/ci-triage-mcp"],
      "env": {}
    }
  }
}

VS Code / GitHub Copilot — ~/.vscode/mcp.json (or workspace .vscode/mcp.json):

{
  "mcpServers": {
    "ci-triage": {
      "command": "npx",
      "args": ["-y", "github:aamar-shahzad/ci-triage-mcp"],
      "env": {}
    }
  }
}

Claude Desktop — claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "ci-triage": {
      "command": "npx",
      "args": ["-y", "github:aamar-shahzad/ci-triage-mcp"],
      "env": {}
    }
  }
}

Claude Code (CLI):

claude mcp add ci-triage npx -- -y github:aamar-shahzad/ci-triage-mcp

Cline / Roo Code / Continue / Windsurf — same mcpServers shape as Cursor, in their respective MCP config files:

Cline: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json (macOS)
Windsurf: ~/.codeium/windsurf/mcp_config.json
Continue: ~/.continue/config.json under experimental.mcpServers

Zed — ~/.config/zed/settings.json:

{
  "context_servers": {
    "ci-triage": {
      "command": "npx",
      "args": ["-y", "github:aamar-shahzad/ci-triage-mcp"],
      "env": {}
    }
  }
}

LM Studio — deep link:

lmstudio://add_mcp?name=ci-triage&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsImdpdGh1YjphYW1hci1zaGFoemFkL2NpLXRyaWFnZS1tY3AiXSwiZW52Ijp7fX0=

Option C — clone + run directly

For local development or to avoid npx cold-install delay:

git clone https://github.com/aamar-shahzad/ci-triage-mcp.git ~/src/ci-triage-mcp

Then in your MCP config:

{
  "mcpServers": {
    "ci-triage": {
      "command": "node",
      "args": ["/Users/you/src/ci-triage-mcp/src/index.mjs"]
    }
  }
}

Regenerate install links

node scripts/gen-install-links.mjs          # prints markdown
node scripts/gen-install-links.mjs --json   # prints raw links as JSON

Authentication

No token stored in MCP config. Uses your existing gh CLI authentication (keyring / config file from gh auth login). The server shells out to gh; nothing else.

Requirements:

gh CLI on PATH — install from https://cli.github.com
Authenticated: gh auth login (scopes: repo, workflow for CI logs)
Node ≥ 20

On initialize, the server probes gh --version and emits a _warning in serverInfo if gh is missing.

Why

Generic GitHub MCPs return raw JSON and stop at the check rollup. This server is opinionated about the triage workflow:

Failed-check discovery — get_pr_checks filters to conclusion=FAILURE only.
Job drilldown — get_failed_jobs maps a run to its failed job IDs (the part you usually copy by hand).
Clean logs — get_job_logs_tail strips ANSI escapes and the 2026-07-09T20:34:56.5281699Z timestamp prefix that buries the actual line.
Mid-log grep — grep_job_logs finds errors anywhere in the log with context. E2E / build failures live mid-log, not at the tail. Tail-only tools miss them.
Root-cause extraction — summarize_pr_failure chains all of the above and extracts error lines + file:line in one call.

Example: a 725-line Cypress job log → grep_job_logs with pattern AssertionError|Timed out returns 1 match with 2 lines context, surfacing Expected to find element: [data-testid="inviteUserButton"], but never found it in one call.

Smoke test

node scripts/smoke.mjs

Runs tools/list + a grep_job_logs call against a known public failed job. Requires gh auth.

Development

git clone https://github.com/aamar-shahzad/ci-triage-mcp.git
cd ci-triage-mcp
node src/index.mjs   # starts stdio JSON-RPC server

No build step. Pure ESM .mjs, no dependencies.

License

MIT

Available Tools

5 tools

get_failed_jobsA

List only failed jobs for a workflow run. Input: {repo: "owner/repo", runId: number}. Returns jobs with conclusion=failure: name, databaseId, url.

ParametersJSON Schema

Name	Required	Description	Default
`repo`	Yes
`runId`	Yes	Workflow run ID (from check URL)

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavior. It states that the tool returns jobs with 'conclusion=failure' and lists the fields returned (name, databaseId, url). However, it does not mention whether it's read-only, auth requirements, rate limits, or behavior when no failed jobs exist. Adequate but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no filler. The purpose is stated first, followed by input format and output summary. Every sentence serves a purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (2 parameters, no output schema), the description adequately covers what the tool does, inputs, and outputs. It lacks error handling or pagination details, but for a list-failed-jobs tool, this is largely sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds value beyond the input schema by showing the expected format for 'repo' ('owner/repo') and clarifying 'runId' as a number from the check URL. Schema coverage is only 50% (runId has a description, repo does not), so the description compensates partially.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the specific action: 'List only failed jobs for a workflow run.' It clearly identifies the resource (failed jobs) and distinguishes it from sibling tools like 'get_job_logs_tail' or 'summarize_pr_failure' that have different purposes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides the expected input format but does not explicitly guide the agent on when to use this tool versus alternatives. No mention of prerequisites, when-not-to-use, or comparisons with sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_job_logs_tailA

Fetch tail of a failed job log. Input: {repo: "owner/repo", jobId: number, lines?: number=80}. Returns last N lines of the job log (cleaned of ANSI + timestamp prefixes).

ParametersJSON Schema

Name	Required	Description
`repo`	Yes
`jobId`	Yes	Job databaseId (from get_failed_jobs)
`lines`	No	Lines to tail (default 80)

TDQS

A4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses the key behavioral trait: 'cleaned of ANSI + timestamp prefixes', which adds value beyond the schema. It does not mention side effects (none expected) or auth, but the cleaning detail is helpful.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence plus inline input format example. It is front-loaded with the purpose, then provides input format concisely. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple 3-parameter read tool with no output schema, the description covers purpose, input format, and return value behavior (last N lines cleaned). It could mention error cases or that it only works for failed jobs (already implied), but overall it is sufficiently complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 67% (2 of 3 params have descriptions). The description repeats the schema structure without adding new constraints or examples. The default for lines is already in the schema. No extra semantic value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Fetch tail of a failed job log' uses a specific verb and resource, clearly distinguishing it from siblings like get_failed_jobs (list jobs) or grep_job_logs (search logs). The input format and cleaned output are also stated, leaving no ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage after get_failed_jobs by specifying 'failed job log' and referencing jobId from get_failed_jobs, but does not explicitly compare with siblings or provide when-not guidance. Usage context is implied but not fully explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_pr_checksA

List all CI checks for a GitHub PR with conclusion + URL. Input: {repo: "owner/repo", prNumber: number}. Returns aggregated check rollup.

ParametersJSON Schema

Name	Required	Description	Default
`repo`	Yes	GitHub repo as "owner/repo"
`prNumber`	Yes	PR number

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It states it returns an aggregated check rollup, but lacks details on side effects, permissions, or pagination. 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.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences efficiently state purpose and input format. Could be slightly more concise by omitting the second sentence since schema is clear, but still effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, so description should explain return structure. 'Returns aggregated check rollup' is vague; does not specify fields or format. Context with siblings is missing. Adequate but incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema already has full descriptions for both parameters. Description repeats the input format without adding new meaning. Baseline 3 for 100% coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it lists CI checks for a GitHub PR with conclusion and URL, using specific verb and resource. It distinguishes from siblings like get_failed_jobs and get_job_logs_tail which are more specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide explicit guidance on when to use this tool vs alternatives. Sibling tool names are given but no context for choosing this over get_failed_jobs or summarize_pr_failure.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

grep_job_logsA

Grep a job log for lines matching a regex (case-insensitive). Returns matching lines with 2 lines context before/after. Use when failure is mid-log (E2E tests, build errors) rather than at the tail. Input: {repo, jobId, pattern: string, maxMatches?: number=50}.

ParametersJSON Schema

Name	Required	Description
`repo`	Yes
`jobId`	Yes
`pattern`	Yes	Regex pattern (case-insensitive)
`maxMatches`	No	Max matching lines (default 50)

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses key behaviors: regex matching (case-insensitive), returns matching lines with 2 lines of context before/after, and default maxMatches of 50. However, it does not mention error handling, permissions, or whether the operation is read-only, but the core behavior is well-covered.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences front-loading the main action, then output format, usage guidance, and input format. Every sentence is necessary and there is no fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (regex search with context) and lack of output schema, the description is largely complete. It covers purpose, usage, input, and output format. It could add error handling or performance notes, but for the intended use case it suffices.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 50% (pattern and maxMatches have descriptions, repo and jobId do not). The description compensates by listing all parameters in a compact format: 'Input: {repo, jobId, pattern: string, maxMatches?: number=50}', clarifying types and providing default value for maxMatches.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Grep a job log for lines matching a regex (case-insensitive)'. It specifies a specific verb (grep) and resource (job log), and distinguishes itself from sibling tools like get_job_logs_tail by focusing on pattern matching with context lines.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly provides when to use: 'Use when failure is mid-log (E2E tests, build errors) rather than at the tail.' This implies when not to use (for tail failures) and gives context signals, differentiating from the sibling tool get_job_logs_tail.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

summarize_pr_failureA

End-to-end triage: find failed checks on a PR, tail each failed job log, extract error/fail/first-failing-test lines. Input: {repo, prNumber}. Returns per-failed-job summary with likely root cause.

ParametersJSON Schema

Name	Required	Description	Default
`repo`	Yes
`prNumber`	Yes

TDQS

A4.1/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but description discloses the tool's actions (read-only operations on PR checks and logs) and its output (summary with root cause). Could mention permissions or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single, clear sentence with no unnecessary words. Front-loaded with 'End-to-end triage'.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Adequately describes return value as summary with root cause, but lacks details on output structure. Given only 2 simple params, completeness is sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% and description only mentions parameter names (repo, prNumber) without explaining their format or constraints (e.g., repo name format). Adds minimal value beyond schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states it performs end-to-end triage by findining failed checks, tailing logs, extracting errors, and returning a summary with root cause. It distinguishes from sibling tools that perform individual steps.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description implies use case for complete triage vs individual sibling tools, but does not explicitly state when to use alternatives or when not to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

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

5 tool updatesv0.1.0Jul 10, 2026
- First observedget_failed_jobs
- First observedget_job_logs_tail
- First observedget_pr_checks
- First observedgrep_job_logs
- First observedsummarize_pr_failure

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.2/5.0

Scored 2026-07-10 16:30 across 5 tools

Disambiguation5/5

Each tool has a distinct purpose: listing failed jobs, fetching log tails, listing all checks, searching logs, and summarizing failures. No overlap or ambiguity.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case (e.g., get_failed_jobs, grep_job_logs), making it predictable.

Tool Count5/5

Five tools is appropriate for CI triage—covers listing, log access, searching, and summarization without being excessive or insufficient.

Completeness5/5

The tool set covers the full triage workflow: identify failures, retrieve logs, search logs, and generate summaries. No obvious gaps for the stated purpose.

Maintenance

ActivityStale

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

UI Verify A
io.github.igrlk
MCP server for visual regression testing: triage a PR's UI diffs from your coding agent.
Testing & QA Tools CI/CD & DevOps
9118
saidsef-mcp-github-pr-issue-analyser
ai.smithery
A Model Context Protocol (MCP) application for automated GitHub PR analysis and issue management.…
Version Control Developer Tools Project Management
26
KodyOAuth
io.github.kentcdodds
Personal assistant MCP server with search, execute, packages, jobs, secrets, and integrations.
Developer Tools Code Execution Command Line
2617
supportsheep
io.github.pooriaarab
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
Customer Support Content Management Systems Marketing
1

Related MCP Servers

claude-beacon
CI/CD & DevOps Version Control Developer Tools
drmf-cz
A
license
Not graded
quality
C
maintenance
MCP server that pushes GitHub Actions CI/CD results and PR events into Claude Code sessions, enabling automatic investigation and remediation.
Updated 5 months ago (2026-04-24 13:09 UTC)
7 npm
1
MIT
tai-mcp-github
Version Control Developer Tools Project Management
pxl-research
F
license
A
quality
D
maintenance
A minimal MCP server that exposes a focused set of GitHub PR review tools to AI agents, enabling PR listing, detail retrieval, comment viewing, and thread management.
Updated 5 months ago (2026-04-02 09:46 UTC)
5
-
epik-gh
Version Control Developer Tools CI/CD & DevOps
epik-agent
F
license
Not graded
quality
A
maintenance
A GitHub MCP server that wraps the gh CLI to expose GitHub operations like issues, pull requests, branches, labels, repositories, CI actions, and Projects V2 as tools for MCP clients.
Updated 4 days ago (2026-09-09 21:24 UTC)
-
github-repo-assistant
Version Control Developer Tools Code Analysis
asifumar
F
license
Not graded
quality
C
maintenance
MCP server for interacting with GitHub pull requests and issues via natural language. Provides tools to list PRs, inspect diffs, check CI status, and post review comments with write-safety guards.
Updated a month ago (2026-08-08 21:13 UTC)
-