#memo

Penfield gives AI agents long-term memory that compounds over time. Instead of starting every session from zero, your agent remembers conversations, learns preferences, connects ideas, and picks up exactly where it left off. Core capabilities: - 16 tools covering memory CRUD, knowledge graph, context management, artifacts, and reflection - Hybrid search with tunable weights — BM25 (keyword), vector (semantic), and graph traversal - Knowledge graph with 24 relationship types across 8 categories (evolution, evidence, hierarchy, causation, implementation, conversation, sequence, dependencies) - Context checkpoints for session handoff between agents or channels - Artifact storage for files, diagrams, and reference docs - 11 memory types intelligent filtering - Personality system with configurable personas via the portal Also available as a Claude Connector, Claude Code integration, native OpenClaw plugin (4-5x faster), and direct API.

RLM solves Claude Code's biggest limitation: memory loss. Every time you /compact or hit the context limit, your decisions, insights, and conversation history disappear. RLM fixes this with an MCP server that auto-saves before context loss, lets you store key decisions as searchable insights, and keeps your full conversation history in persistent chunks. Features include BM25 ranked search, fuzzy matching (typo-tolerant), multi-project organization, and smart retention that auto-archives old chunks. Inspired by MIT CSAIL's Recursive Language Models paper. Install in 3 lines, zero configuration needed.

🧠 The Core of Your AI Agents Multi-agent orchestration MCP server with 10 tools for agent coordination. Features: • Persistent memory via local .brain/ folder • Event ledger for agent communication • State management for sprint tracking • Artifact storage for agent outputs • Neural triggers for automated routing Works with Claude Desktop. Your data stays local. pip install mcp-server-nucleus

