{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-memory-plus","slug":"memory-plus","name":"Memory-Plus","type":"repo","url":"https://github.com/Yuchen20/Memory-Plus","page_url":"https://unfragile.ai/memory-plus","categories":["rag-knowledge","code-editors","app-builders"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-memory-plus__cap_0","uri":"capability://memory.knowledge.semantic.memory.recording.with.vector.embedding","name":"semantic-memory-recording-with-vector-embedding","description":"Records user-provided memories (text, code snippets, context) by converting them into vector embeddings via Google Gemini API, then storing them in a Qdrant vector database with metadata (timestamps, categories, versioning). The MemoryProtocol class handles text splitting for optimal chunk sizes, embedding generation, and persistent storage with category-based organization, enabling semantic search across recorded memories in subsequent sessions.","intents":["I want my AI agent to remember important context, code patterns, or user preferences across multiple conversations","I need to store structured memories (project notes, API keys, user preferences) that persist beyond a single chat session","I want to tag memories by category (project, user-preference, codebase-pattern) for organized retrieval"],"best_for":["developers building multi-session AI agents with Cursor, Windsurf, or custom LLM applications","teams using multiple AI coders that need shared context across tools","builders prototyping context-aware AI assistants that learn user patterns"],"limitations":["Requires Google Gemini API key for embedding generation — no offline embedding option","Text splitting uses fixed chunk sizes; may not preserve semantic boundaries for highly structured code","No built-in encryption for stored memories — data stored locally in plaintext within Qdrant","Embedding generation adds latency (~500ms-1s per record) due to cloud API calls"],"requires":["Python 3.9+","Google Gemini API key (GEMINI_API_KEY environment variable)","Qdrant vector database instance (local or remote)","FastMCP framework"],"input_types":["plain text","code snippets","structured JSON metadata","category tags (string)"],"output_types":["vector embeddings (1536-dimensional for Gemini)","memory records with metadata (id, timestamp, category, version)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_1","uri":"capability://memory.knowledge.semantic.memory.retrieval.with.similarity.search","name":"semantic-memory-retrieval-with-similarity-search","description":"Retrieves relevant memories from the Qdrant vector database using cosine similarity search on query embeddings, with optional filtering by category, recency, or metadata. The retrieve_memories() MCP tool converts user queries into embeddings via Gemini API, performs vector similarity matching against stored memories, and returns ranked results with relevance scores, enabling context-aware memory injection into agent prompts.","intents":["I want to find relevant past memories when the AI agent needs context for a new task","I need to filter memories by category (e.g., 'project-X' or 'user-preferences') to avoid irrelevant context","I want to retrieve the most recent N memories for quick context without semantic search overhead"],"best_for":["AI agents that need to dynamically fetch relevant context before generating responses","multi-turn conversation systems where memory relevance changes per query","developers building RAG pipelines that require semantic search over agent-specific memories"],"limitations":["Similarity search quality depends on embedding model quality — Gemini embeddings may not capture domain-specific semantics","No hybrid search (semantic + keyword) — purely vector-based, may miss exact-match memories","Requires Qdrant to be running and accessible — no fallback to local search if database is unavailable","Latency for each retrieval query (~500ms-1s) due to embedding generation and vector search"],"requires":["Python 3.9+","Google Gemini API key","Qdrant vector database with pre-populated memory vectors","FastMCP framework"],"input_types":["query text (natural language or code)","category filter (optional string)","limit parameter (optional integer for top-K results)"],"output_types":["ranked list of memory records with similarity scores (0-1)","metadata (timestamp, category, version) for each retrieved memory"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_10","uri":"capability://memory.knowledge.meta.memory.guidance.with.usage.patterns","name":"meta-memory-guidance-with-usage-patterns","description":"Exposes MCP Resources that provide meta-cognitive guidance on when and how to use memories effectively, including usage patterns, best practices, and memory organization recommendations. The system tracks memory access patterns and suggests when memories should be recorded, updated, or deleted based on agent behavior and memory statistics.","intents":["I want guidance on when my agent should record vs. retrieve memories","I need to understand memory usage patterns to optimize memory organization","I want recommendations on memory lifecycle (when to update, consolidate, or delete)"],"best_for":["developers optimizing memory usage in long-running agents","teams auditing memory effectiveness and coverage","builders learning best practices for persistent agent memory"],"limitations":["Meta-memory guidance is heuristic-based — not personalized to specific agent use cases","No machine learning on usage patterns — recommendations are rule-based","Guidance is informational only — not enforced or automated","No integration with actual memory operations — guidance is separate from execution"],"requires":["Python 3.9+","Qdrant vector database with memory access logs","MCP-compatible client"],"input_types":["optional time window (e.g., 'last 7 days')","optional category filter (string)"],"output_types":["usage statistics (total records, retrieval frequency, update rate)","recommendations (text guidance on memory optimization)"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_11","uri":"capability://memory.knowledge.local.vector.database.with.qdrant.backend","name":"local-vector-database-with-qdrant-backend","description":"Uses Qdrant as the persistent vector storage backend, supporting both local (in-process) and remote (server) deployments. The MemoryProtocol class manages Qdrant collections, handles vector insertion/deletion/update operations, and maintains metadata indexing. This provides semantic search capabilities without requiring cloud-based vector databases, enabling fully local operation for privacy-sensitive applications.","intents":["I want to store memory vectors locally without sending data to cloud services","I need a vector database that supports semantic search with metadata filtering","I want to run Memory-Plus entirely on-premises for compliance or privacy reasons"],"best_for":["privacy-conscious organizations handling sensitive data","teams with strict data residency requirements","developers building offline-capable agents"],"limitations":["Qdrant requires separate installation and management — adds operational complexity","Local Qdrant instances have limited scalability — not suitable for >10M vectors","No built-in backup or replication — requires manual Qdrant administration","Vector database state is separate from application state — requires coordination for consistency"],"requires":["Python 3.9+","Qdrant instance (local or remote)","network connectivity to Qdrant (localhost:6333 for local)","sufficient disk space for vector storage"],"input_types":["vector embeddings (1536-dimensional for Gemini)","metadata (JSON-serializable key-value pairs)"],"output_types":["vector IDs (UUID strings)","search results with similarity scores"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_12","uri":"capability://data.processing.analysis.google.gemini.embedding.generation","name":"google-gemini-embedding-generation","description":"Generates vector embeddings for text content using Google Gemini API (embedding-001 model), converting text into 1536-dimensional vectors for semantic search. The MemoryProtocol class handles API calls, batches requests for efficiency, and caches embeddings to reduce API costs. This enables semantic similarity matching without requiring local embedding models.","intents":["I want to convert text memories into semantic vectors for similarity search","I need high-quality embeddings that capture semantic meaning across different domains","I want to avoid running local embedding models to reduce computational overhead"],"best_for":["developers prioritizing embedding quality over latency","teams with Google Cloud credits or budget for API calls","builders creating multi-domain agents where general-purpose embeddings are sufficient"],"limitations":["Requires Google Gemini API key and active billing — adds operational cost (~$0.02 per 1M tokens)","Embedding generation adds ~500ms-1s latency per request due to API round-trip","No offline fallback — cannot generate embeddings without API access","Embedding model is fixed (embedding-001) — no option for domain-specific models","API rate limits may throttle bulk embedding operations"],"requires":["Python 3.9+","Google Gemini API key (GEMINI_API_KEY environment variable)","network connectivity to Google API endpoints","active Google Cloud billing"],"input_types":["text content (string, up to model's token limit)","optional batch of texts (list of strings)"],"output_types":["embedding vector (1536-dimensional float array)","embedding metadata (model version, token count)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_13","uri":"capability://data.processing.analysis.text.chunking.with.semantic.preservation","name":"text-chunking-with-semantic-preservation","description":"Splits long text documents into semantic chunks using configurable chunk size and overlap parameters in the MemoryProtocol class. The chunking strategy preserves sentence boundaries and attempts to avoid breaking code blocks or structured content, enabling efficient embedding and retrieval of large documents while maintaining semantic coherence.","intents":["I want to split large documents into manageable chunks for embedding","I need to preserve semantic boundaries when chunking code or structured text","I want to control chunk size and overlap for optimal retrieval performance"],"best_for":["systems ingesting large documents (>10KB) that need to be split for embedding","developers optimizing retrieval granularity (chunk size affects search precision)","teams handling mixed content types (code, documentation, prose)"],"limitations":["Chunking algorithm is simple (fixed size with overlap) — may not preserve semantic boundaries in code","No format-specific chunking (e.g., code-aware splitting by functions) — treats all text uniformly","Chunk overlap is fixed — no adaptive overlap based on content type","No validation that chunks are semantically coherent — relies on fixed size heuristic"],"requires":["Python 3.9+","configurable chunk size and overlap parameters"],"input_types":["text content (string)","chunk size (integer, characters)","overlap size (integer, characters)"],"output_types":["list of text chunks (strings)","chunk metadata (start position, end position)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_2","uri":"capability://memory.knowledge.memory.update.with.versioning","name":"memory-update-with-versioning","description":"Updates existing memories by appending new content or modifying entries while maintaining a version history in Qdrant. The update_memory() MCP tool accepts a memory ID and new content, re-embeds the updated text, stores it with an incremented version number, and preserves the original version for audit trails. This enables agents to refine memories over time without losing historical context.","intents":["I want to refine or correct a memory that was previously recorded","I need to track how a memory (e.g., user preference, project context) has evolved over sessions","I want to append new information to an existing memory rather than creating a duplicate"],"best_for":["long-running AI agents that need to evolve their understanding of users or projects","compliance-heavy applications requiring audit trails of memory changes","developers building iterative learning systems where agent knowledge improves over time"],"limitations":["Version history is stored in Qdrant but not automatically pruned — old versions accumulate storage overhead","No conflict resolution for concurrent updates — last-write-wins semantics","Re-embedding on every update adds latency (~500ms-1s per update)","No rollback mechanism — version history is read-only for audit purposes"],"requires":["Python 3.9+","Google Gemini API key","Qdrant vector database with existing memory records","memory ID from a previous record_memory() call"],"input_types":["memory ID (string UUID)","updated content (text or code)","optional metadata updates (category, tags)"],"output_types":["updated memory record with new version number","confirmation of version history preservation"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_3","uri":"capability://memory.knowledge.memory.deletion.with.metadata.cleanup","name":"memory-deletion-with-metadata-cleanup","description":"Deletes memories from the Qdrant vector database by ID, removing both the vector embedding and associated metadata (timestamps, categories, versions). The delete_memory() MCP tool performs hard deletion with optional cascade cleanup of related metadata, ensuring no orphaned records remain in the vector store.","intents":["I want to remove sensitive or outdated memories from the agent's knowledge base","I need to clean up duplicate or erroneous memories that were recorded","I want to ensure GDPR/privacy compliance by deleting user-related memories on request"],"best_for":["privacy-conscious applications handling user data","agents that need to forget incorrect or harmful memories","compliance-heavy systems requiring data deletion capabilities"],"limitations":["Hard deletion is permanent — no soft-delete or recovery mechanism","Deletion does not update in-memory caches if agent has loaded memories into context","No cascading deletion of related memories (e.g., all versions of a memory) — must delete by specific ID","No audit log of deletions — only the deletion action itself is recorded"],"requires":["Python 3.9+","Qdrant vector database access","memory ID from a previous record_memory() or retrieve_memories() call"],"input_types":["memory ID (string UUID)","optional cascade flag (boolean)"],"output_types":["deletion confirmation with count of deleted records"],"categories":["memory-knowledge","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_4","uri":"capability://memory.knowledge.category.based.memory.organization.and.filtering","name":"category-based-memory-organization-and-filtering","description":"Organizes memories into user-defined categories (e.g., 'project-X', 'user-preferences', 'codebase-patterns') stored as metadata in Qdrant. The MemoryProtocol class filters memories by category during retrieval, and the MCP Resources layer exposes category management endpoints. This enables agents to segment memories logically and retrieve only relevant subsets without full database scans.","intents":["I want to organize memories by project, user, or topic to avoid context pollution","I need to retrieve only memories from a specific category (e.g., 'project-A' memories only)","I want to list all available categories to understand what memories the agent has"],"best_for":["multi-project or multi-user AI agents that need memory isolation","teams using shared AI coders (Cursor, Windsurf) with per-project context","developers building domain-specific agents with clear memory boundaries"],"limitations":["Categories are flat strings — no hierarchical organization (e.g., 'project/subproject')","No automatic category inference — categories must be explicitly assigned at record time","Category filtering is metadata-based, not semantic — cannot find memories by topic similarity across categories","No category-level access control — all categories visible to all agents"],"requires":["Python 3.9+","Qdrant vector database","category string defined at memory record time"],"input_types":["category name (string)","optional metadata filters (key-value pairs)"],"output_types":["list of memory records matching category","category metadata (count, last-updated timestamp)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_5","uri":"capability://tool.use.integration.mcp.protocol.server.with.tool.exposure","name":"mcp-protocol-server-with-tool-exposure","description":"Implements a FastMCP server (mcp.py) that exposes memory operations (record_memory, retrieve_memories, update_memory, delete_memory) as MCP Tools, category management as MCP Resources, and memory visualization as MCP Prompts. The server bridges AI agents (Cursor, Windsurf, Claude Desktop) with the MemoryProtocol engine via the Model Context Protocol, enabling standardized tool calling without custom integration code.","intents":["I want to use Memory-Plus with any MCP-compatible AI agent (Cursor, Windsurf, Claude Desktop) without custom code","I need to expose memory operations as callable tools that agents can invoke autonomously","I want to provide memory resources and prompts that guide agents on when/how to use memories"],"best_for":["developers integrating Memory-Plus with MCP-compatible IDEs (Cursor, Windsurf)","teams building custom MCP agents that need persistent memory","builders creating Claude Desktop plugins with memory capabilities"],"limitations":["MCP protocol overhead adds ~50-100ms per tool call compared to direct Python imports","Tool schemas must be manually defined in mcp.py — no automatic schema generation from MemoryProtocol","No built-in rate limiting or quota management for tool calls","Requires MCP-compatible client — cannot be used with non-MCP agents"],"requires":["Python 3.9+","FastMCP framework","MCP-compatible client (Cursor, Windsurf, Claude Desktop, or custom MCP client)","network connectivity between client and MCP server"],"input_types":["MCP tool call requests (JSON-RPC format)","tool arguments matching defined schemas"],"output_types":["MCP tool responses (JSON-RPC format)","structured tool results with metadata"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_6","uri":"capability://memory.knowledge.memory.visualization.with.graph.clustering","name":"memory-visualization-with-graph-clustering","description":"Generates interactive graph visualizations of memory clusters using the visualize_memories MCP Prompt. The system groups semantically similar memories into clusters based on vector embeddings, then renders them as interactive graphs showing memory relationships and density. This helps developers understand memory organization and identify gaps or redundancies in recorded memories.","intents":["I want to visualize how my memories are organized and clustered semantically","I need to identify redundant or overlapping memories that could be consolidated","I want to understand the density and coverage of memories across different topics"],"best_for":["developers debugging memory organization in long-running agents","teams auditing memory quality and coverage","builders optimizing memory retrieval by understanding semantic clusters"],"limitations":["Graph visualization requires external rendering library (e.g., Plotly, Graphviz) — not included in core","Clustering algorithm (likely k-means or DBSCAN) not specified in documentation — may produce suboptimal clusters","Visualization scales poorly with >1000 memories — rendering becomes slow and unreadable","No interactive filtering in visualization — must regenerate graph to change view"],"requires":["Python 3.9+","Qdrant vector database with populated memories","visualization library (Plotly, Graphviz, or similar)","MCP-compatible client supporting prompt responses"],"input_types":["optional category filter (string)","optional clustering parameters (number of clusters, algorithm)"],"output_types":["graph visualization (HTML, SVG, or image format)","cluster metadata (size, centroid, member IDs)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_7","uri":"capability://memory.knowledge.recent.memory.access.with.recency.shortcuts","name":"recent-memory-access-with-recency-shortcuts","description":"Provides fast access to the N most recently recorded memories via the recent_memories MCP Resource, bypassing semantic search overhead. The MemoryProtocol class maintains timestamp metadata for each memory, enabling quick retrieval of recent entries without vector similarity computation. This enables agents to quickly reference fresh context without embedding latency.","intents":["I want to quickly access the last N memories without waiting for semantic search","I need to check what was most recently recorded to avoid duplicate entries","I want to provide agents with fresh context from the current session"],"best_for":["agents that need immediate access to recent context within a session","systems with strict latency requirements (<100ms) for memory access","developers building real-time interactive agents where semantic search is too slow"],"limitations":["Recency-based retrieval ignores semantic relevance — may return irrelevant recent memories","No ranking within recent memories — returns in strict chronological order","Requires timestamp metadata to be accurate — clock skew can cause ordering issues","Limited to fixed N (e.g., last 10) — no flexible window specification"],"requires":["Python 3.9+","Qdrant vector database with timestamp metadata","MCP-compatible client"],"input_types":["limit parameter (integer, e.g., 10 for last 10 memories)","optional category filter (string)"],"output_types":["ordered list of recent memory records (newest first)","metadata (timestamp, category, relevance score if available)"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_8","uri":"capability://memory.knowledge.file.import.with.document.ingestion","name":"file-import-with-document-ingestion","description":"Ingests external documents (text files, code files, markdown) directly into memory by reading file content, splitting into chunks via the MemoryProtocol text splitter, generating embeddings, and storing in Qdrant. The file import process preserves document structure and metadata (filename, file type, import timestamp), enabling bulk memory population from codebases or documentation.","intents":["I want to import my codebase documentation into memory so the agent can reference it","I need to bulk-load project context from files rather than manually recording each piece","I want to ingest API documentation or style guides as memories for code generation"],"best_for":["developers onboarding AI agents with existing project documentation","teams migrating from manual context management to persistent memory","builders creating domain-specific agents that need pre-loaded knowledge"],"limitations":["Text splitting uses fixed chunk sizes — may break semantic boundaries in code or structured documents","No format-specific parsing — treats all files as plain text, losing structure from markdown, JSON, or code","File import is synchronous — large files (>10MB) block the MCP server","No deduplication — importing the same file twice creates duplicate memories","Requires file system access on the server — cannot import from remote URLs"],"requires":["Python 3.9+","Google Gemini API key","Qdrant vector database","file system access to documents being imported"],"input_types":["file path (string, local file system)","optional category tag (string)","optional metadata (author, version, etc.)"],"output_types":["list of memory IDs created from file chunks","import summary (total chunks, total tokens, processing time)"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-memory-plus__cap_9","uri":"capability://tool.use.integration.agent.integration.template.with.fastclient","name":"agent-integration-template-with-fastclient","description":"Provides agent_memory.py template demonstrating FastAgent integration with Memory-Plus MCP server, showing how to build interactive chat agents with persistent memory. The template includes session management, memory-aware prompt construction, and direct MCP server communication, enabling developers to quickly scaffold custom agents without reimplementing memory integration.","intents":["I want to build a custom AI agent that uses Memory-Plus for persistent context","I need a working example of how to integrate Memory-Plus with FastAgent","I want to understand the pattern for memory-aware prompt construction in agents"],"best_for":["developers building custom LLM agents with memory requirements","teams prototyping multi-turn agents that need context persistence","builders learning MCP integration patterns for agent development"],"limitations":["Template is example code — requires customization for production use","No built-in error handling or retry logic for MCP server failures","Memory injection into prompts is manual — no automatic context selection","Template assumes FastAgent framework — not applicable to other agent frameworks"],"requires":["Python 3.9+","FastAgent framework","Memory-Plus MCP server running and accessible","API key for LLM (OpenAI, Anthropic, or compatible)"],"input_types":["user input (text)","session context (optional)"],"output_types":["agent response (text)","memory operations log (optional)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":31,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","Google Gemini API key (GEMINI_API_KEY environment variable)","Qdrant vector database instance (local or remote)","FastMCP framework","Google Gemini API key","Qdrant vector database with pre-populated memory vectors","Qdrant vector database with memory access logs","MCP-compatible client","Qdrant instance (local or remote)","network connectivity to Qdrant (localhost:6333 for local)"],"failure_modes":["Requires Google Gemini API key for embedding generation — no offline embedding option","Text splitting uses fixed chunk sizes; may not preserve semantic boundaries for highly structured code","No built-in encryption for stored memories — data stored locally in plaintext within Qdrant","Embedding generation adds latency (~500ms-1s per record) due to cloud API calls","Similarity search quality depends on embedding model quality — Gemini embeddings may not capture domain-specific semantics","No hybrid search (semantic + keyword) — purely vector-based, may miss exact-match memories","Requires Qdrant to be running and accessible — no fallback to local search if database is unavailable","Latency for each retrieval query (~500ms-1s) due to embedding generation and vector search","Meta-memory guidance is heuristic-based — not personalized to specific agent use cases","No machine learning on usage patterns — recommendations are rule-based","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.5,"ecosystem":0.6,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:03.578Z","last_scraped_at":"2026-05-03T14:00:15.503Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=memory-plus","compare_url":"https://unfragile.ai/compare?artifact=memory-plus"}},"signature":"AM2j9nKb1m1+ppuEH3t6ilnfhoDZa6JjGRFsW0a376/c+LeDBvz6mMEEXJmDLQ5UyAiiOQOiltqbcMcdFX6ICA==","signedAt":"2026-06-20T14:30:48.801Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/memory-plus","artifact":"https://unfragile.ai/memory-plus","verify":"https://unfragile.ai/api/v1/verify?slug=memory-plus","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}