> ## 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.

# MCP Server (No-code)

> Give an agent on Gumloop, n8n, Claude, or any MCP-aware platform persistent memory with just a URL and a token. No code.

Synap hosts a remote **MCP server** so no-code platforms can have persistent memory without running an SDK or writing any code. You connect it the way every MCP-aware tool connects to a remote server: paste an **MCP Server URL** and a **Bearer token**. Your agent then discovers Synap's memory tools and calls them automatically.

<Note>
  This is the **no-code** surface. If you're building with code, use an [SDK or framework integration](/integrations/overview) instead. You get the same memory, with more control.
</Note>

## How it works

The MCP server re-fronts Synap's existing memory operations as a small set of tools. The model decides when to call them from their descriptions alone, so you configure nothing:

* **Forward everything.** Your agent forwards each conversation turn to a single "log" tool. You never decide what is "memory-worthy"; Synap's extraction pipeline decides what to keep.
* **Recall before replying.** Your agent fetches what's already known about the person before it answers.
* **Async by design.** Logging is fire-and-forget so a slow write never stalls a reply; extraction happens in the background.

## Get your connection details

<Steps>
  <Step title="Open the MCP page in your dashboard">
    In the Synap dashboard, go to **MCP** in the sidebar.
  </Step>

  <Step title="Create an agent">
    Describe, in plain English, what your agent does and what it should remember. Synap designs the memory architecture for you; there's nothing to configure.
  </Step>

  <Step title="Copy the URL and generate a token">
    The page shows your **MCP Server URL** and lets you generate a **Bearer token**. The token is shown once, so copy it now.

    Your MCP Server URL looks like:

    ```
    https://synap-mcp.maximem.ai/mcp
    ```
  </Step>
</Steps>

<Warning>
  Always use a standard **Bearer token**, never a custom header. Some platforms (e.g. Gumloop with Anthropic models) drop custom headers, so Bearer is the only reliable option. Your Synap API key *is* the Bearer token.
</Warning>

## Connect your platform

<Tabs>
  <Tab title="Gumloop">
    <Steps>
      <Step title="Add the credential">
        **Settings → Credentials → Add → MCP Server**. Paste your **MCP Server URL**, choose **Bearer token**, and paste your token. Connect.
      </Step>

      <Step title="Enable it on your agent">
        Add an **Agent** (or **Ask AI**) node and enable the Synap MCP credential. The memory tools appear automatically.
      </Step>

      <Step title="Chat">
        Talk to your agent. It logs each turn and recalls what's known before replying.
      </Step>
    </Steps>
  </Tab>

  <Tab title="n8n">
    <Steps>
      <Step title="Add an MCP Client Tool node">
        Add an **AI Agent** node and an **MCP Client Tool** node. Point the MCP Client Tool at your **MCP Server URL**, choose **Bearer Auth**, and paste your token.
      </Step>

      <Step title="Wire it in">
        Connect the MCP Client Tool node into the AI Agent node's **tools** input.
      </Step>

      <Step title="Self-hosted note">
        On self-hosted n8n you may need `N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true`, and (behind nginx) to disable proxy buffering on the MCP path.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Claude / other MCP clients">
    <Steps>
      <Step title="Add a remote MCP server">
        In your MCP-aware client, add a custom connector / remote MCP server. Use your **MCP Server URL** with **Bearer** auth and paste your token.
      </Step>

      <Step title="Use it">
        The agent discovers the Synap memory tools and calls them automatically.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Tools

The MCP server exposes these tools. Descriptions are written so the model calls them on its own; you don't wire anything up.

| Tool                   | What it does                                                                                |
| ---------------------- | ------------------------------------------------------------------------------------------- |
| `log_exchange`         | Forward a user (and optional assistant) turn to be remembered. Synap decides what persists. |
| `recall_context`       | Recall what's already known about the current person, for use before replying.              |
| `list_recent_memories` | List recent memories; handy for debugging or confirming memory works.                       |
| `check_memory_status`  | Check whether a logged exchange finished processing (extraction is asynchronous).           |

### Arguments

* **`user_id`** *(optional)*: a stable id for the end-user. Pass it on both `log_exchange` and `recall_context` to keep each person's memory separate.
* **`customer_id`** *(optional)*: an organization id, for B2B / multi-tenant agents.
* **`conversation_id`** *(optional)*: groups turns into a conversation.
* **`wait_for_processing`** *(optional, `log_exchange`)*: when `true`, waits for extraction to finish and reports the outcome instead of returning immediately. Leave it off for normal turn-by-turn logging.

## Scoping memory

Who sees which memories is decided by the ids you pass; there's nothing to configure:

<CardGroup cols={3}>
  <Card title="One shared memory" icon="users">
    Pass no ids. Everything is shared across the agent. Good for a single-purpose assistant.
  </Card>

  <Card title="Per end-user" icon="user">
    Pass `user_id`. Each person gets their own private memory; everyone still shares the agent's general knowledge.
  </Card>

  <Card title="Per organization" icon="building">
    Pass `customer_id` for B2B agents that serve multiple customer organizations.
  </Card>
</CardGroup>

<Tip>
  For a real per-user experience, map your platform's user identifier into `user_id`, for example an n8n expression like `{{ $json.userId }}` or a Gumloop input. The same id on `log_exchange` and `recall_context` keeps each person's memory separate.
</Tip>

## Prove it works

The dashboard's **MCP** page includes a **Test my memory** button: it writes a sample memory and reads it back live, so you can confirm your token works before going live. In your platform, the same loop is the real test: tell your agent a fact, then in a new session ask what it remembers.

## Troubleshooting

<AccordionGroup>
  <Accordion title="The agent never saves or recalls">
    Confirm the tools are listed on the credential/node. If the model still doesn't call them, add a one-line instruction to your agent prompt: *"Use your memory tools: log every user message and recall before replying."*
  </Accordion>

  <Accordion title="Works on OpenAI but not on Claude (Gumloop)">
    That's the custom-header drop. Make sure auth is set as a **Bearer token**, not a custom header.
  </Accordion>

  <Accordion title="Recall returns nothing right after saving">
    Extraction is asynchronous, so wait a few seconds and try again, or use `check_memory_status` (or `wait_for_processing`) to confirm processing finished.
  </Accordion>

  <Accordion title="Connection won't establish">
    Re-check the URL (it ends in `/mcp`) and that the token is pasted exactly. Tokens are shown once, so regenerate from the MCP page if you've lost it.
  </Accordion>
</AccordionGroup>

## Going further

* [Patterns overview](/patterns/overview): reusable memory patterns across frameworks.
* [Cookbook overview](/cookbook/overview): end-to-end worked examples.