mcp-memory-taskmanager/README.md

Intelligent MCP Memory System with Task Manager - Domain-specific knowledge organization and autonomous task management for AI assistants

# 🧠 MCP Memory System - Componentized Knowledge Management

> **Transforme modelos menores em especialistas através de memória componentizada e pensamento sequencial**

## 🎯 Visão do Projeto

O MCP Memory System revoluciona como agentes de IA aprendem e aplicam conhecimento de programação. Ao invés de um único arquivo de memória extenso, criamos **microinterações especializadas** com **grafos de conhecimento** organizados por domínio, permitindo que até mesmo modelos menores tenham performance de modelos grandes.

### 🔑 Conceitos Fundamentais

- **🧩 Componentização**: Memórias especializadas por domínio (Frontend, Backend, DevOps, etc.)
- **🔄 Microinterações**: Isolamento de informações para especialistas específicos
- **🕸️ Grafos de Conhecimento**: Relações estruturadas entre conceitos e soluções
- **⚡ Otimização para Modelos Menores**: Performance de GPT-4 com modelos como GPT-3.5
- **📈 Aprendizado Contínuo**: Sistema que fica mais inteligente com tentativas e erros
- **🧠 Pensamento Sequencial**: Raciocínio estruturado passo a passo
- **🎯 Task Manager**: Planejamento e execução autônoma de tarefas
- **🔌 Multi-IDE Support**: Funciona com Claude Desktop, Cursor, Windsurf, Trae AI e VS Code

## 🏗️ Arquitetura do Sistema

```
mcp-memory/
├── 📁 memories/                    # Memórias especializadas por domínio
│   ├── 🎨 frontend/
│   │   ├── react.jsonl            # Padrões React específicos
│   │   ├── vue.jsonl               # Padrões Vue específicos
│   │   └── angular.jsonl           # Padrões Angular específicos
│   ├── ⚙️ backend/
│   │   ├── nodejs.jsonl            # Padrões Node.js
│   │   ├── python.jsonl            # Padrões Python
│   │   └── java.jsonl              # Padrões Java
│   ├── 🚀 devops/
│   │   ├── docker.jsonl            # Containerização
│   │   ├── kubernetes.jsonl        # Orquestração
│   │   └── ci-cd.jsonl             # Pipelines CI/CD
│   ├── 📱 mobile/
│   ├── 🗄️ database/
│   ├── 🔒 security/
│   ├── 🧪 testing/
│   ├── 🏛️ architecture/
│   ├── 🎨 ui-design/
│   └── 👥 ux-design/
├── 🛠️ tools/                       # Ferramentas MCP
│   ├── memory-operations.js        # Operações de memória
│   ├── sequential-thinking.js      # Pensamento sequencial
│   └── knowledge-graph.js          # Grafos de conhecimento
├── 📋 prompts/                     # Instruções do agente
│   ├── AgentInstructions.md        # Instruções principais
│   ├── UserHulls.md               # Configurações do usuário
│   ├── ProjectHulls.md            # Configurações do projeto
│   └── DomainSpecificInstructions.md
├── ⚙️ mcp-config.json              # Configuração MCP completa
└── 📖 README.md                    # Este arquivo
```

## 🚀 Instalação Rápida

### Via NPX (Recomendado)
```bash
# Instalação global do sistema
npm install -g @gabriel/mcp-memory-taskmanager

# Ou instalação direta via NPX
npx @gabriel/mcp-memory-taskmanager
```

### Configuração Manual

1. **Clone o repositório**:
```bash
git clone https://github.com/gabriel/mcp-memory-taskmanager.git
cd mcp-memory-taskmanager
```

2. **Configure seu IDE**:

#### 🎯 Cursor
```bash
# Copie a configuração para Cursor
cp mcp-config.json ~/.cursor/mcp.json
```

#### 🌊 Windsurf
```bash
# Copie a configuração para Windsurf
cp mcp-config.json ~/.windsurf/mcp.json
```

#### 💻 VS Code
```bash
# Crie configuração no workspace
mkdir -p .vscode
cp mcp-config.json .vscode/mcp.json
```

