MemHeaven

by nazar256

215 downloads

Not rated

GitHub

About

Self-hosted remote MCP for durable, searchable AI memory you own. Deploy your Cloudflare Worker, then connect ChatGPT and other hosted clients to its OAuth-protected /mcp endpoint.

Details

Author: nazar256
Downloads: 215
Categories: AI, Developer Tools, Knowledge Base

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name MemHeaven

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

From the repository

{
  "mcpServers": {
    "memheaven": {
      "type": "http",
      "url": "https://{worker_domain}/mcp"
    }
  }
}

`mempalace_status`

diagnostics and backend capabilities for memory-relevant chats.

`mempalace_wake_context`

bounded, privacy-scoped startup context for memory-relevant chats.

`mempalace_list_wings`

tenant-scoped wings and active drawer counts.

`mempalace_list_rooms`

tenant-scoped rooms and active drawer counts.

`mempalace_get_taxonomy`

the current tenant-scoped wing and room taxonomy.

`mempalace_get_aaak_spec`

compact guidance for concise, readable memory notes.

`mempalace_search`

hybrid semantic and lexical search over tenant-scoped drawers.

`mempalace_check_duplicate`

exact or semantic duplicate checks before writing memory.

`mempalace_get_drawer`

one tenant-scoped drawer with bounded content and provenance.

`mempalace_list_drawers`

active tenant-scoped drawers with optional scope filters.

`mempalace_add_drawer`

durable drawer content storage and semantic indexing.

`mempalace_update_drawer`

drawer updates and reindexing of changed content or metadata.

`mempalace_delete_drawer`

soft-delete of a tenant-scoped drawer and semantic index entries.

`mempalace_diary_write`

concise diary entry writing and scoped semantic indexing.

`mempalace_diary_read`

recent diary entries with optional scope filters.

`mempalace_diary_search`

semantic diary search for one explicit agent.

`mempalace_diary_reindex`

diary semantic index backfill or refresh maintenance.

`mempalace_kg_query`

tenant-scoped temporal knowledge-graph fact queries.

`mempalace_kg_check`

deterministic reliability checks for active KG conflicts and stale facts.

`mempalace_kg_add`

tenant-scoped temporal knowledge-graph fact creation.

`mempalace_kg_invalidate`

invalidation of an exact tenant-scoped knowledge-graph fact.

`mempalace_kg_timeline`

recent knowledge-graph timeline for an entity or all facts.

`mempalace_kg_stats`

tenant-scoped knowledge-graph statistics.

`mempalace_traverse`

bounded traversal of the tenant shared-room graph and tunnels.

`mempalace_find_tunnels`

tenant-scoped cross-wing shared rooms acting as passive tunnels.

`mempalace_graph_stats`

tenant-scoped graph, shared-room, and tunnel statistics.

`mempalace_create_tunnel`

explicit tenant-scoped tunnel creation between locations.

`mempalace_list_tunnels`

tenant-scoped explicit tunnel listing with endpoint filters.

`mempalace_delete_tunnel`

deletion of a tenant-scoped explicit tunnel by ID.

`mempalace_follow_tunnels`

following explicit tunnels connected to a wing and room.

`mempalace_hook_settings`

the configured save policy for this deployment.

`mempalace_memories_filed_away`

latest tenant-scoped write filing status.

`mempalace_reconnect`

configured binding and index health.

`mempalace_sync`

reports that local filesystem and git sync is unsupported in hosted mode.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "memheaven": {
            "memheaven": {
                "type": "http",
                "url": "https://{worker_domain}/mcp"
            }
        }
    }
}

McpServers

{
    "memheaven": {
        "type": "http",
        "url": "https://{worker_domain}/mcp"
    }
}

MemHeaven is a self-hosted remote MCP memory server for ChatGPT and other cloud AI agents.

It gives hosted AI clients searchable long-term memory you own, deployed on Cloudflare. MemHeaven is inspired byMemPalace's long-term-memory model while using a remote deployment shape for hosted clients.

Deploy on a Cloudflare Free account. No VM, no Docker, no database admin.

Free-tier limits apply; heavy usage may require paid Cloudflare usage.

