Capstone: Build and Deploy a Multi-Tool MCP Server

Project Assistant MCP Server
├── Tools
│   ├── query_tasks — Search and filter project tasks
│   ├── create_task — Add new tasks to the database
│   ├── search_code — Find code patterns in project files
│   └── get_git_log — Show recent commits
├── Resources
│   ├── project://readme — Project documentation
│   ├── project://schema — Database table structure
│   └── project://team — Team member directory
└── Prompts
    ├── code_review — Structured code review template
    └── sprint_plan — Sprint planning conversation starter

import os
import sqlite3
import subprocess
from mcp.server.fastmcp import FastMCP
from mcp.types import UserMessage

mcp = FastMCP("Project Assistant")

# Configuration from environment
PROJECT_DIR = os.environ.get("PROJECT_DIR", os.getcwd())
DB_PATH = os.environ.get("DB_PATH", "tasks.db")

@mcp.resource("project://readme")
def get_readme() -> str:
    """Project README for context."""
    readme_path = os.path.join(PROJECT_DIR, "README.md")
    if os.path.exists(readme_path):
        return open(readme_path).read()
    return "No README.md found in project directory."

@mcp.resource("project://schema")
def get_schema() -> str:
    """Database schema for task queries."""
    return """
    Table: tasks
    - id INTEGER PRIMARY KEY
    - title TEXT NOT NULL
    - status TEXT (open, in_progress, done)
    - assignee TEXT
    - priority TEXT (low, medium, high, critical)
    - created_at TIMESTAMP
    - updated_at TIMESTAMP
    """

@mcp.tool()
def query_tasks(
    status: str = "",
    assignee: str = "",
    priority: str = ""
) -> str:
    """Search project tasks. Filter by status, assignee, or priority."""
    conditions = []
    params = []
    if status:
        conditions.append("status = ?")
        params.append(status)
    if assignee:
        conditions.append("assignee = ?")
        params.append(assignee)
    if priority:
        conditions.append("priority = ?")
        params.append(priority)

    where = " AND ".join(conditions)
    sql = "SELECT id, title, status, assignee, priority FROM tasks"
    if where:
        sql += f" WHERE {where}"
    sql += " ORDER BY created_at DESC LIMIT 20"

    conn = sqlite3.connect(DB_PATH)
    rows = conn.execute(sql, params).fetchall()
    conn.close()

    if not rows:
        return "No tasks match your filters."
    lines = ["ID | Title | Status | Assignee | Priority"]
    for row in rows:
        lines.append(f"{row[0]} | {row[1]} | {row[2]} | {row[3]} | {row[4]}")
    return "\n".join(lines)

@mcp.tool()
def search_code(pattern: str, file_extension: str = "") -> str:
    """Search for a text pattern in project files."""
    if len(pattern) < 2:
        return "Error: search pattern must be at least 2 characters"

    cmd = ["grep", "-rn", "--include", f"*.{file_extension}" if file_extension else "*", pattern]
    try:
        result = subprocess.run(
            cmd, cwd=PROJECT_DIR,
            capture_output=True, text=True, timeout=10
        )
        if result.stdout:
            lines = result.stdout.strip().split("\n")[:20]
            return "\n".join(lines)
        return f"No matches found for '{pattern}'"
    except subprocess.TimeoutExpired:
        return "Search timed out — try a more specific pattern"

@mcp.prompt()
def code_review(filepath: str) -> list:
    """Perform a structured code review."""
    return [UserMessage(
        content=f"""Review the file at {filepath}. Analyze:
1. **Bugs** — Logic errors, edge cases, null/undefined handling
2. **Security** — Input validation, injection risks, auth issues
3. **Performance** — Unnecessary allocations, algorithmic complexity
4. **Readability** — Naming clarity, function length, comments

For each issue, cite the line number and suggest a specific fix."""
    )]

@mcp.prompt()
def sprint_plan(sprint_name: str) -> list:
    """Plan a new sprint with task prioritization."""
    return [UserMessage(
        content=f"""Let's plan sprint '{sprint_name}'. Help me:
1. Review open tasks (use query_tasks to see what's available)
2. Prioritize by impact and urgency
3. Assign tasks based on team capacity
4. Identify blockers and dependencies
5. Set sprint goals (2-3 measurable outcomes)"""
    )]

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY server.py .
EXPOSE 8080
CMD ["python", "server.py", "--transport", "http", "--port", "8080"]

{
  "mcpServers": {
    "project-assistant": {
      "command": "python",
      "args": ["/path/to/server.py"],
      "env": {
        "PROJECT_DIR": "/path/to/your/project",
        "DB_PATH": "/path/to/tasks.db"
      }
    }
  }
}