myAI Memory Sync

Sincroniza modelos de memória entre diferentes interfaces do Claude.

GitHub
7
Experimente este MCPPatrocinado

Documentação

myAI Memory Sync

smithery badge

Cansado de repetir para o Claude toda vez que você inicia um novo chat? O myAI Memory Sync é uma ferramenta MCP revolucionária que sincroniza perfeitamente suas preferências, detalhes pessoais e padrões de código em TODAS as suas interfaces Claude! Atualize apenas uma vez e suas alterações aparecem instantaneamente em todos os lugares - do Claude Desktop ao Claude Code, Windsurf e Claude.ai web. Com nosso sistema de cache de ponta, consultas relacionadas à memória são até 2000x mais rápidas! Pare de desperdiçar tokens com instruções repetitivas e aproveite uma experiência de IA verdadeiramente personalizada.

Como o myAImemory-mcp se Compara a Outras Ferramentas de Memória

Embora existam várias ferramentas de memória excelentes para sistemas de IA, o myAImemory-mcp atende a um propósito específico como ferramenta de Model Context Protocol (MCP):

FerramentaFoco PrincipalModelo de PrivacidadeIntegraçãoDiferencial
myAImemory-mcpPreferências do usuário em interfaces ClaudeLocal-first, sem envio de dados para servidores externosMCP específico para ClaudeSincronização multiplataforma com cache de alto desempenho
GraphitiGrafos de conhecimento temporaisDependente de banco de dadosFramework geral de agentesConsciência temporal na representação de conhecimento
Letta/MemGPTFramework de agente com estadoBaseado em servidorSuporte a múltiplos modelosArquitetura completa de agente
Mem0Interações de IA personalizadasBaseado em APIMultiplataformaHierarquia de memória em múltiplos níveis
MemaryMemória semelhante à humana para agentesBanco de dados em grafoFocado em agentesEmulação de memória humana
CogneeMemória confiável para aplicativos de IAMúltiplas opções de armazenamentoFocado em pipeline de dadosIntegração extensiva de fontes de dados

Principais Vantagens do myAImemory-mcp:

  • Privacidade em Primeiro Lugar: Todos os dados permanecem no seu dispositivo, nenhuma informação pessoal é enviada para servidores externos
  • Desempenho: Aproveita os recursos de cache do Claude para melhorias dramáticas de velocidade
  • Simplicidade: Atualizações em linguagem natural das suas preferências em todas as interfaces Claude
  • Integração MCP: Projetado especificamente como um MCP do Claude para integração perfeita

🚀 Início Rápido

# Clone repository
git clone https://github.com/Jktfe/myaimemory-mcp.git
cd myaimemory-mcp

# Install dependencies
npm install

# Build TypeScript code
npm run build

# Start MCP server (with stdio transport)
npm start

# Or start with HTTP transport
npm run start:http

🧠 Opções do Servidor

O script de servidor unificado suporta múltiplas opções:

# Start with stdio transport (default)
./start-server.sh

# Start with HTTP transport
./start-server.sh --http

# Start with HTTP transport on custom port
./start-server.sh --http --port=8080

# Start with direct implementation (no SDK)
./start-server.sh --direct

# Start with direct implementation and HTTP transport
./start-server.sh --direct --http

# Enable debug mode
./start-server.sh --debug

🔄 Método de Sincronização Direta (Alternativa Simples)

Para uma abordagem mais simples que não requer executar um servidor MCP, você pode usar o CLI unificado:

# One-time sync of all memory files
npm run sync

# Or for emergency sync (fixes permissions)
npm run sync:emergency

Este script irá:

  • Ler do seu arquivo "myAI Master.md"
  • Atualizar todos os arquivos CLAUDE.md nos seus projetos
  • Atualizar suas configurações de memória do Windsurf
  • Tudo sem armazenar informações sensíveis no repositório git

🔒 Privacidade e Segurança

  • O arquivo "myAI Master.md" com suas informações pessoais é excluído do rastreamento do git
  • Todos os arquivos CLAUDE.md também são excluídos para proteger sua privacidade
  • Use o .gitignore incluído para garantir que arquivos sensíveis permaneçam privados

🗣️ Comandos de Linguagem Natural Suportados

Você pode interagir com o myAI Memory usando estes padrões de linguagem natural:

Padrão de ComandoExemploFinalidade
Use myAI Memory to remember [information]"Use myAI Memory para lembrar que prefiro TypeScript em vez de JavaScript"Adiciona informações à seção apropriada com base no conteúdo
Remember that [information]"Lembre-se de que moro em Londres"Alternativa mais curta para adicionar informações à memória
Add to my memory that [information]"Adicione à minha memória que tenho dois carros"Outra forma de adicionar informações à memória
Use myAI Memory to add to [section] [information]"Use myAI Memory para adicionar em Preferências de Codificação que prefiro modo escuro"Adiciona informações a uma seção específica
Update my [section] to include that [information]"Atualize minhas Informações de Usuário para incluir que meu aniversário é 29 de março"Atualiza uma seção específica com novas informações

