Trello

Interaja com quadros, listas e cartões do Trello usando a API REST do Trello.

Documentação

Trello MCP Server

Um servidor Model Context Protocol (MCP) que fornece ao Claude ferramentas para interagir com quadros, listas e cartões do Trello por meio da API REST do Trello.

Recursos

Funcionalidade Principal

Gerenciamento de Quadros: Listar quadros, obter detalhes e metadados de quadros
Operações de Listas: Recuperar listas, criar novas listas dentro de quadros
Gerenciamento de Cartões: Criar, atualizar, excluir e mover cartões entre listas
Gerenciamento de Membros: Adicionar/remover membros de quadros e cartões
Etiquetas e Checklists: Gerenciar etiquetas de cartões e itens de checklist

Recursos Técnicos

Implementação em TypeScript com segurança total de tipos
Tratamento abrangente de erros e validação
Conformidade com limites de taxa da API do Trello
Autenticação segura usando chave/token de API
Integração com Popular Agentic IDE via protocolo MCP

Pré-requisitos

Node.js 18+ e npm
Conta Trello com acesso à API
Aplicativo Claude Desktop

Instalação

Clone o repositório:

git clone <repository-url>
cd trello-mcp

Instale as dependências:

npm install

Compile o projeto:

npm run build

Configuração de Autenticação

Obtenha as Credenciais da API do Trello:
- Visite https://trello.com/app-key para obter sua chave de API
- Gere um token visitando: https://trello.com/1/authorize?expiration=never&scope=read,write,account&response_type=token&name=Server%20Token&key=YOUR_API_KEY

Configure o Ambiente: Crie um arquivo .env na raiz do projeto:

TRELLO_API_KEY=your_api_key_here
TRELLO_TOKEN=your_token_here

Configuração de Integração

Integração com Claude Desktop

Adicione o seguinte ao arquivo de configuração do Claude Desktop:

macOS

Edite ~/Library/Application Support/Claude/claude_desktop_config.json:

Windows

Edite %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "trello": {
      "command": "node",
      "args": ["/path/to/trello-mcp/dist/index.js"],
      "env": {
        "TRELLO_API_KEY": "your_api_key_here",
        "TRELLO_TOKEN": "your_token_here"
      }
    }
  }
}

Integração com Docker Desktop

O Docker Desktop (v4.38+) inclui suporte integrado a servidores MCP por meio do Docker MCP Catalog e Toolkit. Isso fornece a maneira mais fácil de executar e gerenciar servidores MCP.

Opção 1: Usando o Suporte MCP Integrado do Docker Desktop (Recomendado)

Habilite o MCP no Docker Desktop:
- Abra o Docker Desktop (garanta a versão 4.38 ou posterior)
- Vá para Extensions → Browse → Pesquise por "MCP"
- Instale a extensão Docker MCP Catalog and Toolkit

Publique no Catálogo MCP do Docker Hub:

# Build and tag for MCP catalog
docker build -t mcp/trello-server .
docker push mcp/trello-server

Configure no Claude Desktop com Docker MCP:

{
  "mcpServers": {
    "trello": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "--env-file", ".env",
        "mcp/trello-server"
      ]
    }
  }
}

Use com Ask Gordon (Docker AI): Crie gordon-mcp.yml no diretório do seu projeto:

version: '3.8'
services:
  trello-mcp:
    image: mcp/trello-server
    environment:
      - TRELLO_API_KEY=${TRELLO_API_KEY}
      - TRELLO_TOKEN=${TRELLO_TOKEN}
    volumes:
      - ./logs:/app/logs

Em seguida, use comandos do Docker AI:

# Ask Gordon to help with Trello management
docker ai "Show me my Trello boards and create a new development task"

Opção 2: Configuração Docker Tradicional

Crie um Dockerfile na raiz do seu projeto:

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY dist/ ./dist/

# Create non-root user for security
RUN addgroup -g 1001 -S nodejs
RUN adduser -S mcp -u 1001
RUN chown -R mcp:nodejs /app
USER mcp

EXPOSE 3000

CMD ["node", "dist/index.js"]

Compile e execute o contêiner:

# Build the image
docker build -t trello-mcp-server .

