# How to connect Mem0 to Hermes Agent (paste one key, 47 tools)

> Connect Mem0 to Hermes with ClawLink: paste your Mem0 key once and 47 tools work from chat. No MCP server to run, nothing stored on your machine.

Web version: https://claw-link.dev/hermes/mem0

Most guides for giving Hermes Agent Mem0 access start with registering your own OAuth app or pasting API keys into env files, then leave the token refresh and tool wiring to you. ClawLink gives Hermes a more practical Mem0 setup: pair once in the browser and your always-on Hermes agent can act on Mem0 for you, reading and doing real work on your behalf with no auth, token refresh, or tool wiring to build yourself.

**Start here — paste this into Hermes to set up ClawLink:**

> Set up ClawLink for Hermes and tell me when it's ready.
> 1. Install the plugin: `hermes plugins install ClawLink-HQ/hermes-plugin --enable`
> 2. Start pairing with `hermes clawlink begin`. It prints an approval link, so show me the link and stop, don't wait.
> 3. I'll approve it in my browser, then reply "approved".
> 4. When I say approved, finish setup: `hermes clawlink finish`
> 5. Then run `hermes clawlink test` and tell me whether ClawLink is ready.

## Setup

It takes three steps to connect Hermes to Mem0.

1. **Install ClawLink** — add the plugin to Hermes Agent once.
2. **Connect Mem0** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask Hermes Agent in plain English.

**Alternative for any agent (no plugin needed):** if the Hermes Agent plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect mem0  # connect Mem0 (browser OAuth)
npx -y @useclawlink/cli actions mem0  # list available actions
npx -y @useclawlink/cli run mem0 <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The prompt above walks Hermes through this. By hand, it is four commands and a browser approval:

```bash
hermes plugins install ClawLink-HQ/hermes-plugin --enable
hermes clawlink begin    # prints an approval link — open it and approve
hermes clawlink finish   # after approving in the browser
hermes clawlink test
```