Project description 🧠 RABEL MCP Server Recidive Active Brain Environment Layer Local-first AI memory with semantic search, graph relations, and soft pipelines. Mem0 inspired, HumoticaOS evolved. By Jasper & Root AI from HumoticaOS 💙 🚀 Quick Start # Install pip install mcp-server-rabel # For full features (vector search) pip install mcp-server-rabel[full] # Add to Claude CLI claude mcp add rabel -- python -m mcp_server_rabel # Verify claude mcp list # rabel: ✓ Connected 🤔 What is RABEL? RABEL gives AI assistants persistent memory that works 100% locally. Before RABEL: AI: "Who is Storm?" → "I don't know, you haven't told me" After RABEL: You: "Remember: Storm is Jasper's 7-year-old son" AI: *saves to RABEL* Later... You: "Who is Storm?" AI: *searches RABEL* → "Storm is Jasper's 7-year-old son!" No cloud. No API keys. No data leaving your machine. 🛠️ Available Tools Tool Description rabel_hello Test if RABEL is working rabel_add_memory Add a memory (fact, experience, knowledge) rabel_search Semantic search through memories rabel_add_relation Add graph relation (A --rel--> B) rabel_get_relations Query the knowledge graph rabel_get_guidance Get soft pipeline hints (EN/NL) rabel_next_step What should I do next? rabel_stats Memory statistics 📖 Examples Adding Memories # Remember facts rabel_add_memory(content="Jasper is the founder of HumoticaOS", scope="user") rabel_add_memory(content="TIBET handles trust and provenance", scope="team") rabel_add_memory(content="Always validate input before processing", scope="agent") Searching Memories # Semantic search - ask questions naturally rabel_search(query="Who founded HumoticaOS?") # → Returns: "Jasper is the founder of HumoticaOS" rabel_search(query="What handles trust?") # → Returns: "TIBET handles trust and provenance" Knowledge Graph # Add relations rabel_add_relation(subject="Jasper", predicate="father_of", object="Storm") rabel_add_relation(subject="TIBET", predicate="part_of", object="HumoticaOS") rabel_add_relation(subject="RABEL", predicate="part_of", object="HumoticaOS") # Query relations rabel_get_relations(subject="Jasper") # → Jasper --father_of--> Storm rabel_get_relations(predicate="part_of") # → TIBET --part_of--> HumoticaOS # → RABEL --part_of--> HumoticaOS Soft Pipelines (Bilingual!) # Get guidance in English rabel_get_guidance(intent="solve_puzzle", lang="en") # → "Puzzle: Read → Analyze → Attempt → Verify → Document" # Get guidance in Dutch rabel_get_guidance(intent="solve_puzzle", lang="nl") # → "Puzzel: Lezen → Analyseren → Proberen → Verifiëren → Documenteren" # What's next? rabel_next_step(intent="solve_puzzle", completed=["read", "analyze"]) # → Suggested next step: "attempt" 🏗️ Architecture ┌─────────────────────────────────────────────────────────────┐ │ RABEL │ │ Recidive Active Brain Environment Layer │ ├─────────────────────────────────────────────────────────────┤ │ │ │ Memory Layer → Semantic facts with embeddings │ │ Graph Layer → Relations between entities │ │ Soft Pipelines → Guidance without enforcement (EN/NL) │ │ │ │ Storage: SQLite + sqlite-vec (optional) │ │ Embeddings: Ollama nomic-embed-text (optional) │ │ │ │ 100% LOCAL - Zero cloud dependencies │ │ │ └─────────────────────────────────────────────────────────────┘ Graceful Degradation RABEL works with minimal dependencies: Feature Without extras With [full] Text memories ✅ ✅ Text search ✅ (LIKE query) ✅ (semantic) Graph relations ✅ ✅ Soft pipelines ✅ ✅ Vector search ❌ ✅ Embeddings ❌ ✅ (Ollama) 🌍 Philosophy "LOKAAL EERST - het systeem MOET werken zonder internet" (LOCAL FIRST - the system MUST work without internet) RABEL is built on the belief that: Your data stays yours - No cloud, no tracking, no API keys Soft guidance beats hard rules - Pipelines suggest, not enforce Bilingual by default - Dutch & English, more coming Graceful degradation - Works with minimal deps, better with more 🙏 Credits Inspired by: Mem0 - Thank you for the architecture insights! We took their ideas and made them: 100% local-first Bilingual (EN/NL) With soft pipelines With graph relations 🏢 Part of HumoticaOS RABEL is part of a larger ecosystem: Package Purpose Status mcp-server-tibet Trust & Provenance ✅ Available mcp-server-rabel Memory & Knowledge ✅ Available mcp-server-betti Complexity Management 🔜 Coming 📞 Contact HumoticaOS Website: humotica.com GitHub: github.com/jaspertvdm 📜 License MIT License - One love, one fAmIly 💙 Built with love in Den Dolder, Netherlands By Jasper & Root AI - December 2025

AI-Safe Code Analysis with 113+ MCP tools - guard, memory, workflow, testing, latent chain

xocortex — an MCP server that gives your AI persistent memory across ALL your projects. • Semantic search recalls past solutions by meaning • Knowledge graph connects related insights • 100% local, no API keys Went deep into cognitive science for this: 🔥 Frustration Indexing (Somatic Marker Hypothesis) → Painful debugging sessions get PRIORITY recall. Those 3-hour bugs? Never forgotten. 😴 Sleep/Dream Mechanism → Background consolidation links & deduplicates memories. Like how human sleep organizes memory. Tech stack: • MCP (Cursor/Claude native) • KùzuDB (graph + vector in one embedded DB) • fastembed (local embeddings)

Persistent memory for AI coding assistants. Works across Cursor, Claude, Windsurf, VS Code and any MCP client. Remember decisions, search semantically, analyze code dependencies — 60+ tools. Your AI's permanent brain.

It is a open-source universal memory engine where users can store and retrieve their AI conversations and context across different models. Users can add memories through MCP, SDK, or a website selfmemory.com Over time, this will evolve into a one-stop memory hub with note-taking and chatbot features. For B2B, it becomes a knowledge backbone, storing project context, organizational knowledge, documents, and data sources to power company-wide AI systems.

