> ## Documentation Index
> Fetch the complete documentation index at: https://docs.agentscope.io/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> For AgentScope Python, use https://docs.agentscope.io/stable/en/index for new projects. For existing projects, check the installed agentscope version and use matching versioned documentation.
> The /latest/ alias points to development documentation. Use it only with the matching development source. Do not mix AgentScope 1.x and 2.x APIs.
> State the AgentScope version when providing installation commands or code examples. ReMe uses its own continuously updated /reme/latest/ documentation.

# Agent Integrations

> Connect supported agents to ReMe through maintained in-process Python, tool, Skill, and plugin integrations.

This page covers maintained host integrations. Claude Code, Hermes, OpenClaw, Codex, and other CLI-capable agents connect to a [deployed ReMe service](/reme/latest/en/integration/deployment); QwenPaw uses the in-process Python path. For AgentScope's `ReMeMiddleware`, use the [Python integration](/reme/latest/en/integration/python-sdk#agentscope).

## Choose an Integration Pattern

The following patterns differ in how they package service access and memory behavior:

| Pattern      | What it provides                                                                            | Best for                                                         |
| ------------ | ------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
| Direct tools | Calls to the service through MCP, CLI, or HTTP                                              | Custom Agents that already manage tool use and session lifecycle |
| Skill        | Rules for when to search, read, and record through a service client                         | Hosts that support portable Agent Skills                         |
| Plugin       | Connection configuration, tools or Skills, and lifecycle hooks in one host-specific package | Hosts with a maintained ReMe plugin                              |

All three patterns connect to the same service boundary:

```text theme={null}
Agent ── tools / Skill / plugin ──> MCP / CLI / HTTP ──> ReMe service ──> workspace
```

The Agent-side integration does not own the ReMe process. It selects the service interface, supplies session context, and decides when returned memory should affect an answer.

### Skill

