home / skills / sickn33 / antigravity-awesome-skills / agent-memory-mcp

agent-memory-mcp skill

safe

This skill provides a persistent, searchable memory for AI agents that automatically syncs with project docs via an MCP server.

This is most likely a fork of the agent-memory-mcp skill from xfstudio

npx playbooks add skill sickn33/antigravity-awesome-skills --skill agent-memory-mcp

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.1 KB

---
name: agent-memory-mcp
author: Amit Rathiesh
description: A hybrid memory system that provides persistent, searchable knowledge management for AI agents (Architecture, Patterns, Decisions).
---

# 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

1. **Clone the Repository**:
   Clone the `agentMemory` project into your agent's workspace or a parallel directory:

   ```bash
   git clone https://github.com/webzler/agentMemory.git .agent/skills/agent-memory
   ```

2. **Install Dependencies**:

   ```bash
   cd .agent/skills/agent-memory
   npm install
   npm run compile
   ```

3. **Start the MCP Server**:
   Use the helper script to activate the memory bank for your current project:

   ```bash
   npm run start-server <project_id> <absolute_path_to_target_workspace>
   ```

   _Example for current directory:_

   ```bash
   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.

```bash
npm run start-dashboard <absolute_path_to_target_workspace>
```

Access at: `http://localhost:3333`

Overview

This skill is a hybrid persistent memory system that runs as an MCP server to give agents long-term, searchable knowledge management for architecture, patterns, and decisions. It keeps project documentation in sync with a memory bank and exposes tools to read, write, search, and analyze memories. A lightweight dashboard provides visibility into memory contents and usage metrics.

How this skill works

The skill runs an MCP-compatible server that accepts read, write, search, and stats calls. It indexes memories by key, type, and tags so agents can retrieve contextually relevant artifacts quickly. It can be started per-project and watches or syncs with a target workspace so documentation and decisions remain discoverable and persistent.

When to use it

Maintain a central, searchable store of architecture decisions and design patterns for a project.
Enable autonomous agents to reference past work, standards, and security findings when making changes.
Persist agent discoveries, bug investigations, or runbooks so future runs reuse context.
Provide cross-team visibility into patterns, rationale, and system trade-offs.
Audit and analyze memory usage across multiple agent sessions.

Best practices

Use consistent keys, types (e.g., decision, pattern, doc), and tags to keep search precise.
Write concise content and include links or references to source files for traceability.
Periodically run memory_stats to identify stale or duplicated entries and prune them.
Start a per-project MCP instance so memories stay scoped to a workspace and avoid noise.
Combine memory search with contextual prompts so agents surface only relevant entries.

Example use cases

Save a security audit finding with tags (auth, high-priority) so future agents flag related changes.
Record an architecture decision (keyed) when choosing a new database or API pattern.
Search for existing React patterns before implementing a new component to ensure consistency.
Retrieve a prior debugging session summary to speed up incident response.
Visualize memory distribution in the dashboard to plan knowledge consolidation.

FAQ

How do agents query memories?

Agents call the memory_search tool with a query string and optional type/tags, or use memory_read by key to fetch exact entries.

Can I run the memory server per project?

Yes. Start an MCP server instance scoped to the target workspace so memories stay project-specific and easier to manage.