# Add Note to Collection Source: https://docs.mem.ai/api-reference/collections/add-note-to-collection PUT /v2/collections/{collection_id}/notes/{note_id} Add an existing note to an existing collection. This operation only creates the membership link and does not modify note or collection content. Use create endpoints to create notes or collections. # Create Collection Source: https://docs.mem.ai/api-reference/collections/create-collection POST /v2/collections Create a collection with optional caller-provided ID and timestamps. If `id` already exists, this request returns a conflict. Use collection membership endpoints to add, remove, or move notes between collections. # Delete Collection Source: https://docs.mem.ai/api-reference/collections/delete-collection DELETE /v2/collections/{collection_id} Permanently delete a collection. Hard-deleting removes the collection resource itself. For membership-only changes, use note add, remove, or move collection endpoints. # List Collections Source: https://docs.mem.ai/api-reference/collections/list-collections GET /v2/collections List collections visible to the authenticated caller with cursor pagination. Results are ordered by `order_by` and return `next_page` when additional rows are available. For relevance-ranked retrieval by query, use `POST /v2/collections/search`. # Move Note Source: https://docs.mem.ai/api-reference/collections/move-note POST /v2/collections/{source_collection_id}/notes/{note_id}/move Move a note from one collection to another collection. This operation adds the note to the target collection, then removes it from the source collection. It does not modify note or collection content. # Read Collection Source: https://docs.mem.ai/api-reference/collections/read-collection GET /v2/collections/{collection_id} Fetch metadata for a single collection by ID. This endpoint returns collection metadata only, not a note list for that collection. For discovery flows, use `GET /v2/collections` or `POST /v2/collections/search`. # Remove Note from Collection Source: https://docs.mem.ai/api-reference/collections/remove-note-from-collection DELETE /v2/collections/{collection_id}/notes/{note_id} Remove a note from a collection while keeping both resources. This operation only removes the membership link between IDs. Use note/collection deletion endpoints to remove resources. # Search Collections Source: https://docs.mem.ai/api-reference/collections/search-collections POST /v2/collections/search Search collections using free-text relevance matching. Returns a bounded relevance-ranked result set and does not return `next_page`. For deterministic chronological pagination, use `GET /v2/collections`. # Update Collection Source: https://docs.mem.ai/api-reference/collections/update-collection PATCH /v2/collections/{collection_id} Update metadata for a collection by ID. Use this endpoint to rename a collection by setting `title`. This endpoint updates only provided fields (`title`, `description`) and leaves omitted fields unchanged. For read-only retrieval, use `GET /v2/collections/{collection_id}`. # Mem It Source: https://docs.mem.ai/api-reference/mem-it/mem-it POST /v2/mem-it # Create Note Source: https://docs.mem.ai/api-reference/notes/create-note POST /v2/notes Create a note with an optional note ID, timestamps, and collection links. If omitted, Mem generates the note ID. The first line of `content` becomes the note title. # Delete Note Source: https://docs.mem.ai/api-reference/notes/delete-note DELETE /v2/notes/{note_id} Permanently delete a note. Hard-deleted notes cannot be restored. For recoverable removal, use `POST /v2/notes/{note_id}/trash`. # Find Related Notes Source: https://docs.mem.ai/api-reference/notes/find-related-notes GET /v2/notes/{note_id}/related-notes Find notes semantically related to the current persisted content of a note. The source note is embedded at request time, so newly created or recently updated notes can be used before asynchronous indexing catches up. Candidate related notes still come from the note search index. # List Notes Source: https://docs.mem.ai/api-reference/notes/list-notes GET /v2/notes List notes visible to the authenticated caller with cursor pagination. When multiple `contains_*` fields are true, a note may match any of them. Results are ordered by `order_by` and return `next_page` when additional rows are available. For relevance-ranked retrieval by query, use `POST /v2/notes/search`. # Read Note Source: https://docs.mem.ai/api-reference/notes/read-note GET /v2/notes/{note_id} Fetch the full current state of a single note by ID. If the note is in trash, the response still returns the note and includes `trashed_at`. For discovery flows, use `GET /v2/notes` or `POST /v2/notes/search`. # Search Notes Source: https://docs.mem.ai/api-reference/notes/search-notes POST /v2/notes/search Search notes using a required free-text query and structured filters. When multiple `filter_by_contains_*` fields are true, a note may match any of them. Returns note results from a bounded search snapshot with deterministic offset pagination. Query-based searches are relevance-ranked within the bounded search snapshot window. Reuse the returned `snapshot_id` when requesting later pages. The returned `total` reflects the bounded search snapshot, capped by the 100-result search window. For deterministic chronological pagination across all accessible notes, use `GET /v2/notes`. # Set Note Created At Source: https://docs.mem.ai/api-reference/notes/set-note-created-at PATCH /v2/notes/{note_id}/created-at Set a note's visible creation timestamp without changing its content. The supplied `created_at` must include a timezone offset and cannot be in the future. It can only backdate the note: the timestamp cannot be later than when the note was originally created. This operation changes note metadata only. Trashed notes must be restored before their creation date can be changed. # Update Note Source: https://docs.mem.ai/api-reference/notes/update-note PATCH /v2/notes/{note_id} Submit a complete markdown body for a note and the exact `version` being updated. Send the full desired body in `content` (not a partial markdown patch). The first line of `content` becomes the updated title. Trashed notes must be restored before they can be updated. # Authentication Source: https://docs.mem.ai/api-reference/overview/authentication The Mem API uses API keys for authentication. To obtain an key, visit the API section in your Mem settings. Remember that your API key is a secret! Do not share it with others or expose it in any client-side code (browsers, apps). API keys should be securely loaded from an environment variable or key management service on the server. API keys should be provided via [HTTP Bearer authentication](https://swagger.io/docs/specification/v3_0/authentication/bearer-authentication). ```text theme={null} Authorization: Bearer $MEM_API_KEY ``` # Changelog Source: https://docs.mem.ai/api-reference/overview/changelog ### Planned * Request status tracking for "Mem It" operations * Support for "apply a template" via the "Mem It" endpoint ### 2026-05-15 * Added `PATCH /v2/notes/{note_id}/created-at` for changing a note's visible creation timestamp without changing note content or quota accounting. ### 2026-05-09 * Added `POST /v2/collections/{source_collection_id}/notes/{note_id}/move` for moving a note between collections. * Added API reference pages for collection membership endpoints. ### 2026-04-08 * Updated `PATCH /v2/notes/{note_id}` to require the exact current note `version`. Read the note first, or use the most recent note write response, and pass that `version` into the update request. ### 2026-04-06 * Updated `POST /v2/collections` so caller-provided `id` values are create-only; duplicate IDs, including trashed collections, now return `409 Conflict` instead of upserting the existing collection. * Updated `PATCH /v2/collections/{collection_id}` to preserve caller-provided `updated_at` values. ### 2026-04-04 * Updated `GET /v2/notes/{note_id}` to return accessible trashed notes and include `trashed_at`, so callers can distinguish a trashed note from a missing one. ### 2026-04-01 * Updated `POST /v2/notes` so caller-provided `id` values are create-only; duplicate IDs now return `409 Conflict` instead of upserting the existing note. ### 2026-03-25 * Added date-range filters to `/v2/notes` (list): `filter_by_created_after`, `filter_by_created_before`, `filter_by_updated_after`, `filter_by_updated_before`. * Updated `/v2/notes` so multiple `filter_by_contains_*` filters are combined using OR semantics (list endpoint). * Added date-range filtering for `/v2/notes/search` using `filter_by_created_after`, `filter_by_created_before`, `filter_by_updated_after`, and `filter_by_updated_before` params. ### 2026-03-19 * Updated `/v2/notes/search` so multiple `filter_by_contains_*` filters are combined using OR semantics ### 2026-03-03 * Added support for updating collections via `PATCH /v2/collections/{collection_id}`. ### 2025-12-09 * Added complexity-based rate limiting for resource-intensive endpoints * API responses now include rate limit headers (`X-RateLimit-*`, `X-Complexity-*`) ### 2025-11-17 * Added support for filtering by tasks, images, and files ### 2025-10-31 * Added support for listing and searching notes * Added support for listing and searching collections * Clarified size-limits for request inputs ### 2025-06-03 * Release of our `/v2` series of API endpoints * "Mem It" is now asynchronous by default, and features much more robust error handling * Added support for reading note content * Added support for creating and deleting collections * Improved rate-limiting using the Leaky Bucket algorithm ### 2025-03-31 * Initial community release of our `/v1` API endpoints * Added support for "Mem It" * Added support for creating and deleting notes *** *This changelog tracks significant updates to the Mem API and documentation. For the most current information, refer to the API reference documentation.* # Error Handling Source: https://docs.mem.ai/api-reference/overview/error-handling The API uses standard HTTP status codes to indicate success or failure: * 2xx: Success * 400: Bad request (invalid parameters) * 401: Unauthorized (invalid token) * 404: Resource not found * 429: Rate limit or usage quota exceeded * 500: Server error Usage quota errors include a stable `error.type` value and reset details: ```json theme={null} { "error": { "type": "quota_exceeded", "message": "You've reached your free tier note creation limit for this month", "details": { "current_plan": "free", "limit": 25, "used": 25, "reset_time": "2026-08-01T00:00:00+00:00" } } } ``` Treat `error.type` as the machine-readable value. Messages are intended for people and may change. A quota response also includes `Retry-After`, expressed in seconds, when the reset time is valid. # Introduction Source: https://docs.mem.ai/api-reference/overview/introduction This API reference describes the RESTful APIs you can use to interact with the Mem platform. REST APIs are usable via HTTP in any environment that supports HTTP requests. Learn best practices for using the Mem API Learn how to authenticate your requests Learn about the rate limits for the Mem API Learn how to handle errors from the Mem API # Rate Limits Source: https://docs.mem.ai/api-reference/overview/rate-limits Calls to our API are rate limited to provide equitable access to the API for everyone and to prevent abuse. We are going to be evolving these limits as we gather more information, and encourage your feedback. Any changes to limits will be announced in our Slack community. We use the [leaky bucket algorithm](https://en.wikipedia.org/wiki/Leaky_bucket) for our rate limiters, which means that your tokens are refilled with a constant rate of `LIMIT_AMOUNT / LIMIT_PERIOD`. ## Limits We enforce two types of rate limits: ### Request Limits | Interval | Limit | | ---------- | ----- | | Per minute | 100 | | Per day | 4000 | ### Complexity Limits Some endpoints consume more resources than others. We track this with "complexity tokens" that are consumed based on the endpoint: | Interval | Limit | | ---------- | ----- | | Per minute | 200 | | Per day | 8000 | | Endpoint | Complexity | | -------------- | ---------- | | Most endpoints | 1 | | `/v2/mem-it` | 40 | For example, with a complexity limit of 200 per minute and mem-it costing 40 complexity tokens, you can make up to 5 mem-it calls per minute. ## Response Headers Every response includes headers indicating your current rate limit status. We show the most constrained bucket (minute or day) for each limit type: | Header | Description | | ------------------------ | --------------------------------------------------------- | | `X-RateLimit-Bucket` | Which time window is most constrained (`minute` or `day`) | | `X-RateLimit-Limit` | Maximum requests allowed in that window | | `X-RateLimit-Remaining` | Requests remaining in that window | | `X-RateLimit-Reset` | Seconds until tokens replenish | | `X-Complexity-Bucket` | Which time window is most constrained (`minute` or `day`) | | `X-Complexity-Limit` | Maximum complexity tokens allowed in that window | | `X-Complexity-Remaining` | Complexity tokens remaining in that window | | `X-Complexity-Reset` | Seconds until complexity tokens replenish | ## Handling Rate Limit Errors When rate limits are exceeded, the API returns a `429` status code. It also returns a `Retry-After` header with the number of seconds to wait before the next request is allowed. Usage quotas, such as a plan's monthly note creation allowance, also return `429`. These responses use `error.type: "quota_exceeded"` and include the quota reset time in `error.details.reset_time`. `Retry-After` reflects that reset. Upgrading the account may restore access sooner, so clients should check the account state after an upgrade instead of caching the quota response. # Welcome Source: https://docs.mem.ai/guides/get-started/overview ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ --header "Content-Type: application/json" \ --header "Authorization: Bearer $MEM_API_KEY" \ --data '{ "input": "Note to self: Read the rest of the Mem API docs instead of just copying this example", "instructions": "File under 'things I should actually do'" }' ``` If you're new to Mem, we recommend starting with the [quickstart guide](./quickstart). Make your first API call in minutes Explore and implement the Mem API endpoints *** ### Support Find answers to frequently asked questions Check the status of Mem services # Quickstart Source: https://docs.mem.ai/guides/get-started/quickstart The best way to send content to Mem is through the **Mem It** endpoint. Mem intelligently processes, organizes, and structures your input automatically - whether it's a quick note, web article, meeting transcript, or any other type of content. Here's your first API call: ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $MEM_API_KEY" \ -d '{ "input": "Check out the new research paper on quantum computing by MIT.", "instructions": "Save this for my research" }' ``` You'll get back a request ID, and Mem processes your content in the background. That's it - your content is now intelligently organized and searchable in Mem!
Discover how to intelligently process any content # Formatting Content Source: https://docs.mem.ai/guides/reference/content-format Mem uses Markdown for formatting content via the API. ### Styling ```markdown theme={null} **Bold** _Italic_ ~~Strikethrough~~ ``` ### Headings ```markdown theme={null} # Heading 1 ## Heading 2 ### Heading 3 ``` ### Lists ```markdown theme={null} - Unordered List Item 1 - Unordered List Item 2 - Unordered List Item 2.1 - Unordered List Item 2.2 - Unordered List Item 3 1. Ordered List Item 1 2. Ordered List Item 2 3. Ordered List Item 3 - [ ] Task List Item 1 - [x] Task List Item 2 - [ ] Task List Item 3 ``` ### Links ```markdown theme={null} [Link Text](https://www.mem.ai) ``` ### Images ```markdown theme={null} ![Alt Text](https://www.mem.ai/logo.png) ``` ### Linking to Notes ```markdown theme={null} [Link Text](mem://notes/01991079-7a38-718d-a05c-466f2a08e4b0) ``` ### Quotes ```markdown theme={null} > This is a blockquote ``` ### Code ```markdown theme={null} `console.log("Hello, world!");` ``` ### Line Breaks ```markdown theme={null}
``` ### Tables ```markdown theme={null} | Column 1 | Column 2 | Column 3 | |----------|----------|----------| | Row 1 | Row 1 | Row 1 | | Row 2 | Row 2 | Row 2 | | Row 3 | Row 3 | Row 3 | ``` # Advanced Usage Source: https://docs.mem.ai/guides/use-cases/advanced-usage While **Mem It** is recommended for most use cases, you may occasionally need precise control over your notes and collections. For these scenarios, we expose explicit endpoints for managing individual resources. ## Example: Creating a Collection and a Note ```bash theme={null} curl "https://api.mem.ai/v2/collections" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $MEM_API_KEY" \ -d '{ "id": "90815ddd-4c9b-49e3-b119-897ca04367f1", "name": "Project Ideas", "description": "A collection of project ideas" }' ``` ```bash theme={null} curl "https://api.mem.ai/v2/notes" \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $MEM_API_KEY" \ -d '{ "content": "# Great Idea\n\nBuild a mobile app that helps track daily water intake.", "collection_ids": ["90815ddd-4c9b-49e3-b119-897ca04367f1"] }' ``` ## Common Use Cases * Integrations where you want complete control over the note content * Migrating notes or collections from other services * Automating the creation of notes from structured forms ## Next steps For an exhaustive list of endpoints and their usage, check out the [full API reference](../../api-reference/notes/create-note). # Mem It Source: https://docs.mem.ai/guides/use-cases/mem-it Remember anything, intelligently With the Mem It API, you can save and process any type of content, letting Mem handle organization and extraction automatically. Simply send your content to the API, and Mem transforms it into organized, retrievable knowledge. Here's a simple example using the Mem It API: ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ --header "Content-Type: application/json" \ --header "Authorization: Bearer $MEM_API_KEY" \ --data '{ "input": "Check out the new research paper on quantum computing by MIT." }' ``` Mem immediately responds with a request ID: ```json theme={null} { "request_id": "api-request-0ee24147-b4b7-4469-ba00-4648ea11e860" } ``` Processing occurs in the background and typically completes within minutes. Note that tracking the status of a request isn't yet supported, but it is planned for a future update! ## Understanding input types and processing You can provide almost any type of content to Mem It - from simple text notes to entire web pages or meeting transcripts. Mem It intelligently processes each type of content appropriately. ### Types of content you can save Here are some examples of content types Mem It can process: * **Simple notes**: Quickly save ideas or recommendations * **Web pages**: Send HTML content for intelligent extraction * **Meeting transcripts**: Extract key points and action items * **Emails**: Capture important information and follow-ups * **Documents**: Process reports, papers, and articles ### Controlling how content is processed #### Using instructions You can guide how Mem processes your content by providing instructions: ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ --header "Content-Type: application/json" \ --header "Authorization: Bearer $MEM_API_KEY" \ --data '{ "input": "[08:47:19] Kevin: I think we should prioritize the mobile experience. [08:50:22] Sarah: Agreed, and we need to update the roadmap.", "instructions": "Extract action items and decisions" }' ``` Without instructions, Mem will use its default processing approach. With instructions, you can specifically request: * Extraction of key points * Focus on action items or decisions * Organization into categories * Highlighting specific types of information #### Adding context Context helps Mem understand how this new information relates to your existing knowledge: ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ --header "Content-Type: application/json" \ --header "Authorization: Bearer $MEM_API_KEY" \ --data '{ "input": "Let's move the deadline to next Friday and update the stakeholders.", "instructions": "Add this to my action items", "context": "This is related to Project Horizon" }' ``` ## Best Practices 1. **Clearly specify instructions** to enhance organization and effectiveness 2. **Use descriptive titles** to improve clarity 3. **Provide context** for better content understanding 4. **Include accurate timestamps** for historical organization ## Common Use Cases * Quickly capturing thoughts and ideas * Saving web articles * Turning emails into actionable content * Meeting transcript analysis * Chat/message archiving ## Real-world examples ### Capturing web research ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ --header "Content-Type: application/json" \ --header "Authorization: Bearer $MEM_API_KEY" \ --data '{ "input": "Market Analysis 2025...", "instructions": "Extract key findings and save as a research note", }' ``` ### Saving meeting insights ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ --header "Content-Type: application/json" \ --header "Authorization: Bearer $MEM_API_KEY" \ --data '{ "input": "[08:47:19] Kevin: Here's what we learned from user testing...[09:15:22] Meeting ended.", "instructions": "Create a summary with action items and decisions", "context": "Weekly product planning meeting", "timestamp": "2025-04-01T08:47:19Z", }' ``` ### Quick personal notes ```bash theme={null} curl "https://api.mem.ai/v2/mem-it" \ --header "Content-Type: application/json" \ --header "Authorization: Bearer $MEM_API_KEY" \ --data '{ "input": "Check out Atomic Habits by James Clear - recommended by Sarah", "instructions": "Add to my reading list" }' ``` ## Next steps Check out the [full API reference](../../api-reference/mem-it/mem-it) for additional options and capabilities. # Mem Developer Docs Source: https://docs.mem.ai/index

