Jira/Confluence Team Lead MCP
This server bridges Jira sprint data with Confluence documentation, providing team leads with tools to:
Verify Jira/Confluence connections and auto-discover configuration (story points field, deployment type).
List sprints on a board (filter by state) to find sprint IDs.
Retrieve sprint issues with filtering by status/category, and optionally publish results to Confluence.
Generate multi-sprint developer rollups using changelog data, showing completed/carried-over work, cycle/lead time, and time in progress.
Produce refinement readiness reports for stories missing estimates, DOR/DOD labels, or descriptions, scoped to backlog or sprint, with suggested attendees.
Analyze sprint health with totals, breakdowns, and a changelog-derived burndown.
Detect stale/quiet issues by identifying active issues with no recent comments.
Publish reports to Confluence pages, supporting static tables or interactive Table Filter macros (if installed).
Check Confluence capabilities (Cloud vs. Data Center, app availability) to optimize report formatting.
Provides tools for publishing generated reports as Confluence pages and checking Confluence capabilities such as table filtering and deployment type.
Provides tools for retrieving sprint issues, developer sprint history, and refinement readiness reports from Jira, enabling team leads to track sprint progress and developer performance.
Click on "Deploy 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., "@Jira/Confluence Team Lead MCP What's in this sprint and how did the team do last sprint?"
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.
Jira / Confluence Team Lead
An MCP server and an Angular dashboard that answer the questions a team lead actually has, and can publish the answer to Confluence:
What's in this sprint, and is it going to land?
How did each developer do over the last few sprints? (real changelog-derived cycle/lead time, not a guess from current status)
What's not ready for the next refinement session, and who should be in the room?
Who has gone quiet? — active work with no comment for over a day.
Built and tested against a personal Atlassian Cloud site first; the target
corporate instance is a .env change, not a code change.
Layout
src/jira_confluence_mcp/ the report engine (metrics, rendering, Atlassian client)
server.py MCP server — stdio, for Claude
api.py HTTP API — for the dashboard
frontend/ Angular dashboard
scripts/demo_server.py run the dashboard on synthetic data, no Jira neededThe MCP tools and the dashboard call the same report builders, so a number shown in the UI and a number quoted in chat can't drift apart.
Related MCP server: Jira Daily PM Radar
See it working without Jira
Two terminals, no credentials required:
.venv\Scripts\python.exe scripts\demo_server.pycd frontend && npm startThen open http://localhost:4200. The data is invented, but it flows through the real changelog parsing and metric code.
Setup
python -m venv .venv
.venv\Scripts\python.exe -m pip install -e ".[dev]"Copy .env.example to .env and fill in the base URL, your Atlassian email,
and an API token from https://id.atlassian.com/manage-profile/security/api-tokens.
Then register the server (.mcp.json in this repo already does it for Claude
Code — adjust the absolute paths if you move the project):
claude mcp add jira-confluence -- "C:\DEV\Jira Confluence MCP\.venv\Scripts\python.exe" -m jira_confluence_mcp.serverFirst call should always be check_connection — it verifies both products,
prints the resolved defaults, and tells you which custom field it picked for
story points.
The dashboard
.venv\Scripts\python.exe -m jira_confluence_mcp.apicd frontend && npm startThe dev server proxies /api to the backend on port 8000, so there's no CORS
to configure. Four screens:
Overview — completion against time elapsed, points, at-risk count, a changelog-derived burndown, load per person, and a filterable issue table.
Developers — the multi-sprint table, one row per developer per sprint. Sort any column, filter by developer or sprint, export to CSV. This is the thing Confluence's static tables can't do.
Refinement — what's not ready, why, and a copyable attendee list.
Quiet work — active issues with no recent comment, per person.
Every screen has a Publish to Confluence button that writes the same report as the MCP tool would. The browser sends the report kind, never markup — the server regenerates the storage format itself, so the API can't be used to inject arbitrary content into a Confluence page.
Reports are cached for 120 s so the dashboard doesn't hammer Jira; each page's Refresh button bypasses the cache.
Node version: the CLI is pinned to Angular 21 because Angular 22 needs Node ≥ 22.22.3 and this machine has 22.17.0. Upgrade Node first if you want to move to 22.
Tools
Tool | What it does |
| Auth check + resolved config. Run this first on a new instance. |
| Sprints on a board, so you can find sprint ids. Falls back to listing boards if none is configured. |
| Issues in a sprint, filterable by status name or status category. Key, summary, assignee, story points, status. |
| 2–5 sprint rollup per developer: completed, carried over, avg time in progress, cycle time, lead time. |
| Stories missing an estimate or DOR/DOD labels, plus a suggested attendee list. |
| One-call sprint overview: totals, breakdowns, burndown. Powers the Overview screen. |
| Active work with no comment for over N days — who's gone quiet. |
| Create or overwrite a page from storage-format XHTML. |
| Cloud vs Data Center, and whether the Table Filter app is available. |
Every report tool returns rows (structured), markdown (for reading), and —
with include_confluence_storage=true — confluence (storage format). Pass
publish=true to write it straight to a page; re-running overwrites the same
page by title.
Metric definitions
These are the decisions baked into metrics.py. Worth agreeing with the team
before the numbers get used in a retro.
Completed — the issue was in a Done-category status at sprint close (
completeDate, elseendDate, else now for an active sprint). Judged at sprint close, so an issue finished the week after the sprint ended counts as carried over for that sprint. Never evaluated past now, so an active sprint is measured against today rather than its future end date.Carried over — everything in the sprint that was not completed.
Re-opened work — an issue that was Done and moved back out is not completed. Closed → re-opened → closed again reports the final close.
Time in progress — calendar hours in In Progress-category statuses, summed across visits, capped at completion or sprint close.
Cycle time — first entry into an In Progress-category status → completion.
Lead time — issue created → completion.
Grouping — by the issue's current assignee. Reassigned work is credited to whoever holds it now; the changelog has the data to split it by holder if that turns out to matter.
Status categories (new / indeterminate / done) are read from the
instance rather than hard-coded status names, so a workflow that calls it
"Development" instead of "In Progress" still works. Any status the instance
does not report is surfaced in the report's warnings.
Confluence tables
Storage-format tables are static — not sortable or filterable. Options, in the order worth trying on a target instance:
table_style="table-filter"— wraps the table in the Table Filter, Charts & Spreadsheet macro. Runcheck_confluence_capabilitiesfirst; reading the app inventory needs admin rights, so anullresult means "ask an admin", not "not installed".Confluence Cloud's database content type — behaves like an embedded spreadsheet, but cannot be created through the REST content API this server uses. Manual setup only for now.
table_style="plain"(default) — static table. Re-run the report grouped or sorted differently when another view is needed. Good enough for MVP.
Switching to another instance
Only .env changes:
JIRA_BASE_URL/CONFLUENCE_BASE_URL— set both explicitly if Jira and Confluence are on different hosts (usual for Data Center).ATLASSIAN_DEPLOYMENT— leaveautounless the URL doesn't give it away. Data Center means/rest/api/2and offset-paged search; the client handles the switch, including falling back from the Cloud-only/search/jql.JIRA_STORY_POINTS_FIELD— auto-discovery looks for "Story Points" / "Story point estimate"; pin the custom field id if the instance renamed it.REFINEMENT_DOR_LABELS/REFINEMENT_DOD_LABELS— the team's actual labels.ATLASSIAN_CA_BUNDLE— corporate root CA, for an internal TLS chain. Prefer this over turningATLASSIAN_VERIFY_SSLoff.
Tests
.venv\Scripts\python.exe -m pytest -qcd frontend && npm test80 Python tests and 20 Angular tests, no Atlassian instance required — HTTP is
mocked with respx, and the metric logic is tested as pure functions over
changelog fixtures.
Not built yet
get_story_comment_summary— a full per-developer comment timeline within a story.get_stale_issuescovers the "who has gone quiet" half of it; decide whether the rest is worth having after a few sprints of real use.Push alerting (Slack/Teams) for quiet stories. The detection exists; only the delivery channel is missing.
Postgres sync. Today the dashboard reads Jira live behind a 120 s cache, which is fine at team scale. The
rowspayloads are already shaped for a table-per-report load if history or cross-team rollups are wanted later.Auth on the API. It binds to localhost and assumes whoever reaches it is you. Anything beyond your own machine needs real authentication in front of it.
Available Tools
7 toolscheck_confluence_capabilitiesB
Report what this Confluence instance supports for interactive tables: deployment flavour and whether the Table Filter, Charts & Spreadsheet app is installed. Use before choosing table_style.
Inputs: space_key. Returns: object
check_connectionA
Verify Jira and Confluence credentials and show the resolved configuration (base URLs, deployment flavour, discovered story points field, defaults). Run this first on a new instance.
Inputs: no named parameters. Returns: object
get_developer_sprint_historyA
Multi-sprint rollup grouped by developer (2-5 sprints is the useful range). Uses the Jira changelog, so time-in-status, cycle time and lead time are real, not inferred from current status. One flat table with developer as a column, so it can be sorted and filtered.
Inputs: sprint_ids (required), publish, space_key, page_title, +5 more. Returns: object
get_refinement_readiness_reportA
Weekly refinement readiness report: stories missing an estimate or missing DOR/DOD labels, plus a suggested attendee list for the refinement meeting. scope is 'backlog' (board backlog) or 'sprint'. checks defaults to estimate,dor,dod — add 'description' to also flag stories with no description.
Inputs: limit, scope, checks, publish, +9 more. Returns: object
get_sprint_issuesA
Issues in a sprint, optionally filtered by status name (e.g. 'Needs Refinement') or status category (new/indeterminate/done). Returns key, summary, assignee, story points and status. Set publish=true to write the result to Confluence.
Inputs: sprint_id (required), publish, statuses, space_key, +6 more. Returns: object
list_sprintsB
List sprints on a board so you can pick sprint ids. state is one of active, closed, future (comma-separate for several).
Inputs: limit, state, board_id. Returns: object
publish_confluence_pageA
Create or overwrite a Confluence page. body must be Confluence storage format (XHTML) — pass the confluence value from a report, or your own markup. Matching an existing page by title updates it.
Inputs: body (required), title (required), space_key, parent_page_id. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 7 tools
Each tool has a clear focus: connection verification, sprint listing, sprint issue retrieval, developer history, readiness report, Confluence publishing, and Confluence capability checking. The two 'check' tools are distinct in scope (credentials/config vs. instance capabilities), and the three 'get' tools serve different analytical purposes. Minor potential confusion between get_sprint_issues and get_refinement_readiness_report, but their descriptions clarify.
All tool names follow a consistent verb_noun pattern with snake_case (check_connection, list_sprints, get_sprint_issues, etc.). Verbs are consistent with actions: check for verification, list for enumeration, get for retrieval, publish for writing. No mixed conventions.
Seven tools is well-scoped for a Jira/Confluence reporting server. Each tool fills a distinct role: setup verification, sprint navigation, issue analysis, developer performance, readiness reporting, publishing, and format capability detection. No redundancy or bloat.
The tool set covers the full reporting workflow: verify connection, find sprints, analyze issues by sprint or developer, generate readiness report, and publish results to Confluence. Minor gaps like listing boards or projects are handled through configuration defaults rather than requiring tools. No tool for arbitrary JQL queries, but not necessary for the stated purpose.
Maintenance
Related MCP Connectors
Generate answers & visualizations from your engineering data to track software development health.
Executive status across Jira, Azure DevOps and Basecamp: workstreams, scorecard and actions.
Track stories, organize sprints, and manage project workflows across your team
Agile project management over MCP: boards, epics, roadmap, retros, whiteboards, wiki, metrics
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceA Scrum-aware MCP server that provides semantic analysis of Jira issues, sprint health, and Agile workflow intelligence, returning structured summaries and recommendations instead of raw Jira payloads.5MIT
- AlicenseNot gradedqualityDmaintenanceEnables PM radar analysis of Jira projects, providing daily, sprint, and backlog reports with issue context and search.MIT
- AlicenseAqualityDmaintenanceGenerates sprint retrospectives grounded in actual data from Jira, GitHub, and Slack, providing evidence-backed insights and action items.644 npmMIT
- AlicenseCqualityDmaintenanceAn AI-powered MCP server unifying Jira, GitHub, and Confluence integrations, enabling sprint health analysis, smart issue creation, and release notes generation via natural language.31MIT