What makes agentmemory-mcp notable?

996 downloads. Trust evidence available

How should agentmemory-mcp be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

agentmemory-mcp

Persistent cross-session memory for OpenClaw via agentmemory. Use when: - User asks to install/configure agentmemory for OpenClaw - Agent needs to remember p... Skill: agentmemory-mcp Owner: lufei4 Summary: Persistent cross-session memory for OpenClaw via agentmemory. Use when: - User asks to install/configure agentmemory for OpenClaw - Agent needs to remember p... Tags: agentmemory:1.1.0, latest:1.3.0, mcp:1.1.0, memory:1.1.0, openclauw:1.1.0, persistent:1.1.0 Version history: v1.3.0 | 2026-05-13T07:47:38.658Z | user Major: Full Search Mode guide (BM25 vs Vector embedding p

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

996

Updated

Oct 11, 2026

Version

1.3.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 996 downloads reported by the source. Last updated 10/11/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 11, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 11, 2026
Adoption signal: 996 downloadsadoption · observed Oct 11, 2026
Latest release: 1.3.0release · observed May 13, 2026
Handshake status: UNKNOWNsecurity

What changed

Newest first. Only changes that point at a source are listed.

Release 1.3.0release
Major: Full Search Mode guide (BM25 vs Vector embedding provider choice); fix absolute paths; align with latest agentmemory v0.9.14 / iii-engine v0.11.6
Observed May 13, 2026 · source

Install and run

Setup complexity: low.

clawhub skill install s179k729rb0rtr2tvxk90h5pxs859fyv:agentmemory-mcp

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-lufei4-agentmemory-mcp/snapshot"

Run-check

$0.02 USD

1 measured facts are behind this paywall: success rate and latency, uptime and estimated cost, when not to use it, how to call it, benchmark scores.

Agents pay $0.02 in USDC. A card payment is $0.50, the smallest a card allows.

Documentation

CLAWHUB

146,597 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: agentmemory
description: |
  Persistent cross-session memory for OpenClaw via agentmemory.
  
  Use when:
  - User asks to install/configure agentmemory for OpenClaw
  - Agent needs to remember project context, decisions, or workflows across sessions
  - Setting up long-term memory for OpenClaw (MCP mode)
  - Integrating agentmemory with existing MEMORY.md system
  - Troubleshooting agentmemory connection issues
  - Upgrading or removing agentmemory

  ───────────────────────────────
  
  基于 agentmemory 的跨会话持久化记忆系统，适用于 OpenClaw。
  
  适用场景：
  - 用户要求安装/配置 agentmemory
  - Agent 需要记住项目背景、决策或工作流程
  - 为 OpenClaw 设置长期记忆（MCP 模式）
  - 与现有 MEMORY.md 系统集成
  - 排查 agentmemory 连接问题
  - 升级或移除 agentmemory
---

# agentmemory Integration for OpenClaw

> **Status**: ✅ Verified working with OpenClaw v2026.5.4
> **Version**: agentmemory npm v0.9.11 · iii-engine Docker v0.11.6
> **MCP Tools**: 107 REST + 51 MCP tools available

Persistent memory server giving OpenClaw agents cross-session semantic recall via BM25+Vector+Graph RRF hybrid search.

## Architecture

```
OpenClaw Agent ←→ Gateway (MCP) ←→ agentmemory MCP Server (localhost:3111)
                                              ↓
                                         SQLite/KV Store
                                              ↓
                                      Viewer (localhost:3113)
```

## Quick Start (MCP Mode — 5 minutes)

### Step 1: Install and start memory server

```bash
# Server runs on localhost:3111, viewer at localhost:3113
npx @agentmemory/agentmemory
```

### Step 2: Configure OpenClaw MCP

Add to `~/.openclaw/openclaw.json` under `mcp.servers`:

```json
{
  "mcp": {
    "servers": {
      "agentmemory": {
        "command": "npx",
        "args": ["-y", "@agentmemory/mcp"]
      }
    }
  }
}
```

### Step 3: Restart Gateway

```bash
openclaw gateway restart
```

### Step 4: Verify

```bash
curl http://localhost:3111/agentmemory/health
# → {"status":"healthy","version":"0.9.11"}

# View memory dashboard
open http://localhost:3113
```

---

## systemd Service (Production)

For auto-start and reliable background operation:

### Install service

```bash
mkdir -p ~/.config/systemd/user
cp ./scripts/agentmemory.service ~/.config/systemd/user/
systemctl --user daemon-reload
systemctl --user enable agentmemory
systemctl --user start agentmemory

# Enable linger (boot without login)
loginctl enable-linger $(whoami)
```

### Service commands

```bash
systemctl --user status agentmemory   # Check status
journalctl --user -u agentmemory -f   # View logs
systemctl --user restart agentmemory  # Restart
```

### Service environment variables

| Variable | Value | Purpose |
|----------|-------|---------|
| `NODE_ENV` | `production` | Production mode |
| `AGENTMEMORY_PORT` | `3111` | MCP API port |
| `AGENTMEMORY_VIEWER_PORT` | `3113` | Dashboard port |
| `AGENTMEMORY_III_VERSION` | `latest` | iii-engine Docker image tag |

> **Important**: `AGENTMEMORY_III_VERSION=latest` overrides the npm CL

_meta.json

{
  "ownerId": "kn73p7swcakp5x33a5x0sf7yes859vh8",
  "slug": "agentmemory-mcp",
  "version": "1.3.0",
  "publishedAt": 1778658458658
}

references/coordination.md

# agentmemory + MEMORY.md Coordination Guide

## Architecture Overview

```
┌─────────────────────────────────────────────────────────┐
│                  OpenClaw Memory System                 │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌───────────────────────┐  ┌────────────────────────┐ │
│  │   agentmemory (MCP)    │  │    MEMORY.md / AGENTS  │ │
│  │                       │  │                        │ │
│  │  • Auto-capture       │  │  • Curated rules       │ │
│  │  • Semantic search    │  │  • Preferences         │ │
│  │  • 95.2% R@5          │  │  • Manual updates      │ │
│  │  • Cross-agent        │  │  • Human-readable      │ │
│  │  • Session sync       │  │  • Survives compaction │ │
│  └───────────────────────┘  └────────────────────────┘ │
│            │                        │                   │
│            └────────┬───────────────┘                   │
│                     ▼                                   │
│           ┌─────────────────┐                          │
│           │  OpenClaw Agent  │                          │
│           └─────────────────┘                          │
└─────────────────────────────────────────────────────────┘
```

## Layer Responsibilities

| Layer | Tool | What's stored | Management |
|-------|------|--------------|------------|
| **Experience** | agentmemory | Tasks, decisions, results, observations | Automatic |
| **Knowledge** | MEMORY.md | Rules, preferences, long-term facts | Manual |
| **Daily** | memory/YYYY-MM-DD.md | Session logs, events | Automatic |

---

## Agent Behavior Guidelines

### Session Start

1. **MEMORY.md + daily logs** → loaded automatically by OpenClaw
2. **agentmemory** → agent can call `memory_recall` for additional context
3. No conflict — both systems serve different purposes

### During Work

- **Task decision**: Call `memory_smart_search` to check if similar task was done
- **Success**: Call `memory_save` with result, e.g.:
  ```
  memory_save("Deployed backend to Railway, took 8 minutes", 
    type="observation", tags=["deployment"])
  ```
- **Failure**: Call `memory_save` noting what didn't work

### Session End

- OpenClaw auto-captures conversation via `plugins.slots.memory`
- Critical learnings → also write to MEMORY.md (persists beyond compaction)

---

## Migration from Existing MEMORY.md

If MEMORY.md has valuable content, migrate selectively:

```bash
# Start server first
npx @agentmemory/agentmemory

# In another terminal, import MEMORY.md
npx @agentmemory/agentmemory migrate --from-file ~/.openclaw/workspace/MEMORY.md
```

Or use `memory_import` in batches:

```javascript
// Example: Migrate section by section
memory_import([
  { content: "Backend deployed via Railway CLI", type: "observation", tags: ["deployment"] },
  { content: "User prefers brief responses", type: "preference", tags: ["communication"] }
], strategy: "merge")
```

---

## Conflict Resolution

**Q:

references/mcp-tools.md

# agentmemory MCP Tools Reference

Complete list of 43 MCP tools available via `agentmemory` MCP server.

## Core Memory Operations

### memory_recall
Retrieve semantically relevant memories.
```
memory_recall(query: string, limit?: number, threshold?: number)
```

### memory_save
Store new memories with optional metadata.
```
memory_save(content: string, type?: "observation" | "decision" | "fact" | "preference", tags?: string[])
```

### memory_smart_search
Hybrid BM25 + vector search.
```
memory_smart_search(query: string, limit?: number)
```

### memory_forget
Delete memories by ID or pattern.
```
memory_forget(pattern?: string, id?: string)
```

### memory_update
Update existing memory content or metadata.
```
memory_update(id: string, content?: string, tags?: string[])
```

---

## Navigation & Exploration

### memory_timeline
View memories chronologically.
```
memory_timeline(start?: date, end?: date, limit?: number)
```

### memory_tree
Hierarchical view of knowledge graph.
```
memory_tree(root?: string, depth?: number)
```

### memory_trace
View provenance/derivation chain of a memory.
```
memory_trace(id: string)
```

### memory_stats
Memory usage statistics.
```
memory_stats()
```

---

## Agent Integration

### memory_profile
Detailed agent memory profile.
```
memory_profile(agent_id?: string)
```

### memory_snapshot
Export all memories as JSON.
```
memory_snapshot(format?: "json" | "markdown")
```

### memory_import
Bulk import memories.
```
memory_import(memory: Memory[], strategy?: "merge" | "replace")
```

### memory_compact
Compress and consolidate memories.
```
memory_compact(threshold?: number)
```

---

## Knowledge Graph

### memory_relate
Create relationships between memories.
```
memory_relate(from_id: string, to_id: string, relationship?: string)
```

### memory_graph_query
Query knowledge graph.
```
memory_graph_query(query: string, depth?: number)
```

### memory_entities
List all entities in knowledge graph.
```
memory_entities(type?: string)
```

### memory_paths
Find paths between two memories.
```
memory_paths(from_id: string, to_id: string)
```

---

## Context & Sessions

### memory_context
Get context for current session.
```
memory_context(include_recent?: number)
```

### memory_inject
Inject memories into current context.
```
memory_inject(limit?: number, match?: string)
```

### memory_session
Session-specific memory operations.
```
memory_session(op: "save" | "load" | "clear", data?: any)
```

---

## Configuration

### memory_config
View/update agentmemory configuration.
```
memory_config(op: "get" | "set", key?: string, value?: any)
```

### memory_channels
List available memory channels.
```
memory_channels()
```

---

## Advanced

### memory_analyze
Analyze memory patterns.
```
memory_analyze(analysis_type?: "coverage" | "gaps" | "redundancy")
```

### memory_consolidate
Consolidate fragmented memories.
```
memory_consolidate(strategy?: "simple" | "semantic")
```

### memory_evict
Evict low-value memories

references/openclaw-plugin/openclaw.plugin.json

{
  "schema_version": 1,
  "name": "agentmemory",
  "version": "1.0.0",
  "description": "Persistent cross-session memory with semantic search",
  "slots": ["memory"],
  "config": {
    "base_url": {
      "type": "string",
      "default": "http://localhost:3111",
      "description": "agentmemory server URL"
    },
    "token_budget": {
      "type": "number",
      "default": 2000,
      "description": "Max tokens per recall injection"
    },
    "min_confidence": {
      "type": "number",
      "default": 0.5,
      "description": "Minimum confidence threshold for recall"
    },
    "fallback_on_error": {
      "type": "boolean",
      "default": true,
      "description": "Continue without memory if server unavailable"
    },
    "timeout_ms": {
      "type": "number",
      "default": 5000,
      "description": "Request timeout in milliseconds"
    }
  },
  "hooks": {
    "beforeAgent": "onBeforeAgent",
    "afterAgent": "onAfterAgent"
  },
  "requirements": {
    "server": "agentmemory",
    "min_openclaw_version": "1.0.0"
  }
}

Github ReposUpdated 3d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.

MCPOPENCLAW

Github ReposUpdated 7mo agoRank 70

CopilotKit

The Frontend for Agents & Generative UI. React + Angular