About Trello MCP Server (TypeScript)
A TypeScript MCP server for AI assistants to read Trello boards, lists, and cards. It exposes Trello API queries as MCP tools, with asynchronous operations and environment-based configuration.
Key features
- 01List the authenticated user's boards
- 02Retrieve lists on a board
- 03Read cards by board or list
- 04Fetch detailed card information
- 05Asynchronous operations and error handling
Use cases
- 01Review boards in a Trello account
- 02Inspect a board's lists and cards
- 03Look up details for a specific card
MCP support
The server exposes Trello query tools to MCP clients, including tools for boards, lists, cards, and card details.
Configuration
Local server config is the same for every client. Copy it into your client’s MCP config file.
We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.
Tools
Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.
Details
From the project READMETrello MCP Server (TypeScript)
A TypeScript implementation of a Model Context Protocol (MCP) server for Trello integration, providing tools for AI assistants to interact with Trello boards, lists, and cards.
Features
- Full Trello API integration through MCP tools
- Asynchronous operations for better performance
- Type-safe implementation using TypeScript
- Comprehensive error handling
- Environment-based configuration
Prerequisites
- Node.js 18.x or higher
- npm or yarn
- Trello API credentials
Installation
# Install dependencies
make install
Configuration
Create a .env file in the root directory with your Trello credentials:
TRELLO_API_KEY=your_api_key
TRELLO_TOKEN=your_token
Available Commands
# Install dependencies
make install
# Build the project
make build
# Start the server
make start
# Clean build artifacts
make clean
# Run linter
make lint
MCP Tools
get_boards
Retrieves all Trello boards for the authenticated user.
// No input parameters required
get_lists
Fetches all lists from a specified board.
{
"request": {
"board_id": string // ID of the board
}
}
get_cards
Gets cards from a board or specific list.
{
"request": {
"board_id": string, // ID of the board
"list_id"?: string // Optional: ID of a specific list
}
}
get_card_details
Retrieves detailed information about a specific card.
{
"request": {
"card_id": string // ID of the card
}
}
Development
The project uses TypeScript for type safety and better developer experience. The source code is organized as follows:
src/index.ts- Main server entry pointsrc/trello-client.ts- Trello API client implementationsrc/types.ts- TypeScript type definitions
Building
The project uses TypeScript compiler for building:
# Build the project
make build
# The output will be in the build/ directory
Error Handling
The server implements comprehensive error handling for:
- API authentication errors
- Rate limiting
- Network issues
- Invalid request parameters
Contributing
- Fork the repository
- Create your feature branch (
git checkout -b feature/amazing-feature) - Commit your changes (
git commit -m 'Add some amazing feature') - Push to the branch (
git push origin feature/amazing-feature) - Open a Pull Request
Using with Cline
To use this MCP server with Cline, add the following configuration to your Cline MCP settings file (~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json):
{
"mcpServers": {
"trello-ts": {
"command": "node",
"args": ["/path/to/mcp-server-ts-trello/build/index.js"],
"env": {
"TRELLO_API_KEY": "your_api_key",
"TRELLO_TOKEN": "your_token"
}
}
}
}
After adding the configuration and restarting Cline, you can use the following MCP tools:
get_boards: List all Trello boardsget_lists: Get lists from a boardget_cards: Get cards from a board or listget_card_details: Get detailed card information
License
ISC License - See LICENSE file for details
Comments
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.