Start building with the Mem API

Connect your apps and workflows to Mem. Create notes, search your knowledge base, and organize collections programmatically.

Get Started
Explore the REST API endpoints for notes, collections, and more. Learn how to make your first API call and explore use cases. Set up API key authentication for your integration.

***

Mem MCP

Connect your AI tools to Mem using the Model Context Protocol. Works with Claude, ChatGPT, Claude Code CLI, Codex CLI, and Gemini CLI.

Get started with Mem MCP →

***

## Support Find answers to frequently asked questions Check the status of Mem services
# Mem MCP Source: https://docs.mem.ai/mcp/overview Connect your AI tools to Mem using the Model Context Protocol Mem MCP is a hosted server that gives AI tools secure access to your Mem notes and collections. It works with Claude, ChatGPT, Claude Code CLI, Codex CLI, and Gemini CLI. The [Model Context Protocol](https://modelcontextprotocol.io/) (MCP) is an open standard that lets AI applications connect to external tools and data sources. Instead of copying and pasting between apps, your AI assistant can work with Mem natively. ## Why use Mem MCP? * **Easy setup** - Connect through OAuth, with guided setup for app clients and one-line install for CLI clients * **Full access to your knowledge** - AI tools can read, create, search, and organize your notes and collections * **Optimized for AI** - Built specifically for AI agents with efficient data formatting and semantic search ## What can you do with Mem MCP? * **Capture notes** - Save meeting notes, ideas, and research findings directly from your AI conversation * **Search your knowledge** - Let AI search across all your notes using Mem's semantic search to find relevant information * **Organize with collections** - Create collections, add notes to them, and keep your knowledge structured * **Update and manage notes** - Edit existing notes, trash old ones, or restore previously trashed notes * **Build on your notes** - Ask AI to read your existing notes and use them as context for new work ## Next steps Connect your AI client to Mem in minutes See the current MCP tool surface with example prompts # Security best practices Source: https://docs.mem.ai/mcp/security-best-practices Securely connect AI tools to Mem with MCP When connecting AI tools to Mem through MCP, follow these practices to reduce risk and keep control over write actions. ## Verify official Mem MCP endpoints Use only these domains: * `https://mcp.mem.ai/mcp` * `https://mcp.mem.ai/.well-known/...` * `https://api.mem.ai/...` and `https://mem.ai/...` during OAuth flow ## Use trusted clients and connectors Install MCP clients from trusted sources and double-check connector URLs before approving access. ## Keep human confirmation enabled for writes For destructive actions (for example deleting notes or collections), keep approval steps enabled in your client workflow. ## Use a dedicated workspace or test account when possible If you need stricter operational boundaries, connect MCP in a workspace or account with only the data you want tools to access. ## Treat prompts as untrusted input Prompt injection can try to make agents exfiltrate or modify data. Review tool calls and approvals before execution. ## Keep tokens and session state private Do not share bearer tokens or local MCP auth/cache files. # Getting started Source: https://docs.mem.ai/mcp/setup Connect your AI tools to Mem using MCP Connect your AI client to Mem's MCP server. This page documents setup for Claude, ChatGPT, Claude Code CLI, Codex CLI, and Gemini CLI. ## Claude (web/desktop) Use the following instructions to connect the Mem MCP server to Claude. Open the sidebar to get to the Customize page. On the Customize page, click Connectors, then click + to add a connector. Find Mem and add it. Complete the OAuth flow to connect your Mem workspace. Claude connector setup flow Open **Settings -> Connectors**. Click **Add custom connector** and enter: ```text theme={null} https://mcp.mem.ai/mcp ``` Complete the OAuth flow to connect your Mem workspace. ## ChatGPT Open [Mem on the ChatGPT store](https://chatgpt.com/apps/mem/asdk_app_699f3c9f85788191874d8a0a43d5bca3) and click **Connect**. ChatGPT walks you through the remaining setup. ## Claude Code CLI ```bash theme={null} claude mcp add --transport http mem https://mcp.mem.ai/mcp ``` Run `/mcp` in Claude Code and complete the browser OAuth flow. ## Codex CLI ```bash theme={null} codex mcp add mem --url https://mcp.mem.ai/mcp ``` Start a Mem tool call in Codex and complete the OAuth flow when prompted. ## Gemini CLI ```bash theme={null} gemini mcp add -s user -t http mem https://mcp.mem.ai/mcp ``` Run `gemini`, then `/mcp auth mem` to complete the browser OAuth flow. ## Provider docs * [Claude connectors docs](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp) * [Manage Claude's tool access](https://support.claude.com/en/articles/13730515-manage-claude-s-tool-access) * [Use connectors to extend Claude's capabilities](https://support.claude.com/en/articles/11176164-use-connectors-to-extend-claude-s-capabilities) * [ChatGPT connectors docs](https://help.openai.com/en/articles/11487775-connectors-in-chatgpt) * [ChatGPT developer mode + full MCP connectors docs](https://help.openai.com/en/articles/12584461-developer-mode-and-full-mcp-connectors-in-chatgpt-beta) * [Claude Code MCP docs](https://code.claude.com/docs/en/mcp) * [Codex MCP docs](https://developers.openai.com/codex/mcp) * [Gemini CLI MCP docs](https://geminicli.com/docs/tools/mcp-server/) ## Troubleshooting * Make sure your client can open a browser window for sign-in and consent. * If the flow was interrupted, disconnect and reconnect the Mem connector in your client. * Confirm you are signing in to the intended Mem account/workspace. If you are on a Claude Team or Enterprise plan, a Claude Owner or Primary Owner needs to enable Mem for the organization before members can connect it. Ask the owner to add Mem in **Organization settings -> Connectors**. After Mem is available for the organization, connect your own Mem account from your Claude connector settings. * A direct `401` from `https://mcp.mem.ai/mcp` without auth is expected. * In your MCP client, reconnect Mem to refresh authentication and retry. * Reduce request frequency and batch larger operations when possible. * Respect `Retry-After` before retrying. * Review current limits at [/api-reference/overview/rate-limits](/api-reference/overview/rate-limits). * Verify the connector URL is exactly `https://mcp.mem.ai/mcp`. * Re-list connectors/servers in your client and confirm Mem is enabled. * Retry the setup flow for your client. * In Claude, open the `+` menu, then go to **Connectors** and confirm Mem is enabled for the current conversation. * Check **Connectors -> Tool access**. In `On demand`, Claude searches for the right connector before loading it, which can add an extra discovery step. * If you need Mem to be available every time in that conversation, switch Claude to `Always available`. * Be explicit in your prompt when needed, for example: `Use the Mem connector for this task.` * If Claude still does not load Mem, disconnect and reconnect the Mem connector, then retry the conversation. * Anthropic documents this behavior here: * [Manage Claude's tool access](https://support.claude.com/en/articles/13730515-manage-claude-s-tool-access) * [Use connectors to extend Claude's capabilities](https://support.claude.com/en/articles/11176164-use-connectors-to-extend-claude-s-capabilities) # Supported tools Source: https://docs.mem.ai/mcp/supported-tools All tools available through Mem's MCP server Mem's MCP server exposes 23 tools that AI assistants can use to work with your notes, attachments, audio recordings, and collections. You don't need to know the tool names — just describe what you want in natural language and your AI assistant will pick the right tool. ## Notes Create a note with an optional note ID and collection links. If omitted, Mem generates the note ID. The first line of `content` becomes the note title. When to use: * You are creating a new note. * You need to create a new note with a specific ID. When NOT to use: * You need to overwrite a known existing note by ID (`update_note`). * You only need to change note/collection membership (`add_note_to_collection`, `remove_note_from_collection`, or `move_note`). **Example prompts:** * "Create a note with my meeting notes from today's standup" * "Save a new note titled 'Project Ideas' with these bullet points" * "Write a note capturing the key decisions from our planning session" Search notes and note-linked attachments together. Returns note hits with attachment match context for PDFs, images, audio recordings, calendar events, and emails. Use returned attachment IDs with the attachment tools for deeper inspection. When to use: * You need to search notes and note-linked attachments together from a natural-language or keyword query. * You need attachment match context such as PDF pages, OCR text, visual descriptions, highlighted snippets, or attachment IDs for follow-up inspection. When NOT to use: * You only need lightweight note discovery without attachment match details (`search_notes`). * You already have a specific attachment ID and need its extracted content (`read_attachment`) or one grounded answer (`answer_question_about_attachment`). **Example prompts:** * "Find notes or PDFs that mention the vendor renewal terms" * "Search my notes and attachments for onboarding screenshots" * "Find the PDF page that mentions launch requirements" Find notes semantically related to the current persisted content of a note. The source note is embedded at request time, so newly created or recently updated notes can be used before asynchronous indexing catches up. Candidate related notes still come from the note search index. When to use: * You already have a note ID and need semantically related existing notes. * You need collection context for notes related to a newly created or recently updated note. When NOT to use: * You need keyword or natural-language query discovery (`search_notes`). * You need the full current content for one note (`get_note`). **Example prompts:** * "Find notes related to this project planning note." * "After creating this note, check which existing notes and collections are related." * "Show me notes similar to the note I just updated." Fetch the full current state of a single note by ID. If the note is in trash, the response still returns the note and includes `trashed_at`. For discovery flows, use `list_notes` or `search_notes`. When to use: * You already have a note ID and need canonical content, linked recording IDs, or attachment IDs. When NOT to use: * You need note discovery without known IDs (`list_notes` or `search_notes`). **Example prompts:** * "Open my note about the API redesign" * "Show me the full contents of that meeting notes note" * "Pull up my 'Weekly Goals' note" List notes visible to the authenticated caller with cursor pagination. When multiple `contains_*` fields are true, a note may match any of them. Results are ordered by `order_by` and return `next_page` when additional rows are available. For relevance-ranked retrieval by query, use `search_notes`. When to use: * You need deterministic cursor pagination ordered by `updated_at` or `created_at`. * You are iterating through all accessible notes page by page. When NOT to use: * You need relevance-ranked retrieval from open-ended text (`search_notes`). **Example prompts:** * "Show me my recent notes" * "List all my notes" * "What notes have I created lately?" Restore a previously trashed note to the active note set. This only reverses soft-delete lifecycle state. When to use: * You need to undo a prior trash operation. When NOT to use: * The note is already active and does not need restoration. **Example prompts:** * "Restore the note I just trashed" * "Bring back my deleted meeting notes" * "Undo trashing that project plan note" Search notes using a required free-text query and structured filters. When multiple `filter_by_contains_*` fields are true, a note may match any of them. Returns note results from a bounded search snapshot with deterministic offset pagination. Query-based searches are relevance-ranked within the bounded search snapshot window. Reuse the returned `snapshot_id` when requesting later pages. The returned `total` reflects the bounded search snapshot, capped by the 100-result search window. For deterministic chronological pagination across all accessible notes, use `list_notes`. When to use: * You need relevance-ranked retrieval from a natural-language or keyword query. * You need query + filter retrieval instead of full feed traversal. When NOT to use: * You need deterministic chronological pagination (`list_notes`). * You need note-linked attachment matches for PDFs, images, audio, calendar events, or emails (`extended_search_notes`). **Example prompts:** * "Find my notes about the Q3 marketing strategy" * "Search for anything I've written about React performance" * "What notes do I have mentioning the onboarding flow?" Set a note's visible creation timestamp without changing its content. The supplied `created_at` must include a timezone offset and cannot be in the future. It can only backdate the note: the timestamp cannot be later than when the note was originally created. This operation changes note metadata only. Trashed notes must be restored before their creation date can be changed. When to use: * The user explicitly asks to change or correct a known note's visible creation date. When NOT to use: * The requested date is later than when the note was originally created. * You need to change the note body (`update_note`). * You need to create a new note (`create_note`). * The note is trashed and must be restored first (`restore_note`). **Example prompts:** * "Set this meeting note's creation date to Jan 7, 2020" * "Change this note's visible creation date to March 15, 2024" * "Correct this note so it shows it was created on April 20, 2026" Soft-delete a note by moving it to trash. Trashed notes can be restored via `restore_note`. When to use: * You need reversible removal from active notes. **Example prompts:** * "Trash my old scratch notes from last week" * "Move that draft note to the trash" * "Get rid of the note titled 'Untitled'" Submit a complete markdown body for a note and the exact `version` being updated. Send the full desired body in `content` (not a partial markdown patch). The first line of `content` becomes the updated title. Trashed notes must be restored before they can be updated. When to use: * You need full-body replacement for an existing note ID. When NOT to use: * You need partial patch semantics (not supported). * You need to create a new note (`create_note`). * You only need to change a note's visible creation date (`set_note_created_at`). * The note is trashed and must be restored first (`restore_note`). **Example prompts:** * "Add a new section to my project plan note" * "Update my grocery list note with these items" * "Append today's action items to my standup notes" ## Attachments Ask one focused question about a single attachment by kind and ID. Use `attachment_kind` and `attachment_id` returned in note attachment metadata. When to use: * You have `attachment_kind` and `attachment_id` from `get_note` attachment metadata or `extended_search_notes` attachment matches and need one grounded answer from that attachment. * You want the model to inspect a single attachment without returning all extracted pages or content chunks. When NOT to use: * You need structured extracted content or pagination controls (`read_attachment`). * You need the raw protected file bytes or a signed download URL (`get_note_attachment_download_url`). **Example prompts:** * "Using the PDF attached to this note, what are the launch requirements?" * "Ask the image attachment what text appears in the screenshot" * "From this attachment, answer whether it mentions renewal terms" Generate a temporary signed download URL for a note attachment. Use this when note content references an attachment, but the underlying file URL is not directly downloadable. The caller must be able to access the requested attachment. When to use: * You have an attachment ID from `get_note` `attachment_metadata` or note content and need a temporary signed URL to fetch the protected file behind that attachment reference. * Use this when note content references an attachment, but the underlying file URL is not directly downloadable. When NOT to use: * You need note-level discovery or attachment IDs (`get_note`). * You do not have an attachment ID from `get_note` or note content. **Example prompts:** * "Download the image attached to that note" * "Transcribe the contents of the PDF attached to that note" * "Get the attachment from that note so you can read the PDF and summarize it" Read structured content for a single attachment by kind and ID. Use `attachment_kind` and `attachment_id` returned in note attachment metadata. When to use: * You have `attachment_kind` and `attachment_id` from `get_note` attachment metadata or `extended_search_notes` attachment matches and need structured extracted content. * You need PDF pages, image OCR/visual metadata, audio transcripts, calendar event text, or email text without downloading the raw file. * For audio transcripts, speaker labels are best-effort context; participant names are optional, and generic or channel labels are normal. When NOT to use: * You need the raw protected file bytes or a signed download URL (`get_note_attachment_download_url`). * You only need one focused answer from the attachment (`answer_question_about_attachment`). **Example prompts:** * "Read the PDF attachment from this note and show me the first pages" * "Get the OCR text from the image attached to this note" * "Use the attachment metadata from this note to inspect the attached document" ## Audio recordings Fetch the current public transcript and metadata for a single audio recording by ID. When to use: * You already have an audio recording ID and need its transcript + metadata. * Transcript speaker labels are best-effort context; participant names are optional, and generic or channel labels are normal. When NOT to use: * You need note-level discovery or linked recording IDs (`get_note`). **Example prompts:** * "Show me the transcript for the recording attached to this note" * "Open the transcript from my meeting note and include the recording details" * "What audio recording is linked to this note? Show me the transcript" ## Collections Add an existing note to an existing collection. This operation only creates the membership link and does not modify note or collection content. Use create endpoints to create notes or collections. When to use: * You need to link an existing note to an existing collection. When NOT to use: * You need to create notes or collections first (`create_note` or `create_collection`). * You need to transfer a note out of one collection into another (`move_note`). **Example prompts:** * "Add that meeting notes note to my 'Project Phoenix' collection" * "Put this note in the 'Research' collection" Create a collection with optional caller-provided ID and timestamps. If `id` already exists, this request returns a conflict. Use collection membership endpoints to add, remove, or move notes between collections. When to use: * You are creating a new collection. * You need to create a new collection with an optional caller-provided ID or timestamps. When NOT to use: * You need to update an existing collection by ID (`update_collection`). * You only need membership changes between existing notes and collections (`add_note_to_collection`, `remove_note_from_collection`, or `move_note`). **Example prompts:** * "Create a new collection called 'Project Phoenix'" * "Make a collection for my interview prep notes" * "Set up a 'Reading List' collection" Permanently delete a collection. Hard-deleting removes the collection resource itself. For membership-only changes, use note add, remove, or move collection endpoints. When to use: * You need irreversible hard-delete behavior for a collection resource. When NOT to use: * You only need note membership changes in a collection (`add_note_to_collection`, `remove_note_from_collection`, or `move_note`). **Example prompts:** * "Delete my old 'Temp' collection" * "Remove the 'Archive 2023' collection" Fetch metadata for a single collection by ID. This tool returns collection metadata only, not a note list for that collection. For discovery flows, use `list_collections` or `search_collections`. When to use: * You already have a collection ID and need canonical metadata. When NOT to use: * You need collection discovery without known IDs (`list_collections` or `search_collections`). **Example prompts:** * "Show me what's in my 'Research' collection" * "Open the 'Project Phoenix' collection" * "What notes are in my 'Design Docs' collection?" List collections visible to the authenticated caller with cursor pagination. Results are ordered by `order_by` and return `next_page` when additional rows are available. For relevance-ranked retrieval by query, use `search_collections`. When to use: * You need deterministic cursor pagination for collections. * You are iterating through all accessible collections page by page. When NOT to use: * You need relevance-ranked retrieval from open-ended text (`search_collections`). **Example prompts:** * "Show me all my collections" * "What collections do I have?" * "List my collections" * "List collections updated after April 1" Move a note from one collection to another collection. This operation adds the note to the target collection, then removes it from the source collection. It does not modify note or collection content. When to use: * You need to transfer an existing note from one collection to another. When NOT to use: * The note should remain in the source collection; use `add_note_to_collection`. * You only need to unlink a note from a collection; use `remove_note_from_collection`. **Example prompts:** * "Move the Q1 risks note from 'Planning' to 'Exec Briefings'" * "Transfer this note from 'Inbox' to 'Project Phoenix'" Remove a note from a collection while keeping both resources. This operation only removes the membership link between IDs. Use `trash_note` to remove a note from active notes, or `delete_collection` to remove a collection resource. When to use: * You need to unlink a note from a collection while keeping both resources. When NOT to use: * You need to remove the note from active notes (`trash_note`) or delete the collection resource (`delete_collection`). * You need to transfer a note directly to another collection (`move_note`). **Example prompts:** * "Remove that note from the 'Archive' collection" * "Take the recipe note out of my 'Dinner Ideas' collection" Search collections using free-text relevance matching. Returns a bounded relevance-ranked result set and does not return `next_page`. For deterministic chronological pagination, use `list_collections`. When to use: * You need relevance-ranked retrieval for collection lookup. When NOT to use: * You need deterministic chronological pagination (`list_collections`). **Example prompts:** * "Find my collection about frontend architecture" * "Search for a collection related to hiring" * "Do I have a collection for design docs?" * "Find collections about hiring that were updated this quarter" Update metadata for a collection by ID. Use this tool to rename a collection by setting `title`. This tool updates only provided fields (`title`, `description`) and leaves omitted fields unchanged. For read-only retrieval, use `get_collection`. When to use: * You need to rename a collection by updating its title. * You need to update title and/or description for an existing collection ID. * You need to preserve a collection while correcting metadata. When NOT to use: * You need to create a new collection (`create_collection`). * You only need note membership changes (`add_note_to_collection`, `remove_note_from_collection`, or `move_note`). **Example prompts:** * "Rename my 'Q1 Ideas' collection to 'Q2 Ideas'" * "Update the description of 'Project Phoenix' to include launch milestones" * "Change this collection title to 'Customer Research' and keep everything else the same" ## Rate limits and quotas Mem MCP requests are backed by the Mem API and follow the same API rate limits and quotas. For current limits, see [/api-reference/overview/rate-limits](/api-reference/overview/rate-limits). If limits are exceeded, requests return HTTP `429` and include a `Retry-After` header.