#### 🤖 Claude Desktop
```bash
# Configure Claude Desktop
cp mcp-config.json ~/.config/claude/claude_desktop_config.json
```

3. **Reinicie seu IDE** para carregar os servidores MCP

## 🎮 Como Usar

### 🔄 Fluxo de Trabalho Básico

1. **📥 Recebimento da Tarefa**: Agente recebe uma tarefa de programação
2. **🧠 Pensamento Sequencial**: Quebra o problema em etapas estruturadas
3. **🔍 Consulta de Memória**: Busca conhecimento nos domínios relevantes
4. **⚡ Aplicação Especializada**: Aplica padrões e melhores práticas específicas
5. **🛠️ Implementação**: Executa a solução otimizada
6. **📚 Aprendizado**: Armazena novos padrões e resultados
7. **🔗 Conexões**: Cria relações cross-domain quando aplicável

### 💡 Exemplo Prático

**Tarefa**: "Criar um dashboard React com dados em tempo real"

```mermaid
graph TD
    A[Tarefa Recebida] --> B[Pensamento Sequencial]
    B --> C[Consulta Frontend Memory]
    B --> D[Consulta Backend Memory]
    B --> E[Consulta UI Design Memory]
    C --> F[Padrões React + WebSocket]
    D --> G[APIs Real-time + Node.js]
    E --> H[Dashboard Design Patterns]
    F --> I[Implementação Otimizada]
    G --> I
    H --> I
    I --> J[Armazenar Aprendizado]
    J --> K[Conectar Domínios]
```

## ⚙️ Configuração Completa

### 🎯 Trae AI

Adicione à sua configuração MCP do Trae AI:

```json
{
  "mcpServers": {
    "specialized-memory": {
      "command": "npx",
      "args": ["-y", "@gabriel/mcp-memory-taskmanager"],
      "env": {
        "MEMORY_FILE_PATH": "C:\\Users\\your-username\\Desktop\\memory\\memory.json",
        "TASK_MANAGER_FILE_PATH": "C:\\Users\\your-username\\Desktop\\tasks\\tasks.json",
        "ENABLE_BACKUP": "true",
        "MAX_MEMORY_SIZE": "10000",
        "ENABLE_DOMAIN_SPECIALIZATION": "true",
        "ENABLE_KNOWLEDGE_GRAPHS": "true"
      }
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  },
  "globalSettings": {
    "memoryIntegration": {
      "enableCrossDomainConnections": true,
      "autoStorePatterns": true,
      "learningMode": "continuous"
    },
    "sequentialThinking": {
      "enableStructuredReasoning": true,
      "maxThoughts": 10,
      "enableReflection": true
    },
    "performanceOptimization": {
      "enableContextCompression": true,
      "prioritizeRelevantMemories": true,
      "cacheFrequentPatterns": true
    }
  }
}
```

### 🤖 Claude Desktop

Adicione ao seu `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "specialized-memory": {
      "command": "npx",
      "args": ["-y", "@gabriel/mcp-memory-taskmanager"],
      "env": {
        "MEMORY_FILE_PATH": "/path/to/memory.json",
        "TASK_MANAGER_FILE_PATH": "/path/to/tasks.json",
        "ENABLE_DOMAIN_SPECIALIZATION": "true"
      }
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}
```

### 🎯 Cursor

Adicione às configurações MCP do Cursor:

```json
{
  "mcpServers": {
    "specialized-memory": {
      "command": "npx",
      "args": ["-y", "@gabriel/mcp-memory-taskmanager"]
    },
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}
```

## 🧩 Domínios Especializados

### 🎨 Frontend Development
- **Tecnologias**: React, Vue, Angular, Svelte, Next.js
- **Padrões**: Componentes, Hooks, Estado, Performance, Acessibilidade
- **Memória**: Soluções específicas por framework e padrão

### ⚙️ Backend Development
- **Tecnologias**: Node.js, Python, Java, C#, Go, Rust
- **Padrões**: APIs, Bancos de Dados, Arquitetura, Segurança
- **Memória**: Implementações otimizadas por linguagem

