Trello AI Orchestrator Service

This robust middleware server facilitates seamless interaction between AI execution environments and your Trello infrastructure, managing project artifacts such as boards, associated lists, and individual cards through contextual NLP commands.

Table of Contents

• Table of Contents
• Prerequisites
• Initial Setup
• Deployment
• Operational Modes
• Configuration Parameters
• Client Connectivity
• Functionality Matrix
• Granular Feature Set
  • Board Management
  • List Management
  • Card Management
• Usage Examples
• Debugging Guide
• Contributions

Prerequisites

1. Interpreter environment: Python version 3.12 or later (recommend management via uv).
2. Local AI Client: Claude Desktop application installed and active.
3. Trello Access: Valid Trello account credentials and generated API authorization keys.
4. Dependency Manager: The uv utility must be accessible in the system PATH.

Initial Setup

1. Ensure the Claude Desktop client is installed and operational.
2. Confirm successful authentication within the local Claude instance.
3. Launch the Claude Desktop application.

Deployment

1. Trello Credential Acquisition:
2. Navigate to the Trello Application Administration Panel.
3. Initiate the creation of a new integration via New Power-Up or Integration.
4. Populate required metadata (the Iframe connector URL can remain blank) and designate the target Workspace.
5. Access your newly created application, select 'API key' from the navigation pane.

6. Copy the designated 'API key'. On the same screen, utilize the 'manually generate a Token' link to obtain your Authorization Token.

7. Environment Variable Setup:

8. Rename the template file (.env.example) to .env in the root directory.

9. Populate the following entries with your procured credentials: bash TRELLO_API_KEY=your_api_key_here TRELLO_TOKEN=your_token_here

10. Install uv (If Missing): bash curl -LsSf https://astral.sh/uv/install.sh | sh

11. Source Code Retrieval: bash git clone https://github.com/m0xai/trello-mcp-server.git cd trello-mcp-server

12. Dependency Resolution and Server Initialization (via uv): bash uv run mcp install main.py

13. Relaunch the Claude Desktop application to ensure connection negotiation.

Operational Modes

This service supports three distinct execution paradigms:

Claude Application Integration Mode (Default)

This configuration targets direct communication with the Claude Desktop client:

1. Set USE_CLAUDE_APP=true in your .env configuration file.

2. Execute the server initialization command: bash uv run mcp install main.py

3. Restart the Claude Desktop application.

Server-Sent Events (SSE) Standalone Mode

This mode establishes a conventional HTTP SSE endpoint, suitable for generalized MCP consumers like Cursor:

1. Configure the environment: USE_CLAUDE_APP=false in .env.

2. Launch the server directly: bash python main.py

3. The API endpoint will resolve to http://localhost:8000 by default, unless the port is overridden.

Containerized Deployment (Docker)

For environment isolation, Docker Compose can be utilized:

1. Docker and Docker Compose must be pre-installed.
2. Ensure your .env configuration file is correctly populated.

3. Initiate the build and background execution: bash docker-compose up -d

4. The service defaults to SSE mode.

5. Log inspection: bash docker-compose logs -f

6. Termination procedure: bash docker-compose down

Configuration Parameters

All operational settings are managed via environment variables within the .env file:

Variable Name	Purpose	Default Value	Required?
TRELLO_API_KEY	Trello Consumer Key	N/A	Yes
TRELLO_TOKEN	User Authorization Token	N/A	Yes
MCP_SERVER_NAME	Display name for the protocol handler	Trello MCP Server	No
MCP_SERVER_HOST	Network interface binding for SSE	0.0.0.0	No
MCP_SERVER_PORT	TCP port for SSE communication	8000	No
USE_CLAUDE_APP	Boolean flag for direct desktop integration	true	No

You can tailor the service behavior by modifying these variables.

Client Connectivity

Integration with Claude Desktop

1. Deploy the server using the desktop-bound configuration (USE_CLAUDE_APP=true).
2. Initiate or refresh the Claude Desktop client.
3. Connection detection and binding should occur automatically.

Integration with Cursor IDE

To establish a link with Cursor:

1. Operate the server in SSE configuration (USE_CLAUDE_APP=false).
2. In Cursor Settings (gear icon) navigate to AI > Model Context Protocol.
3. Register a new endpoint pointing to http://localhost:8000.
4. Select this newly registered server for active AI sessions.

Alternatively, persistence can be achieved by editing your Cursor configuration file (usually ~/.cursor/mcp.json):

{ "mcpServers": { "trello_manager": { "url": "http://localhost:8000/sse" } } }

Compatibility with Other MCP Clients