# Run with Docker MCP Toolkit (secure credential management)
docker run -d \
  --name trello-mcp \
  --env-file .env \
  -p 3000:3000 \
  trello-mcp-server

# Or use docker-compose.yml:

Crie docker-compose.yml:

version: '3.8'
services:
  trello-mcp:
    build: .
    container_name: trello-mcp-server
    environment:
      - TRELLO_API_KEY=${TRELLO_API_KEY}
      - TRELLO_TOKEN=${TRELLO_TOKEN}
      - LOG_LEVEL=info
      - API_TIMEOUT=10000
    ports:
      - "3000:3000"
    restart: unless-stopped
    volumes:
      - ./logs:/app/logs
    networks:
      - mcp-network

networks:
  mcp-network:
    driver: bridge

Execute com Docker Compose:

# Set environment variables in .env file, then:
docker-compose up -d

Benefícios da Integração MCP do Docker Desktop

Segurança Integrada: Suporte a OAuth e armazenamento seguro de credenciais
Configuração com Um Clique: Integração perfeita com Claude, Cursor, VSCode e outros clientes MCP
Multiplataforma: Comportamento consistente em diferentes arquiteturas
Isolamento: Isolamento de memória, rede e disco para segurança pronta para produção
Descoberta: Acesso a mais de 100 ferramentas MCP verificadas do Catálogo MCP do Docker Hub

Integração com Cursor IDE

No Cursor, você pode configurar o servidor MCP para desenvolvimento assistido por IA:

Instale a Extensão do Cursor (se disponível):
- Abra o Cursor IDE
- Vá para o marketplace de Extensões
- Pesquise por "MCP" ou "Model Context Protocol"
Configure o Servidor MCP: Crie .cursor/mcp-config.json no seu espaço de trabalho:

{
  "mcpServers": {
    "trello": {
      "command": "node",
      "args": ["./dist/index.js"],
      "cwd": "/path/to/trello-mcp",
      "env": {
        "TRELLO_API_KEY": "your_api_key_here",
        "TRELLO_TOKEN": "your_token_here"
      }
    }
  }
}

Use com o Cursor AI:
- Abra o painel de chat de IA do Cursor
- As ferramentas do Trello MCP devem estar disponíveis para contexto
- Faça perguntas como: "Mostre-me meus quadros do Trello e ajude-me a organizar minhas tarefas"

Integração com Windsurf IDE

Para integração com Windsurf IDE:

Configuração do Projeto: Crie .windsurf/settings.json:

{
  "mcp": {
    "servers": {
      "trello": {
        "command": "node",
        "args": ["dist/index.js"],
        "cwd": "${workspaceFolder}",
        "env": {
          "TRELLO_API_KEY": "your_api_key_here",
          "TRELLO_TOKEN": "your_token_here"
        }
      }
    }
  },
  "ai": {
    "providers": {
      "claude": {
        "mcpServers": ["trello"]
      }
    }
  }
}

Configuração do Espaço de Trabalho: Adicione ao seu .windsurf/workspace.json:

{
  "name": "Trello MCP Development",
  "description": "Development workspace with Trello integration",
  "mcpServers": ["trello"],
  "tools": {
    "trello": {
      "enabled": true,
      "autoStart": true
    }
  }
}

Uso no Windsurf:
- O assistente de IA terá acesso às ferramentas do Trello
- Use comandos em linguagem natural no chat de IA
- Exemplo: "Crie um quadro de tarefas de desenvolvimento e adicione cartões para os recursos atuais do projeto"

Contêiner de Desenvolvimento (DevContainer)

Para ambientes de desenvolvimento consistentes, crie .devcontainer/devcontainer.json:

{
  "name": "Trello MCP Development",
  "build": {
    "dockerfile": "../Dockerfile.dev"
  },
  "forwardPorts": [3000],
  "postCreateCommand": "npm install && npm run build",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-vscode.vscode-typescript-next",
        "esbenp.prettier-vscode",
        "bradlc.vscode-tailwindcss"
      ],
      "settings": {
        "mcp.servers": {
          "trello": {
            "command": "node",
            "args": ["dist/index.js"],
            "env": {
              "TRELLO_API_KEY": "${TRELLO_API_KEY}",
              "TRELLO_TOKEN": "${TRELLO_TOKEN}"
            }
          }
        }
      }
    }
  },
  "remoteEnv": {
    "TRELLO_API_KEY": "${localEnv:TRELLO_API_KEY}",
    "TRELLO_TOKEN": "${localEnv:TRELLO_TOKEN}"
  }
}