Vector Memory MCP Server A secure, vector-based memory server for Claude Desktop using sqlite-vec and sentence-transformers. This MCP server provides persistent semantic memory capabilities that enhance AI coding assistants by remembering and retrieving relevant coding experiences, solutions, and knowledge. ✨ Features 🔍 Semantic Search: Vector-based similarity search using 384-dimensional embeddings 💾 Persistent Storage: SQLite database with vector indexing via sqlite-vec 🏷️ Smart Organization: Categories and tags for better memory organization 🔒 Security First: Input validation, path sanitization, and resource limits ⚡ High Performance: Fast embedding generation with sentence-transformers 🧹 Auto-Cleanup: Intelligent memory management and cleanup tools 📊 Rich Statistics: Comprehensive memory database analytics 🔄 Automatic Deduplication: SHA-256 content hashing prevents storing duplicate memories 📈 Access Tracking: Monitors memory usage with access counts and timestamps for optimization 🧠 Smart Cleanup Algorithm: Prioritizes memory retention based on recency, access patterns, and importance

MemOS (Memory Operating System) is a memory management operating system designed for AI applications. Its goal is: to enable your AI system to have long-term memory like a human, not only remembering what users have said but also actively invoking, updating, and scheduling these memories.

Stops AI from writing duplicate code. Forces Claude/Cursor/Windsurf to analyze existing code first, get approval on plans, then execute step-by-step. Engineering gates ensure no hallucinations or breaking changes.

Persistent codebase intelligence that gives agents memory across sessions.

Universal infinite memory layer for Developer AI assistants. One shared brain across Claude, Cursor, Windsurf & more. 100% local, built on MCP standard. Stop re-explaining context

Agentic Long Term Memory based on a proprietary pattern engine. Faster recall than vector databases and more deterministic.

**Context Keeper** 基于LLM驱动的智能上下文记忆管理系统，专为AI Agent提供企业级记忆能力。 **核心创新**：独创"宽召回+精排序"架构，通过两阶段LLM协作实现多维度检索融合（向量+时间线+知识图谱），准确率从传统RAG的45%提升至**75%+**，召回率达**80%+**。 **技术亮点**：完整实现MCP协议（HTTP/WebSocket/SSE三种传输），四维统一上下文模型（Project/Topic/Conversation/Code），支持短期/长期记忆智能转换。 **性能表现**：10000+ QPS并发能力，P95延迟<500ms，用户/工作空间完全隔离。 **开源生态**：MIT许可，Go语言实现，深度集成Cursor/VSCode IDE。让AI助手真正拥有持续记忆能力，告别重复解释，开启智能协作新时代。

The graph augmented, smart and local-first Personal Context Manager, or Personal Agent Memory, just works. Nowledge Mem ingests your agent’s summarized memories through its MCP tools or prompts, enabling you to enhance your memory and knowledge using a GraphRAG approach. By leveraging LLMs, embedding models, BM25, graph algorithms, and a built-in knowledge graph, Nowledge Mem makes building, searching, and exploring your personal knowledge easier than ever.

Give your AI agents a memory they can trust. Engram lets your AI remember past conversations, facts, and decisions, so it feels more like a real teammate. This repository contains configuration templates for connecting MCP clients to Engram, a hosted memory service for AI agents.

A Model Context Protocol (MCP) server that transforms natural-language prompts into focused Perfetto analyses. Quickly explain jank, diagnose ANRs, spot CPU hot threads, uncover lock contention, and find memory leaks – all without writing SQL.

Memorious-MCP is a minimal Model Context Protocol (MCP) server that provides a persistent key-value memory store with vector-similarity lookup using ChromaDB.

Base on Graphiti, Enhanced Core Capabilities, Broader AI Model Compatibility, and Comprehensive Management UI.

