Build a Jira Sprint Planning MCP Server That Autonomously Prioritizes Backlogs in 2026

The Sprint Planning Time Sink

Agile teams spend 2-4 hours per sprint on planning: reviewing the backlog, estimating story points, checking dependencies, and negotiating scope. For a 10-person team with 2-week sprints, that is 50-100 hours per quarter spent on planning alone. This MCP server automates the data-driven parts of planning, leaving humans to make the final judgment calls.

Server Implementation (server/jira_sprint.py)

# server/jira_sprint.py
from fastmcp import FastMCP
from pydantic import BaseModel
import httpx
import json
from datetime import datetime, timedelta

mcp = FastMCP(name=\"jira-sprint-planner\", version=\"1.0.0\")

JIRA_URL = process.env[\"JIRA_URL\"]
JIRA_TOKEN = process.env[\"JIRA_API_TOKEN\"]
JIRA_EMAIL = process.env[\"JIRA_EMAIL\"]

auth = (JIRA_EMAIL, JIRA_TOKEN)

@mcp.tool()
async def search_backlog(
    project: str,
    issue_type: str = \"Story\",
    max_results: int = 50,
) -> dict:
    \"\"\"Search Jira backlog for prioritized issues.\"\"\"
    jql = f\"project = {project} AND issuetype = {issue_type} AND status = 'To Do' ORDER BY priority DESC, created DESC\"
    async with httpx.AsyncClient() as client:
        resp = await client.get(
            f\"{JIRA_URL}/rest/api/3/search\",
            params={\"jql\": jql, \"maxResults\": max_results, \"fields\": \"summary,priority,story_points,labels,created,assignee\"},
            auth=auth,
        )
        data = resp.json()

    issues = [{
        \"key\": i[\"key\"],
        \"summary\": i[\"fields\"][\"summary\"],
        \"priority\": i[\"fields\"][\"priority\"][\"name\"],
        \"story_points\": i[\"fields\"].get(\"story_points\"),
        \"labels\": i[\"fields\"].get(\"labels\", []),
        \"created\": i[\"fields\"][\"created\"],
    } for i in data.get(\"issues\", [])]

    return {\"issues\": issues, \"total\": data.get(\"total\", 0)}

@mcp.tool()
async def analyze_velocity(
    project: str,
    sprints: int = 6,
) -> dict:
    \"\"\"Analyze team velocity from recent sprints.\"\"\"
    async with httpx.AsyncClient() as client:
        # Get recent sprints
        board_resp = await client.get(
            f\"{JIRA_URL}/rest/agile/1.0/board/{project}/sprint\",
            params={\"maxResults\": sprints},
            auth=auth,
        )
        sprints_data = board_resp.json().get(\"values\", [])

        velocity_data = []
        for sprint in sprints_data:
            if sprint[\"state\"] == \"closed\":
                sprint_issues = await client.get(
                    f\"{JIRA_URL}/rest/agile/1.0/sprint/{sprint['id']}/issue\",
                    auth=auth,
                )
                issues = sprint_issues.json().get(\"issues\", [])
                completed_points = sum(
                    i[\"fields\"].get(\"story_points\", 0) or 0
                    for i in issues if i[\"fields\"][\"status\"][\"name\"] == \"Done\"
                )
                velocity_data.append({
                    \"sprint_name\": sprint[\"name\"],
                    \"completed_points\": completed_points,
                    \"total_issues\": len(issues),
                })

    avg_velocity = sum(v[\"completed_points\"] for v in velocity_data) / max(len(velocity_data), 1)
    return {
        \"sprints\": velocity_data,
        \"avg_velocity\": round(avg_velocity, 1),
        \"velocity_trend\": \"increasing\" if len(velocity_data) > 1 and velocity_data[0][\"completed_points\"] > velocity_data[-1][\"completed_points\"] else \"stable\",
    }

@mcp.tool()
async def generate_sprint_plan(
    project: str,
    sprint_name: str,
    team_capacity_hours: int = 80,
) -> dict:
    \"\"\"Generate an optimized sprint plan based on velocity and priority.\"\"\"
    velocity = await analyze_velocity(project)
    backlog = await search_backlog(project)

    # Simple priority scoring
    scored = []
    for issue in backlog[\"issues\"]:
        priority_score = {\"Highest\": 4, \"High\": 3, \"Medium\": 2, \"Low\": 1}.get(issue[\"priority\"], 2)
        scored.append({**issue, \"score\": priority_score})

    scored.sort(key=lambda x: x[\"score\"], reverse=True)

    # Fill sprint based on avg velocity
    sprint_items = []
    total_points = 0
    target_points = velocity[\"avg_velocity\"]

    for issue in scored:
        points = issue.get(\"story_points\") or 3  # Default estimate
        if total_points + points <= target_points:
            sprint_items.append(issue)
            total_points += points

    return {
        \"sprint_name\": sprint_name,
        \"planned_items\": len(sprint_items),
        \"total_points\": total_points,
        \"target_points\": target_points,
        \"items\": [{\"key\": i[\"key\"], \"summary\": i[\"summary\"], \"points\": i.get(\"story_points\") or 3} for i in sprint_items],
    }

if __name__ == \"__main__\":
    mcp.run(transport=\"stdio\")

Performance Benchmarks

Production Reality Check

Rate-limit handling: Jira Cloud allows 100 requests/minute. For large backlogs, implement cursor-based pagination. Cache velocity data for 1 hour. Authentication: Use API tokens (not passwords) for Jira Cloud. For Jira Server, use personal access tokens. Data accuracy: Story point estimates are suggestions, not mandates. Always have the team validate the AI-generated plan in the planning meeting.

By <a href="https://x.com/deeepakbagada" rel="nofollow noopener noreferrer">Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested: August 2026 with FastMCP 3.14, Python 3.12, Jira Cloud API v3, and httpx 0.28.