Access memory management from MCP

Quick connection through the console

1. Open Qoder Settings. On macOS, press Shift+Command+,. On Windows, press Ctrl+Shift+,.

2. Go to MCP Services > My Services > + Add.

3. Select Add by Configuration and paste the following JSON. What you paste in the console is a single server fragment without the mcpServers wrapper.

   {
     "mem0": {
       "type": "http",
       "url": "http://<host>:<port>/mcp",
       "headers": {
         "Authorization": "Token ${MEM0_API_KEY:-apikey}"
       }
     }
   }

4. Set the API key in the .env file at the project root.

   MEM0_API_KEY=<API_KEY>

Connect through a configuration file

Qoder supports configuration files at three scopes. Their paths and recommended purposes are as follows:

• For team sharing, use the project level (shared) scope and create .mcp.json at the project root:

  {
    "mcpServers": {
      "mem0": {
        "type": "http",
        "url": "http://<host>:<port>/mcp",
        "headers": {
          "Authorization": "Token ${MEM0_API_KEY:-apikey}"
        }
      }
    }
  }

• For personal use when you need to write the key directly, use the project level (local) scope. Enter the actual API key in .qoder/settings.local.json and do not commit it to Git:

  {
    "mcpServers": {
      "mem0": {
        "type": "http",
        "url": "http://<host>:<port>/mcp",
        "headers": {
          "Authorization": "Token <API_KEY>"
        }
      }
    }
  }

Quick add from the command line

1. Run the following command in the terminal to register the MCP server in one line:

   claude mcp add --transport http mem0 http://<host>:<port>/mcp \
     --header "Authorization: Token <API_KEY>"

2. Verify that the server is added:

   claude mcp list

   After you enter the Claude Code interactive interface, type /mcp to view the connection status.

Project-level configuration file (recommended for teams)

1. Create the .mcp.json file at the project root and commit it to Git to enable team sharing:

   {
     "mcpServers": {
       "mem0": {
         "type": "http",
         "url": "http://<host>:<port>/mcp",
         "headers": {
           "Authorization": "Token ${MEM0_API_KEY:-apikey}"
         }
       }
     }
   }

2. Set the environment variable in the terminal:

   export MEM0_API_KEY="<API_KEY>"

User-level configuration (applies across projects)

To allow all projects to access PolarDB memory management, use the user-level scope:

claude mcp add --transport http mem0 --scope user \
  http://<host>:<port>/mcp \
  --header "Authorization: Token <API_KEY>"

Quick add from the command line

1. Store the complete authentication header value in an environment variable.

   export MEM0_AUTH_HEADER="Token <API_KEY>"

2. Add the MCP server and verify.

   codex mcp add mem0 --url http://<host>:<port>/mcp
   codex mcp list

Connect through a configuration file

Codex configures MCP servers in TOML format and supports two scopes:

1. Store the complete authentication header value in an environment variable.

   export MEM0_AUTH_HEADER="Token <API_KEY>"

2. Edit ~/.codex/config.toml and add the following configuration.

   [mcp_servers.mem0]
   url = "http://<host>:<port>/mcp"
   env_http_headers = { Authorization = "MEM0_AUTH_HEADER" }

3. Verify that the server is added.

   codex mcp list

Interactive add

1. Run the following command to complete the add through an interactive guide:

   hermes mcp add mem0 --url "http://<host>:<port>/mcp"

2. The command automatically completes the following operations:

   • Prompts you to enter the API key and saves it to ~/.hermes/.env.

   • Connects to the PolarDB memory management server to verify the connection and discovers the available MCP tools.

   • Writes the configuration to ~/.hermes/config.yaml.

3. Start Hermes to use it:

   hermes

YAML configuration file

1. Store the API key.

   echo 'MEM0_API_KEY=<API_KEY>' >> ~/.hermes/.env

2. Edit ~/.hermes/config.yaml.

   mcp_servers:
     mem0:
       url: "http://<host>:<port>/mcp"
       headers:
         Authorization: "Token ${MEM0_API_KEY}"
       timeout: 180
       connect_timeout: 60

3. Verify the connection.

   hermes mcp test mem0

Management commands

(Optional) Advanced configuration

To customize the timeout, keepalive, tool filtering, or sampling capabilities, refer to the following configuration. The tools.include field takes MCP tool names. For the values, see Common MCP tools reference.

mcp_servers:
  mem0:
    url: "http://<host>:<port>/mcp"
    headers:
      Authorization: "Token ${MEM0_API_KEY}"
    timeout: 180
    connect_timeout: 60
    keepalive_interval: 60    # Keepalive interval, in seconds
    tools:
      include: ["add_memory_v1_memories_post", "search_memories_v2_memories_search_post", "get_all_memories_v2_memories_post"]
    sampling:
      enabled: true
      model: "gpt-4"
      max_tokens_cap: 4096

Connect through the API

The first three steps are one-time configuration. The Vault and the agent can be reused by multiple sessions. After that, you only need to run step 4 each time you start a session.

1. Create a Vault.

   curl -X POST https://api.qoder.com/api/v1/cloud/vaults \
   -H "Authorization: Bearer $QODER_PAT" \
   -H "Content-Type: application/json" \
   -d '{"display_name": "PolarDB Memory"}'
   

2. Append a credential to the Vault. The mcp_server_url must exactly match the mcp_servers[].url in the next step (including the trailing slash). The platform matches credentials by this URL exactly.

   curl -X POST https://api.qoder.com/api/v1/cloud/vaults/<vault_id>/credentials \
   -H "Authorization: Bearer $QODER_PAT" \
   -H "Content-Type: application/json" \
   -d '{
     "auth": {
       "type": "static_bearer",
       "mcp_server_url": "http://<host>:<port>/mcp",
       "token": "<API_KEY>"
     }
   }'
   

3. Create an agent and declare the MCP endpoint in mcp_servers.

   curl -X POST https://api.qoder.com/api/v1/cloud/agents \
   -H "Authorization: Bearer $QODER_PAT" \
   -H "Content-Type: application/json" \
   -d '{
     "name": "mem0-agent",
     "model": "ultimate",
     "system": "You can use the mem0 tool to read and write long-term memories. Retrieve relevant memories before answering.",
     "tools": [{"type": "agent_toolset_20260401", "enabled_tools": ["Bash", "Read", "Write"]}],
     "mcp_servers": [{"name": "mem0", "type": "url", "url": "http://<host>:<port>/mcp"}]
   }'
   

4. When creating a session, associate the Vault through vault_ids. The platform injects the credential automatically.

   curl -X POST https://api.qoder.com/api/v1/cloud/sessions \
   -H "Authorization: Bearer $QODER_PAT" \
   -H "Content-Type: application/json" \
   -d '{
     "agent": "<agent_id>",
     "vault_ids": ["<vault_id>"]
   }'