Quick links:Quickstart·Getting started from zero·ChatGPT setup·Client compatibility·Security model·Behavior evals

AI assistants are useful in the moment, but they often forget project context across chats, sessions, and tools.

Built-in memory features can help, but they are usually provider-owned and are not the same thing as an inspectable, searchable memory layer you control. Local-first memory tools are powerful too, but hosted clients like ChatGPT and other remote agents need a remote MCP server.

- searchable memory they own
- inspectable and deletable stored context
- continuity for coding agents and other AI workflows across sessions
- a remote MCP deployment shape instead of a laptop-only setup

Choose MemHeaven when a hosted client or AI agent needs a searchable memory layer that persists outside the current chat:

- ChatGPT needs to retrieve project decisions, preferences, notes, or other durable context across chats.
- A remote MCP client cannot depend on a memory service running only on your laptop.
- Separate users or workflows need tenant-scoped access to stored context.
- You want to inspect, search, and delete the records held by your own deployment.

External memory, not a replacement for ChatGPT memory

MemHeaven does not change ChatGPT's built-in memory. It is a separate OAuth-protected MCP service that your client can call for context stored in your own deployment. There is no shared public MemHeaven instance: you operate the Worker, storage bindings, OAuth configuration, and access keys in your Cloudflare account.

ChatGPT long-term memory over remote MCP

If you want ChatGPT to use a searchable memory layer across chats without putting that memory in a shared third-party service, deploy MemHeaven in your own Cloudflare account and connect ChatGPT to your instance's/mcpendpoint. This external memory complements ChatGPT's built-in memory: you can inspect, search, and delete the records stored by your own deployment. See the ChatGPT setupand security modelbefore connecting a client.

- AI assistants forget project context across chats and sessions.
- Built-in memory is useful, but it is usually provider-owned and not an exact, searchable memory layer.
- Local-first memory tools are powerful, but hosted clients need remote MCP.
- Users want inspectable, searchable, deletable, portable memory.
- Coding agents need continuity across sessions, editors, and tools.

Cloudflare Free account is enough for personal use

MemHeaven is designed for personal use and small trusted-group usage on Cloudflare-managed services.

- Workerruns the HTTP server.
- D1stores relational metadata and indexes.
- R2stores drawer and diary bodies.
- Vectorizepowers semantic vector search.
- Workers AIgenerates embeddings.

- no VM
- no Docker
- no database admin
- no long-running server process

Free-tier limits apply. MemHeaven doesnotpromise unlimited free usage, enterprise uptime, or zero cost under every workload. Also note that some underlying Cloudflare services, especially Vectorize, have their own plan and usage constraints, so review the current Cloudflare pricing before a broad rollout.

npm install cp wrangler.toml.example wrangler.toml npm run init -- --base-url https://memheaven.<your-workers-subdomain>.workers.dev npm run secrets:generate npx wrangler secret put JWT_SIGNING_SECRET npx wrangler secret put TOKEN_ENCRYPTION_KEY npx wrangler secret put AUTH_KEY_PEPPER export AUTH_KEY_PEPPER='<same AUTH_KEY_PEPPER value>' npm run keygen -- --tenant personal --label "Personal" npx wrangler deploy

https://memheaven.<your-workers-subdomain>.workers.dev/mcp

When the authorization page opens, paste the printedraw_key.

If you want the hand-holding version, use docs/GETTING_STARTED_FROM_ZERO.md.

Full details:docs/CLIENT_COMPATIBILITY.md

Use MemHeaven conservatively for writes and proactively for reads when prior context matters. The MCP tools return their own detailed guidance, so the ChatGPT/custom-agent instruction can stay short.

Use MemHeaven for cross-session memory. When prior context may matter, start with mempalace_wake_context if available; otherwise call mempalace_status and follow its returned guidance. Do not mix work, personal, or project scopes. Save only durable facts, decisions, and preferences as concise plain text.

Full guide:docs/AGENT_MEMORY_PROTOCOL.md

MemHeaven is inspired by MemPalace, the open-source local-first AI memory project that helped show how useful verbatim, searchable long-term memory can be for AI agents.

MemPalace made a strong case for keeping original context and organizing it in a navigable memory structure. MemHeaven explores a different deployment shape: remote MCP memory for hosted clients and trusted shared setups.

We see that as complementary to MemPalace’s on-device approach, not a replacement for it.

- A Cloudflare Worker exposes OAuth endpoints and the authenticated/mcpendpoint.
- Hosted AI clients connect over Streamable HTTP MCP.
- D1 stores metadata, indexes, KG facts, tunnels, quotas, and audit rows.
- R2 stores full verbatim drawer and diary bodies.
- Workers AI generates embeddings.
- Vectorize performs semantic search over chunked memory content.
- Access keys gate authorization and map users to tenant-scoped memory.

- docs/GETTING_STARTED_FROM_ZERO.md
- docs/CLIENT_COMPATIBILITY.md
- docs/AGENT_MEMORY_PROTOCOL.md
- [docs/SECURITY.md

- OAuth 2.1 + PKCE + dynamic client registration for ChatGPT-compatible remote MCP.
- Access-key-gated consent page backed by stateless JWT auth artifacts.
- Tenant-scoped drawer, diary, knowledge-graph, and tunnel storage.
- Streamable HTTP MCP server usingWebStandardStreamableHTTPServerTransportwith per-request stateless bootstrap.
- MemPalace-compatiblemempalace_*tool surface, including adapted local-only tools.
- Worker-safe semantic search using Workers AI embeddings + Vectorize + R2/D1 hydration.
- Quota guardrails, redacted audit logging, smoke scripts, and local test coverage.
- Synthetic memory behavior evals for retrieval, scope isolation, tenant isolation, and KG lifecycle regressions.

Use the local eval harness before/after retrieval, wake-context, or KG behavior changes:

npm run eval:local npm run eval:baseline

The optional remote smoke/eval skips safely unless configured with environment variables:

…

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

mempalace_status

mempalace_wake_context

mempalace_list_wings

mempalace_list_rooms

mempalace_get_taxonomy

mempalace_get_aaak_spec

mempalace_search

mempalace_check_duplicate

mempalace_get_drawer

mempalace_list_drawers

mempalace_add_drawer

mempalace_update_drawer

mempalace_delete_drawer

mempalace_diary_write

mempalace_diary_read

mempalace_diary_search

mempalace_diary_reindex

mempalace_kg_query

mempalace_kg_check

mempalace_kg_add

mempalace_kg_invalidate

mempalace_kg_timeline

mempalace_kg_stats

mempalace_traverse

mempalace_find_tunnels

mempalace_graph_stats

mempalace_create_tunnel

mempalace_list_tunnels

mempalace_delete_tunnel

mempalace_follow_tunnels

mempalace_hook_settings

mempalace_memories_filed_away

mempalace_reconnect

mempalace_sync

Claude Desktop / Cursor

McpServers

External memory, not a replacement for ChatGPT memory

ChatGPT long-term memory over remote MCP

Cloudflare Free account is enough for personal use

Install

More like this

Aws Kb Retrieval Server

Memory

Sentry

Github

Git

GitLab

`mempalace_status`

`mempalace_wake_context`

`mempalace_list_wings`

`mempalace_list_rooms`

`mempalace_get_taxonomy`

`mempalace_get_aaak_spec`

`mempalace_search`

`mempalace_check_duplicate`

`mempalace_get_drawer`

`mempalace_list_drawers`

`mempalace_add_drawer`

`mempalace_update_drawer`

`mempalace_delete_drawer`

`mempalace_diary_write`

`mempalace_diary_read`

`mempalace_diary_search`

`mempalace_diary_reindex`

`mempalace_kg_query`

`mempalace_kg_check`

`mempalace_kg_add`

`mempalace_kg_invalidate`

`mempalace_kg_timeline`

`mempalace_kg_stats`

`mempalace_traverse`

`mempalace_find_tunnels`

`mempalace_graph_stats`

`mempalace_create_tunnel`

`mempalace_list_tunnels`

`mempalace_delete_tunnel`

`mempalace_follow_tunnels`

`mempalace_hook_settings`

`mempalace_memories_filed_away`

`mempalace_reconnect`

`mempalace_sync`