A Skill is the behavior layer above the service interface, not a service or transport. The bundled [`skills/reme_memory/`](https://github.com/agentscope-ai/ReMe/tree/main/skills/reme_memory) uses the ReMe CLI; another host can apply the same behavior through MCP tools or HTTP.

To use the Skill, install the complete `skills/reme_memory/` directory in the host's skill location. Keep `SKILL.md` and its supporting rules together. The host should then:

1. Search, then read relevant files before answering about earlier conversations, preferences, decisions, or project history.
2. Record only durable facts, preferences, decisions, and lessons; do not store secrets or sensitive information by default.
3. Call `auto_memory` after a useful session or when stable information appears, using a stable `session_id` from the host lifecycle.
4. Let ReMe's cron run `auto_dream`, or trigger it from the host lifecycle.
5. Treat ReMe as memory input; the Agent still decides whether and how to use the result.

The Skill does not start ReMe or invent missing conversation history.

### Plugin

A plugin packages the pieces needed by a specific host, such as service connection settings, tools, Skills, and session hooks. It should point to an already deployed ReMe service and use the host lifecycle for automatic recall or recording. Installing a plugin does not imply that it starts or owns ReMe.

## Maintained Integrations

ReMe currently documents or includes maintained integration paths for these hosts:

| Host             | Integration                 | Recall                            | Recording                                  |
| ---------------- | --------------------------- | --------------------------------- | ------------------------------------------ |
| Claude Code      | ReMe plugin                 | MCP tools and `reme-memory` Skill | Automatic Stop hook                        |
| Hermes Agent     | ReMe memory-provider plugin | HTTP search before model calls    | Queued `auto_memory` after completed turns |
| QwenPaw          | In-process Python API       | Host-managed search and retrieval | Host lifecycle and model configuration     |
| OpenClaw / Codex | `reme_memory` Skill         | ReMe CLI                          | Requires explicit host lifecycle hooks     |

The following sections cover their host-specific setup and verification. The bundled Skill can also be adapted by any CLI-capable agent.

## Claude Code

The Claude Code plugin combines MCP recall, a recall skill, and asynchronous session recording. It connects to a shared ReMe MCP server and does not start ReMe itself.

### 1. Start ReMe

Install ReMe through the [ReMe Quick Start](/reme/latest/en/quickstart), then keep the MCP service running:

```bash theme={null}
reme start service.backend=mcp service.transport=streamable-http
```

The default endpoint is `http://127.0.0.1:2333/mcp`. Automatic recording also requires the configured LLM environment.

### 2. Install the Plugin

Clone the ReMe repository. From its root, add the bundled marketplace and install the plugin in Claude Code:

```text theme={null}
/plugin marketplace add ./plugins/claude_code
/plugin install reme@reme-marketplace
```

Restart Claude Code, run `/mcp`, and confirm that the `reme` server and tools are connected.

The package is located under `plugins/claude_code/`. Its `.mcp.json` defines the server URL, the `reme-memory` skill controls recall, and `hooks/auto_memory.py` calls `auto_memory_cc` after a session ends.

### 3. Verify Recall and Recording

Write a distinctive memory from a terminal:

```bash theme={null}
reme write \
  path=digest/wiki/claude-code-check \
  name="Claude Code Check" \
  description="Claude Code integration check" \
  content="Project rule: run pytest before submitting changes."
```

Ask Claude Code what to run before submitting changes. It should search and read ReMe before answering.

Next, end a conversation containing durable information and search for a distinctive phrase after a short delay:

```bash theme={null}
reme search query="<phrase from the conversation>" limit=5
```

The Stop hook runs asynchronously and is best-effort: an unavailable ReMe service does not block Claude Code. If you change the server port, update `plugins/claude_code/reme/.mcp.json` too. See the [plugin README](https://github.com/agentscope-ai/ReMe/blob/main/plugins/claude_code/README.md) for hook overrides and log locations.

## Hermes Agent

The Hermes memory-provider plugin connects to a separately managed ReMe HTTP service. It recalls relevant memory before each model call and records completed turns through `auto_memory` without blocking the main conversation path.

### 1. Start ReMe

Use a dedicated workspace and endpoint for each Hermes profile that must remain isolated:

```bash theme={null}
reme start \
  workspace_dir="$HOME/.reme-hermes-default" \
  service.backend=http \
  service.host=127.0.0.1 \
  service.port=2333
```

BM25 recall does not require embeddings, but automatic recording needs a working LLM configuration.

### 2. Install and Configure the Plugin

```bash theme={null}
hermes plugins install agentscope-ai/ReMe/plugins/hermes_agent
hermes memory setup
```

Select `reme`, confirm the HTTP endpoint, then run `hermes memory status`. Configuration is stored in `$HERMES_HOME/reme.json`. A single ReMe workspace shares recalled memory, so use separate workspaces and endpoints when Hermes profiles must not share context.

### 3. Understand Failure Behavior

Recall uses a short independent timeout before model calls. Completed turns are queued for a serial background writer. On shutdown, the writer is given a bounded interval to drain. Health, retrieval, and recording cooldowns are isolated so one failing path does not unnecessarily disable the others. See the [Hermes plugin README](https://github.com/agentscope-ai/ReMe/blob/main/plugins/hermes_agent/README.md) for configuration fields and lifecycle details.

## QwenPaw

QwenPaw's recommended path is to embed ReMe through its Python API so the host can reuse the application lifecycle and model configuration while keeping memory local and file-based. Follow the [Python SDK guide](/reme/latest/en/integration/python-sdk) and keep exactly one runtime owner for the workspace.

### Verify Recall and Recording

Write a test memory from a terminal:

```bash theme={null}
reme write \
  path=digest/personal/qwenpaw-check \
  name="QwenPaw Check" \
  description="QwenPaw integration check" \
  content="User preference: lead with the conclusion in technical explanations."
```

Ask QwenPaw how you prefer technical explanations. Confirm that its in-process integration searches ReMe and reads the file before answering.

After providing another durable fact, end the session and search for its keywords. The host must supply a stable session identifier and its real message history; do not invent missing conversation content.

## OpenClaw, Codex, and Other CLI-Capable Agents

Install the complete [`skills/reme_memory/`](https://github.com/agentscope-ai/ReMe/tree/main/skills/reme_memory) directory in the host's Skill location and keep the ReMe HTTP service running. The Skill uses the CLI to search, read, traverse, and record memory. `read` accepts Markdown only; for other text results, inspect size with `reme stat` before using `reme load`.

The Skill does not provide automatic recording by itself. Connect `auto_memory` to an explicit host session or turn hook, pass a stable `session_id`, and provide only actual conversation messages. ReMe omits recalled tool results and base64 data when persisting transcripts so retrieved or binary content does not become source conversation material.