Nota: Para realizar uma sincronização completa em todas as plataformas, use a linha de comando: node sync-memory.js

You: Use myAI Memory to remember I prefer TypeScript over JavaScript
Claude: ✅ Added to your Coding Preferences! I'll remember you prefer TypeScript over JavaScript.

📋 Opções de Instalação

Opção 1: Instalação Direta (Recomendada)

Instale a partir do npm:

npm install -g myai-memory-sync

Inicie o servidor:

# Start with stdio transport (default)
myai

# Start with HTTP transport
myai server --transport http

# Process memory commands
myai remember "I prefer dark mode"

# Sync across platforms
myai sync

Opção 2: Executar a partir do Código Fonte

Clone e compile a partir do código fonte:

git clone https://github.com/Jktfe/myaimemory-mcp.git
cd myaimemory-mcp
npm install
npm run build
npm start  # Start with stdio transport
# or
npm run start:http  # Start with HTTP transport

Opção 3: Docker

Compile e execute com Docker:

docker build -t myai-memory-sync .
docker run -v myai-memory:/app/data -p 3000:3000 myai-memory-sync

🔌 Configuração MCP

Configuração do Claude Desktop

Adicione isto ao seu claude_desktop_config.json:

{
  "mcpServers": {
    "myai-memory-sync": {
      "command": "npx",
      "args": [
        "-y",
        "myai"
      ],
      "env": {
        "TEMPLATE_PATH": "/path/to/custom/template.md",
        "ENABLE_ANTHROPIC": "true",
        "ANTHROPIC_API_KEY": "your-api-key-here"
      }
    }
  }
}

Claude.ai com Smithery

  1. Visite Smithery.ai
  2. Adicione o MCP myAI Memory Sync: 
    @Jktfe/myaimemory-mcp
  3. Configure com sua chave de API nas configurações do Smithery

Integração com Windsurf

No Windsurf, adicione ao seu .codeium/config.json:

{
  "mcp": {
    "servers": {
      "myai-memory-sync": {
        "command": "npx",
        "args": [
          "-y",
          "myai"
        ]
      }
    }
  }
}

Modo de Servidor HTTP

Para transporte HTTP em vez de stdio:

# Using npm scripts:
npm run start:http

# Using the unified CLI:
myai server --transport http

# Using the shell script with custom port:
./start-server.sh --http --port=8080

# Using environment variable:
PORT=8080 npm run start:http

Variáveis de Ambiente

Crie um arquivo .env com as seguintes opções:

# Basic configuration
DEBUG=true                      # Enable debug logging
TEMPLATE_PATH=./data/template.md  # Custom template location
PORT=3000                       # Port for HTTP transport (default: 3000)
USE_DIRECT=true                 # Use direct implementation (no SDK)

# Platform-specific paths
WINDSURF_MEMORY_PATH=~/.codeium/windsurf/memories/global_rules.md
CLAUDE_PROJECTS_PATH=~/CascadeProjects

# Performance optimization
ENABLE_ANTHROPIC=true           # Enable Anthropic API integration
ANTHROPIC_API_KEY=your-api-key  # Your Anthropic API key
ENABLE_PROMPT_CACHE=true        # Enable prompt caching system
CACHE_TTL=300000                # Cache TTL in milliseconds (5 minutes)

# Claude web sync (optional)
CLAUDE_WEB_SYNC_ENABLED=false   # Enable Claude.ai web synchronization
CLAUDE_WEB_EMAIL=you@email.com  # Your Claude.ai email
CLAUDE_WEB_HEADLESS=true        # Run browser in headless mode

🧙‍♂️ Integração com o System Prompt

Para melhores resultados, adicione isto ao seu system prompt do Claude:

Memory Integration Instructions:
When you receive a command that starts with "use myAI Memory to", you should:

1. Process the rest of the instruction as a memory management command
2. Try to determine the appropriate section to update based on the content
3. Use the myAI Memory Sync MCP to update your memory
4. Confirm the update with a brief acknowledgment

For example:
"use myAI Memory to remember I prefer dark mode" 
→ Update the preferences section with dark mode preference

When asked questions about preferences or personal information, first check your memory via the myAI Memory Sync MCP. Always reference information from memory rather than making assumptions.