### 🚀 DevOps & Infrastructure
- **Tecnologias**: Docker, Kubernetes, Terraform, AWS, Azure
- **Padrões**: CI/CD, Monitoramento, Segurança, Escalabilidade
- **Memória**: Configurações e pipelines testados

### 📱 Mobile Development
- **Tecnologias**: React Native, Flutter, Swift, Kotlin
- **Padrões**: Performance, UX, Integração, Offline
- **Memória**: Soluções específicas por plataforma

### 🗄️ Database
- **Tecnologias**: PostgreSQL, MongoDB, Redis, Elasticsearch
- **Padrões**: Schema, Otimização, Escalabilidade, Backup
- **Memória**: Designs e queries otimizados

### 🔒 Security
- **Tecnologias**: OAuth2, JWT, Encryption, Compliance
- **Padrões**: Autenticação, Autorização, Proteção de Dados
- **Memória**: Implementações seguras validadas

### 🧪 Testing
- **Tecnologias**: Jest, Cypress, Playwright, k6
- **Padrões**: Unit, Integration, E2E, Performance
- **Memória**: Estratégias de teste por cenário

### 🏛️ Architecture
- **Padrões**: Microservices, Clean Architecture, DDD
- **Conceitos**: Escalabilidade, Resiliência, Performance
- **Memória**: Decisões arquiteturais documentadas

### 🎨 UI Design
- **Ferramentas**: Figma, Design Systems, Component Libraries
- **Padrões**: Responsive, Accessibility, Typography
- **Memória**: Padrões visuais e componentes

### 👥 UX Design
- **Métodos**: User Research, Usability Testing, A/B Testing
- **Padrões**: User Journey, Information Architecture
- **Memória**: Insights de usuário e otimizações

## ⚡ Otimizações para Modelos Menores

### 🎯 Estratégias Implementadas

1. **📦 Compressão de Contexto**
   - Redução inteligente do tamanho do contexto
   - Priorização de informações relevantes
   - Cache de padrões frequentes

2. **🔍 Busca Semântica**
   - Recuperação eficiente de conhecimento
   - Matching por similaridade
   - Ranking por relevância

3. **🧠 Memória Estruturada**
   - Organização hierárquica
   - Relações explícitas
   - Contexto especializado

4. **📈 Aprendizado Incremental**
   - Melhoria contínua
   - Feedback loops
   - Adaptação automática

### 📊 Resultados Esperados

| Métrica | Modelo Padrão | Com MCP Memory | Melhoria |
|---------|---------------|----------------|----------|
| Qualidade do Código | 70% | 90% | +20% |
| Tempo de Resposta | 5s | 2s | -60% |
| Precisão de Sugestões | 60% | 85% | +25% |
| Redução de Erros | - | - | -60% |
| Produtividade | 100% | 140% | +40% |

## 🔧 Variáveis de Ambiente

- `MEMORY_FILE_PATH`: Caminho para dados de memória (padrão: `./memory/memory.json`)
- `TASK_MANAGER_FILE_PATH`: Caminho para dados de tarefas (padrão: `./tasks/tasks.json`)
- `ENABLE_BACKUP`: Habilitar backups automáticos (padrão: `false`)
- `MAX_MEMORY_SIZE`: Número máximo de memórias (padrão: `10000`)
- `ENABLE_DOMAIN_SPECIALIZATION`: Habilitar especialização por domínio (padrão: `true`)
- `ENABLE_KNOWLEDGE_GRAPHS`: Habilitar grafos de conhecimento (padrão: `true`)
- `ENABLE_CROSS_DOMAIN_CONNECTIONS`: Habilitar conexões entre domínios (padrão: `true`)
- `LEARNING_MODE`: Modo de aprendizado (`continuous`, `batch`, `manual`) (padrão: `continuous`)

## Available Tools

### Memory System

#### `store_memory`
Store information with domain classification.

**Parameters:**
- `content` (string): The information to store
- `domain` (string): Domain classification (coding, personal, work, etc.)
- `tags` (array): Tags for categorization
- `importance` (number): Importance level (1-10)

