🧠 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)

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

git clone https://github.com/gabriel/mcp-memory-taskmanager.git
cd mcp-memory-taskmanager

2. Configure seu IDE:

🎯 Cursor

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

🌊 Windsurf

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

💻 VS Code

# Crie configuração no workspace
mkdir -p .vscode
cp mcp-config.json .vscode/mcp.json

🤖 Claude Desktop

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

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:

{
  "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:

{
  "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:

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

🔧 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

// 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

// 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

// 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

// 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

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

Running in Development Mode

npm run dev

Testing

npm test

Using MCP Inspector

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 ✅

• Sistema de memória componentizado
• Integração MCP Sequential Thinking
• Configurações especializadas
• 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

# 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
• 🎯 Configuração por IDE
• 🧠 Guia de Pensamento Sequencial
• 🔧 API de Memória
• 🎨 Padrões por Domínio
• 📊 Métricas e Monitoramento
• 🕸️ Grafos de Conhecimento
• ⚡ Otimização para Modelos Menores

🆘 Suporte

🐛 Reportar Bugs

• GitHub Issues: Criar novo issue
• Template: Use o template de bug report
• Logs: Inclua logs relevantes

💡 Solicitar Features

• GitHub Discussions: Iniciar discussão
• RFC: Para mudanças grandes, crie um RFC

📞 Contato

• Email: support@mcp-memory-system.com
• Discord: Servidor da Comunidade
• Twitter: @MCPMemorySystem

📄 Licença

Este projeto está licenciado sob a MIT License - veja o arquivo 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