Taiga MCP Bridge

Overview

The Taiga MCP Bridge is a powerful integration layer that connects Taiga project management platform with the Model Context Protocol (MCP), enabling AI tools and workflows to interact seamlessly with Taiga's resources.

This bridge provides a comprehensive set of tools and resources for AI agents to:

Create and manage projects, epics, user stories, tasks, and issues in Taiga
Track sprints and milestones
Assign and update work items
Query detailed information about project artifacts
Manage project members and permissions

By using the MCP standard, this bridge allows AI systems to maintain contextual awareness about project state and perform complex project management tasks programmatically.

Features

Comprehensive Resource Support

The bridge supports the following 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

Installation

This project uses uv for fast, reliable Python package management.

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

Development Installation

For development (includes testing and code quality tools):

./install.sh --dev

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})

Example: Complete Project Creation Workflow

Here's a complete example of creating a project with epics and user stories:

from mcp.client import Client

# Initialize MCP client
client = Client()

# Authenticate and get session ID
auth_result = client.call_tool("login", {
    "username": "admin",
    "password": "password123",
    "host": "https://taiga.mycompany.com"
})
session_id = auth_result["session_id"]

# Create a new project
project = client.call_tool("create_project", {
    "session_id": session_id,
    "name": "My New Project",
    "description": "A test project created via MCP"
})
project_id = project["id"]

# Create an epic
epic = client.call_tool("create_epic", {
    "session_id": session_id,
    "project_id": project_id,
    "subject": "User Authentication",
    "description": "Implement user authentication features"
})
epic_id = epic["id"]

# Create a user story in the epic
story = client.call_tool("create_user_story", {
    "session_id": session_id,
    "project_id": project_id,
    "subject": "User Login",
    "description": "As a user, I want to log in with my credentials",
    "epic_id": epic_id
})

# Logout when done
client.call_tool("logout", {"session_id": session_id})

Development

Project Structure

pyTaigaMCP/
├── src/
│   ├── server.py          # MCP server implementation with tools
│   ├── taiga_client.py    # Taiga API client with all CRUD operations
│   ├── tools.py           # MCP tools definitions
│   └── config.py          # Configuration settings with Pydantic
├── tests/
│   ├── conftest.py        # Shared pytest fixtures
│   ├── unit/              # Unit tests
│   └── integration/       # Integration tests
├── pyproject.toml         # Project configuration and dependencies
├── install.sh             # Installation script
├── run.sh                 # Server execution script
└── README.md              # Project documentation

Testing

Run tests with pytest:

# Run all tests
pytest

# Run only unit tests
pytest tests/unit/

# Run only integration tests
pytest tests/integration/

# Run tests with specific markers
pytest -m "auth"  # Authentication tests
pytest -m "core"  # Core functionality tests

# Run tests with coverage reporting
pytest --cov=src

Debugging and Inspection

Use the included inspector tool for debugging:

# Default stdio transport
./inspect.sh

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

# For development mode
./inspect.sh --dev

Error Handling

All API operations return standardized error responses in the following format:

{
  "status": "error",
  "error_type": "ExceptionClassName",
  "message": "Detailed error message"
}

Performance Considerations

The bridge implements several performance optimizations:

Connection Pooling: Reuses HTTP connections for better performance
Rate Limiting: Prevents overloading the Taiga API
Retry Mechanism: Automatically retries failed requests with exponential backoff
Session Cleanup: Regularly cleans up expired sessions to free resources

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Install development dependencies (./install.sh --dev)
Make your changes
Run tests (pytest)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Taiga for their excellent project management platform
Model Context Protocol (MCP) for the standardized AI communication framework
All contributors who have helped shape this project

Deploy Server

HTTP connection URL

security – no known vulnerabilities

license - permissive license

quality - confirmed to work

How are these scores calculated?

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

Tools

View all tools

A protocol bridge that connects AI systems to Taiga project management platform, enabling AI tools to create and manage projects, epics, user stories, tasks, issues, and sprints.

Related Resources

Reddit Discussion about this server

Related MCP Servers

Jira MCP Server
uddeshya-23
-
security
F
license
-
quality
Enables AI models to interact with Jira using a standardized protocol, offering full Jira REST API integration with features like optimal performance through connection pooling, error handling, and request monitoring.
Last updated -
2
Targetprocess MCP Server
aaronsb
A
security
A
license
A
quality
Provides tools for interacting with Targetprocess, a project management and agile planning platform, enabling AI assistants to search, create, and update project entities with proper validation.
Last updated -
6
MIT License
Unity MCP Server
GrandMasterK414
-
security
F
license
-
quality
A protocol server that bridges AI assistants with Unity projects, allowing them to analyze code, parse scenes, generate scripts, and perform other Unity operations through specialized tools.
Last updated -
Agile Luminary MCP Serverofficial
AgileLuminary
-
security
A
license
-
quality
A Model Context Protocol server that connects AI clients to the Agile Luminary project management system, allowing users to retrieve project details, work assignments, and product information within AI conversations.
Last updated -
1
MIT License

View all related MCP servers

Taiga MCP Bridge

Taiga MCP Bridge

Overview

Features

Comprehensive Resource Support

Installation

Prerequisites

Basic Installation

Development Installation

Manual Installation

Configuration

Usage

With stdio mode

Running the Bridge

Transport Modes

Authentication Flow

Example: Complete Project Creation Workflow

Development

Project Structure

Testing

Debugging and Inspection

Error Handling

Performance Considerations

Contributing

License

Acknowledgments

Tools

Related Resources

Related MCP Servers

Jira MCP Server

Targetprocess MCP Server

Unity MCP Server

Agile Luminary MCP Serverofficial

Appeared in Searches

New MCP Servers

MCP directory API