#### `search_memory`
Search stored memories by content, domain, or tags.

**Parameters:**
- `query` (string): Search query
- `domain` (string): Filter by domain
- `tags` (array): Filter by tags
- `limit` (number): Maximum number of results

### Task Manager

#### `request_planning`
Register a new user request and plan its associated tasks.

**Parameters:**
- `originalRequest` (string): The original user request
- `splitDetails` (string): Details about how the request was split
- `tasks` (array): Array of task objects with title and description

#### `get_next_task`
Get the next pending task for a request.

**Parameters:**
- `requestId` (string): The request ID

#### `mark_task_done`
Mark a task as completed.

**Parameters:**
- `requestId` (string): The request ID
- `taskId` (string): The task ID
- `completedDetails` (string): Details about task completion

#### `approve_task_completion`
Approve a completed task.

**Parameters:**
- `requestId` (string): The request ID
- `taskId` (string): The task ID

#### `approve_request_completion`
Approve the completion of an entire request.

**Parameters:**
- `requestId` (string): The request ID

## 💡 Exemplos de Uso

### 🧠 Armazenamento de Memória Especializada

```typescript
// Armazenar padrão React específico
store_memory({
  content: "Use React.memo para otimização de componentes quando props não mudam frequentemente. Combine com useMemo e useCallback para máxima eficiência.",
  domain: "frontend",
  subdomain: "react",
  tags: ["react", "optimization", "performance", "memo", "hooks"],
  importance: 9,
  pattern_type: "component_optimization",
  code_example: `const OptimizedComponent = React.memo(({ data, onAction }) => {
  const memoizedValue = useMemo(() => expensiveCalculation(data), [data]);
  const memoizedCallback = useCallback(() => onAction(data.id), [onAction, data.id]);
  
  return <div>{memoizedValue}</div>;
});`,
  related_concepts: ["useMemo", "useCallback", "performance", "re-rendering"]
});

// Armazenar padrão de API Backend
store_memory({
  content: "Implementação de rate limiting com Redis para APIs Node.js usando express-rate-limit",
  domain: "backend",
  subdomain: "nodejs",
  tags: ["nodejs", "api", "rate-limiting", "redis", "security"],
  importance: 8,
  pattern_type: "api_security",
  code_example: `const rateLimit = require('express-rate-limit');
const RedisStore = require('rate-limit-redis');

const limiter = rateLimit({
  store: new RedisStore({ client: redisClient }),
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP'
});

app.use('/api/', limiter);`,
  related_concepts: ["security", "scalability", "redis", "middleware"]
});
```

### 🔍 Busca Inteligente por Domínio

```typescript
// Buscar padrões React específicos
search_memory({
  query: "React component optimization performance",
  domain: "frontend",
  subdomain: "react",
  tags: ["optimization", "performance"],
  pattern_type: "component_optimization",
  limit: 5,
  include_related: true
});

// Buscar padrões de segurança para APIs
search_memory({
  query: "API security authentication JWT",
  domain: "backend",
  tags: ["security", "authentication"],
  pattern_type: "api_security",
  limit: 3,
  cross_domain_search: true // Buscar também em domínio security
});
```

### 🎯 Planejamento de Tarefas com Pensamento Sequencial

