Integration

Long-term memory for Canvas MCP Client

Canvas MCP Client is the open-source, self-hostable infinite-canvas dashboard for MCP servers — sticky notes, AI chat, kanban, markdown, spreadsheets, all zoomable widgets talking to one or more MCP servers. Its 1.0.0 release wires HTTP / SSE through FastMCP's `Client(url, auth=...)`, and the only built-in `auth` option is OAuth. Engram's hosted endpoint is Bearer-key, so the recipe adds Engram as a stdio server inside Canvas with `mcp-remote` bridging stdio to Engram's SSE endpoint.

Get an API key (free) All integrations →

Install

Three steps: sign up for an Engram API key, paste a BYOK LLM-provider key on /models, then drop the snippet below into Canvas MCP Client.

Three steps to memory in your agent

Sign up. Free, no card. You'll land on a Getting Started page that walks the next two steps.
Add your LLM key. Engram is BYOK. Paste an OpenAI / Anthropic / Groq / Together / Fireworks key and we'll route every extraction and query call through your provider. You pay your provider directly. We never see your inference.
Paste the snippet below into your agent and restart it. Use Authorization: Bearer <api-key>with the API key from your portal.

Canvas MCP Client: open-source infinite-canvas dashboard

Canvas 1.0.0's remote MCP transport only supports OAuth, so Engram is wired as a stdio server inside Canvas via mcp-remote (bridges stdio → SSE with a Bearer header).

Inside Canvas, add an MCP server with this config:

Canvas server JSON

{
  "name": "engram",
  "command": "npx",
  "args": [
    "-y",
    "mcp-remote",
    "https://mcp.lumetra.io/mcp/sse",
    "--transport",
    "sse-only",
    "--header",
    "Authorization:Bearer <api-key>"
  ]
}

If running Canvas in Docker, make sure npx is on PATH inside the backend container — the Python-only image needs a docker-compose.override.yml that installs Node, otherwise the stdio bridge can't spawn.
First boot scrapes awesome-mcp-servers into SQLite and can take 10+ minutes. Tail docker compose logs -f backend and wait for Uvicorn running on 0.0.0.0:8000 before adding the server.

Hard-code the key; no shell interpolation

FastMCP (which Canvas uses) passes args verbatim to npx — a ${ENGRAM_API_KEY} placeholder is sent literally. Paste the real eng_live_... string into the JSON, or pre-render with envsubst before pasting.

What you can do once memory's wired in

Build a "second brain" canvas: an AI Chat widget wired to `engram` for memory, sticky notes for ephemeral scratch, markdown widgets rendering recall
Spin up a fresh canvas against the same Engram bucket and your knowledge is still there — Canvas saves widget layout to SQLite, Engram persists the actual memories
Run Canvas in Docker with the recipe's `docker-compose.override.yml` so `npx` is on PATH inside the Python-only backend container (otherwise the stdio bridge can't spawn)
Use Canvas's per-widget MCP scoping to let one widget read memories while another writes — same bucket, different roles

FAQ

Why stdio + `mcp-remote` instead of pointing Canvas straight at the SSE URL?

Canvas 1.0.0's HTTP / SSE transports go through FastMCP's `Client(url, auth=...)`, and the only built-in `auth` option is OAuth. Engram is Bearer-keyed, so the workaround is stdio + `mcp-remote`, which injects the `Authorization: Bearer ...` header on Canvas's behalf. When Canvas ships first-class header / OAuth support for remote MCP servers (on their roadmap), the recipe collapses to a plain SSE entry.

Why is first boot so slow?

Canvas's `init_database.py` runs synchronously on first startup and scrapes ~2,200 entries from the awesome-mcp-servers registry into its own SQLite catalog. That step can take 10+ minutes depending on GitHub rate limits. Tail `docker compose logs -f backend` and wait for `Uvicorn running on http://0.0.0.0:8000`. Subsequent restarts short-circuit this (the `db_exists` check skips re-scraping).

Can I use `${ENGRAM_API_KEY}` interpolation in the Canvas server JSON?

No. FastMCP (which Canvas uses) passes the `args` array to `npx` verbatim — it does NOT do shell interpolation on those strings, so a `${ENGRAM_API_KEY}` placeholder is sent literally as part of the header value. Hard-code the real `eng_live_...` string in the JSON, or pre-render with `envsubst < canvas-mcp-server.json` and paste the output.

Related integrations

Ship durable memory in Canvas MCP Client today

Free tier: 10K memories and 50K retrievals per month. No credit card. Same Engram backend powers all 41 integrations, so memories you write from one client are immediately queryable from the rest.

Start free See pricing