Trello

Interactúa con tableros, listas y tarjetas de Trello usando la API REST de Trello.

GitHub
1
Prueba este MCPPatrocinado

Documentación

Servidor MCP de Trello

Un servidor de Model Context Protocol (MCP) que proporciona a Claude herramientas para interactuar con tableros, listas y tarjetas de Trello a través de la API REST de Trello.

Características

Funcionalidad Principal

  • Gestión de Tableros: Listar tableros, obtener detalles y metadatos de tableros
  • Operaciones con Listas: Recuperar listas, crear nuevas listas dentro de tableros
  • Gestión de Tarjetas: Crear, actualizar, eliminar y mover tarjetas entre listas
  • Gestión de Miembros: Añadir/eliminar miembros de tableros y tarjetas
  • Etiquetas y Listas de Verificación: Gestionar etiquetas de tarjetas y elementos de listas de verificación

Características Técnicas

  • Implementación en TypeScript con seguridad de tipos completa
  • Manejo integral de errores y validación
  • Cumplimiento de límites de velocidad para la API de Trello
  • Autenticación segura mediante clave/token de API
  • Integración con Popular Agentic IDE mediante el protocolo MCP

Requisitos Previos

  • Node.js 18+ y npm
  • Cuenta de Trello con acceso a la API
  • Aplicación Claude Desktop

Instalación

  1. Clonar el repositorio:
git clone <repository-url>
cd trello-mcp
  1. Instalar dependencias:
npm install
  1. Compilar el proyecto:
npm run build

Configuración de Autenticación

  1. Obtener Credenciales de API de Trello:

    • Visita https://trello.com/app-key para obtener tu clave de API
    • Genera un token visitando: https://trello.com/1/authorize?expiration=never&scope=read,write,account&response_type=token&name=Server%20Token&key=YOUR_API_KEY

  2. Configurar el Entorno: Crea un archivo .env en la raíz del proyecto:

    TRELLO_API_KEY=your_api_key_here
TRELLO_TOKEN=your_token_here

Configuración de Integración

Integración con Claude Desktop

Añade lo siguiente a tu archivo de configuración de Claude Desktop:

macOS

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

Windows

Edita %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"
      }
    }
  }
}

Integración con Docker Desktop

Docker Desktop (v4.38+) incluye soporte integrado para servidores MCP mediante el Catálogo y Kit de Herramientas MCP de Docker. Esto proporciona la forma más sencilla de ejecutar y gestionar servidores MCP.

Opción 1: Usar el Soporte MCP Integrado de Docker Desktop (Recomendado)

  1. Habilitar MCP en Docker Desktop:

    • Abre Docker Desktop (asegúrate de tener la versión 4.38 o posterior)
    • Ve a Extensiones → Explorar → Busca "MCP"
    • Instala la extensión Catálogo y Kit de Herramientas MCP de Docker

  2. Publicar en el Catálogo MCP de Docker Hub:

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

  3. Configurar en Claude Desktop con Docker MCP:

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

  4. Usar con Ask Gordon (Docker AI): Crea gordon-mcp.yml en tu directorio de proyecto:

    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

    Luego usa comandos de Docker AI:

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

Opción 2: Configuración Tradicional de Docker

Crea un Dockerfile en la raíz de tu proyecto:

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"]

Compila y ejecuta el contenedor:

# 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:

Crea 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

Ejecuta con Docker Compose:

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

Beneficios de la Integración MCP de Docker Desktop

  • Seguridad Integrada: Soporte OAuth y almacenamiento seguro de credenciales
  • Configuración con Un Clic: Integración perfecta con Claude, Cursor, VSCode y otros clientes MCP
  • Multiplataforma: Comportamiento consistente en diferentes arquitecturas
  • Aislamiento: Aislamiento de memoria, red y disco para seguridad de nivel producción
  • Descubrimiento: Acceso a más de 100 herramientas MCP verificadas del Catálogo MCP de Docker Hub

Integración con Cursor IDE

En Cursor, puedes configurar el servidor MCP para desarrollo asistido por IA:

  1. Instalar la Extensión de Cursor (si está disponible):

    • Abre Cursor IDE
    • Ve al mercado de extensiones
    • Busca "MCP" o "Model Context Protocol"

  2. Configurar el Servidor MCP: Crea .cursor/mcp-config.json en tu espacio de trabajo:

{
  "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"
      }
    }
  }
}
  1. Usar con Cursor AI:
    • Abre el panel de chat de IA de Cursor
    • Las herramientas MCP de Trello deberían estar disponibles para contexto
    • Haz preguntas como: "Muéstrame mis tableros de Trello y ayúdame a organizar mis tareas"

Integración con Windsurf IDE

Para la integración con Windsurf IDE:

  1. Configuración del Proyecto: Crea .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"]
      }
    }
  }
}
  1. Configuración del Espacio de Trabajo: Añade a tu .windsurf/workspace.json:
{
  "name": "Trello MCP Development",
  "description": "Development workspace with Trello integration",
  "mcpServers": ["trello"],
  "tools": {
    "trello": {
      "enabled": true,
      "autoStart": true
    }
  }
}
  1. Uso en Windsurf:
    • El asistente de IA tendrá acceso a las herramientas de Trello
    • Usa comandos en lenguaje natural en el chat de IA
    • Ejemplo: "Crea un tablero de tareas de desarrollo y añade tarjetas para las características actuales del proyecto"

Contenedor de Desarrollo (DevContainer)

Para entornos de desarrollo consistentes, crea .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}"
  }
}

Crea 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"]

Herramientas Disponibles

Operaciones con Tableros

  • list_boards - Obtener todos los tableros accesibles para el usuario
  • get_board - Obtener información detallada sobre un tablero específico
  • get_board_members - Listar miembros de un tablero

Operaciones con Listas

  • get_lists - Obtener todas las listas en un tablero
  • create_list - Crear una nueva lista en un tablero
  • update_list - Actualizar propiedades de lista (nombre, posición)

Operaciones con Tarjetas

  • get_cards - Obtener tarjetas de un tablero o lista
  • create_card - Crear una nueva tarjeta
  • update_card - Actualizar propiedades de tarjeta (nombre, descripción, fecha de vencimiento)
  • move_card - Mover tarjeta a una lista diferente
  • delete_card - Eliminar una tarjeta
  • add_card_member - Añadir miembro a una tarjeta
  • remove_card_member - Eliminar miembro de una tarjeta

Operaciones con Etiquetas

  • get_labels - Obtener etiquetas disponibles para un tablero
  • add_card_label - Añadir etiqueta a una tarjeta
  • remove_card_label - Eliminar etiqueta de una tarjeta

Operaciones con Listas de Verificación

  • get_card_checklists - Obtener listas de verificación en una tarjeta
  • create_checklist - Crear una nueva lista de verificación en una tarjeta
  • add_checklist_item - Añadir elemento a una lista de verificación
  • update_checklist_item - Actualizar elemento de lista de verificación (marcar completo/incompleto)

Desarrollo

Estructura del Proyecto

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 a JavaScript
  • npm run dev - Ejecutar en modo desarrollo con recarga automática
  • npm run start - Iniciar el servidor MCP
  • npm run test - Ejecutar pruebas

Pruebas

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

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

Ejemplos de Uso

Una vez integrado con Claude Desktop, puedes usar lenguaje natural para interactuar con Trello:

  • "Muéstrame todos mis tableros de Trello"
  • "Crea una nueva tarjeta llamada 'Corregir error de inicio de sesión' en la lista 'Por hacer' de mi tablero de Desarrollo"
  • "Mueve la tarjeta 'Revisar PR #123' a la lista 'Hecho'"
  • "Añade la etiqueta 'Prioridad' a la tarjeta sobre la migración de base de datos"
  • "Lista todas las tarjetas en mi tablero Personal que vencen esta semana"

Manejo de Errores

El servidor incluye manejo integral de errores para:

  • Problemas de conectividad de red
  • Credenciales de API inválidas
  • Límites de velocidad (errores 429)
  • IDs de tablero/lista/tarjeta inválidos
  • Errores de permisos

Notas de Seguridad

  • Las credenciales de API se pasan mediante variables de entorno
  • No se registran ni almacenan credenciales en texto plano
  • Todas las solicitudes de API usan HTTPS
  • Se respetan los límites de velocidad para evitar abuso de la API

Contribuciones

  1. Haz un fork del repositorio
  2. Crea una rama de características
  3. Realiza tus cambios con tipos TypeScript adecuados
  4. Añade pruebas para la nueva funcionalidad
  5. Envía una solicitud de extracción

Licencia

Licencia MIT - consulta el archivo LICENSE para más detalles

Soporte

Para problemas y preguntas: