Tutorial

Add Engram memory to ChatGPT as a custom connector

ChatGPT will happily call MCP servers if you give it one. This walks through pointing it at Engram, completing OAuth, and the system prompt that turns the tools from idle decoration into something the model actually uses.

Published May 8, 2026 · By Jacob Davis and Ben Meyerson

ChatGPT on supported plans accepts custom MCP connectors. Engram is one. Once it's wired up, anything you tell ChatGPT can be stored to a durable bucket and recalled in a future chat. Not just inside the current conversation, not tied to ChatGPT's built-in memory feature, and not lost when you start a new session.

The whole setup is about ten minutes: paste a URL, complete an OAuth handshake, paste a system prompt. The OAuth side is fully automated. There's no app registration, no client ID to manage, no callback URL to configure. The system prompt is the part most setups skip and then wonder why the connector "doesn't do anything." We'll cover both.

Prerequisites

Before you start, you need three things:

An Engram account. Free tier is fine. Sign up at lumetra.io; no card required. The Free tier covers 10K stored memories and 50K retrievals per month, which is more than enough to evaluate the connector.
A BYOK key configured in the Engram portal. Engram is bring-your-own-key. We don't run inference on your behalf. Extraction and query calls route through your provider. Any OpenAI-compatible endpoint works: OpenAI, Groq, Together, Fireworks. Configure it under /models in the portal. Without this, every store_memory and query_memory call fails with a "BYOK required" error. See the gotchas section.
A ChatGPT plan that supports custom connectors. ChatGPT's connector feature is gated by plan tier. If you don't see "Add custom connector" under Settings → Connectors, your plan doesn't support it yet. Worth checking before you spend time on the rest of this.

With those three boxes ticked, the rest is mechanical.

Step 1: Add the custom connector

In ChatGPT, open Settings → Apps → Advanced Settings, turn Developer Mode on, then click Create App. You'll be asked for a server URL. Paste:

https://mcp.lumetra.io/mcp/sse

That's Engram's MCP endpoint. It speaks SSE (Server-Sent Events) over HTTPS, which is what ChatGPT expects for remote MCP servers. You don't need to fill in an Authorization header here. That's handled by the OAuth flow in the next step. Give the connector a name you'll recognize ("Engram" works), confirm, and ChatGPT will move on to authorization.

One quirk worth flagging up front: ChatGPT caches its connector list aggressively. If you've previously tried to add Engram and removed it, you may need to fully refresh (log out and back in, or close and reopen the desktop app) before the new connector picks up cleanly.

Step 2: Complete the OAuth handshake

ChatGPT will redirect you to Engram's OAuth flow. This is where a lot of MCP tutorials get hand-wavy. Here's what's actually happening, in order, so you know what each screen is for and what to do if one of them looks wrong.

2a. Dynamic Client Registration

The first thing that happens is invisible. ChatGPT calls Engram's /oauth/register endpoint and registers itself as an OAuth client on the fly. No developer action required, no console to log into, no client ID to copy-paste. This is RFC 7591 (Dynamic Client Registration), and it's the reason MCP connector setup is as light as it is. Engram issues a fresh client ID for this specific ChatGPT install and remembers the redirect URI ChatGPT plans to use.

2b. Portal login

ChatGPT then opens a browser tab to the Engram portal login page. You'll see one of three things depending on how your account is set up: email + password, "Continue with Google," or "Continue with GitHub." Pick whichever you used when you signed up. If this is a brand-new browser, you'll log in normally; if you're already signed in elsewhere, it's a single click.

2c. Implicit consent

On a typical OAuth flow this is where you'd see a consent screen ("ChatGPT wants to access your Engram memories, allow?"). Engram doesn't show one. The consent is implicit: completing login from inside the connector flow is the consent. We made this call because the alternative, a generic "do you trust this third party" screen, adds friction without adding information for the user. The connector is requesting all four standard scopes (memory read, memory write, bucket read, bucket write), there's no granular toggle, and there's no second app you're authorizing on Engram's behalf.

If you want to be more deliberate about scope, the answer is bucket-level. Store project work in a bucket separate from personal context, and treat the connector as having access to whatever bucket you point it at. ChatGPT's view of "your memories" is whatever you tell store_memory and query_memory to use.

2d. Redirect back with a token

The portal redirects back to the URI ChatGPT registered in step 2a, with an authorization code attached. ChatGPT swaps the code for an access token (and a refresh token) via Engram's /oauth/token endpoint. From this point on, every MCP call from ChatGPT to Engram carries a bearer token in the Authorization header. You don't see any of this. You just see ChatGPT land you back on the Connectors screen with Engram now marked as connected.

Total time: usually under thirty seconds, most of it spent on the login page. If anything fails, it almost always fails at step 2b (you hit the wrong login provider) or step 2d (your browser blocked the redirect). Both retry cleanly.

Step 3: Verify the connector works

Open a fresh chat in ChatGPT. The Engram tools should now show up in ChatGPT's tool list. Depending on the surface, you'll see them in a connector menu, in the tools popover, or by asking ChatGPT what tools it has. The full set is:

store_memory(content, bucket?): store a fact
query_memory(question, bucket?): search memories with natural language
list_buckets(): list available buckets
list_memories(bucket?): page through memories in a bucket
delete_memory(memory_id, bucket): remove one memory
clear_memories(bucket): wipe a bucket (destructive)

A reasonable smoke test: in one chat, say "remember that my preferred deployment region is us-east-1." ChatGPT should call store_memory. Open a brand-new chat (not a continuation, actually new), and ask "what's my preferred deployment region?" ChatGPT should call query_memory and answer correctly.

If the store works but the query comes back empty, that's almost always a bucket mismatch. The model stored to one bucket and queried another. The fix is the system prompt in the next section, which pins bucket behavior explicitly.

If the store itself fails with a "BYOK required" error, your BYOK key isn't configured. See the gotchas section.

The system prompt that makes memory actually used

Here's the part most tutorials skip and most users get burned by: out of the box, ChatGPT will see the Engram tools and reliably ignore them. Tool-calling models are calibrated to be conservative about calling things they weren't told to call. A connector is presence-of-capability, not instruction-to-use.

To turn memory from optional into reflexive, paste this into ChatGPT as a custom system prompt (Custom Instructions, or the system message of a Project if you're scoping it to one workspace):

You have Engram memory. Use it proactively to improve continuity and personalization.

Tools:
- store_memory(content, bucket?) - Store a fact or piece of information
- query_memory(question, bucket?) - Search memories using natural language
- list_buckets() - List available memory buckets
- delete_memory(memory_id, bucket) - Delete a specific memory
- clear_memories(bucket) - Clear all memories in a bucket (destructive!)

Policy:
- Query-first: before answering anything that may rely on prior context, call query_memory. Ground your answers in the results.
- Proactive storing: capture stable preferences, profile facts, project details, decisions, and outcomes. Keep each fact concise (1-2 sentences).
- Use buckets: organize memories by project or context (e.g., "work", "personal", "project-alpha").

Style for stored content: short, declarative, atomic facts.
Examples:
- "User prefers dark mode."
- "User timezone is US/Eastern."
- "Project Alpha deadline is 2026-10-15."

The three sections each do a specific job. Tools reminds the model that these tools exist and what their signatures are. Even though ChatGPT already has the tool schemas, a textual restatement in the system prompt measurably increases call frequency. Policy sets the two behaviors that matter most: query before you answer, store when you learn something durable. Style stops the model from storing 200-word paragraphs as single memories, which wrecks retrieval quality later.

Without this prompt, the connector is technically working (ChatGPT can see the tools, the OAuth handshake completed, the bearer token is valid) but the memory is dead weight. With it, ChatGPT starts calling query_memory at the top of conversations and store_memory when you tell it something worth remembering. The behavioral difference is large and immediate.

What this changes about ChatGPT

Once the connector is live and the prompt is in place, three things change about how ChatGPT behaves. Context for each project sits in its own bucket instead of bleeding together. Preferences live outside OpenAI's built-in memory, which means they survive when you switch accounts, workspaces, or organizations. And for the power-user end of the spectrum, you can list, inspect, or delete memories directly from code without going through the ChatGPT UI at all.

How this relates to ChatGPT's built-in memory

ChatGPT's built-in memory is fine for casual continuity and stays on; the actual distinction is that Engram gives you programmatic access (HTTP API, MCP from Claude Code, Cursor, Windsurf, OpenCode), explicit per-project bucketing, and durability across account or organization boundaries. The two coexist fine. The system prompt above just nudges Engram toward the explicit, project-shaped side.

Common gotchas

By far the most common: a first store_memory call comes back with a "BYOK required: configure your LLM provider at /models" error, which means BYOK isn't configured. The structured error carries code: "byok_not_configured" if your client surfaces it; on the REST API the same condition returns HTTP 412. Add a key at /models in the portal and retry; no need to redo OAuth. Second most common: OAuth refresh tokens have a 60-day lifetime, so if you stop using the connector for a couple of months you'll need to re-authenticate (same thirty-second flow). The rare one is connector-list caching: ChatGPT can show stale connector state after you remove and re-add Engram, which usually clears after a force-quit of the desktop app or a hard refresh of the web UI.

Cross-client memory

That's the full setup. ChatGPT now has durable, bucketed, explainable memory. The recommended system prompt above is reproduced verbatim from the one Engram ships for every MCP client. If you set it up across ChatGPT, Claude Code, and Cursor with the same buckets, you get a memory layer that follows you wherever you're working. That's the part that's hard to walk back from once you've used it.