Then connect Mem0 in the [ClawLink dashboard](https://claw-link.dev/dashboard) — paste your Mem0 API key once.

Verify the connection by asking Hermes:

> Call mem0_get_projects and mem0_fetch_detailed_list_of_organizations, then tell me which orgs and projects this connection can reach and which of them I own.

### Using a different agent?

The Hermes plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once Mem0 is connected in the dashboard, that agent calls the same 47 Mem0 tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## Mem0 MCP for Hermes

Looking for a Mem0 MCP server for Hermes Agent? ClawLink connects Mem0 to Hermes Agent and exposes 47 Mem0 tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using OpenClaw instead? The [OpenClaw Mem0 integration](https://claw-link.dev/openclaw/mem0) works the same way.

Every search result and answer engine teaches the same Mem0 flow: run `hermes memory setup`, choose mem0, paste an API key into a `~/.hermes/.env` file, and you get the memory tools Hermes ships natively, three of them. This page is a different question. The key goes to a hosted setup page once, Hermes Agent pairs with `hermes clawlink begin` and `hermes clawlink finish`, and the agent gets the full Mem0 platform API, 47 tools: organizations, projects, members, webhooks, agents and agent runs, memory records, semantic search, memory events, and exports. Nothing is written to an env file on your machine, and the key lives server-side where rotating it means changing one thing.

## What the Hermes Agent Mem0 integration can do

47 Mem0 tools are ready for Hermes Agent once the account is connected. The 30 below are the ones people reach for most; your agent can call all 47.

### 30 of 47 Mem0 tools for Hermes

| Tool | What it does |
|---|---|
| **Add member to project** `mem0_add_member_to_project` | Adds an existing user to a project (identified by `project_id` within organization `org_id`), assigning a valid system role. |
| **Add new memory records** `mem0_add_new_memory_records` | Stores new memory records from a list of messages, optionally inferring structured content; requires association via `agent_id`, `user_id`, `app_id`, or `run_id`. |
| **Add organization member** `mem0_add_organization_member` | Adds a new member, who must be a registered user, to an organization, assigning them a specific role. |
| **Create a new agent** `mem0_create_a_new_agent` | Creates a new agent with a unique `agent_id` and an optional `name`; additional metadata may be assigned by the system. |
| **Create a new agent run** `mem0_create_a_new_agent_run` | Creates a new agent run in the mem0.ai system. |
| **Create a new application** `mem0_create_a_new_application` | Creates a new application, allowing metadata to be passed in the request body (not an explicit field in this action's request model); ensure `app_id` is unique to avoid potential errors or unintended updates. |
| **Create a new organization entry** `mem0_create_a_new_organization_entry` | Creates a new organization entry using the provided name and returns its details. |
| **Create a new user** `mem0_create_a_new_user` | Creates a new user with the specified unique `user_id` and supports associating `metadata` (not part of the request schema fields). |
| **Create memory entry** `mem0_create_memory_entry` | Lists/searches existing memory entries with filtering and pagination; critically, this action retrieves memories and does *not* create new ones, despite its name. |
| **Create project** `mem0_create_project` | Creates a new project with a given name within an organization that must already exist. |
| **Create webhook** `mem0_create_webhook` | Creates a new webhook for a specific project to receive real-time notifications. Use when you need to set up event-driven integrations that trigger on memory operations. |
| **Fetch detailed list of organizations** `mem0_fetch_detailed_list_of_organizations` | Retrieves a summary list of organizations for administrative oversight; returns summary data |
| **Fetch details of a specific organization** `mem0_fetch_details_of_a_specific_organization` | Fetches comprehensive details for an organization using its `org_id`; the `org_id` must be |
| **Fetch list of entity filters** `mem0_fetch_list_of_entity_filters` | Retrieves predefined filter definitions for entities (e.g., by type, creation/modification |
| **Fetch specific entity details with optional filters** `mem0_fetch_specific_entity_details_with_optional_filters` | Fetches detailed information for an existing entity (user, agent, app, or run) identified by |
| **Get event status by event ID** `mem0_get_event_status_by_event_id` | Retrieves a single async event by ID to check its current status and results |
| **Get memories by entity** `mem0_get_memories_by_entity` | Retrieve all memories associated with a specific entity (user, agent, app, or run) |
| **Get memory export** `mem0_get_memory_export` | Retrieves the status and results of a memory export job by its ID |
| **Get organization members** `mem0_get_organization_members` | Fetches a list of members for a specified, existing organization |
| **Get project details** `mem0_get_project_details` | Fetches comprehensive details for a specified project within an organization |
| **Get project members** `mem0_get_project_members` | Retrieves all members for a specified project within an organization |
| **Get project webhooks** `mem0_get_project_webhooks` | Retrieves all webhooks configured for a specific project |
| **Get projects** `mem0_get_projects` | Retrieves all projects for a given organization `org_id` to which the caller has access |
| **Get user memory stats** `mem0_get_user_memory_stats` | Retrieves a summary of the authenticated user's memory activity, including total memories |
| **List entities with optional org and project filters** `mem0_list_entities_with_optional_org_and_project_filters` | Retrieves a list of entities, optionally filtered by organization or project (prefer |
| **Perform semantic search on memories** `mem0_perform_semantic_search_on_memories` | Searches memories semantically using a natural language query and metadata filters |
| **Retrieve all events for the currently logged in user** `mem0_retrieve_all_events_for_the_currently_logged_in_user` | Retrieves a paginated list of events for the authenticated user, filterable and paginable via |
| **Retrieve list of memory events** `mem0_retrieve_list_of_memory_events` | Retrieves a chronological list of all memory events (e.g., user inputs, AI responses) from the |
| **Retrieve memory by unique identifier** `mem0_retrieve_memory_by_unique_identifier` | Retrieves a complete memory entry by its unique identifier; `memory_id` must be valid and for |
| **Retrieve memory history by ID** `mem0_retrieve_memory_history_by_id` | Retrieves the complete version history for an existing memory, using its unique `memory_id`, to |

## Example prompts

**Map the account**

> Call mem0_get_projects and mem0_fetch_detailed_list_of_organizations, then tell me which orgs and projects this connection can reach and which of them I own.

**Search stored memory**

> Use mem0_perform_semantic_search_on_memories across \<project> for \<topic> and summarise what the stored memories say, flagging anything that looks contradictory.

**Export the memory set**

> Use mem0_get_memory_export for \<project> and tell me what format it returns, how large the set is, and whether anything predates this month.

**Check the plumbing**

> Call mem0_get_project_webhooks for \<project> and list what events are wired up, then tell me which events are not covered.

## How the Mem0 tools behave

Details that decide whether a Mem0 prompt is a fast answer or a quota-burning sweep.

- **Memory and platform are different surfaces.** The memory tools (add records, semantic search, get memories by entity) sit alongside org, project, member, webhook, agent, and run tools, so "what can this agent do" is answered by listing both, not just the memory ones.
- **Almost everything is addressed by id.** Organizations, projects, agents, and entities are ids from the list tools; an id from documentation fails like a 403 or a not-found depending on the endpoint.
- **Memory is add and retrieve, with events on top.** `mem0_add_new_memory_records` and `mem0_perform_semantic_search_on_memories` are the pair; `mem0_retrieve_list_of_memory_events` and `mem0_get_event_status_by_event_id` cover what changed and why.
- **Exports are one call.** `mem0_get_memory_export` pulls the set for portability instead of paging through searches.
- **Writes are account-scoped and quota-charged.** Creating projects, webhooks, and agents lands in your Mem0 account and consumes its monthly add quota, so reads-first prompts are the safe shape.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual API key setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want Mem0 working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Credential handling** | Collect, validate, store, and rotate the Mem0 API key yourself, then make sure every tool call uses the right account. | Users complete the hosted ClawLink setup once and the connected Mem0 account becomes available to the agent without you building credential management. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Mem0. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right Mem0 actions to the runtime in a format your agent can reliably use. | 47 tools for Mem0 are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Mem0 to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for Hermes Agent users instead. You install the plugin once, connect Mem0 in the browser, and the 47 tools above work from chat. There is no SDK and no config file, and the Mem0 key you paste at setup is stored server-side rather than kept in your environment. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### Hermes paired but still can't use Mem0
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

### Connection succeeds but no tools appear
Reconnect Mem0 from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling Mem0 tools
Mem0 tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every Mem0 call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### Mem0 returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### Mem0 returns 403 although the account shows as connected
The engines teach the cause list for this error and it is mostly account state, not connection state: a plan tier that does not include the endpoint, an expired or rotated key killing every consumer at once, a key pasted from the wrong environment, and an org or scope mismatch between the key's account and the resource. ChatGPT adds the shape that bites here: a `user_id` or `agent_id` scope mismatch, where the call carries an id the key's account does not own. The cause no engine teaches is the placeholder: an org, project, or agent id from documentation instead of from `mem0_get_projects`, which Mem0 answers as a permission error because the object is not in the connected scope. Have the agent list what the account can see before reconnecting.

Ask the agent to diagnose it:

```text
Call mem0_get_projects and mem0_fetch_detailed_list_of_organizations. Tell me which orgs and projects this connection can reach, then quote the exact error and the id from the failed call. Do not retry it yet.
```

### Mem0 starts returning rate-limit or quota errors partway through a run
Mem0's limits are monthly add and retrieval caps per plan, so an agent doing a bulk import in one session is exactly the traffic shape that meets the add cap mid-run: everything succeeds, then the cap hits and further writes fail until the month resets or the plan changes. This is not a throttle to wait out. Have the agent report which calls failed and how many adds it has made this month, then decide whether the work can spread across the billing month or needs the plan raised. Reads and writes count separately, so a retrieval-heavy prompt is not helped by the add quota and vice versa.

Ask the agent to diagnose it:

```text
Tell me which Mem0 calls failed, whether they were add or retrieval calls, and how many of each you have made in the current billing month. Quote the exact error text from the last failure.
```

### Mem0 tools are missing, or one tool name is not found
The fixes search results teach for this symptom assume a local MCP server: the old local mem0-mcp-server is deprecated in favor of the hosted mcp.mem0.ai/mcp, run `npx mcp-add` or hand-edit `claude_desktop_config.json`, then restart the client. None of that applies here, because there is no local config file in this setup. Two hosted-flow causes cover it: schemas load on demand, so the opening Mem0 call in a fresh session can arrive before the catalog and needs one retry, and the tool names here are the platform API's `mem0_` names, not the MCP's names, so a name from the MCP docs fails as not-found even though the capability exists.

Ask the agent to diagnose it:

```text
List the Mem0 tools you actually have access to. If there are none, retry once and tell me whether the second call worked. If some are missing, name one and I will give you the platform-API name for it.
```

### API key setup works but results look incomplete
Double-check that the API key for Mem0 has the right scopes or account access. A valid key can still be too limited for some reads or writes.

### Is there a Hermes Agent Mem0 integration?
Yes. ClawLink is the fastest way to connect Hermes to Mem0: link your Mem0 account once in the browser and Hermes Agent can call the Mem0 API through 47 ready-made tools — no custom code or token handling.

### How do I connect Mem0 to Hermes with ClawLink?
Install the plugin with `hermes plugins install ClawLink-HQ/hermes-plugin --enable`, then pair once: run `hermes clawlink begin`, approve the link in your browser, and run `hermes clawlink finish`. Connect Mem0 in the dashboard and Hermes can use it from the next message — no config files, and the Mem0 key you paste is stored server-side instead of in your environment.

### How long does it take to connect Mem0 to Hermes Agent?
About two minutes. Sign in, click Connect next to Mem0 in the dashboard, authenticate, and Hermes Agent can use it from the next chat message.

### Why use ClawLink instead of wiring Mem0 up myself?
The alternative to ClawLink is usually manual API key setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want Mem0 working from chat.

### What is the difference from `hermes memory setup`?
The flow every engine teaches stores a key in `~/.hermes/.env` with config in `~/.hermes/mem0.json` and exposes the memory tools Hermes ships natively: `mem0_profile`, `mem0_search`, and `mem0_conclude`. This connection is the Mem0 platform API instead: 47 tools covering organizations, projects, members, webhooks, agents and agent runs, memory records, semantic search, events, and exports, through the same Mem0 account. The key is not in any environment file because there is no local config file in this setup at all.

### Does this still make sense now that Mem0 has Agent Mode and its own hosted MCP?
Honestly: `mem0 init --agent` self-provisions an API key in about five seconds, and Mem0's hosted MCP at mcp.mem0.ai/mcp exists, so keyless and serverless are no longer ours to claim. What neither of those gives you is the platform surface: Agent Mode answers the "without managing a key" intent with memory tools only, and the hosted MCP exposes Mem0's tools through one server. Here the same hosted model runs under your own Mem0 account and the agent gets 47 tools, the platform-API surface, with the pairing flow the only client-side setup. Pick on surface, not on keylessness.

### What can the agent do beyond memory?
The memory tools are the core: `mem0_add_new_memory_records`, `mem0_perform_semantic_search_on_memories`, `mem0_get_memories_by_entity`, and `mem0_get_memory_export`. Around them sits the platform surface the engines never mention: `mem0_get_projects` and `mem0_fetch_detailed_list_of_organizations` for structure, `mem0_get_project_members` and `mem0_add_organization_member` for access, `mem0_get_project_webhooks` and `mem0_create_webhook` for plumbing, and `mem0_create_a_new_agent` and `mem0_get_event_status_by_event_id` for agent runs and their outcomes. That is the difference from the three-tool manual flow: the agent can administer the account it remembers through.

### Which Mem0 plan limits apply to this connection?
Mem0's limits are monthly caps on add and retrieval requests, not per-minute throttles. The current tiers on mem0.ai/pricing: Hobby is 10,000 add and 1,000 retrieval requests per month, Starter is 50,000 and 5,000, and Pro is 500,000 add and 50,000 retrieval. The connection uses your Mem0 account's plan, so an agent bulk-writing memories in one session can meet the monthly add cap mid-run; the failure is a quota error, not a connection failure, and the fix is spreading the work or raising the plan, not reconnecting.

### What should I be careful about with AI memory?
Retrieval surfaces stored memories into prompts, so the engines' safety answers all converge on the same rule: only store what you would let the model see. Memory poisoning and prompt injection via retrieved content are the taught risks, and redaction of sensitive values before storage is the taught practice. The connection's write surface matters here, `mem0_add_new_memory_records` writes into your account from chat, so a prompt that asks for an inventory of what is stored is a good first call rather than a scary one.

### Hermes paired but still can't use Mem0
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

## Related

- [DataRobot](https://claw-link.dev/hermes/datarobot) — DataRobot is a machine learning platform that automates model building, deployment, and monitoring, enabling organizations to derive predictive insights from large datasets.
- [Chatbotkit tools](https://claw-link.dev/hermes/chatbotkit) — ChatBotKit is a platform that enables developers to build and manage AI-powered chatbots, offering comprehensive APIs and SDKs for seamless integration into applications.
- [ElevenLabs tools](https://claw-link.dev/hermes/elevenlabs) — Generate speech and voice cloning