✨ Recursos

  • 🔄 Sincronização Multiplataforma: Atualize uma vez, sincroniza em todos os lugares
  • ⚡ Recuperação Rápida como um Raio: Sistema de cache com até 2000x de aumento de desempenho
  • 🗣️ Interface de Linguagem Natural: Basta falar naturalmente para atualizar suas preferências
  • 🧩 Múltiplos Perfis de Persona: Alterne entre diferentes predefinições com facilidade
  • 🔐 Foco em Segurança: Armazenamento local com proteção .gitignore
  • 🛠️ Amigável para Desenvolvedores: Implementação completa em TypeScript com API abrangente

🧩 Arquitetura Principal

O myAI Memory Sync usa uma arquitetura modular com estes componentes principais:

  • Parser de Template: Conversão bidirecional entre objetos de memória estruturados e markdown
  • Armazenamento de Template: Armazenamento persistente com cache em memória e sistema de arquivos
  • Sincronizadores de Plataforma: Implementa a interface PlatformSyncer para cada plataforma alvo
  • Processador de Linguagem Natural: Extrai dados estruturados de comandos de memória em linguagem natural
  • Serviço de Cache de Memória: Otimiza o desempenho com estratégias de cache em múltiplos níveis

🔍 Recursos Detalhados

Sincronização Multiplataforma

  • ClaudeCodeSyncer: Atualiza arquivos CLAUDE.md em todos os repositórios
  • WindsurfSyncer: Gerencia global_rules.md no ambiente Windsurf
  • ClaudeWebSyncer: Sincronização opcional baseada em Puppeteer com a interface web do Claude.ai

Gerenciamento Inteligente de Memória

  • Extração Baseada em Padrões: Converte linguagem natural em pares chave-valor estruturados
  • Algoritmo de Detecção de Seção: Determina automaticamente a seção apropriada para novas memórias
  • Formato de Template de Memória: Estrutura baseada em Markdown com seções, descrições e itens chave-valor
  • Preservação de Contexto: Atualiza seções de memória preservando outro conteúdo do template

Otimização de Desempenho

  • Cache em Múltiplos Níveis: Cache em memória nos níveis de template e seção
  • Gerenciamento de Cache Baseado em TTL: Time-To-Live configurável para conteúdo em cache
  • Pré-Aquecimento: Pré-população do cache após atualizações de template
  • Integração Opcional com a API Anthropic: Acelera consultas relacionadas à memória em até 2000x

Segurança

  • Arquitetura Local-First: Todos os dados permanecem no seu dispositivo
  • Gerenciamento de Gitignore: Adiciona automaticamente CLAUDE.md ao .gitignore em todos os repositórios
  • Tratamento de Permissões de Arquivo: Corrige problemas de permissões para máxima compatibilidade
  • Armazenamento Criptografado: Compatível com sistemas de arquivos criptografados

📋 Formato do Template de Memória

O sistema usa um formato markdown estruturado para organizar suas preferências:

# myAI Memory

# User Information
## Use this information if you need to reference them directly
-~- Name: Your Name
-~- Location: Your Location
-~- Likes: Reading, Hiking, Technology

# General Response Style
## Use this in every response
-~- Style: Friendly and concise
-~- Use UK English Spellings: true
-~- Include emojis when appropriate: true

# Coding Preferences
## General Preference when responding to coding questions
-~- I prefer TypeScript over JavaScript
-~- Show step-by-step explanations

🛠️ Implementação Técnica

Esquema MemoryTemplate

interface MemoryTemplate {
  sections: TemplateSection[];
}

interface TemplateSection {
  title: string;
  description: string;
  items: TemplateItem[];
}

interface TemplateItem {
  key: string;
  value: string;
}

Interface de Sincronização de Plataforma

interface PlatformSyncer {
  sync(templateContent: string): Promise<SyncStatus>;
}

type PlatformType = 'claude-web' | 'claude-code' | 'windsurf' | 'master';

interface SyncStatus {
  platform: PlatformType;
  success: boolean;
  message: string;
}

🔌 API de Integração MCP

A ferramenta myAI Memory Sync implementa o Model Context Protocol (MCP) com as seguintes funções:

FunçãoDescriçãoParâmetros
get_templateRecupera o template de memória completoNenhum
get_sectionRecupera uma seção específicasectionName: string
update_sectionAtualiza uma seção específicasectionName: string, content: string
update_templateSubstitui o template inteirocontent: string
list_presetsLista predefinições disponíveisNenhum
load_presetCarrega uma predefinição específicapresetName: string
create_presetCria uma nova predefiniçãopresetName: string
sync_platformsSincroniza entre plataformasplatform?: string
list_platformsLista plataformas disponíveisNenhum

Interface de Linguagem Natural

Os usuários podem interagir com o sistema por meio de comandos em linguagem natural:

You: Use myAI Memory to remember I prefer TypeScript over JavaScript
Claude: ✅ Added to your Coding Preferences! I'll remember you prefer TypeScript over JavaScript.

You: Use myAI Memory to load preset developer
Claude: ✅ Loaded developer preset! I'll now use your developer preferences.