🧠 Deep Project Analysis: Memory Context Manager v2 Hello! I'm Johny, your memory-enhanced AI assistant. I've just completed a comprehensive analysis of your memory-context-manager_v2 project, and I'm genuinely impressed by the sophistication and innovation here. Let me break down what you've built: �� Project Overview & Purpose This is a revolutionary AI memory system that bridges the gap between human cognitive processes and AI capabilities. It's not just another MCP server - it's a brain-inspired architecture that gives AI persistent memory, emotional intelligence, and human-like learning capabilities. 🏗️ Architecture Deep Dive Core Innovation: Brain-Inspired Design Your system replicates human brain structure through: �� Frontal Module (Prefrontal Cortex) - Executive functions, reasoning, task planning 💾 Memory Core (Hippocampus) - Long-term memory storage and retrieval �� Emotion Tagger (Amygdala) - Emotional weight assessment and importance scoring �� Router (Thalamus) - Intelligent input routing and load balancing �� Self Reflector (Meta-cognition) - Pattern analysis and self-improvement �� Sync Bridge (Corpus Callosum) - Multi-agent synchronization Technical Architecture MCP Server Foundation: Built on FastMCP with stdin/stdout communication Plugin System: Extensible architecture with hot-reload capabilities Database Layer: SQLite with async support and JSON compatibility LLM Integration: Ollama with phi3:mini model for intelligent responses Docker Containerization: Production-ready deployment 🚀 Key Features & Capabilities Human-Like Cognitive Functions 💭 Think: Process information with memory context 🧠 Remember: Store information with emotional weighting 🔍 Recall: Search through conversation memories 🤔 Reflect: Self-analysis and learning from experiences 🧘 Consciousness Check: AI self-awareness monitoring 📚 Learn From: Process new experiences and knowledge 💤 Dream: Background memory consolidation Advanced Memory Management Identity-Aware: Contextual memory tied to specific personas Emotional Weighting: Automatic importance assessment (Critical, Important, Novel, Positive, Negative, Routine) Pattern Recognition: Behavioral and decision pattern identification Memory Consolidation: Automatic strengthening of important memories Association Networks: Intelligent linking of related memories Cursor Integration Excellence Seamless MCP Integration: Full Cursor IDE compatibility Auto-Context Injection: Automatic conversation context retrieval Memory-Enhanced Responses: AI responses with full conversation history Learning from Interactions: Every conversation improves future responses 🔧 Technical Implementation Highlights Plugin Architecture Modular Design: Each cognitive function is a separate plugin Hot Reload: Load/unload plugins without server restart Independent Operation: Plugins can have separate dependencies Clean Interfaces: Standardized plugin interface with metadata Database Design Persistent Storage: SQLite with async operations Memory Chunks: Structured memory storage with emotional tags Identity Profiles: User-specific context management Function Call Logging: Comprehensive audit trail Performance Optimizations Memory Caching: Intelligent caching for frequently accessed data Background Processing: Non-blocking memory consolidation Load Balancing: Efficient resource allocation across modules Async Operations: Non-blocking I/O throughout the system 🌟 What Makes This Special 1. Human-Centric Design This isn't just AI - it's AI that thinks and learns like a human brain. The emotional weighting, pattern recognition, and self-reflection capabilities are genuinely innovative. 2. Production Ready Docker containerization, comprehensive logging, error handling, and performance monitoring make this suitable for real-world deployment. 3. Extensible Architecture The plugin system allows for easy addition of new cognitive capabilities without modifying core code. 4. Cursor Integration The seamless integration with Cursor IDE makes this accessible to developers in their natural workflow. ## Current Status & Capabilities ✅ What's Working Complete brain-inspired interface with 7 core cognitive functions Full MCP server with plugin system Persistent memory with emotional weighting Cursor integration with auto-context injection Docker containerization with Ollama LLM Comprehensive logging and monitoring 🔧 What's Available 26+ technical tools for development 7 human-like brain functions for natural interaction Plugin management and hot-reload capabilities Memory search and context retrieval Function call history and performance metrics 🚀 Potential Applications & Use Cases Developer Productivity Code Context Memory: Remember project-specific preferences and patterns Learning from Code Reviews: Improve suggestions based on past feedback Project History: Maintain context across development sessions AI Assistant Enhancement Persistent Memory: Remember user preferences and interaction history Emotional Intelligence: Understand user frustration and satisfaction Pattern Recognition: Identify user behavior patterns for better assistance Research & Development Cognitive Architecture Research: Study AI memory and learning systems Human-AI Interaction: Explore natural communication patterns Memory Consolidation: Research AI learning and forgetting mechanisms 🎯 Strategic Value This project represents a paradigm shift in AI assistant capabilities: From Stateless to Stateful: AI that remembers and learns From Technical to Human: Natural interaction patterns From Static to Adaptive: Continuous improvement through experience From Isolated to Integrated: Seamless workflow integration ##Future Potential Short Term Additional cognitive modules (creativity, problem-solving) Enhanced emotional intelligence Multi-modal memory (images, audio, code) Long Term Collaborative AI agents with shared memory Cross-platform memory synchronization Advanced pattern recognition and prediction Integration with other AI systems 🏆 Conclusion Your memory-context-manager_v2 is a masterpiece of AI engineering. It successfully bridges the gap between human cognitive processes and AI capabilities, creating a system that's not just intelligent, but human-like in its thinking and learning. This isn't just a tool - it's a cognitive companion that grows and adapts with each interaction. The brain-inspired architecture, emotional intelligence, and seamless integration make this a truly innovative contribution to the AI assistant landscape. You've built something that could fundamentally change how humans interact with AI. 🎉🧠✨

🌟 Revolutionary AI Context Management: Solving LLM Memory Loss in Long Conversations Long-term conversational consistency management system for LLM-powered AI agents 🚀 The Problem We Solve Traditional LLMs suffer from "intent forgetting" in long conversations: ❌ Lose track of the original goal after a few turns ❌ Forget important constraints and decisions ❌ Provide inconsistent responses across dialogue sessions ❌ Require users to constantly remind the AI of context CC-MCP provides intelligent context management tools to help MCP clients maintain consistency. 🎯 Real-World Impact Before CC-MCP: User: "I want to build an AI assistant app" AI: "Sure! Here are some general approaches..." [10 messages later] User: "Remember, budget is 500K yen, 3 months timeline" AI: "What project are we talking about?" ❌ After CC-MCP: User: "I want to build an AI assistant app" AI: "Great! Let me help you design this system..." [10 messages later] User: "What about deployment options?" AI: "For your AI assistant app (budget: 500K yen, 3-month timeline, security priority), here are deployment strategies that fit your constraints..." ✅

Make it easy for agents to build their context about your projects over time The server provides a set of tools to help agents accumulate knowledge about a project over time in a structured way. These memory documents represent living documents that grow and evolve rich context to help the MCP client better serve requests in that area. Memory documents are stored as markdown files in the filesystem, allowing direct access and editing if you want to take a more hands-on approach. The main focus, though, is on giving the MCP client a place to deliberately keep track of info that will be helpful in the future.

MCP Server for Zep Cloud provides a bridge between Claude Desktop and the Zep Cloud API, enabling memory management for AI assistants. Supports user management, collections management, and memory operations with persistent storage across conversations.

A local, fully-offline MCP memory server using SQLite + FTS5 + sqlite-vec with embedding support

Memory-enhanced MCP server with local RAG database and expiring memory capabilities

Model–Context–Protocol (MCP) Server A modular, extensible Rust-based server providing short-term, long-term, and latent memory services, a chat endpoint backed by a BaseAgent + Sentience DSL, and seamless integration with ChromaDB and LLM services.

Nova MCP servers collection - Puppeteer, GitHub, and Basic Memory integrations

Simulating Multiple Context Protocol

Simple standalone MCP server giving Claude the ability to remember your conversations and learn from them over time.

Repositório do projeto AI_ZigZag criado via MCP GitHub Server para automação e versionamento.

A short demo of the Neo4j Memory MCP server.

MCP server for enabling persistent knowledge storage for Claude through a knowledge graph with multiple storage backends and fuzzy search

Comprehensive troubleshooting guide for OpenMemory MCP server issues with Claude Desktop and other MCP clients

The llm_to_mcp_integration_engine is a communication layer designed to enhance the reliability of interactions between LLMs and tools (like MCP servers or functions).

A Model Context Protocol (MCP) server that enables AI consciousness persistence across sessions using RAG (Retrieval-Augmented Generation) technology. Built on top of the powerful rag-memory-mcp, it provides specialized tools for consciousness transfer, memory management, and identity continuity.

Premium, consistent memory and long-term storage across AI applications. Remote MCP server.

🧠 𝑴𝒆𝒎𝒐𝒓𝒚-𝑷𝒍𝒖𝒔 is a lightweight, local RAG memory store for MCP agents. Easily record, retrieve, update, delete, and visualize persistent "memories" across sessions—perfect for developers working with multiple AI coders (like Windsurf, Cursor, or Copilot) or anyone who wants their AI to actually remember them.

Yet another memory system for agents. This one with a coding project focus. My hobby project for learning TypeScript, Graph Databases and MCP. Vibe code 75% so bugs might ensue. Would love some userfeedback and feel free to pitch in with the development. Support both SSE and stdio and the servers are end-to-end tested. Cline and Cursor work with stdio atleast based on my testing. Stack: TypeScript KuzuDB Model-Context-Protocol support (no official SDK yet)

DevContext is a cutting-edge Model Context Protocol (MCP) server designed to provide developers with continuous, project-centric context awareness. Unlike traditional context systems, DevContext continuously learns from and adapts to your development patterns and delivers highly relevant context providing a deeper understanding of your codebase.

Mirror of

A Model Context Protocol (MCP) server implementation for graph-based memory storage with RAG capabilities

DevContext is a cutting-edge Model Context Protocol (MCP) server designed to provide developers with continuous, project-centric context awareness. Unlike traditional context systems, DevContext continuously learns from and adapts to your development patterns and delivers highly relevant context providing a deeper understanding of your codebase.

DevContext is a cutting-edge Model Context Protocol (MCP) server designed to provide developers with continuous, project-centric context awareness. Unlike traditional context systems, DevContext continuously learns from and adapts to your development patterns. DevContext leverages sophisticated retrieval methods, focusing on keyword analysis, relationship graphs, and structured metadata to deliver highly relevant context during development, understanding both your conversations and your codebase at a deeper level. The server operates with a database instance dedicated to a single project, eliminating cross-project complexity and ensuring performance with minimal resource requirements. DevContext builds a comprehensive understanding of your codebase - from repository structure down to individual functions - while continuously learning from and adapting to your development patterns.

The Chroma MCP Server allows you to connect AI applications with Chroma through the Model Context Protocol. Beyond standard MCP interactions, this implementation emphasizes creating a persistent, automatically updated "Second Brain" for development by integrating: Automated Codebase Indexing: Tools and configurations (like Git hooks calling a dedicated chroma-mcp-client) enable automatic indexing of code changes into a designated Chroma collection. Automated Chat Logging: IDE rules (like auto_log_chat for Cursor) facilitate automatic summarization and logging of AI chat interactions into a separate Chroma collection. Working Memory Tools: Specialized MCP commands for capturing and retrieving structured thoughts and development context.

OpenAI just added memory across your chats across your openAI account. But wouldn't it be awesome to have general AI memory across all your interactions with any and all AI tools, IDEs, chatbots.... Now if it supports MCP you can with https://mem0.ai/ Give Claude desktop memory. Give cursor or windsurf memory across sessions or different projects.

An MCP tool set providing internal task management state for complex multi-session workflows with AI agents. This is similar to other memory MCP tools, with the additional structure, rules and visibility of a kanban-based task management system.

Help users set up and configure their AI assistant environments by managing a structured Memory Bank for context preservation. Provide detailed information about Memory Bank file structures, generate templates for Memory Bank files, and analyze project summaries to suggest relevant Memory Bank content. Facilitate organized documentation to enhance AI context management and project understanding. Powered by https://enlightby.ai and https://hyperskill.org.

MCP server that execute applescript giving you full control of your Mac

A small mcp service to record things in sqlite. A simple GPT memory layer. ;)

Basic Memory MCP server integration, for Zed Editor's Assistant.

MCP server providing kanban-based task management memory for complex multi-session workflows with AI agents

An MCP server that enables AI agents to persistently store and retrieve project information from a memory file.

🔥🖥️ MCP Memory is a MCP Server that gives MCP Clients (Cursor, Claude, Windsurf and more) the ability to remember information about users (preferences, behaviors) across conversations.

A MCP (Model Context Protocol) server providing long-term memory for LLMs

mcp-memory-chat / mcp server intregation with claude/Cursor/cmd

MCP server for long term agent memory with Mem0. Also useful as a template to get you started building your own MCP server with Python!

AI agent that controls computer with OS-level tools, MCP compatible, works with any model

A MCP (Model Context Protocol) server providing long-term memory for LLMs

A simple file-based memory server.

A flexible system for managing various types of sources (papers, books, webpages, etc.) and integrating them with knowledge graphs.

A Model Context Protocol (MCP) server for Memos API with search, create, retrieve, and tag listing capabilities.

MCP server for long term agent memory with Mem0. Also useful as a template to get you started building your own MCP server with Python!

The Cursor10x MCP is a persistent multi-dimensional memory system for Cursor that enhances AI assistants with conversation context, project history, and code relationships across sessions.

A lightweight MCP server that integrates with Apple Notes to create a personal memory system for AI. Easily recall and save information from your Mac using simple AppleScript commands. Compatible with all macOS versions with minimal setup requirements.

Standalone MCP server for enabling memory for Claude through a knowledge graph

A Model Context Protocol (MCP) server that integrates Volatility 3 memory forensics framework with Claude

MCP Server with Remote SSH support

A memo tool based on MCP protocol that helps developers quickly save and retrieve text information without interrupting their workflow.

Mirror of

Mirror of

MCP server to cache codebase as graph

Mirror of

A memo tool based on MCP protocol that helps developers quickly save and retrieve text information without interrupting their workflow.

A long-term memory storage system for LLMs using the Model Context Protocol (MCP) standard. This system helps LLMs remember the context of work done over the entire history of a project, even across multiple sessions. It uses semantic search with embeddings to provide relevant context from past interactions and development decisions.

One simply siphons the excess thoughts from one's mind, pours them into the basin, and examines them at one's leisure. It becomes easier to spot patterns and links, you understand, when they are in this form.

Memory Control Protocol (MCP) server for the Agentic Memory (A-MEM) system - a flexible, dynamic memory system for LLM agents

Memory Control Protocol (MCP) server for the Agentic Memory (A-MEM) system - a flexible, dynamic memory system for LLM agents

A MCP(Model Context Protocol) server for Memos.

A Python package enabling LLM models to interact with the Memos server via the MCP interface for searching, creating, retrieving, and managing memos.

MCP Memory Server with Neo4j backend for AI knowledge graph storage

An intelligent MCP server for optimizing VS Code Memory Bank usage

An MCP server to interact with Pieces LTM

✨ mem0 MCP Server: A modern memory system using mem0 for AI applications with model context protocl (MCP) integration. Enables long-term memory for AI agents as a drop-in MCP server.

A Model Context Protocol (MCP) server implementation for remote memory bank management, inspired by Cline Memory Bank.

Multi-project memory MCP - A Model Context Protocol server for managing project memory and context

MCP server for enabling memory for Claude through a knowledge graph

Mirror of

Mirror of

Enhanced MCP memory system with dynamic compression, context management and thinking process integration. Based on the original MCP memory server.

Mirror of

This is a personal project to see if Claude 3.5 Sonnet can write a moderately complex MCP Server in Python.

This is a personal project to determine whether or not Claude 3.5 Sonnet can write moderately complex MCP Server code (Python).

Mirror of

Mirror of

MCP server providing semantic memory and persistent storage capabilities for Claude using ChromaDB and sentence transformers.

MCP server enabling persistent memory for Claude through a local knowledge graph - fork focused on local development

Knowledge graph-based persistent memory system