```typescript
// Planejar desenvolvimento de dashboard complexo
request_planning({
  originalRequest: "Criar dashboard React com dados em tempo real, autenticação JWT e testes automatizados",
  splitDetails: "Quebrar em fases: arquitetura, frontend, backend, integração, testes e deploy",
  domains_involved: ["frontend", "backend", "security", "testing", "devops"],
  tasks: [
    {
      title: "Arquitetura e Design System",
      description: "Definir arquitetura, componentes base e design system",
      domain: "architecture",
      estimated_complexity: 7,
      dependencies: []
    },
    {
      title: "Componentes React Base",
      description: "Criar componentes reutilizáveis com TypeScript",
      domain: "frontend",
      estimated_complexity: 6,
      dependencies: ["architecture"]
    },
    {
      title: "API Backend com WebSocket",
      description: "Implementar APIs REST e WebSocket para dados real-time",
      domain: "backend",
      estimated_complexity: 8,
      dependencies: ["architecture"]
    },
    {
      title: "Sistema de Autenticação JWT",
      description: "Implementar auth completo com refresh tokens",
      domain: "security",
      estimated_complexity: 7,
      dependencies: ["backend"]
    },
    {
      title: "Testes Automatizados",
      description: "Unit, integration e E2E tests",
      domain: "testing",
      estimated_complexity: 6,
      dependencies: ["frontend", "backend", "security"]
    },
    {
      title: "CI/CD e Deploy",
      description: "Pipeline automatizado com Docker e Kubernetes",
      domain: "devops",
      estimated_complexity: 5,
      dependencies: ["testing"]
    }
  ],
  learning_objectives: [
    "Padrões de real-time data com WebSocket",
    "Otimização de performance React",
    "Estratégias de teste para aplicações real-time",
    "Deploy de aplicações com WebSocket"
  ]
});
```

### 🔗 Conexões Cross-Domain

```typescript
// Criar conexão entre padrões Frontend e Backend
create_cross_domain_connection({
  source_domain: "frontend",
  target_domain: "backend",
  connection_type: "api_integration",
  pattern_relationship: {
    frontend_pattern: "react_data_fetching",
    backend_pattern: "rest_api_design",
    integration_notes: "Usar React Query para cache e sincronização com APIs REST"
  },
  shared_concepts: ["error_handling", "loading_states", "data_validation"]
});
```

## Development

### Building from Source

```bash
git clone https://github.com/gabriel/mcp-memory-taskmanager.git
cd mcp-memory-taskmanager
npm install
npm run build
```

### Running in Development Mode

```bash
npm run dev
```

### Testing

```bash
npm test
```

### Using MCP Inspector

```bash
npm run inspector
```

## 📁 Estrutura de Arquivos

```
mcp-memory-taskmanager/
├── 📂 src/
│   ├── index.ts                    # Implementação principal do servidor MCP
│   ├── memory-operations.ts        # Operações de memória especializadas
│   ├── sequential-thinking.ts      # Integração pensamento sequencial
│   ├── knowledge-graph.ts          # Sistema de grafos de conhecimento
│   ├── domain-specialists/         # Especialistas por domínio
│   │   ├── frontend-specialist.ts
│   │   ├── backend-specialist.ts
│   │   ├── devops-specialist.ts
│   │   └── ...
│   └── utils/
│       ├── compression.ts          # Compressão de contexto
│       ├── semantic-search.ts      # Busca semântica
│       └── pattern-matching.ts     # Matching de padrões
├── 📂 dist/                        # JavaScript compilado
├── 📂 prompts/                     # Configurações do agente
│   ├── AgentInstructions.md        # Instruções principais
│   ├── UserHulls.md               # Configurações do usuário
│   ├── ProjectHulls.md            # Configurações do projeto
│   └── DomainSpecificInstructions.md
├── 📂 memories/                    # Armazenamento de memórias
│   ├── 🎨 frontend/
│   │   ├── react.jsonl
│   │   ├── vue.jsonl
│   │   └── angular.jsonl
│   ├── ⚙️ backend/
│   │   ├── nodejs.jsonl
│   │   ├── python.jsonl
│   │   └── java.jsonl
│   ├── 🚀 devops/
│   ├── 📱 mobile/
│   ├── 🗄️ database/
│   ├── 🔒 security/
│   ├── 🧪 testing/
│   ├── 🏛️ architecture/
│   ├── 🎨 ui-design/
│   └── 👥 ux-design/
├── 📂 knowledge-graphs/            # Grafos de conhecimento
│   ├── domain-relationships.json
│   ├── pattern-connections.json
│   └── cross-domain-links.json
├── 📂 tasks/                       # Gerenciamento de tarefas
│   └── tasks.json
├── 📂 configs/                     # Configurações
│   ├── mcp-config.json
│   ├── domain-config.json
│   └── optimization-config.json
├── 📂 docs/                        # Documentação
│   ├── installation.md
│   ├── domain-guides/
│   └── api-reference.md
├── package.json
├── tsconfig.json
└── README.md
```

