I've built something that's been missing from AI assistants: a real, persistent, intelligent memory across all your conversations and projects, with proactive suggestions based on context.

  What Is It?

  MCP Memory is a Model Context Protocol (MCP) server that transforms any AI assistant into a learning companion that remembers everything, recognizes patterns, and proactively suggests relevant context from your history.

  Think of it as giving your AI assistant the equivalent of human episodic memory - but better. The MCP is written in go, and in order to implement, I've written the entire protocol as an SDK (also available, at https://github.com/fredcamaral/gomcp-sdk)

  Why Does This Matter?

  Ever had these frustrations with AI assistants?
  - "I already told you this last week..." - No conversation persistence
  - "You solved this same problem before!" - No pattern recognition across sessions
  - "Remember my coding preferences?" - Starts from scratch every time
  - "What was that solution we discussed?" - No searchable memory

  MCP Memory solves all of these.

  Add one config block to Claude Desktop/VS Code/Cursor, and suddenly your AI:
  - Remembers everything across sessions and projects
  - Finds similar problems you've solved before using semantic search
  - Recognizes patterns in your coding style, preferences, and decisions
  - Suggests relevant context proactively based on what you're working on
  - Learns across repositories with intelligent cross-referencing

  Technical Highlights

  - Smart chunking that understands conversation flow and context boundaries
  - Vector embeddings with ChromaDB for semantic similarity search
  - Pattern recognition engine that learns your preferences and workflows
  - Multi-repository intelligence for cross-project insights
  - Production-ready with Docker auto-updates, monitoring, and security
  - Memory decay that automatically summarizes and archives old memories
  - Relationship mapping that links related conversations and solutions
  - Serves through HTTP or SSE; for the HTTP, I've implemented a stdio <> HTTP proxy in JS (following the idea of Hashicorp's Terraform MCP)

  Demo

  After setup, try this:
  1. Tell your AI: "Remember I prefer TypeScript over JavaScript for new projects"
  2. Later: "What do you know about my coding preferences?"
  3. It remembers and builds on that knowledge over time

  The memory persists across:
  - Different conversation sessions
  - Multiple projects and repositories
  - Weeks and months of usage
  - Various AI clients (Claude, VS Code, Cursor, etc.), customized for the capabilities of each one

  What Makes It Different

  Unlike simple conversation history or the current MCPs alike, MCP Memory:
  - Understands context - knows when you're debugging vs. implementing
  - Learns patterns - recognizes your decision-making style
  - Connects dots - links related problems across different projects
  - Evolves - gets smarter as you use it more

  Production Ready

  - Auto-updating Docker deployment with Watchtower
  - Comprehensive monitoring and health checks
  - Security with encryption and access controls
  - Backup and restoration capabilities
  - Scales from personal use to team deployments

  Source & Docs

  GitHub: https://github.com/fredcamaral/mcp-memory
  License: MIT
  Setup time: Under 5 minutes

  Compatible with Claude Desktop, VS Code (Continue), Cursor, and any MCP-supporting AI client.

  ---

  I've been using this for my own development work for weeks, and it's genuinely changed how productive I am with AI assistants. Instead of re-explaining context every session, my AI actually builds on our previous conversations.

  Would love feedback from the HN community - especially from those working with AI coding assistants daily.

  Try it out and let me know what you think!