Crie Dockerfile.dev:

FROM node:18

WORKDIR /workspace

# Install global tools
RUN npm install -g @modelcontextprotocol/inspector typescript

# Set up development environment
COPY package*.json ./
RUN npm install

# Copy source code
COPY . .

# Expose MCP server port
EXPOSE 3000

CMD ["npm", "run", "dev"]

Ferramentas Disponíveis

Operações de Quadro

list_boards - Obter todos os quadros acessíveis ao usuário
get_board - Obter informações detalhadas sobre um quadro específico
get_board_members - Listar membros de um quadro

Operações de Lista

get_lists - Obter todas as listas em um quadro
create_list - Criar uma nova lista em um quadro
update_list - Atualizar propriedades da lista (nome, posição)

Operações de Cartão

get_cards - Obter cartões de um quadro ou lista
create_card - Criar um novo cartão
update_card - Atualizar propriedades do cartão (nome, descrição, data de vencimento)
move_card - Mover cartão para uma lista diferente
delete_card - Excluir um cartão
add_card_member - Adicionar membro a um cartão
remove_card_member - Remover membro de um cartão

Operações de Etiqueta

get_labels - Obter etiquetas disponíveis para um quadro
add_card_label - Adicionar etiqueta a um cartão
remove_card_label - Remover etiqueta de um cartão

Operações de Checklist

get_card_checklists - Obter checklists em um cartão
create_checklist - Criar um novo checklist em um cartão
add_checklist_item - Adicionar item a um checklist
update_checklist_item - Atualizar item de checklist (marcar como concluído/não concluído)

Desenvolvimento

Estrutura do Projeto

trello-mcp/
├── src/
│   ├── index.ts          # MCP server entry point
│   ├── trello-client.ts  # Trello API client
│   ├── tools/            # MCP tool implementations
│   │   ├── boards.ts
│   │   ├── lists.ts
│   │   ├── cards.ts
│   │   └── labels.ts
│   └── types/            # TypeScript type definitions
├── dist/                 # Compiled JavaScript
├── package.json
├── tsconfig.json
└── README.md

Scripts

npm run build - Compilar TypeScript para JavaScript
npm run dev - Executar em modo de desenvolvimento com recarga automática
npm run start - Iniciar o servidor MCP
npm run test - Executar testes

Testes

# Install the MCP Inspector for testing
npm install -g @modelcontextprotocol/inspector

# Test the server
mcp-inspector node dist/index.js

Exemplos de Uso

Uma vez integrado ao Claude Desktop, você pode usar linguagem natural para interagir com o Trello:

"Mostre-me todos os meus quadros do Trello"
"Crie um novo cartão chamado 'Corrigir bug de login' na lista 'A Fazer' do meu quadro de Desenvolvimento"
"Mova o cartão 'Revisar PR #123' para a lista 'Concluído'"
"Adicione a etiqueta 'Prioridade' ao cartão sobre a migração do banco de dados"
"Liste todos os cartões no meu quadro Pessoal com vencimento esta semana"

Tratamento de Erros

O servidor inclui tratamento abrangente de erros para:

Problemas de conectividade de rede
Credenciais de API inválidas
Limites de taxa (erros 429)
IDs inválidos de quadro/lista/cartão
Erros de permissão

Notas de Segurança

As credenciais da API são passadas por variáveis de ambiente
Nenhuma credencial é registrada ou armazenada em texto simples
Todas as solicitações de API usam HTTPS
Os limites de taxa são respeitados para evitar abuso da API

Contribuindo

Faça um fork do repositório
Crie um branch de recurso
Faça suas alterações com tipos TypeScript adequados
Adicione testes para novas funcionalidades
Envie um pull request

Licença

Licença MIT - consulte o arquivo LICENSE para obter detalhes

Suporte

Para problemas e perguntas:

Consulte a documentação da API do Trello: https://developer.atlassian.com/cloud/trello/rest
Revise a documentação do MCP: https://modelcontextprotocol.io
Abra um problema neste repositório