## 📈 Métricas e Monitoramento

### 🎯 KPIs de Sucesso

- **Componentização**: 90% das memórias organizadas por domínio
- **Microinterações**: 100% das operações usam memória especializada
- **Aprendizado Contínuo**: Melhoria mensurável na qualidade
- **Otimização**: Modelos menores atingem 80% da performance de modelos grandes
- **Integração**: 100% compatibilidade com IDEs principais

### 📊 Métricas Técnicas

- ⚡ Tempo de resposta < 2s para consultas
- 🎯 Taxa de acerto > 85% em sugestões
- 🔄 Redução de 60% em erros repetitivos
- 📈 Aumento de 40% na produtividade

## 🛠️ Desenvolvimento e Contribuição

### 🚀 Roadmap

#### Fase 1: Infraestrutura Base ✅
- [x] Sistema de memória componentizado
- [x] Integração MCP Sequential Thinking
- [x] Configurações especializadas
- [x] Documentação completa

#### Fase 2: Grafos de Conhecimento 🔄
- [ ] Implementação de grafos especializados
- [ ] Sistema de aprendizado contínuo
- [ ] Métricas de performance
- [ ] Otimizações para modelos menores

#### Fase 3: Distribuição e Escala 📋
- [ ] Package NPX
- [ ] Testes de integração
- [ ] CI/CD pipeline
- [ ] Documentação interativa

### 🤝 Como Contribuir

1. **Fork** o repositório
2. **Crie** uma branch para sua feature
3. **Implemente** suas mudanças
4. **Teste** com diferentes IDEs
5. **Submeta** um Pull Request

### 🧪 Testes

```bash
# Testes unitários
npm test

# Testes de integração
npm run test:integration

# Testes com IDEs
npm run test:ide

# Testes de performance
npm run test:performance

# Testes de domínios especializados
npm run test:domains

# Testes de grafos de conhecimento
npm run test:knowledge-graphs
```

## 📚 Documentação Adicional

- 📖 [Guia de Instalação Detalhado](./docs/installation.md)
- 🎯 [Configuração por IDE](./docs/ide-setup.md)
- 🧠 [Guia de Pensamento Sequencial](./docs/sequential-thinking.md)
- 🔧 [API de Memória](./docs/memory-api.md)
- 🎨 [Padrões por Domínio](./docs/domain-patterns.md)
- 📊 [Métricas e Monitoramento](./docs/metrics.md)
- 🕸️ [Grafos de Conhecimento](./docs/knowledge-graphs.md)
- ⚡ [Otimização para Modelos Menores](./docs/model-optimization.md)

## 🆘 Suporte

### 🐛 Reportar Bugs
- **GitHub Issues**: [Criar novo issue](https://github.com/gabriel/mcp-memory-taskmanager/issues)
- **Template**: Use o template de bug report
- **Logs**: Inclua logs relevantes

### 💡 Solicitar Features
- **GitHub Discussions**: [Iniciar discussão](https://github.com/gabriel/mcp-memory-taskmanager/discussions)
- **RFC**: Para mudanças grandes, crie um RFC

### 📞 Contato
- **Email**: support@mcp-memory-system.com
- **Discord**: [Servidor da Comunidade](https://discord.gg/mcp-memory)
- **Twitter**: [@MCPMemorySystem](https://twitter.com/MCPMemorySystem)

## 📄 Licença

Este projeto está licenciado sob a **MIT License** - veja o arquivo [LICENSE](LICENSE) para detalhes.

## 🙏 Agradecimentos

- **Anthropic** pelo protocolo MCP e Sequential Thinking
- **Comunidade MCP** pelas ferramentas e inspiração
- **Desenvolvedores** que contribuíram com feedback e testes
- **IDEs** que suportam o protocolo MCP

---

**🚀 Transforme seu agente de IA em um especialista em programação com o MCP Memory System!**

*Feito com ❤️ para a comunidade de desenvolvedores*