Configure your AI platform
Choose the integration method that fits your setup.
Claude Code
Codex CLI
Gemini CLI
Cursor
Windsurf
Continue.dev
Grok CLI
Grok API
Llama
OpenClaw 🦞
Hermes Agent
Any MCP Client
Claude Code MCP Configuration Scopes:
| Scope | File | Applies to |
|---|
| User (global) | ~/.claude.json | All projects on your machine |
| Project (shared) | .mcp.json in project root | Everyone on the project (via git) |
| Local (private) | ~/.claude.json under projects | One project, just you |
User scope (recommended) — merge mcpServers into your existing ~/.claude.json (macOS/Linux) or %USERPROFILE%\.claude.json (Windows):
{
"mcpServers": {
"memory": {
"command": "ai-memory",
"args": ["--db", "~/.claude/ai-memory.db", "mcp", "--tier", "semantic"]
}
}
}json
Restart Claude Code. It will discover all 43 memory tools natively. No daemon, no ports. MCP servers do not go in settings.json or settings.local.json. The --tier flag is required — options: keyword, semantic (default), smart, autonomous. Smart/autonomous require Ollama.
Windows: Use ai-memory.exe for the command and forward slashes in paths: "C:/Users/YourName/.claude/ai-memory.db"
OpenAI Codex CLI Configuration Scopes:
| Scope | File | Applies to |
|---|
| Global (user) | ~/.codex/config.toml | All projects on your machine |
| Project | .codex/config.toml in project root | Trusted projects only |
Windows: %USERPROFILE%\.codex\config.toml. Override config dir with CODEX_HOME env var.
# OpenAI Codex CLI MCP configuration
[mcp_servers.memory]
command = "ai-memory"
args = ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"]
enabled = truetoml
CLI shortcut: codex mcp add memory -- ai-memory --db ~/.local/share/ai-memory/memories.db mcp --tier semantic
Codex uses TOML with underscored key mcp_servers (not camelCase). Supports env, env_vars, enabled_tools, disabled_tools, startup_timeout_sec, tool_timeout_sec. Use /mcp in the TUI to view server status. Windows/WSL: WSL uses Linux home by default — set CODEX_HOME to share config with Windows host. See Codex MCP docs.
Google Gemini CLI Configuration Scopes:
| Scope | File | Applies to |
|---|
| User (global) | ~/.gemini/settings.json | All projects on your machine |
| Project | .gemini/settings.json in project root | Scoped to that project |
Windows: %USERPROFILE%\.gemini\settings.json. Env vars: $VAR / ${VAR} (all platforms), %VAR% (Windows).
{
"mcpServers": {
"memory": {
"command": "ai-memory",
"args": ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"],
"timeout": 30000
}
}
}json
CLI shortcut: gemini mcp add memory ai-memory -- --db ~/.local/share/ai-memory/memories.db mcp --tier semantic
Avoid underscores in server names (use hyphens). Tool names are auto-prefixed as mcp_memory_<toolName>. Env vars in env field support $VAR / ${VAR} (all platforms) and %VAR% (Windows). Gemini sanitizes sensitive patterns (*TOKEN*, *SECRET*) from inherited env unless declared. Add "trust": true to skip confirmation. CLI: gemini mcp list/remove/enable/disable. See Gemini CLI MCP docs.
Cursor IDE Configuration Scopes:
| Scope | File | Applies to |
|---|
| Global (user) | ~/.cursor/mcp.json | All projects on your machine |
| Project | .cursor/mcp.json in project root | Overrides global for same-named servers |
Windows: %USERPROFILE%\.cursor\mcp.json. Also configurable via Settings > Tools & MCP.
{
"mcpServers": {
"memory": {
"command": "ai-memory",
"args": ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"]
}
}
}json
Or add via Cursor Settings > Tools & MCP. Restart Cursor after editing. Verify with green dot in Settings. Supports env, envFile, ${env:VAR_NAME} interpolation (can be unreliable for shell profile vars — use envFile as workaround). ~40 tool limit across all servers. See Cursor MCP docs.
Windsurf (Codeium) Configuration Scopes:
| Scope | File | Applies to |
|---|
| Global only | ~/.codeium/windsurf/mcp_config.json | All projects (no project scope) |
Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json. Also configurable via MCP Marketplace or Settings > Cascade > MCP Servers.
{
"mcpServers": {
"memory": {
"command": "ai-memory",
"args": ["--db", "~/.codeium/windsurf/ai-memory.db", "mcp", "--tier", "semantic"]
}
}
}json
Supports ${env:VAR_NAME} interpolation in command, args, env, serverUrl, url, and headers. 100 tool limit across all servers. Can also add via MCP Marketplace or Settings > Cascade > MCP Servers. See Windsurf MCP docs.
Continue.dev Configuration Scopes:
| Scope | File | Applies to |
|---|
| User (global) | ~/.continue/config.yaml | All projects on your machine |
| Project | .continue/mcpServers/ dir in project root | Per-server YAML/JSON files |
Windows: %USERPROFILE%\.continue\config.yaml. Project dir auto-detects JSON configs from other tools.
# Continue.dev MCP configuration
mcpServers:
- name: memory
command: ai-memory
args:
- "--db"
- "~/.continue/ai-memory.db"
- "mcp"
- "--tier"
- "semantic"yaml
MCP tools only work in agent mode. Supports ${{ secrets.SECRET_NAME }} for secret interpolation. Project-level .continue/mcpServers/ directory auto-detects JSON configs from other tools (Claude Code, Cursor, etc.). See Continue MCP docs.
Grok CLI (AlphaOne fork) — Deep Integration:
| Scope | Config File | Applies to |
|---|
| User-level | ~/.grok/user-settings.json | All sessions |
// ~/.grok/user-settings.json
{
"mcp": {
"servers": [
{
"id": "ai-memory",
"label": "AI Memory",
"enabled": true,
"transport": "stdio",
"command": "ai-memory",
"args": ["mcp", "--tier", "semantic"]
}
]
}
}json
Deep integration features: Auto-recall on session start (injects relevant memories into system prompt), compaction summaries auto-stored as mid-tier memories, MCP tools available in all modes (agent, plan, ask), session-scoped connections (binary spawns once per session, not per message). Default tier semantic uses local MiniLM embeddings — no Ollama required. Install: curl -fsSL https://raw.githubusercontent.com/alphaonedev/grok-cli/main/install.sh | bash
xAI Grok API Configuration:
| Scope | Method | Applies to |
|---|
| Per-request | API tools array (no config file) | Each API call individually |
Remote HTTPS only (no stdio). Start ai-memory behind an HTTPS reverse proxy.
# Step 1: Start the ai-memory HTTP server
ai-memory serve --host 127.0.0.1 --port 9077 &
# Expose via HTTPS reverse proxy (nginx, caddy, cloudflare tunnel, etc.)
# Step 2: Add the MCP server to your Grok API call
curl https://api.x.ai/v1/responses \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "grok-3",
"tools": [{
"type": "mcp",
"server_url": "https://your-server.example.com/mcp",
"server_label": "memory",
"server_description": "Persistent AI memory with recall and search"
}],
"input": "What do you remember about our project?"
}'bash
HTTPS required. server_label is required. Supports Streamable HTTP and SSE transports. Optional: allowed_tools, authorization, headers. Works with xAI SDK, OpenAI-compatible Responses API, and Voice Agent API. See xAI Remote MCP docs.
META Llama Stack Configuration:
| Scope | Method | Applies to |
|---|
| Declarative | run.yaml — tool_groups section | Deployment-wide (supports ${env.VAR}) |
| Programmatic | Python/Node SDK — toolgroups.register() | Runtime registration |
Llama Stack uses toolgroup registration with an HTTP backend.
# Step 1: Start the ai-memory HTTP server
ai-memory serve --host 127.0.0.1 --port 9077 &
# Step 2: Register as a Llama Stack toolgroup
# In your Llama Stack config, register the MCP endpoint:
# toolgroup: ai-memory
# provider: remote::mcp-endpoint
# url: http://127.0.0.1:9077
# Or use the REST API directly in custom tool definitions:
# POST /api/v1/memories, GET /api/v1/recall, etc.bash
META Llama uses Llama Stack for tool registration. Run ai-memory serve and register as a toolgroup via Python SDK or run.yaml (supports ${env.VAR_NAME} interpolation). Transport migrating from SSE to Streamable HTTP. See Llama Stack Tools docs.
OpenClaw Configuration:
| Scope | File | Applies to |
|---|
| Single config | Platform config file | All projects (single config file) |
Important: OpenClaw uses mcp.servers (NOT mcpServers). The key structure is different from most other platforms.
{
"mcp": {
"servers": {
"memory": {
"command": "ai-memory",
"args": ["--db", "~/.local/share/ai-memory/memories.db", "mcp", "--tier", "semantic"]
}
}
}
}json
CLI shortcut:
openclaw mcp set memory '{"command":"ai-memory","args":["--db","~/.local/share/ai-memory/memories.db","mcp","--tier","semantic"]}'bash
Management: openclaw mcp list · openclaw mcp show <name> · openclaw mcp unset <name>. See OpenClaw MCP docs.
Nous Research Hermes Agent Configuration:
| Scope | File | Applies to |
|---|
| Global only | ~/.hermes/config.yaml | All projects (no per-project scope) |
Important: Hermes uses YAML format with mcp_servers (underscored, NOT camelCase).
# Hermes Agent MCP configuration
# File: ~/.hermes/config.yaml
mcp_servers:
memory:
command: ai-memory
args:
- "--db"
- "~/.local/share/ai-memory/memories.db"
- "mcp"
- "--tier"
- "semantic"yaml
HTTP remote (alternative):
mcp_servers:
memory:
url: "http://localhost:9077/mcp"yaml
Supports both stdio (local) and HTTP (remote) transports. Per-server tool filtering via tools.include/tools.exclude. Additional fields: env, timeout, connect_timeout, enabled, sampling. See Hermes MCP docs.
Generic MCP Client Configuration:
| Transport | Method | Details |
|---|
| stdio | ai-memory mcp | JSON-RPC 2.0, spawned by AI client |
| HTTP | ai-memory serve | REST API on localhost:9077 |
Point your MCP client at the ai-memory binary with the mcp subcommand:
{
"mcpServers": {
"memory": {
"command": "ai-memory",
"args": ["--db", "path/to/memory.db", "mcp", "--tier", "semantic"]
}
}
}json
The MCP server exposes 43 tools over stdio using JSON-RPC. Any client that speaks MCP will discover them automatically. Adjust the --db path to your preferred location.
