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

# Other MCP clients

> Cline, Continue, Kiro, Qwen Code, Warp, Zed, Hermes, pi, and OpenHuman

Every client below shares the same flow: start the server with `npx @agentmemory/agentmemory`, wire the client, restart it, then verify with one prompt and the viewer at `http://localhost:3113` or `curl -X POST http://localhost:3111/agentmemory/smart-search -H 'Content-Type: application/json' -d '{"query": "test"}'`.

The first six have automated `connect` adapters that back up the target file, merge the entry, and verify the write. The last three are manual installs; `connect` prints the exact instructions instead of mutating files.

## Automated adapters

<Tabs>
  <Tab title="Cline">
    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect cline
    ```

    Detects `~/.cline/` and writes the standard block to `~/.cline/mcp.json` (the CLI surface):

    ```json ~/.cline/mcp.json theme={"dark"}
    {
      "mcpServers": {
        "agentmemory": {
          "command": "npx",
          "args": ["-y", "@agentmemory/mcp"],
          "env": {
            "AGENTMEMORY_URL": "${AGENTMEMORY_URL:-http://localhost:3111}",
            "AGENTMEMORY_SECRET": "${AGENTMEMORY_SECRET:-}",
            "AGENTMEMORY_TOOLS": "${AGENTMEMORY_TOOLS:-all}"
          }
        }
      }
    }
    ```

    VS Code extension users paste the same block via Cline Settings, MCP Servers, Edit JSON. The guideline lands as a project rule at `.clinerules/agentmemory.md` (no frontmatter, always active).
  </Tab>

  <Tab title="Continue">
    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect continue
    ```

    Continue v1+ prefers `~/.continue/config.yaml`, and the adapter branches on what exists:

    * `config.yaml` exists: the adapter refuses to rewrite your YAML (preserving comments and anchors safely needs a parser it does not ship) and prints the exact block to merge.
    * only legacy `config.json` exists: the entry is merged in place. Continue uses array form, `{"name": "agentmemory", "command": "npx", ...}` inside a `mcpServers` list, not an object.
    * neither exists: a fresh `config.yaml` is created:

    ```yaml ~/.continue/config.yaml theme={"dark"}
    mcpServers:
      - name: agentmemory
        command: npx
        args:
          - "-y"
          - "@agentmemory/mcp"
        env:
          AGENTMEMORY_URL: "${AGENTMEMORY_URL:-http://localhost:3111}"
          AGENTMEMORY_SECRET: "${AGENTMEMORY_SECRET:-}"
          AGENTMEMORY_TOOLS: "${AGENTMEMORY_TOOLS:-all}"
    ```

    Guideline: project rule at `.continue/rules/00-agentmemory.md` (Continue does not auto-read AGENTS.md).
  </Tab>

  <Tab title="Kiro">
    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect kiro
    ```

    Detects `~/.kiro/` and writes the standard block to the user-level `~/.kiro/settings/mcp.json`. Workspace overrides live in `.kiro/settings/mcp.json` next to your code. Guideline: a steering file at `~/.kiro/steering/agentmemory.md` with `inclusion: always` frontmatter.
  </Tab>

  <Tab title="Qwen Code">
    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect qwen
    ```

    Detects `~/.qwen/` and writes the standard block into `~/.qwen/settings.json` (Qwen's `mcpServers` shape matches Claude Code's). Qwen's hook payload is field-compatible with Claude Code, so the bundled 12-hook scripts work unmodified when wired through the `hooks` section of the same `settings.json`. Guideline: marked block in `~/.qwen/QWEN.md`.
  </Tab>

  <Tab title="DeepSeek Harness">
    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect dsh
    ```

    Detects the Harness home (`DSH_HOME`, defaulting to `~/.dsh`) and appends one row to the home-level `cordis.patch.yml`, the machine-local patch layer every Harness profile loads:

    ```yaml $DSH_HOME/cordis.patch.yml theme={"dark"}
    - insert:
        - id: agentmemory
          name: '@deepseek-ai/dsh-mcp-client'
          config:
            transport: stdio
            serverName: agentmemory
            command: npx
            args: ['-y', '@agentmemory/mcp']
            env:
              AGENTMEMORY_URL: http://localhost:3111
    ```

    The bundled mcp-client plugin registers the tools as `mcp__agentmemory__<tool>` before the first turn. Harness env blocks take literal strings (no shell interpolation), so edit the URL directly if your engine binds elsewhere. Re-running is idempotent; `--force` replaces the rows.

    For auto-capture, add `--with-hooks`:

    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect dsh --with-hooks
    ```

    This writes agentmemory's Claude Code shaped hook manifest to `$DSH_HOME/agentmemory.hooks.json` (absolute script paths, no env expansion needed) and adds a second patch row for `@deepseek-ai/dsh-hooks-claude-code`, Harness's first-party Claude Code hook bridge. Prompts and tool calls then flow into memory automatically on the bridge's supported points: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop. The manifest's PreCompact entry is outside the bridge's supported subset and is skipped with a warning. The bridge runs hooks through Harness's shell service (`subprocess` + `bash` rows), which the standard `dsh-base` bundle provides; a hand-rolled minimal composition must include them or the bridge stays pending.

    Both rows are verified against a live Harness run from source: the mcp-client row registers the four memory tools and executes them through the real tool pipeline, and the hook bridge delivers the Claude Code payload to the bundled capture scripts, landing tool observations in the daemon with `tool`-channel provenance.
  </Tab>

  <Tab title="Warp">
    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect warp
    ```

    Detects `~/.warp/` and writes the standard block to `~/.warp/.mcp.json`. Warp also auto-discovers skills from `.claude/skills/`, so with the Claude Code plugin installed the 8 agentmemory action skills appear in Warp's slash-command palette. Guideline: marked block in the project's `AGENTS.md` (Warp's global Rules are UI-managed, so there is no global file to write).
  </Tab>

  <Tab title="Zed">
    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect zed
    ```

    Zed keys MCP servers under `context_servers`, not `mcpServers`, in `~/.config/zed/settings.json` (Zed uses the XDG path even on macOS):

    ```json ~/.config/zed/settings.json theme={"dark"}
    {
      "context_servers": {
        "agentmemory": {
          "command": "npx",
          "args": ["-y", "@agentmemory/mcp"],
          "env": {
            "AGENTMEMORY_URL": "${AGENTMEMORY_URL:-http://localhost:3111}",
            "AGENTMEMORY_SECRET": "${AGENTMEMORY_SECRET:-}",
            "AGENTMEMORY_TOOLS": "${AGENTMEMORY_TOOLS:-all}"
          }
        }
      }
    }
    ```

    Guideline: marked block in `~/.config/zed/AGENTS.md`.
  </Tab>
