Backlog Manager

Gerencie pendências de tarefas usando um sistema de armazenamento baseado em arquivos JSON.

GitHub

Experimente este MCPPatrocinado

Documentação

Backlog Manager MCP Server

Um servidor MCP simples de rastreamento de tarefas e gerenciamento de backlog para assistentes de IA (projeto hack)

Sumário

Visão Geral
Recursos
Pré-requisitos
Instalação
Configuração
Executando o Servidor
Ferramentas MCP
Integração com Clientes MCP
Exemplos de Uso
Solução de Problemas
Contribuição
Licença

Visão Geral

O Backlog Manager é um servidor MCP (Machine-Consumable Programming) para gerenciamento de issues e tarefas com abordagem baseada em arquivos. Ele fornece ferramentas para agentes de IA e outros clientes criarem issues, adicionarem tarefas a elas e acompanharem o status das tarefas. Issues representam solicitações de funcionalidades de alto nível ou bugs, enquanto tarefas representam itens de trabalho específicos necessários para resolver a issue.

Construído usando o protocolo MCP da Anthropic, ele suporta transportes SSE e stdio para integração flexível com assistentes de IA como Claude, ou outros clientes compatíveis com MCP.

Recursos

Gerenciamento de Issues: Criar, listar, selecionar e acompanhar issues com descrições
Acompanhamento de Tarefas: Adicionar tarefas a issues com títulos, descrições e acompanhamento de status
Fluxo de Status: Acompanhar o progresso das tarefas pelos estados Novo, Em Trabalho e Concluído
Armazenamento Baseado em Arquivos: Formato de armazenamento JSON portátil para fácil backup e controle de versão
Transporte Flexível: Suporte para comunicação SSE (HTTP) e stdio
Suporte a Docker: Execute em contêineres para fácil implantação e isolamento

Pré-requisitos

Python: 3.12 ou superior
Gerenciador de Pacotes: uv (recomendado) ou pip
Docker: (Opcional) Para implantação em contêineres
Cliente MCP: Claude Code, Windsurf, ou qualquer outro cliente compatível com MCP

Instalação

Usando uv (Recomendado)

# Clone the repository
git clone https://github.com/username/backlog-manager-mcp.git
cd backlog-manager-mcp

# Install dependencies
uv pip install -e .

# Verify installation
uv run backlog-manager  # This should start the server

Usando Docker

# Build the Docker image
docker build -t backlog/manager --build-arg PORT=8050 .

# Run the container
docker run -p 8050:8050 backlog/manager

# Verify container is running
docker ps | grep backlog/manager

Configuração

Configure o comportamento do servidor usando variáveis de ambiente em um arquivo .env:

# Create environment file from example
cp .env.example .env

Exemplo de conteúdo do arquivo .env:

# Transport mode: 'sse' or 'stdio'
TRANSPORT=sse

# Server configuration (for SSE transport)
HOST=0.0.0.0
PORT=8050

# Data storage
TASKS_FILE=tasks.json

Variável	Descrição	Padrão	Obrigatório
`TRANSPORT`	Protocolo de transporte (sse ou stdio)	`sse`	Não
`HOST`	Host para vincular ao usar transporte SSE	`0.0.0.0`	Não
`PORT`	Porta para escutar ao usar transporte SSE	`8050`	Não
`TASKS_FILE`	Caminho para o arquivo de armazenamento de tarefas	`tasks.json`	Não

Executando o Servidor

Iniciar o Servidor (Modo SSE)

# Using the CLI command
uv run backlog-manager

# Or directly with Python
uv run src/backlog_manager/main.py

Você deve ver uma saída semelhante a:

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8050 (Press CTRL+C to quit)

Nota: O servidor não suporta a flag --help pois foi projetado como um servidor MCP, não como um aplicativo CLI tradicional.

Usando o Modo stdio

Ao usar o modo stdio, você não precisa iniciar o servidor separadamente - o cliente MCP o iniciará automaticamente quando configurado corretamente (veja Integração com Clientes MCP).

Ferramentas MCP

O Backlog Manager expõe as seguintes ferramentas via MCP:

Gerenciamento de Issues

Ferramenta	Descrição	Parâmetros
`create_issue`	Criar uma nova issue	`name` (string), `description` (string, opcional), `status` (string, opcional)
`list_issues`	Mostrar todas as issues disponíveis	Nenhum
`select_issue`	Definir a issue ativa	`name` (string)
`initialize_issue`	Criar ou redefinir uma issue	`name` (string), `description` (string, opcional), `status` (string, opcional)
`update_issue_status`	Atualizar o status da issue	`name` (string), `status` (string)

Gerenciamento de Tarefas

Ferramenta	Descrição	Parâmetros
`add_task`	Adicionar tarefa à issue ativa	`title` (string), `description` (string, opcional)
`list_tasks`	Listar tarefas na issue ativa	`status` (string, opcional)
`update_task_status`	Atualizar o status da tarefa	`task_id` (string), `status` (string)

Valores de Status

Tarefas e issues podem ter um dos seguintes status:

New (padrão para novas tarefas/issues)
InWork (em andamento)
Done (concluído)

Integração com Clientes MCP

Configuração SSE

Depois de ter o servidor em execução com transporte SSE, conecte-se a ele usando esta configuração:

{
  "mcpServers": {
    "backlog-manager": {
      "transport": "sse",
      "url": "http://localhost:8050/sse"
    }
  }
}

Configuração do Windsurf:

{
  "mcpServers": {
    "backlog-manager": {
      "transport": "sse",
      "serverUrl": "http://localhost:8050/sse"
    }
  }
}

Configuração do n8n:

Use host.docker.internal em vez de localhost para acessar a máquina host a partir do contêiner n8n:

http://host.docker.internal:8050/sse

Configuração Python com Stdio

{
  "mcpServers": {
    "backlog-manager": {
      "command": "python",
      "args": ["path/to/backlog-manager/src/backlog_manager/main.py"],
      "env": {
        "TRANSPORT": "stdio",
        "TASKS_FILE": "tasks.json"
      }
    }
  }
}

Configuração Docker com Stdio

{
  "mcpServers": {
    "backlog-manager": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "-e", "TRANSPORT=stdio", "backlog/manager"],
      "env": {
        "TRANSPORT": "stdio"
      }
    }
  }
}

Exemplo

O Backlog Manager foi projetado para funcionar perfeitamente com assistentes de IA para ajudar você a organizar o trabalho do seu projeto. O caso de uso mais poderoso é fazer a IA ler especificações e criar automaticamente um backlog estruturado.

Basta pedir ao seu assistente de IA:

Read the spec and create a backlog for features not completed.

O assistente de IA irá:

Ler e analisar o documento de especificação
Identificar recursos e componentes principais
Criar issues para as principais áreas funcionais
Dividir cada issue em tarefas específicas
Organizar tudo em um backlog estruturado