agent-memory-mcp
sickn33/antigravity-awesome-skills
Persistent, searchable memory system for AI agents to store and retrieve architecture, patterns, and decisions.
What is agent-memory-mcp?
A hybrid memory management system that runs as an MCP server, enabling AI agents to persistently store, search, and retrieve knowledge about project architecture, design patterns, and decisions. Use it when you need long-term context that syncs with project documentation across agent sessions.
- Search memories by query, type, or tags with `memory_search`
- Write and persist new knowledge, patterns, or decisions with `memory_write`
- Retrieve specific memory content by key with `memory_read`
- View memory usage analytics with `memory_stats`
- Access a standalone dashboard to visualize memory usage and organization
How to install agent-memory-mcp
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill agent-memory-mcp- Node.js v18 or higher
- Git (to clone the agentMemory repository)
How to use agent-memory-mcp
- 1.Clone the agentMemory repository into your agent's workspace: `git clone https://github.com/webzler/agentMemory.git .agent/skills/agent-memory`
- 2.Install dependencies: `cd .agent/skills/agent-memory && npm install && npm run compile`
- 3.Start the MCP server with your project ID and workspace path: `npm run start-server my-project $(pwd)`
- 4.Use `memory_search()` to find memories by query, type, or tags
- 5.Use `memory_write()` to record new knowledge with a key, type, and content
- 6.Use `memory_read()` to retrieve specific memories by key
- 7.Optionally start the dashboard with `npm run start-dashboard <path>` and access it at `http://localhost:3333`
Use cases
- Store and retrieve authentication patterns across multiple projects
- Document architectural decisions and recall them when making similar choices
- Build a searchable knowledge base of project-specific patterns and conventions
- Track design decisions over time to maintain consistency in large codebases
- Provide agents with persistent context about project structure and past solutions
- AI agents requiring long-term project context
- Development teams managing complex architectures
- Projects with recurring design patterns and decisions
- Teams needing searchable documentation of architectural choices
agent-memory-mcp FAQ
The system supports at least 'pattern' and 'decision' types, with custom types supported via the `type` parameter in `memory_write`.
Use `memory_search()` with a query string, optional type filter, and optional tags array to find relevant memories.
Yes; start separate MCP server instances for different projects by providing different `project_id` and workspace paths to `npm run start-server`.
The skill description indicates it automatically syncs with project documentation, though specific sync mechanisms are not detailed in the setup.
The dashboard visualizes memory usage and organization; access it at `http://localhost:3333` after running `npm run start-dashboard`.
Full instructions (SKILL.md)
Source of truth, from sickn33/antigravity-awesome-skills.
name: agent-memory-mcp description: "A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions)." risk: unknown source: community date_added: "2026-02-27"
Agent Memory Skill
This skill provides a persistent, searchable memory bank that automatically syncs with project documentation. It runs as an MCP server to allow reading/writing/searching of long-term memories.
Prerequisites
- Node.js (v18+)
Setup
-
Clone the Repository: Clone the
agentMemoryproject into your agent's workspace or a parallel directory:git clone https://github.com/webzler/agentMemory.git .agent/skills/agent-memory -
Install Dependencies:
cd .agent/skills/agent-memory npm install npm run compile -
Start the MCP Server: Use the helper script to activate the memory bank for your current project:
npm run start-server <project_id> <absolute_path_to_target_workspace>Example for current directory:
npm run start-server my-project $(pwd)
Capabilities (MCP Tools)
memory_search
Search for memories by query, type, or tags.
- Args:
query(string),type?(string),tags?(string[]) - Usage: "Find all authentication patterns" ->
memory_search({ query: "authentication", type: "pattern" })
memory_write
Record new knowledge or decisions.
- Args:
key(string),type(string),content(string),tags?(string[]) - Usage: "Save this architecture decision" ->
memory_write({ key: "auth-v1", type: "decision", content: "..." })
memory_read
Retrieve specific memory content by key.
- Args:
key(string) - Usage: "Get the auth design" ->
memory_read({ key: "auth-v1" })
memory_stats
View analytics on memory usage.
- Usage: "Show memory statistics" ->
memory_stats({})
Dashboard
This skill includes a standalone dashboard to visualize memory usage.
npm run start-dashboard <absolute_path_to_target_workspace>
Access at: http://localhost:3333
When to Use
This skill is applicable to execute the workflow or actions described in the overview.
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
Related skills
More from sickn33/antigravity-awesome-skills and the wider catalog.

agent-orchestration-multi-agent-optimize
Optimize multi-agent systems with coordinated profiling, workload distribution, and cost-aware orchestration. Use when improving agent performance, throughput, or reliability.

agent-tool-builder
Tools are how AI agents interact with the world. A well-designed

ai-product
Every product will be AI-powered. The question is whether you'll

ai-wrapper-product
Expert in building products that wrap AI APIs (OpenAI, Anthropic,

algolia-search
Expert patterns for Algolia search implementation, indexing

algorithmic-art
Algorithmic philosophies are computational aesthetic movements that are then expressed through code. Output .md files (philosophy), .html files (interactive viewer), and .js files (generative algorithms).