Taiga MCP server

Integrates with Taiga project management platform to enable direct control over projects, epics, user stories, tasks and issues without context switching
Back to servers
Setup instructions
Provider
Talha Orak
Release date
Mar 25, 2025
Language
Python
Stats
8 stars

The Taiga MCP Bridge provides seamless integration between the Taiga project management platform and AI tools using the Model Context Protocol (MCP). This bridge allows AI systems to create and manage Taiga resources like projects, epics, user stories, and tasks while maintaining contextual awareness about project state.

Installation

Prerequisites

  • Python 3.10 or higher
  • uv package manager

Basic Installation

# Clone the repository
git clone https://github.com/your-org/pyTaigaMCP.git
cd pyTaigaMCP

# Install dependencies
./install.sh

Manual Installation

If you prefer to install manually:

# Production dependencies only
uv pip install -e .

# With development dependencies
uv pip install -e ".[dev]"

Configuration

The bridge can be configured through environment variables or a .env file:

Environment Variable Description Default
TAIGA_API_URL Base URL for the Taiga API http://localhost:9000
SESSION_EXPIRY Session expiration time in seconds 28800 (8 hours)
TAIGA_TRANSPORT Transport mode (stdio or sse) stdio
REQUEST_TIMEOUT API request timeout in seconds 30
MAX_CONNECTIONS Maximum number of HTTP connections 10
MAX_KEEPALIVE_CONNECTIONS Max keepalive connections 5
RATE_LIMIT_REQUESTS Max requests per minute 100
LOG_LEVEL Logging level INFO
LOG_FILE Path to log file taiga_mcp.log

Create a .env file in the project root to set these values:

TAIGA_API_URL=https://api.taiga.io/api/v1/
TAIGA_TRANSPORT=sse
LOG_LEVEL=DEBUG

Usage

With stdio mode

Paste the following json in your Claude App's or Cursor's mcp settings section:

{
    "mcpServers": {
        "taigaApi": {
            "command": "uv",
            "args": [
                "--directory",
                "<path to local pyTaigaMCP folder>",
                "run",
                "src/server.py"
            ],
            "env": {
                "TAIGA_TRANSPORT": "<stdio|sse>",                
                "TAIGA_API_URL": "<Taiga API Url (ex: http://localhost:9000)",
                "TAIGA_USERNAME": "<taiga username>",
                "TAIGA_PASSWORD": "<taiga password>"
            }
        }
    }
}

Running the Bridge

Start the MCP server with:

# Default stdio transport
./run.sh

# For SSE transport
./run.sh --sse

Or manually:

# For stdio transport (default)
uv run python src/server.py

# For SSE transport
uv run python src/server.py --sse

Transport Modes

The server supports two transport modes:

  • stdio (Standard Input/Output) - Default mode for terminal-based clients
  • SSE (Server-Sent Events) - Web-based transport with server push capabilities

You can set the transport mode in several ways:

  • Using the --sse flag with run.sh or server.py (default is stdio)
  • Setting the TAIGA_TRANSPORT environment variable
  • Adding TAIGA_TRANSPORT=sse to your .env file

Authentication Flow

This MCP bridge uses a session-based authentication model:

Login

Clients must first authenticate using the login tool:

session = client.call_tool("login", {
    "username": "your_taiga_username",
    "password": "your_taiga_password",
    "host": "https://api.taiga.io" # Optional
})
# Save the session_id from the response
session_id = session["session_id"]

Using Tools and Resources

Include the session_id in every API call:

# For resources, include session_id in the URI
projects = client.get_resource(f"taiga://projects?session_id={session_id}")

# For project-specific resources
epics = client.get_resource(f"taiga://projects/123/epics?session_id={session_id}")

# For tools, include session_id as a parameter
new_project = client.call_tool("create_project", {
    "session_id": session_id,
    "name": "New Project",
    "description": "Description"
})

Check Session Status

You can check if your session is still valid:

status = client.call_tool("session_status", {"session_id": session_id})
# Returns information about session validity and remaining time

Logout

When finished, you can logout to terminate the session:

client.call_tool("logout", {"session_id": session_id})

Supported Resources

The bridge provides comprehensive support for Taiga resources with complete CRUD operations:

  • Projects: Create, update, and manage project settings and metadata
  • Epics: Manage large features that span multiple sprints
  • User Stories: Handle detailed requirements and acceptance criteria
  • Tasks: Track smaller units of work within user stories
  • Issues: Manage bugs, questions, and enhancement requests
  • Sprints (Milestones): Plan and track work in time-boxed intervals

How to install this MCP server

For Claude Code

To add this MCP server to Claude Code, run this command in your terminal:

claude mcp add-json "taigaApi" '{"command":"uv","args":["--directory","<path to local pyTaigaMCP folder>","run","src/server.py"],"env":{"TAIGA_TRANSPORT":"<stdio|sse>","TAIGA_API_URL":"<Taiga API Url (ex: http://localhost:9000)","TAIGA_USERNAME":"<taiga username>","TAIGA_PASSWORD":"<taiga password>"}}'

See the official Claude Code MCP documentation for more details.

For Cursor

There are two ways to add an MCP server to Cursor. The most common way is to add the server globally in the ~/.cursor/mcp.json file so that it is available in all of your projects.

If you only need the server in a single project, you can add it to the project instead by creating or adding it to the .cursor/mcp.json file.

Adding an MCP server to Cursor globally

To add a global MCP server go to Cursor Settings > Tools & Integrations and click "New MCP Server".

When you click that button the ~/.cursor/mcp.json file will be opened and you can add your server like this:

{
    "mcpServers": {
        "taigaApi": {
            "command": "uv",
            "args": [
                "--directory",
                "<path to local pyTaigaMCP folder>",
                "run",
                "src/server.py"
            ],
            "env": {
                "TAIGA_TRANSPORT": "<stdio|sse>",
                "TAIGA_API_URL": "<Taiga API Url (ex: http://localhost:9000)",
                "TAIGA_USERNAME": "<taiga username>",
                "TAIGA_PASSWORD": "<taiga password>"
            }
        }
    }
}

Adding an MCP server to a project

To add an MCP server to a project you can create a new .cursor/mcp.json file or add it to the existing one. This will look exactly the same as the global MCP server example above.

How to use the MCP server

Once the server is installed, you might need to head back to Settings > MCP and click the refresh button.

The Cursor agent will then be able to see the available tools the added MCP server has available and will call them when it needs to.

You can also explicitly ask the agent to use the tool by mentioning the tool name and describing what the function does.

For Claude Desktop

To add this MCP server to Claude Desktop:

1. Find your configuration file:

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

2. Add this to your configuration file:

{
    "mcpServers": {
        "taigaApi": {
            "command": "uv",
            "args": [
                "--directory",
                "<path to local pyTaigaMCP folder>",
                "run",
                "src/server.py"
            ],
            "env": {
                "TAIGA_TRANSPORT": "<stdio|sse>",
                "TAIGA_API_URL": "<Taiga API Url (ex: http://localhost:9000)",
                "TAIGA_USERNAME": "<taiga username>",
                "TAIGA_PASSWORD": "<taiga password>"
            }
        }
    }
}

3. Restart Claude Desktop for the changes to take effect

Want to 10x your AI skills?

Get a free account and learn to code + market your apps using AI (with or without vibes!).

Nah, maybe later