</Tabs>

## Manual installs

<Tabs>
  <Tab title="Hermes Agent">
    `connect hermes` detects `~/.hermes/` but does not rewrite YAML; it prints this block to add to `~/.hermes/config.yaml`:

    ```yaml ~/.hermes/config.yaml theme={"dark"}
    mcp_servers:
      agentmemory:
        command: npx
        args: ["-y", "@agentmemory/mcp"]

    memory:
      provider: agentmemory
    ```

    For deeper integration, copy the Python plugin:

    ```bash theme={"dark"}
    cp -r integrations/hermes ~/.hermes/plugins/agentmemory
    ```

    The plugin hooks six points in the agent loop: `prefetch()` injects memories before each LLM call, `sync_turn()` captures every turn, `on_session_end()` marks sessions for summarization, `on_pre_compress()` re-injects context before compaction, `on_memory_write()` mirrors MEMORY.md writes, and `system_prompt_block()` injects the project profile at session start. It reads `~/.agentmemory/.env` at import time to fill missing `AGENTMEMORY_URL` and `AGENTMEMORY_SECRET` values; shell exports take precedence. Set `AGENTMEMORY_REQUIRE_HTTPS=1` to refuse sending the bearer token over plaintext HTTP to a non-loopback host.

    Validate the install with Hermes's own tooling: `hermes plugins doctor ~/.hermes/plugins/agentmemory` checks the manifest, import, and runtime contracts, and `hermes memory status` should show the provider as installed and available. Verified against Hermes v0.20.1.
  </Tab>

  <Tab title="pi">
    pi uses its extension API, not MCP, so it hooks the agent lifecycle directly against the REST API on 3111. One command installs it:

    ```bash theme={"dark"}
    npx @agentmemory/agentmemory connect pi
    ```

    The bundled extension lands in `~/.pi/agent/extensions/agentmemory/`, which pi auto-discovers — no settings.json edit. A running pi picks it up with `/reload`. Re-running is a no-op while the copy is current; a stale copy refreshes with a backup.

    From a repo checkout, `integrations/pi` is also a pi package, so `pi install ./integrations/pi` works and `pi install` manages it like any other package.

    The extension adds `memory_health`, `memory_search`, and `memory_save` tools, recall on `before_agent_start`, capture on `agent_end`, and the `/agentmemory-status` command. Verify inside pi with `/agentmemory-status`; it should report `agentmemory healthy`.
  </Tab>

  <Tab title="OpenHuman">
    `connect openhuman` detects `~/.openhuman/` and reports a stub: no `integrations/openhuman/` folder exists in the repo yet. OpenHuman is a Memory-trait host; the expected wiring is its Memory trait implemented against the REST proxy at `http://localhost:3111`. Automation lands once that integration folder does.
  </Tab>
</Tabs>

## Any other MCP client

The standalone stdio server works with any MCP host:

```bash theme={"dark"}
npx @agentmemory/mcp
```

Point the host's config at that command with `AGENTMEMORY_URL` in the env. Sandboxed clients (Flatpak, Snap, restrictive containers) that cannot reach the host's localhost should also set `"AGENTMEMORY_FORCE_PROXY": "1"` and point `AGENTMEMORY_URL` at a route the sandbox can reach.

Adapter sources: `src/cli/connect/{cline,continue,dsh,kiro,qwen,warp,zed,hermes,pi,openhuman}.ts`. Plugins: `integrations/hermes/`, `integrations/pi/`.