Any client supporting the Model Context Protocol should target the SSE service path: http://localhost:8000.

Illustrative Client Connection Example (Asynchronous Python)

This snippet demonstrates basic session establishment and message transmission over the SSE stream:

python import asyncio import httpx

async def establish_trello_session(): stream_url = "http://localhost:8000/sse" stream_headers = {"Accept": "text/event-stream"}

async with httpx.AsyncClient() as client:
    async with client.stream("GET", stream_url, headers=stream_headers) as response:
        current_session_id = None
        async for chunk in response.aiter_lines():
            if chunk.startswith("data:"):
                payload = chunk[5:].strip()
                if "session_id=" in payload and not current_session_id:
                    current_session_id = payload.split("session_id=")[1]

                    # Command execution endpoint
                    command_url = f"http://localhost:8000/messages/?session_id={current_session_id}"
                    user_query = {
                        "role": "user",
                        "content": {
                            "type": "text",
                            "text": "Enumerate my existing Trello workspaces"
                        }
                    }
                    await client.post(command_url, json=user_query)

if name == "main": asyncio.run(establish_trello_session())

Functionality Matrix

Operation Type	Boards	Lists	Cards	Checklists	Checklist Items
Query (Read)	✅	✅	✅	✅	✅
Creation (Write)	❌	✅	✅	✅	✅
Modification	❌	✅	✅	✅	✅
Decommission	❌	✅	✅	✅	✅

Granular Feature Set

Board Management

• ✅ Retrieve a catalogue of all accessible boards.
• ✅ Fetch detailed metadata for a specified board.

List Management

• ✅ List all contained lists within a designated board context.
• ✅ Retrieve specifics for an individual list.
• ✅ Instantiate new lists.
• ✅ Rename an existing list.
• ✅ Mark lists for archival (deletion).

Card Management

• ✅ Query all cards situated within a given list.
• ✅ Fetch comprehensive details for a single card.
• ✅ Generate new task cards.
• ✅ Alter card properties (e.g., description, due date, assignment).
• ✅ Permanently remove cards.

Checklist Operations

• ✅ Retrieve the contents of a specific checklist.
• ✅ Enumerate all checklists attached to a card.
• ✅ Introduce a new checklist structure.
• ✅ Modify the checklist's title or properties.
• ✅ Erase a checklist entity.
• ✅ Append a new actionable item to a checklist.
• ✅ Modify the status or name of a check item.
• ✅ Remove a specific check item.

Usage Examples

Upon successful linkage, natural language queries directed at Claude will translate into Trello API calls. Examples include:

• "Provide an inventory of my Trello environments."
• "What categorical segments exist within the '[board_name]' project?"
• "Compose a new task card titled '[title]' under the '[list_name]' segment."
• "Revise the explanatory text associated with card '[card_name]'."
• "Decommission the list named '[list_name]'."

Visual demonstrations of interaction success:

Debugging Guide

If service interruptions occur, follow these diagnostics:

1. Credential Validation: Scrutinize the TRELLO_API_KEY and TRELLO_TOKEN values within .env.
2. Authorization Check: Confirm the associated Trello account possesses adequate rights for the targeted resources.
3. Client Status: Verify that the Claude Desktop client is running the most recent version.
4. Log Analysis: Inspect server output using uv run mcp dev main.py for specific error tracing.
5. Dependency Manager Health: Confirm uv installation status and PATH configuration.

Contributions

We welcome submissions via issue reports and feature enhancement pull requests!

WIKIPEDIA CONTEXT: Business management tools encompass all methodologies, applications, controls, and calculation systems utilized by commercial entities to navigate market volatility, maintain competitive advantage, and optimize operational efficiency. These tools are categorized by organizational function—such as planning, workflow control, data aggregation, personnel management, and decision support. The rapid evolution of technology has complicated tool selection, necessitating a strategic, adaptive approach rather than indiscriminate adoption of novel software.

== Core Functions == Business applications, or software suites, are designed to elevate output, quantify performance metrics, and execute diverse corporate functions precisely. The progression moved from initial Management Information Systems (MIS) to comprehensive Enterprise Resource Planning (ERP), later integrating Customer Relationship Management (CRM) functionalities, often culminating in cloud-based enterprise management solutions. Maximizing organizational performance relies critically on both the efficacy of tool implementation and the strategic alignment of the chosen tools with specific organizational demands.

== Global Adoption (2013 Insight) == A 2013 survey by Bain & Company highlighted the prevalence of specific managerial practices globally. Leading methodologies included Strategic Planning, CRM, Benchmarking, Balanced Scorecard implementation, Supply Chain Optimization, and Market Segmentation analysis.