Agent memory

Skill ranbot-ai/awesome-skills/skills/agent-memory

Awesome Claude Skills, Tools for Customizing Claude AI workflows

Install

npx -y skills add ranbot-ai/awesome-skills --skill agent-memory

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
6 stars6 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

A hybrid memory system that provides persistent, searchable knowledge management for AI agents.

SKILL.md

2.9 KB, as published. Nobody here has run it

agentMemory Skill

When to Use

Use this skill when you need a hybrid memory system that provides persistent, searchable knowledge management for AI agents.

This skill extends your capabilities by providing a persistent, searchable memory bank that automatically syncs with project documentation.

Prerequisites

Node.js installed
Check if agentMemory is already installed in the project:
```
ls -la .agentMemory
```

Setup

Install Dependencies:
```
npm install
```
Build the Project:
```
npm run compile
```
Start the Memory Server: You need to run the MCP server to interact with the memory bank.
```
npm run start-server <project_id> <absolute_path_to_workspace>
```
Note: This skill typically runs as a background process or via an mcp-server configuration. ensuring it is running is key.

Capabilities (MCP Tools)

Once the server is running, you can use these 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({})

Workflow

Initialization: The first time you run this in a project, it may attempt to import existing markdown memory banks from .kilocode/, .clinerules/, or .roo/.
Development Loop:
- Before Task: Search memory for relevant context.
- During Task: Use read/search to answer questions.
- After Task: Write new findings to memory.
Sync: Your writes are automatically synced to standard markdown files in the project.

Limitations

Use this skill only when the task clearly matches its upstream source and local project context.
Verify commands, generated code, dependencies, credentials, and external service behavior before applying changes.
Do not treat examples as a substitute for environment-specific tests, security review, or user approval for destructive or costly actions.