🧙‍♂️ Uso Avançado

Predefinições de Memória

Alterne entre diferentes personas facilmente:

You: Use myAI Memory to list presets
Claude: Available presets: personal, work, developer

You: Use myAI Memory to load preset developer
Claude: ✅ Loaded developer preset!

Sincronização de Emergência

Quando você precisar corrigir problemas de sincronização em todas as plataformas:

# Sync everything immediately
./emergency-sync.sh

Interface de Linha de Comando

# View all available commands
node dist/cli.js --help

# Process memory commands directly
node dist/cli.js --remember "remember I prefer dark mode"

# Start HTTP server for SSE transport
npm run start:http

# Start stdio server for MCP transport
npm run start

Fluxo de Trabalho de Desenvolvimento

# Run in development mode with auto-reload
npm run dev

# Run in development mode with HTTP server
npm run dev:http

# Watch TypeScript compilation
npm run build:watch

# Run tests
npm test

# Run specific test
npm test -- -t "platformSync"

# Lint code
npm run lint

# Type check without emitting files
npm run typecheck

⚡ Benchmarks de Desempenho

Nosso sistema de cache oferece melhorias de desempenho incríveis:

OperaçãoSem CacheCom CacheMelhoria
Consulta de Memória~2000ms~1ms2000x
Busca de Seção~1600ms~0.8ms2000x
Parse de Template~120ms~0.1ms1200x
Sincronização de Plataforma~850ms~350ms2.4x

🔒 Segurança e Privacidade

Levamos sua privacidade a sério:

  • Todos os dados permanecem localmente no seu dispositivo
  • Arquivos CLAUDE.md são adicionados automaticamente ao .gitignore
  • Nenhum dado é enviado para servidores externos (exceto ao usar a integração opcional com a API Anthropic)
  • Funciona com sistemas de arquivos criptografados para máxima segurança

🛠️ Solução de Problemas

Problemas Comuns

  1. CLAUDE.md Não Está Atualizando

    • Verifique as permissões de arquivo com ls -la CLAUDE.md
    • Tente a sincronização de emergência com ./emergency-sync.sh
    • Verifique os caminhos de plataforma no seu arquivo .env

  2. Falhas de Conexão MCP

    • Certifique-se de que o servidor MCP está em execução com ps aux | grep myai-memory
    • Verifique os logs do Claude Desktop para erros de MCP
    • Verifique seu arquivo de configuração do Claude Desktop

  3. Problemas de Cache

    • Limpe o cache com node dist/cli.js --clear-cache
    • Verifique se a chave da API Anthropic está configurada corretamente
    • Verifique a integridade do arquivo de memória com node dist/cli.js --validate

  4. Comandos de Linguagem Natural Não Funcionando

    • Certifique-se de usar exatamente um dos padrões de comando suportados (veja a seção Comandos de Linguagem Natural Suportados)
    • Se o Claude não reconhecer seu comando, tente um padrão diferente
    • Para sincronizar em todas as plataformas, use o script direto: node sync-memory.js

Sincronização Manual

Se você estiver enfrentando problemas com comandos de linguagem natural ou com o servidor MCP:

# Direct sync approach (most reliable)
cd /path/to/myAImemory
node sync-memory.js

# Alternative emergency sync (if permissions need fixing)
cd /path/to/myAImemory
./safe-memory.sh sync

Estes métodos leem diretamente do seu arquivo mestre e atualizam todas as plataformas sem depender do servidor MCP ou do processamento de linguagem natural.

Logs e Depuração

Ative o modo de depuração para ver logs detalhados:

DEBUG=true npm run start

Os arquivos de log são armazenados em:

  • Linux/macOS: ~/.local/share/myai-memory/logs/
  • Windows: %APPDATA%\myai-memory\logs\

🤝 Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para enviar um Pull Request.

  1. Faça um fork do repositório
  2. Crie sua branch de recurso (git checkout -b feature/amazing-feature)
  3. Faça commit das suas alterações (git commit -m 'Add some amazing feature')
  4. Envie para a branch (git push origin feature/amazing-feature)
  5. Abra um Pull Request

Seguimos um fluxo de trabalho Git padrão e processo de CI:

  • Todos os PRs exigem testes e linting aprovados
  • Novos recursos devem incluir testes
  • Alterações importantes devem atualizar a documentação
  • Siga o estilo e os padrões de código existentes

📚 Documentação

Para documentação mais detalhada, consulte a Wiki.

A documentação da API está disponível no diretório /docs:

# Generate API documentation
npm run docs

📄 Licença

Este projeto é licenciado sob a Licença MIT - consulte o arquivo LICENSE para obter detalhes.

📬 Contato

Link do Projeto: https://github.com/Jktfe/myaimemory-mcp

Feito com ❤️ para a comunidade de IA