> ## Documentation Index
> Fetch the complete documentation index at: https://docs.maximem.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Vity MCP Server
> Connect any MCP-capable agent — Claude Code, Cursor, and more — to your Vity memory with a URL and an API key. No code.
Your AI tools each start from zero. This connects them all to the same memory.
The Vity MCP server exposes your memory over the [Model Context Protocol](https://modelcontextprotocol.io), so any MCP-capable agent can recall what you have told it before, look up what you already know, save new facts, and write in your voice. You paste a URL and an API key; the agent discovers the tools and decides when to call them on its own.
Building your own product? You want the [Synap MCP server](/integrations/mcp) instead — that one gives *your agent's users* memory, and takes a `synap_` token. This page is Vity: memory for **you**, in the AI tools you personally use, with an `mx_` key.
## Connection details
| | |
| ------------- | ------------------------------------- |
| **URL** | `https://vity-mcp.maximem.ai/mcp` |
| **Transport** | Streamable HTTP |
| **Auth** | `Authorization: Bearer mx_...` header |
## What your agent can do
Nine tools, in four groups. See [Tools & prompts](/vity/mcp/tools) for arguments and per-tool guidance.
`recall_context` for a ready-to-use context block, `get_user_context` for a structured profile on a topic, `search_memories` for specific remembered facts.
`query_knowledge` returns what you know about a subject and how deeply, so the agent can pitch its answer at the right level.
`get_voice_card` returns how you write; `rewrite_as_me` restyles a draft in your voice; `summarize` gives you a summary that skips what you already know.
`remember` saves one durable fact; `capture_conversation` saves a whole session so it survives into later ones.
Also available: three prompts (`write_as_me`, `brief_me_on`, `catch_me_up`) and two resources (`vity://voice-card`, `vity://knowledge/topics`).
## Get your API key
Generate it in the **Vity** dashboard at [app.maximem.ai](https://app.maximem.ai), not the Synap dashboard at synap.maximem.ai. They are separate products with separate keys: Vity keys start with `mx_`, Synap keys start with `synap_`. A `synap_` key will be rejected here.
1. Sign up or log in at [app.maximem.ai](https://app.maximem.ai).
2. Open **Settings → API Keys**.
3. Click **Generate New Key**.
4. Copy your key (starts with `mx_...`).
Keep this key secure. It grants full read and write access to your memory vault — treat it like a password, and use a separate key per tool so you can revoke one without breaking the others.
## Connect your client
```bash theme={null}
claude mcp add --transport http vity https://vity-mcp.maximem.ai/mcp \
--header "Authorization: Bearer mx_..."
```
Confirm it connected:
```bash theme={null}
claude mcp list
```
`vity` should appear as connected. Inside a session, `/mcp` shows the same thing along with the available tools.
Add this to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` in a project:
```json theme={null}
{
"mcpServers": {
"vity": {
"url": "https://vity-mcp.maximem.ai/mcp",
"headers": { "Authorization": "Bearer mx_..." }
}
}
}
```
Reload Cursor, then check **Settings → MCP** for a green indicator next to `vity`.
Most MCP clients read the same JSON shape. Point them at the URL and attach the key as a header:
```json theme={null}
{
"mcpServers": {
"vity": {
"url": "https://vity-mcp.maximem.ai/mcp",
"headers": { "Authorization": "Bearer mx_..." }
}
}
}
```
If your client asks for a transport, choose **Streamable HTTP** (sometimes listed as "HTTP" or "remote server"). Do not choose SSE or stdio.
### Check it works
Ask your agent something that can only come from memory:
```
What do you know about me?
```
It should call `recall_context` or `get_user_context` and answer from your vault. If it answers "I don't have any information about you", the connection is fine but the vault is empty — see [Troubleshooting](#troubleshooting).
## Client compatibility
This server authenticates with an API key in a request header, so it works with any client that lets you set custom headers — Claude Code, Cursor, and most CLI and desktop MCP clients.
Clients that only support OAuth 2.1 connectors and give you nowhere to put a header — currently the **Claude.ai** and **ChatGPT** connector UIs — cannot connect to this server yet. OAuth support is planned. In the meantime, use a client that accepts headers, or the [OpenClaw](/vity/openclaw) and [Hermes](/vity/hermes) plugins.
## Your data stays yours
Your API key *is* your identity here. The tools resolve whose memory to read from the key alone — none of them takes a user, account, or vault argument, so there is no request an agent could construct, accidentally or otherwise, that reaches anyone else's memory.
What that means in practice:
* **A key only ever reaches its own vault.** Sharing a key shares that vault; revoke it in the dashboard to cut access immediately.
* **Nothing is written unless a write tool is called.** `remember` and `capture_conversation` are the only tools that store anything.
* **Deletion is not exposed over MCP.** Deleting memories is a dashboard action, so no agent can remove your memory on its own initiative. See [Deleting memories](/vity/mcp/tools#deleting-memories).
## Rate limits and credits
Limits apply per API key, per minute. Most retrieval tools allow 60 calls per minute; the LLM-backed ones are lower. `search_memories` and `query_knowledge` cost 1 credit per call, `summarize` costs 20, and `rewrite_as_me` is metered with a ceiling of 1,000 rewrites per day. Everything else is free.
See the [per-tool table](/vity/mcp/tools#tools-at-a-glance) for exact figures, and [Pricing](/resources/pricing) for credit packs.
When a limit is hit, the tool returns a plain-language message the agent can act on — wait and retry for a rate limit, top up for credits — rather than a protocol error.
## Troubleshooting
The header did not reach the server. Check that your config uses the exact header name `Authorization` and the value `Bearer mx_...` — including the word `Bearer` and the space after it. In Claude Code, re-add the server with `--header` quoted as a single argument.
The key is wrong, was revoked, or belongs to the wrong product. Confirm it starts with `mx_` (a `synap_` key is for [Synap](/integrations/mcp) and will not work here), then generate a fresh one at [app.maximem.ai](https://app.maximem.ai) and update your client config.
Confirm the URL includes the `/mcp` path and that the transport is set to Streamable HTTP rather than SSE. Restart the client after editing its config — most read MCP config only at startup.
Your vault may genuinely have nothing on that subject yet. Memory builds up as you use Vity, so a new account starts empty — save something with `remember` and search again.
If you expect a match, the relevance floor may be too high. Ask the agent to retry `search_memories` with `min_score` around `0.15`.
Just captured a conversation? Extraction runs in the background; give it a few seconds before searching.
`get_voice_card` and `rewrite_as_me` need a voice profile built from your writing. Build one in the dashboard, then retry.
`search_memories`, `query_knowledge` and `summarize` consume credits. Top up at [app.maximem.ai](https://app.maximem.ai); retrying without topping up will keep failing.
Still stuck? Email [support@maximem.ai](mailto:support@maximem.ai).