" --content "<markdown>" # Add wiki doc openclaw membase wiki-add "<title>" --content "<markdown>" --project "Docs" openclaw membase wiki-update <docId> --title "<new title>" # Update wiki doc openclaw membase wiki-update <docId> --clear-project # Move to Basic openclaw membase wiki-delete <docId> # Delete wiki doc openclaw membase status # Check API connectivity ``` ## Auto-Recall Runs before every AI response (`before_agent_start` hook) when enabled. Queries Membase for relevant memories and wiki docs and injects them as context when enabled. Casual chat (greetings, acknowledgments) is skipped. The injected context respects a `maxRecallChars` budget to avoid oversized prompts. Auto-Recall is **disabled by default**. Enable it in your plugin config: ```json theme={null} { "plugins": { "entries": { "openclaw-membase": { "config": { "autoRecall": true } } } } } ``` ## Auto-Capture Runs after every AI response (`agent_end` hook). Buffers user and assistant messages per channel and flushes original transcripts to Membase Wiki. Buffers flush after **5 minutes of silence** or **20 messages**, whichever comes first. The last 2 messages are kept as overlap for continuity across batches. ## Configuration All configuration is managed through OpenClaw's plugin settings or `~/.openclaw/openclaw.json`: | Key | Type | Default | Description | | ---------------- | ------- | ----------------------------------------------- | ---------------------------------------------------------------------------------------- | | `apiUrl` | string | `https://api.membase.so` | Membase API URL. Override only if instructed by Membase support. | | `tokenFile` | string | `~/.openclaw/credentials/openclaw-membase.json` | OAuth token cache file path. Stored outside the plugin directory so it survives updates. | | `autoRecall` | boolean | `false` | Inject relevant memories before every AI turn. | | `autoWikiRecall` | boolean | `false` | Inject relevant wiki documents before every AI turn. | | `autoCapture` | boolean | `true` | Automatically store user/assistant conversation transcripts to Wiki. | | `maxRecallChars` | number | `4000` | Max characters of memory context per turn (500–16000). | | `debug` | boolean | `false` | Enable verbose debug logs. | OAuth login keeps stable plugin config in `~/.openclaw/openclaw.json` and stores rotating tokens in `tokenFile`. Legacy keys (`accessToken`, `refreshToken`) are migrated automatically when present. ### Enabling AI Tools The plugin automatically adds itself to `tools.alsoAllow` on first load. If it doesn't take effect, restart the gateway once. If you prefer to configure it manually, use `tools.alsoAllow` (not `tools.allow`) to avoid breaking your existing profile allowlist: ```json theme={null} { "tools": { "profile": "coding", "alsoAllow": ["openclaw-membase"] }, "plugins": { "entries": { "openclaw-membase": { "enabled": true, "config": { "autoRecall": false, "autoWikiRecall": false, "autoCapture": true, "maxRecallChars": 4000, "debug": false } } } } } ``` `"openclaw-membase"` in `tools.alsoAllow` expands to all tools registered by this plugin and is appended on top of the active profile. Using `tools.allow` instead can silently break your profile allowlist. Without this entry, the AI still receives memory context via auto-recall but cannot call the tools explicitly. ## Managing Plugins Use `openclaw plugins` to manage installed plugins, check status, and update versions. <Frame> <img alt="OpenClaw plugins list" /> </Frame> ### Updating the Plugin To update Membase to the latest version: ```bash theme={null} openclaw plugins update openclaw-membase ``` Restart OpenClaw after updating to apply the new version. ## How Membase Differs | | Simple vector memory | **Membase** | | -------------- | ---------------------- | --------------------------------------------------------- | | **Storage** | Flat embeddings | Hybrid: vector embeddings + knowledge graph | | **Search** | Vector similarity only | Vector + graph traversal (entities, relationships, facts) | | **Extraction** | Store raw text | AI-powered entity/relationship extraction | | **Auth** | API key | OAuth 2.0 with PKCE (no secrets to manage) | | **Ingest** | Synchronous | Asynchronous processing | ## GitHub Repository Want to inspect the plugin source, track releases, or contribute improvements? <Card title="openclaw-membase on GitHub" icon="github" href="https://github.com/aristoapp/openclaw-membase"> Browse the source code, open issues, and follow plugin updates in the standalone repository. </Card> ## Next Steps <CardGroup> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history, connect apps, and more. </Card> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Chat with Memory, agent retrieval, and dashboard exploration. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge as wiki documents that OpenClaw can search directly. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See every MCP tool your agent can call. </Card> </CardGroup> # Attached vs Universal Source: https://docs.membase.so/core-concepts/attached-vs-universal Understand why AI memory should be shared across agents, not isolated within individual tools. Learn the difference between attached and universal memory in Membase. ## Attached Memory The AI agents you use every day, ChatGPT, Claude, Gemini, Cursor, and others, each have their own form of memory. But every one of them keeps that memory **isolated**. What you told ChatGPT doesn't exist in Claude. Your Cursor project context is invisible to Gemini. Even within the same agent, switching sessions often means starting from scratch. This is **attached memory**: memory that is bound to a specific agent, session, or tool. <Frame> <img alt="Attached memory: every agent is an island" /> <img alt="Attached memory: every agent is an island" /> </Frame> This means: * **You repeat yourself constantly.** Every new session, every new agent, you re-explain the same preferences and context. * **Knowledge disappears.** When a session ends, valuable context is gone. * **Agents contradict each other.** Different agents may have conflicting or outdated understanding of your preferences. * **No cross-pollination.** A decision made in Claude never benefits your Cursor workflow. ## Universal Memory **Universal memory** is a fundamentally different approach. Instead of each agent maintaining its own isolated memory, all your agents share a **single brain** that is persistent, automatically updated, and grows with you over time. Membase takes this one step further: the universal knowledge layer has **two complementary stores**. **Memory** holds personal context (preferences, decisions, habits, meetings) as a knowledge graph. **Knowledge Wiki** holds factual, reference-style knowledge (docs, specs, stable notes) as linked markdown documents. Both stores are shared across every connected agent. ```mermaid theme={null} graph TB CH[ChatGPT] <--> M((Membase<br/>Universal Memory)) CL[Claude] <--> M GE[Gemini] <--> M C[Cursor] <--> M OC[OpenClaw] <--> M M <--> GM[Gmail] M <--> CAL[Calendar] M <--> SL[Slack] M <--> NO[Notion] M <--> OB[Obsidian] M <--> MD[Markdown] style M fill:#09090B,stroke:#27272A,color:#fff ``` All agents read from and write to both stores. External data sources feed the right store: conversations and integrations such as Gmail, Calendar, and Slack build Memory, while Notion sync, Obsidian imports, Markdown imports, and factual documents build Wiki. * **One brain, shared everywhere.** Tell one agent something, and every agent knows it. No silos, no repetition. * **Two stores, one layer.** Personal context lives in Memory, factual knowledge lives in the Wiki, and agents can search both when a task benefits from them. * **Permanent knowledge.** Context persists across sessions, days, weeks, and months. Nothing is lost when you close a tab. * **Stays current where sources sync.** Conversations, synced emails, calendar events, Slack, and live Notion sources keep context current; one-time imports such as Obsidian and Markdown bootstrap the Wiki. * **Grows with you.** The more you use your agents, the richer your knowledge graph and your wiki become. Your AI gets smarter over time, not just within a single session. ## Comparison | | **Attached Memory** | **Universal Memory** | | ----------------------- | ------------------------------------------- | ---------------------------------------- | | **Scope** | Isolated per agent | Shared across all agents | | **Persistence** | Lost between sessions | Permanent and growing | | **Context setup** | Manual, repeated in every tool | Automatic from past interactions | | **Cross-agent sharing** | None | Instant | | **External data** | Manual setup per agent, if supported at all | Connected once, shared across all agents | | **Consistency** | Agents may contradict each other | Single source of truth | | **Growth** | Resets with each session | Compounds over time | <Info> Membase doesn't replace your agents' built-in context features. It **augments** them with a shared, persistent layer that works across everything you use. </Info> ## Next Steps <CardGroup> <Card title="How Membase Works" icon="gear" href="/core-concepts/how-membase-works"> Dive into the technical architecture. </Card> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history and connect apps to build your knowledge base. </Card> </CardGroup> # How Membase Works Source: https://docs.membase.so/core-concepts/how-membase-works How context flows into Membase's two knowledge stores (Memory and Wiki), gets structured, and comes back to your agents. Membase transforms raw context into structured, retrievable knowledge that your agents can pull from across sessions. This page walks through the full lifecycle. ## Architecture Overview Membase keeps **two complementary knowledge stores**, each optimized for a different shape of information. Agents can read and write both through MCP, and Chat in Dashboard can consult both when stored context helps. <Frame> <img alt="Membase architecture diagram" /> <img alt="Membase architecture diagram" /> </Frame> | | **Memory** | **Wiki** | | ----------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **What it stores** | Personal context: preferences, decisions, habits, meetings, emails | Factual knowledge: docs, specs, references, stable notes | | **How it's structured** | Episodes and entities in a knowledge graph | Markdown documents linked with `[[wikilinks]]`, organized into Projects or Basic | | **Primary input** | Agent conversations (`add_memory`), Chat in Dashboard, chat history import, app integrations (Gmail, Calendar, Slack) | You writing documents in the dashboard, Chat in Dashboard, `add_wiki` calls from agents, Notion live sync, Notion/Obsidian/Markdown imports, supported agent transcript capture | | **Primary retrieval** | `search_memory` (semantic), Chat in Dashboard, graph and table views | `search_wiki` (hybrid: keyword + semantic), Chat in Dashboard, graph and table views | Context from either store flows through three stages: **ingest → process → retrieve**. The rest of this page walks through each stage for both stores. ## 1. Context to Membase How context enters each store. <Tabs> <Tab title="Memory"> Memory receives context from imports, agents, Chat in Dashboard, and integrations. <Steps> <Step title="Chat History Import (bootstrap)"> Already have months of conversations in ChatGPT, Claude, or Gemini? Export your chat history and upload it in [Sources](https://app.membase.so/sources) under the **Chat History** section. The entire archive goes through the same digesting pipeline as live conversations. <Frame> <img alt="Chat History Import" /> </Frame> </Step> <Step title="Live agent conversation"> You talk to your agent normally. During the conversation the agent picks up on preferences, decisions, project details, and other durable context, and calls `add_memory` via MCP. ```text Example theme={null} You: "Let's use Zustand instead of Redux for this project. Also, I prefer functional components over class components." → Agent calls add_memory with this context ``` </Step> <Step title="Chat in Dashboard"> While talking directly to your knowledge base in the dashboard, Chat can save durable personal context as memory when you share something worth keeping. </Step> <Step title="App integration sync"> Connected sources (Gmail, Google Calendar, Slack) sync new data automatically in the background. Each message, event, or email becomes an episode. </Step> <Step title="Membase receives the context"> Membase accepts the incoming context for processing so the agent or sync can keep moving. </Step> </Steps> </Tab> <Tab title="Wiki"> Wiki receives documents directly from you, Chat in Dashboard, or agent tool calls. <Steps> <Step title="Wiki import (bootstrap)"> Already have a markdown knowledge base? Use **Wiki > Add > Import files** to import Notion exports, Obsidian vaults, or Markdown files into a target Project or Basic. `[[wikilinks]]` are preserved where available, and documents upload through the background import flow. See [Importing Documents](/features/wiki#importing-documents). </Step> <Step title="Write a document in the dashboard"> Open the Wiki tab, click **Add > Write document**, choose a Project or Basic, and write in markdown. Manual save and unsaved-changes warnings keep your content safe. </Step> <Step title="Notion live sync"> Connect Notion from Sources, choose the Notion pages available to Membase, then choose a target Wiki Project. Synced pages become source-backed Wiki documents. See [App Integrations](/connectors/apps#notion-live-sync). </Step> <Step title="Agent calls add_wiki"> Your connected agent can call `add_wiki` when you share factual, reference-style knowledge worth keeping. Example: "Write up our deployment rollback checklist" results in a new wiki document instead of a memory. </Step> <Step title="Supported plugin captures transcript"> Supported agent plugins can preserve user/assistant conversation transcripts as original source material in Wiki, separate from extracted personal Memory. </Step> <Step title="Chat creates a document"> Chat in Dashboard can also create wiki documents when you ask it to save factual, reference-style material. </Step> <Step title="Membase receives the document"> The Wiki document is saved directly or prepared for background processing, depending on whether it came from a direct write, sync, or import. </Step> </Steps> </Tab> </Tabs> ## 2. Digesting and Structure How raw input becomes structured, searchable knowledge. <Tabs> <Tab title="Memory"> Every memory (from agents or integrations) goes through the same pipeline. <Steps> <Step title="Episode creation"> The raw input is saved as an **episode**, a snapshot of a conversation or data event. Episodes are the building blocks of memory. </Step> <Step title="Entity extraction"> Membase identifies key entities from the episode: people, projects, tools, preferences, decisions, dates, and other meaningful concepts. ```text Example entities from a conversation theme={null} "Let's use Zustand instead of Redux" → Entities: Zustand, Redux, state management decision ``` </Step> <Step title="Graph construction"> Extracted entities are added to your knowledge graph. New entities connect to existing ones when they overlap, so "Zustand" mentioned in two different conversations becomes one entity with two linked episodes. </Step> <Step title="Deduplication and merging"> If the same fact appears in multiple episodes, Membase merges them. When new information contradicts an existing memory, the latest data takes priority. </Step> </Steps> The result is a continuously growing knowledge graph where entities, relationships, and episodes are all interconnected. <Frame> <img alt="Membase knowledge graph" /> <img alt="Membase knowledge graph" /> </Frame> </Tab> <Tab title="Wiki"> Wiki documents are stored as markdown plus structural metadata for fast retrieval. <Steps> <Step title="Document storage"> The document's title and markdown content are saved to the Wiki store, filed into a Project or Basic. </Step> <Step title="Wikilink parsing"> Membase parses `[[wikilinks]]` in the content and maintains a bidirectional link graph. This is what powers backlinks, the force-directed graph view, and instant `[[` autocomplete in the editor. </Step> <Step title="Search indexing"> Each document is indexed for **hybrid search**: a full-text index (BM25-style) for keyword queries and a semantic embedding for meaning-based queries. Both are fused with Reciprocal Rank Fusion (RRF) at query time. </Step> <Step title="Source provenance and review"> Imported and synced documents keep source provenance when available. When a source update or generated change needs review, Membase can route it through Inbox Review so you can inspect, edit, accept, reject, or undo the change. </Step> </Steps> </Tab> </Tabs> ## 3. Membase to Your Agent How context flows back when an agent or Chat needs it. <Tabs> <Tab title="Memory"> <Steps> <Step title="Agent calls search_memory"> The agent sends a query describing what personal context it needs. This happens automatically when prior context would improve the response. ```text Example theme={null} You: "Set up a new component for the settings page." → Agent calls search_memory: "project tech stack, component preferences" ``` </Step> <Step title="Membase searches the knowledge graph"> The query is matched against your graph using semantic search. Relevant episodes and their connected entities are retrieved. Relevant results might include: * "Uses Next.js with TypeScript" * "Prefers functional components" * "State management: Zustand" * "Styling: Tailwind CSS" </Step> <Step title="Ranked results returned"> Results are scored by relevance and returned as episode-centric bundles. Only the most useful context is included, keeping the agent's context window clean. </Step> <Step title="Agent responds with full context"> The agent generates a response grounded in your actual preferences and project details, without you having to repeat any of it. </Step> </Steps> Here's a real example: Claude retrieving a git workflow from Membase during a conversation. <Frame> <video> <source type="video/mp4" /> </video> </Frame> </Tab> <Tab title="Wiki"> <Steps> <Step title="Agent calls search_wiki"> The agent sends a query describing what factual knowledge it needs. ```text Example theme={null} You: "Remind me how our auth middleware handles expired tokens." → Agent calls search_wiki: "auth middleware expired token" ``` </Step> <Step title="Membase runs hybrid search"> The query is matched with both full-text keyword search and semantic similarity. The two rankings are fused with Reciprocal Rank Fusion, so you get solid results whether the query is literal or conceptual. </Step> <Step title="Full document bodies returned"> Unlike memory episodes, wiki results include the **full document body**, so the agent has enough context to answer directly instead of juggling fragments. </Step> <Step title="Agent responds with full context"> The agent grounds its answer in the retrieved documents and cites them if your prompt encourages citations. </Step> </Steps> </Tab> </Tabs> <Tip> Chat in Dashboard can use both `search_memory` and `search_wiki` when stored context could help, then combine the results into a single answer with citations. Your agents should do the same when the user's question could benefit from either store. </Tip> This entire cycle (ingest → structure → retrieve) runs continuously as you use Membase. The more you interact, the richer both stores become, and the smarter your agents get. ## Next Steps <CardGroup> <Card title="Attached vs Universal" icon="share-nodes" href="/core-concepts/attached-vs-universal"> Understand why shared memory matters. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> Learn about the MCP tools available to your agents. </Card> <Card title="Memory" icon="brain" href="/features/memory"> Dive into memory exploration and management. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Dive into Wiki documents, Projects, imports, and Inbox Review. </Card> </CardGroup> # Chat in Dashboard Source: https://docs.membase.so/features/chat Talk directly to your Membase knowledge base without going through an external agent. Chat with Memory answers questions using your stored memories and wiki documents, with citations and a linked graph panel. **Chat in Dashboard** (also known as "Chat with Memory") lets you talk to your Membase knowledge base directly from the dashboard, without having to open an external agent. Ask about a decision you made last month, a conversation from last week, or a pattern across everything you've worked on, and Chat can ground the answer in your own memories and wiki documents when stored context is relevant. <Frame> <img alt="Chat with Memory interface" /> </Frame> ## What Chat Pulls From When stored context is relevant, Chat can pull from both knowledge stores: * **Memory**: Personal context captured through your agents, Chat in Dashboard, and integrations (preferences, decisions, meetings, emails, and so on). * **Wiki**: Factual knowledge you or your agents stored as wiki documents. Chat uses a focused set of tools under the hood: `search_memory`, `add_memory`, `search_wiki`, and `add_wiki`. The underlying model decides which search tools to call based on your question and weaves the results into a single grounded answer. Chat can also write back to Membase: it can save durable personal context as memory, or create wiki documents when you ask it to save factual reference material. <Note> Dashboard Chat is not the full Wiki CRUD surface. It can create Wiki documents with `add_wiki`, but editing or deleting existing Wiki documents happens in the Wiki dashboard or through connected agents that expose MCP tools such as `update_wiki` and `delete_wiki`. </Note> ## Highlights * **Context-grounded responses**: Answers are grounded in your actual memories and wiki documents when stored context is relevant * **Citations**: Responses that use stored context link back to the exact memories and wiki documents they drew from, so you can verify and explore further * **Graph panel**: See how referenced memories and documents connect to each other * **Session history**: Past conversations are saved in the sidebar so you can pick up where you left off * **Write back to Memory and Wiki**: Chat can save durable personal context as memory and create wiki documents for stable reference material * **Model picker**: Switch between Standard and Advanced models from the model dropdown in the composer <Note> Free plans include 40 dashboard chats per month, and Pro includes 200. Advanced models cost **2x usage** per message compared to Standard models. You will see a `(2x)` suffix next to Advanced model names in the picker. </Note> <Tip> Chat in Dashboard is useful for exploring your own knowledge base, verifying what your agents know about you, and quickly looking up past decisions or reference material without switching to an external agent. </Tip> ## When to Use Chat vs an Agent | You want to... | Use | | ------------------------------------------------------- | --------------------------------------------------- | | Recall a decision, preference, or past conversation | **Chat in Dashboard** | | Look up factual knowledge you stored in the wiki | **Chat in Dashboard** | | Verify what an agent knows about you | **Chat in Dashboard** | | Save durable personal context or a wiki document | **Chat in Dashboard** | | Do real work (code, draft, plan) with memory-aware help | **Connected agent** (Cursor, Claude, ChatGPT, etc.) | | Save context while working inside another tool | **Connected agent** | ## Next Steps <CardGroup> <Card title="Memory" icon="brain" href="/features/memory"> Explore and manage the memories Chat can use. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Explore and manage the wiki documents Chat can use. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See the broader MCP tool set available to connected agents. </Card> <Card title="Connect Agents" icon="robot" href="/connectors/agents/cursor"> Use Membase through external agents like Cursor or Claude. </Card> </CardGroup> # Membase MCP Source: https://docs.membase.so/features/membase-mcp Explore the MCP tools, resources, and prompts that power Membase agent integration. Learn how agents store, search, and retrieve Memory and Wiki context through the Model Context Protocol. Membase connects to AI agents via the **Model Context Protocol (MCP)**, providing a standard way for agents to store, search, and retrieve Memory and Wiki context. ## At a Glance | Type | Name | What it does | Who uses it | | ------------ | ------------------- | -------------------------------------------- | -------------------------------------------------------------------- | | **Tool** | `add_memory` | Save personal context to long-term memory | Agent calls automatically when it learns something worth remembering | | **Tool** | `search_memory` | Search past memories by meaning | Agent calls when past context would help its response | | **Tool** | `get_current_date` | Get current date and time in a timezone | Agent calls before date-filtered memory search | | **Tool** | `add_wiki` | Add a factual knowledge document to the wiki | Agent calls when user shares stable, reference-style knowledge | | **Tool** | `search_wiki` | Hybrid search across wiki documents | Agent calls when factual knowledge would improve its response | | **Tool** | `update_wiki` | Edit an existing wiki document | Agent calls to keep a document current | | **Tool** | `delete_wiki` | Permanently remove a wiki document | Agent calls with user confirmation | | **Resource** | `membase://profile` | Read-only user settings profile | Agent reads when stable profile context matters | | **Resource** | `membase://recent` | Read-only recent memory timeline | Agent reads for latest updates and recency checks | | **Prompt** | `start` | Guidance for memory workflow and safety | Agent can load at session start | You don't need to call any of these yourself. Your agent handles everything automatically based on the conversation. ## Memory vs Wiki Membase exposes two complementary stores through MCP: * **Memory** (`add_memory`, `search_memory`): Personal context that describes the user: preferences, decisions, habits, ongoing projects. * **Wiki** (`add_wiki`, `search_wiki`, `update_wiki`, `delete_wiki`): Factual knowledge that the user wants to keep as reference material: docs, specs, notes, and anything else that is stable and addressable by title. For user questions, agents should generally call **both** `search_memory` and `search_wiki`, then combine the results. See the [Knowledge Wiki guide](/features/wiki) for details. ## MCP Server Membase runs a remote MCP server accessible at: ``` https://mcp.membase.so/mcp ``` | Property | Value | | ------------------ | --------------------- | | **Transport** | Streamable HTTP | | **Authentication** | OAuth (browser-based) | | **Package** | `membase` (npm) | For MCP setups, the `npx -y membase@latest --client <client>` CLI command handles registration and auth automatically for supported clients. See the [Agents guide](/connectors/agents/cursor) for per-client setup. <Note> Claude Code users should start with the [Membase Claude Code plugin](/connectors/agents/claude-code). The plugin exposes the same Membase memory and wiki tools directly inside Claude Code, plus slash commands, hooks, and project-aware workflows. The remote MCP server remains available for other clients and as a Claude Code fallback. </Note> ## Tools Membase exposes tools that agents can call during conversations. They split into two groups: memory tools for personal context and wiki tools for factual knowledge. ### Memory Tools <AccordionGroup> <Accordion title="add_memory" icon="plus"> Stores long-term memory that persists across sessions. Agents use this **proactively** when the user shares durable context worth remembering: preferences, recurring habits, ongoing projects, goals, constraints, etc. Transient one-off information is skipped unless the user explicitly asks to save it. | Parameter | Type | Required | Description | | ---------- | ------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `content` | string (max 50,000 chars) | Yes | The memory content to store | | `project` | string (max 60 chars) | No | Project or category slug to file this memory under. Agents should only set this when the user **explicitly** mentions a project name, tag, label, or category (e.g. "save this under project X", "tag this as Y"). Do not guess or infer. See [Projects](#projects). | | `metadata` | object | No | Leave empty for normal agent usage. | </Accordion> <Accordion title="search_memory" icon="magnifying-glass"> Searches stored memories by **semantic similarity**. Agents use this when the user asks to recall something from a previous session, or proactively when past context would improve their response. Results are returned as episode-centric bundles with related context. | Parameter | Type | Required | Description | | ----------- | ------------------------ | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `query` | string (max 1,000 chars) | Yes | Natural-language search query. Use empty string to fetch recent memories. | | `limit` | integer (1-30) | No | Max results to return (default: 20) | | `offset` | integer | No | Pagination offset (default: 0) | | `date_from` | ISO date/datetime string | No | Inclusive lower bound for date filtering | | `date_to` | ISO date/datetime string | No | Inclusive upper bound for date filtering | | `timezone` | IANA timezone string | No | Date-only parsing timezone, for example `America/Los_Angeles` | | `sources` | array of strings | No | Filter by source. Supports integrations (Slack, Gmail, Google Calendar), AI clients (Cursor, Claude, Claude Code, VS Code, ChatGPT, Codex, Gemini CLI, OpenCode, Poke, OpenClaw, Hermes), imports (ChatGPT, Claude, Gemini), and dashboard-created memories. If omitted, all sources are searched. | | `project` | string (max 60 chars) | No | Restrict search to a single project slug (exact match). Use only when the user explicitly asks for a project or category scope. See [Projects](#projects). | Results can include a **relevance score** (0–1) when available, indicating how closely each match fits the query. </Accordion> <Accordion title="get_current_date" icon="calendar"> Returns the current date and time in the user's Membase timezone (and UTC). Agents call this before `search_memory` to resolve relative phrases like "today", "yesterday", "this week", or "next weekend" into ISO 8601 `date_from`/`date_to` values. This tool takes no input parameters. The response contains four fields: | Field | Description | | ------------ | ------------------------------------------------------------------------- | | `now_utc` | Current UTC timestamp in ISO 8601 (e.g., `2025-01-15T02:30:00.000Z`) | | `timezone` | The effective IANA timezone used (from the user's saved Membase timezone) | | `local_date` | Local date in that timezone (e.g., `2025-01-15`) | | `local_time` | Local time in that timezone (e.g., `11:30:00`) | </Accordion> </AccordionGroup> #### Projects Memories can be grouped into **projects** (lightweight category/tag slugs). Both `add_memory` and `search_memory` accept an optional `project` field. * **User-driven, not inferred**: Agents should set `project` on `add_memory` **only** when the user explicitly mentions a project, tag, label, or category (for example, "save this under `acme-rewrite`", "tag this as `personal`"). Agents must not guess or invent a project. * **Known projects hint**: The Membase MCP server injects the current user's existing project slugs into each tool's description, so agents can reuse existing slugs instead of creating new ones for the same concept. * **Filtered search**: Pass `project: "acme-rewrite"` to `search_memory` to restrict results to that project. Exact slug match only. * **Managed in the dashboard**: Users can move memories between projects and filter by project from the **Memories** tab. See the [Memory guide](/features/memory#projects). <Tip> Users who want hands-off project tagging can drop a line in their profile instructions such as "When I mention `acme` or `side-project`, tag those memories under the corresponding project." The agent will then apply the tag automatically during matching conversations. </Tip> ### Wiki Tools <AccordionGroup> <Accordion title="add_wiki" icon="file-plus"> Creates a new document in the user's knowledge wiki. Agents use this for **factual, reference-style knowledge** (documentation, specs, stable notes). Personal preferences and habits should go through `add_memory` instead. | Parameter | Type | Required | Description | | --------- | -------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `title` | string (1-500 chars) | Yes | Title of the wiki document | | `content` | string (max 100,000 chars) | Yes | Complete markdown content. Preserve reports, discussions, analyses, tables, examples, and decisions unless the user explicitly asks to save a summary. | | `project` | string (max 200 chars) | No | Project name to file this document under. New Projects are created on first use. Leave empty when the user does not name a Project; Membase routes safely or falls back to Basic. | Document creation respects the user's [plan quota](/features/wiki#document-quotas). If the limit is reached the call returns a quota error. When the tool succeeds, agents should tell the user the returned destination when present, such as `Saved to Project: Docs` or `Saved to Basic`. </Accordion> <Accordion title="search_wiki" icon="magnifying-glass"> Searches the user's wiki using **hybrid search**: a full-text keyword index (BM25-style) and semantic similarity, fused with Reciprocal Rank Fusion (RRF). Results include each document's full body so the agent has enough context to answer immediately. | Parameter | Type | Required | Description | | ------------ | ------------------------ | -------- | ----------------------------------------------------------------------------------------------------- | | `query` | string (max 1,000 chars) | Yes | Natural-language or keyword search query. Use empty string `""` to fetch recent wiki documents. | | `limit` | integer (1-20) | No | Max results to return (default: 10) | | `project` | string (max 200 chars) | No | Restrict results to a specific Wiki Project by name. If omitted, all Projects and Basic are searched. | | `collection` | string (max 200 chars) | No | Legacy alias for `project`. Prefer `project` for new clients. | </Accordion> <Accordion title="update_wiki" icon="pen-to-square"> Edits an existing wiki document. Use `search_wiki` first to resolve the document ID. | Parameter | Type | Required | Description | | ------------ | -------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------- | | `doc_id` | UUID | Yes | ID of the document to update | | `title` | string (1-500 chars) | No | New title | | `content` | string (max 100,000 chars) | No | Complete replacement markdown content. Preserve the full updated artifact unless the user explicitly asked for summarization. | | `project` | string or `null` (max 200 chars) | No | Move the document to a Project by name. New Projects are created on first use. Set `project` to `null` to move it to Basic. | | `collection` | string or `null` (max 200 chars) | No | Legacy alias for `project`. Prefer `project` for new clients. Set to `null` to move to Basic. | When the result includes a destination such as `Moved to Project: Docs`, `Moved to Basic`, or `Current destination: Basic`, agents should report it to the user. </Accordion> <Accordion title="delete_wiki" icon="trash"> Permanently deletes a wiki document. This action cannot be undone; agents should ask for user confirmation before calling it. | Parameter | Type | Required | Description | | --------- | ---- | -------- | ---------------------------- | | `doc_id` | UUID | Yes | ID of the document to delete | </Accordion> </AccordionGroup> ## Resources MCP resources provide **read-only data** that agents can pull into their context: | Resource | URI | Description | | ------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------- | | **User Profile** | `membase://profile` | Read-only MCP resource that mirrors **Settings > Profile** (`display_name`, `role`, `interests`, `instructions`, `timezone`) | | **Recent Memories** | `membase://recent` | Top 10 recent memories, ordered by event time when available and capture time otherwise | <Frame> <img alt="Membase MCP resources in Claude" /> </Frame> ## Prompts MCP prompts inject pre-built instructions and context into the agent's system prompt: | Prompt | Description | | --------- | --------------------------------------------------------------------------------------------------------------------- | | **start** | Teaches the agent when to use `search_memory`, when to use resources, when to save memory, and what to avoid storing. | The `start` prompt can be used at session start to provide: 1. **Workflow guidance** for memory retrieval and memory write behavior 2. **Safety guidance** for secrets and transient information 3. **Resource usage guidance** for profile versus recent timeline reads ## Recommended Agent Behavior Use these patterns for best results: 1. For questions about saved knowledge, past conversations, documents, decisions, or user-specific context, search Memory and Wiki together when both could matter. Use Memory for personal context and Wiki for factual/reference knowledge. 2. For stable user settings, agents can read the MCP resource `membase://profile`. It mirrors the dashboard Profile settings: display name, role, interests, custom instructions, and timezone. 3. For latest memory context or recent-memory timeline questions, agents can read `membase://recent`. This is a Memory timeline, not a Wiki or integration changelog. 4. For date-filtered memory searches, call `get_current_date` when needed, then pass explicit ISO date filters to `search_memory`. 5. Save durable user context with `add_memory`; skip secrets and one-off transient data unless explicitly requested. 6. Save factual, reference-style knowledge with `add_wiki`. Preserve the full artifact unless the user explicitly asks for a summary. If the user names a Project, pass it in `project`; otherwise leave it empty and report the returned destination. ## Connection Setup For detailed setup instructions for each agent, see the [Agents guide](/connectors/agents/cursor). <CardGroup> <Card title="Cursor" icon="code" href="/connectors/agents/cursor"> One-click install </Card> <Card title="Claude Code" icon="terminal" href="/connectors/agents/claude-code"> Plugin recommended </Card> <Card title="Claude" icon="robot" href="/connectors/agents/claude-desktop"> Custom connector </Card> <Card title="ChatGPT" icon="message" href="/connectors/agents/chatgpt"> Manual config </Card> </CardGroup> ## Next Steps <CardGroup> <Card title="Memory" icon="brain" href="/features/memory"> Explore and manage memories. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Deep dive on Wiki documents, Projects, imports, and search. </Card> <Card title="Chat in Dashboard" icon="comments" href="/features/chat"> Talk to your knowledge base without an external agent. </Card> </CardGroup> # Memory Source: https://docs.membase.so/features/memory Explore and manage memories in Membase. Browse the knowledge graph and table view, filter by source and project, and understand how memories are created, updated, and deleted. **Memory** is where Membase stores personal context: preferences, decisions, habits, ongoing projects, meetings, emails, and other episodic information captured from your agents, Chat in Dashboard, and integrations. This page covers how to explore memories in the dashboard and how they are created, updated, and deleted. <Tip> Looking for factual knowledge (docs, specs, stable notes)? That lives in the [Knowledge Wiki](/features/wiki). Memory and Wiki are two separate stores, and agents can search both. </Tip> ## Exploring Memory The [Memories](https://app.membase.so/memories) tab offers two views for browsing your knowledge. | View | What you see | Interactions | | -------------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Graph View** | Entities as nodes, relationships as edges | Click an entity to open a detail panel with the episodes that mention it. Click an episode in the panel to jump to Table View. | | **Table View** | Episodes (memories) with source, project, and time | Click an episode to open a detail panel with the episode content. Filter by source, project, or time. Select rows to move them to a project or delete them. | ### Graph View The graph view visualizes your knowledge as an interactive network of **entities** (people, concepts, tools, projects) and the relationships between them. <Frame> <video> <source type="video/mp4" /> </video> <video> <source type="video/mp4" /> </video> </Frame> * **Entity-centric visualization**: Each node represents an entity extracted from your memories * **Interactive navigation**: Click, drag, zoom, and use the zoom controls to explore the graph * **Search**: Search for an entity name to dim unrelated nodes in the graph * **Side panel**: Click any entity to open a detail panel with **Related Episodes**, the memories that mention this entity. Click an episode to switch to Table View focused on it. ### Table View The table view lists all your **episodes** (memories) in a structured, searchable format with source and project attribution. <Frame> <video> <source type="video/mp4" /> </video> <video> <source type="video/mp4" /> </video> </Frame> * **Episode list**: Browse all memories with content previews, source tags, and project labels * **Sorting**: Sort by date or source * **Source filtering**: Filter memories by source (Cursor, Claude, Gmail, Slack, etc.) * **Project filtering**: Filter memories by project slug (see [Projects](#projects)) * **Time range filtering**: Preset ranges (Today, This Week, This Month, This Year, All Time) or a custom date range * **Search**: Text filter over the currently loaded memories (client-side substring match; not semantic) * **Pagination**: Choose 10, 20, or 50 rows per page * **Bulk actions**: Select multiple rows to move them to a project or delete them. * **Side panel**: Click any episode to open a detail panel with the full memory content and the option to change its project. ## Creating Memories Memories enter Membase through agents, Chat in Dashboard, and integrations. Creating memories directly from the Memories tab is not supported yet; use a connected agent or Chat when you want Membase to save new personal context. <CardGroup> <Card title="Agent Conversations" icon="robot"> Your connected agent calls the `add_memory` MCP tool during conversations to save relevant context: preferences, decisions, project details, meetings, and more. </Card> <Card title="Chat in Dashboard" icon="comments"> Chat can also call `add_memory` when you share durable personal context inside the dashboard. </Card> <Card title="Integrations" icon="plug"> Connected data sources like Gmail, Google Calendar, and Slack automatically sync new data into Membase as memories. </Card> </CardGroup> <Info> Manual memory creation from the Memories tab is not available yet. New memories originate from agent interactions, Chat in Dashboard, or integrations. </Info> ## Updating Memories Memories are updated through your agents, not directly edited from the dashboard. When existing context becomes outdated, your agent calls `add_memory` to register the updated information and flags the old memory as outdated. For example, if you switch from Redux to Zustand, the agent saves "uses Zustand" as a new memory and marks the old "uses Redux" memory as no longer valid so it no longer surfaces in future searches. Behind the scenes, Membase also handles updates automatically during digesting: * **Deduplication**: Similar memories from different sources are merged to avoid redundancy. * **Conflict resolution**: When new information contradicts an existing memory, the latest data takes priority. * **Relationship updates**: New connections between entities are added to the knowledge graph as they are discovered. ## Projects Projects are lightweight category tags for memories (slugs up to 60 characters). They let you scope agent searches and browse memories by topic without juggling sources. <Frame> <img alt="Inline project picker on the Memories table" /> </Frame> ### How projects get attached * **Explicit user request**: Agents set the `project` field on `add_memory` only when you explicitly mention a project, tag, label, or category during the conversation (for example, "save this under `acme-rewrite`" or "file this under `personal`"). Agents do not guess or infer a project. * **Profile instructions**: If you want certain projects to be applied automatically, add a rule in your profile instructions (for example, "When I mention `acme`, tag the memory under the `acme` project"). The agent will follow this during matching conversations. * **Dashboard assignment**: Assign or move memory projects directly from the Memories table. Click the project cell on one row, or select multiple rows and use **Move to project** to update them together. ### Filtering and scoped search * **Dashboard filter**: Filter the Memories table by project slug from the toolbar. * **Agent search**: Agents pass `project: "acme"` to `search_memory` when you explicitly ask for a project-scoped recall (for example, "what have I decided on the `acme` project?"). See [Membase MCP: Projects](/features/membase-mcp#projects). * **Known projects sync**: Your current project list is available to connected agents so they can reuse existing slugs instead of creating duplicates. <Tip> Projects are intentionally flat and slug-based. Use short, consistent identifiers (`acme`, `side-project`, `personal`) rather than long descriptive names. </Tip> ## Deleting Memories ### Delete a single memory Delete individual memories from the **Table View**. 1. Switch to Table View. 2. Click the **Delete** icon next to the memory you want to remove. 3. Click **Delete** and confirm. <Frame> <img alt="Delete memory confirmation dialog" /> <img alt="Delete memory confirmation dialog" /> </Frame> ### Delete multiple memories Bulk-delete selected memories from the Table View. 1. Switch to Table View. 2. Tick the checkboxes on the rows you want to remove (or use the header checkbox to select all rows on the page). 3. Click **Delete All** in the bulk-actions bar that appears at the bottom of the table. 4. Confirm in the dialog, which shows how many memories will be removed. <Frame> <img alt="Bulk-delete action on the Memories table" /> </Frame> ### Delete all memories from a source To remove all memories from a specific integration (for example, all Slack memories), go to the **Sources** page in the dashboard and click **Delete memories** on that integration. You will be asked to confirm before deletion. <Note> Disconnecting an integration by itself keeps your existing memories. Use the **Delete memories** action on the Sources page when you want to remove them, which is a separate step from disconnect. </Note> <Warning> Deleted memories cannot be recovered. Make sure you want to permanently remove a memory before deleting. </Warning> ## Next Steps <CardGroup> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge alongside your memories. </Card> <Card title="Chat in Dashboard" icon="comments" href="/features/chat"> Ask questions and get answers grounded in your memories. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See the MCP tools agents use to read and write memory. </Card> <Card title="Connect Apps" icon="plug" href="/connectors/apps"> Enrich memory with Gmail, Calendar, Slack, and more. </Card> </CardGroup> # Knowledge Wiki Source: https://docs.membase.so/features/wiki Store factual knowledge in Membase alongside your memories. Create Wiki documents with markdown and [[wikilinks]], organize them into Projects, import Notion/Obsidian/Markdown sources, and let agents retrieve knowledge through MCP. The **Knowledge Wiki** is your durable knowledge base inside Membase. While Memory captures personal context such as preferences, decisions, and habits, Wiki stores stable reference material: documentation, specs, meeting notes, research, runbooks, source-backed transcripts, and anything else you want to retrieve by title. ## Memory vs Wiki Membase keeps two complementary knowledge stores. Agents can search both, but each is optimized for a different kind of context. | | Memory | Wiki | | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | **What it stores** | Personal context: preferences, decisions, habits, ongoing projects | Factual knowledge: docs, references, specs, stable notes, source transcripts | | **How you capture it** | Agents call `add_memory`, Chat in Dashboard can save durable context, and integrations like Gmail, Calendar, and Slack sync in the background | You write documents, import Notion/Obsidian/Markdown files, live-sync Notion pages, ask Chat to save reference material, or your agent calls `add_wiki` | | **How you retrieve it** | `search_memory`, Chat in Dashboard, graph and table views | `search_wiki`, Chat in Dashboard, Wiki search, graph, and table views | | **Structure** | Episodes and entities in a knowledge graph | Markdown documents linked with `[[wikilinks]]`, filed into Projects or Basic | <Tip> For user questions, agents should usually call both `search_memory` and `search_wiki`: memory for personal context, Wiki for factual knowledge. </Tip> ## Projects Projects are the main way to organize Wiki documents. They keep related docs together, make the Wiki graph easier to scan, and give agents a user-facing filing destination for `add_wiki`, `search_wiki`, and `update_wiki`. The Wiki root opens a Project overview. Each Project card shows its name, description, icon, color, document count, and recent activity, so you can scan the shape of your knowledge base before opening a specific Project. <Frame> <img alt="Wiki Project overview showing Projects and Basic" /> <img alt="Wiki Project overview showing Projects and Basic in dark mode" /> </Frame> When Membase cannot confidently place a document into a Project, it can land in Basic so you can organize it later. Basic is the fallback for documents that have not been assigned to a Project yet. From the Wiki page, you can: * Open the Project overview, search across Projects, and filter by name, description, or document title * Create, rename, reorder, and delete Projects * Edit a Project name, description, icon, and color * Add or import documents into a Project * Move documents between Projects or back to Basic * Scope the document list, graph, and search to a Project ## Documents Wiki documents are markdown files with source awareness and bidirectional links. * **Markdown editor**: Headings, lists, tables, code blocks, and other standard markdown formatting * **`[[Wikilinks]]`**: Type `[[` in the editor to get suggestions from existing document titles * **Linked Mentions**: See documents that reference the current document, with snippets around each mention * **Manual save**: Save from the editor when you are ready * **Unsaved changes warning**: Membase warns before discarding pending edits * **Source provenance**: Imported and synced documents show where they came from when source data is available <Note> Inline image attachments in Wiki documents are not supported yet. External image URLs in markdown can render, but there is no uploader inside the editor today. </Note> ## Inbox Review Wiki can suggest and route changes through **Inbox Review** when an automated update needs your attention. Review items can come from source changes, merge suggestions, larger rewrites, or conflict resolution work. <Frame> <img alt="Self-improving Wiki Inbox Review" /> <img alt="Self-improving Wiki Inbox Review in dark mode" /> </Frame> In Inbox Review, you can: * Inspect the current and proposed content * Accept the proposed change * Edit the proposed title, content, or metadata before accepting * Reject a proposal * Undo supported applied or auto-applied changes The **Updates** tab in Inbox shows recent Wiki activity so you can tell what changed without hunting through individual documents. ## Graph View The Wiki graph visualizes documents as a network. Each node is a document, each edge is a `[[wikilink]]` or derived connection, and Project styling helps related knowledge stand out. * **Force layout**: Drag nodes, zoom, and follow relationships * **Project styling**: Project colors make clusters easier to scan * **Project scope**: View all Wiki documents or one Project at a time * **Click a node**: Open the document from the graph ## Table View The table view is a structured list of documents with sorting, filtering, and bulk actions. * **Sort** by title, Project, updated date, or created date * **Filter** by Project or search query * **Pagination** for large knowledge bases * **Bulk actions**: Move selected documents to a Project or delete them ## Importing Documents Use **Wiki > Add > Import files** to import documents from a file or archive. Supported import formats: | Format | Accepted files | Notes | | ------------ | -------------------------------------- | ----------------------------------------------------------------------------------------------------- | | **Notion** | Notion `.zip` export or Markdown files | One-time import. Use [Notion live sync](/connectors/apps#notion-live-sync) for source-backed updates. | | **Obsidian** | Vault `.zip` or Markdown files | Preserves `[[wikilinks]]` and imports notes into the target Project or Basic. | | **Markdown** | `.md`, `.markdown`, or Markdown ZIPs | Use for generic markdown knowledge bases. | Imports run in the background. The dialog shows upload and processing progress, then reports documents created, documents skipped, update candidates, backlinks created, and errors. ### Target Project When importing files, choose a target Project or Basic. Archive and multi-file imports keep source path information where available, but imported documents start in the destination you choose and can be moved later. See [App Integrations](/connectors/apps) for Notion live sync, Obsidian vault imports, and generic Markdown imports. ## Search Wiki search uses hybrid retrieval: keyword matching plus semantic similarity. This lets you search with exact phrases such as `"OAuth PKCE"` or conceptual queries such as `"how do we authenticate users"`. Search is available in three places: * **Chat in Dashboard**: Chat can pull from Memory and Wiki when stored context is relevant * **Wiki page**: Search filters documents in the current Wiki scope * **Agents via MCP**: Connected agents call `search_wiki` during conversations ### Scoping Search to a Project You can restrict search to one Project: * **Dashboard**: Click a Project in the Wiki navigation to scope the list, graph, and search * **MCP**: Pass `project` to `search_wiki`. Existing Projects are surfaced to agents so they can reuse names. `collection` remains a legacy alias for older clients. ## Managing Wiki Documents Unlike memories, Wiki documents are fully editable from both the dashboard and connected agents. ### Create * **Dashboard**: Click **Add > Write document**, choose a Project or Basic, and write in markdown * **Import**: Use **Add > Import files** for Notion exports, Obsidian vaults, or Markdown files * **Notion live sync**: Connect Notion from Sources and choose a target Project * **Agent**: Ask your connected agent to save a factual artifact; it can call `add_wiki` ### Edit * **Dashboard**: Open any document and edit it inline * **Agent**: Your agent can call `update_wiki` with a document ID to change title, content, or Project * **Inbox Review**: Source-backed or generated proposals can be edited before accepting ### Delete * **Dashboard**: Delete one document from its document view, or bulk-delete selected rows from the table * **Sources**: Remove Notion live-synced documents or imported Obsidian/Markdown documents from the source card * **Agent**: Your agent can call `delete_wiki` with a document ID. Agents should ask for confirmation before deleting. <Warning> Deleted Wiki documents cannot be recovered. Make sure you want to permanently remove a document before deleting. </Warning> ## MCP Tools Your connected agents can read and write Wiki documents using these MCP tools. See the [Membase MCP reference](/features/membase-mcp) for full parameters. | Tool | What it does | | ------------- | -------------------------------------------------------------------------------------------------- | | `add_wiki` | Create a complete Wiki document with title, markdown content, and optional Project filing location | | `search_wiki` | Search Wiki documents and optionally scope results to a Project | | `update_wiki` | Edit an existing document's title, content, or Project | | `delete_wiki` | Permanently remove a document | <Tip> Tell your agent that `add_wiki` is for factual knowledge and `add_memory` is for personal context. Most agents pick this up from the tool descriptions automatically, but repeating it in your system prompt can help. </Tip> ## Document Quotas Wiki documents are counted against your plan. | Plan | Wiki documents | | -------- | -------------- | | **Free** | 200 | | **Pro** | 2,000 | The current usage is shown on the **Billing** tab and at the top of the Wiki page. When you reach the limit, creating, syncing, or importing new documents returns a quota error until you delete existing documents or upgrade your plan. ## Next Steps <CardGroup> <Card title="Memory" icon="brain" href="/features/memory"> Personal context that complements the Wiki. </Card> <Card title="Chat in Dashboard" icon="comments" href="/features/chat"> Ask questions across both Memory and Wiki. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See full parameters for the Wiki MCP tools. </Card> <Card title="Connect Apps" icon="plug" href="/connectors/apps"> Bring more sources into your knowledge base. </Card> </CardGroup> # Bring Your Context Into Membase Source: https://docs.membase.so/getting-started/bring-context Main ways to feed context into Membase: chat history import, agent conversations, Chat in Dashboard, app integrations, Notion sync, and Wiki imports. Membase gets smarter the more context it has. The main ways to bring your context in are: import past conversations, let your agents capture context as you work, save context from Chat in Dashboard, connect external apps, live-sync Notion pages, and import an existing knowledge base into Wiki. ## Chat History Import The fastest way to bootstrap your knowledge base. If you've been using ChatGPT, Claude, or Gemini, you already have months of context in those tools. Chat History Import brings it all into Membase at once. <Frame> <img alt="Chat History Import" /> </Frame> <Steps> <Step title="Export from your LLM client"> Download your conversation history using each platform's export feature (ChatGPT Settings > Data controls > Export data, etc.). </Step> <Step title="Upload to Membase"> Open [Sources](https://app.membase.so/sources), scroll to the **Chat History** section, and upload the exported file. Membase accepts the native export formats from each platform. </Step> <Step title="Membase digests your history"> Your conversations are processed through the same pipeline as live interactions. Preferences, decisions, project context, and relationships are extracted and added to your knowledge graph. </Step> </Steps> <Tip> You don't have to choose between import and live sync. Import your history first to bootstrap, and then let your agents or Chat in Dashboard continue building your knowledge base as you work. </Tip> ## Live Agent Conversations Once you've connected an agent via the [Quickstart](/getting-started/quickstart), context is captured automatically as you chat. Your agent calls `add_memory` whenever it detects something worth remembering: preferences, decisions, project details, and more. <Frame> <img alt="Live agent sync via MCP: Add Memory being called during an agent conversation" /> </Frame> Agents can also call `add_wiki` when you share factual, reference-style knowledge worth keeping as a document (specs, runbooks, stable notes). The two tools route context to the right store automatically. Some agent plugins can also preserve conversation transcripts as Wiki documents. This keeps the original source material searchable without turning every transcript into extracted Memory. You don't need to do anything special. Just chat normally, and your knowledge base grows in the background. ## Chat in Dashboard Chat in Dashboard can also save durable personal context as memory, or create wiki documents when you ask it to save factual reference material. This is useful when you want to add or clarify context without opening an external agent. ## App Integrations Your context doesn't only live in AI conversations. Connect external apps from the **Sources** page to bring in context from the tools you use every day. <CardGroup> <Card title="Gmail" icon="envelope"> Project updates, team discussions, and action items from your inbox. </Card> <Card title="Google Calendar" icon="calendar"> Meetings, deadlines, and schedule context. </Card> <Card title="Slack" icon="hashtag"> Messages, threads, and channel discussions from your workspace. </Card> <Card title="Notion" icon="book"> Selected Notion pages live-synced into Wiki. </Card> <Card title="Obsidian / Markdown" icon="file-lines"> Existing notes, vaults, and Markdown files imported into Wiki. </Card> </CardGroup> <Frame> <img alt="Sources page with app integrations and Wiki imports" /> <img alt="Sources page with app integrations and Wiki imports in dark mode" /> </Frame> Live integrations sync automatically after connection. One-time Wiki imports run in the background and report progress until processing finishes. <Info> For the full list of supported and upcoming integrations, see the [Apps guide](/connectors/apps). </Info> ## Wiki Imports If you already keep notes in Notion, Obsidian, or Markdown files, you can import them as **Wiki documents**. Choose **Wiki > Add > Import files**, select Notion, Obsidian, or Markdown, then choose a target Project or Basic. For Obsidian vaults, `[[wikilinks]]` are preserved and documents land in the Wiki tab instead of the memory graph. Choose a target Project or Basic during import, then reorganize documents from the Wiki table when needed. See [App Integrations](/connectors/apps#wiki-imports) for import formats and destination behavior. For Notion, use [App Integrations](/connectors/apps#notion-live-sync) to choose between live sync and one-time export imports. ## What Gets Captured | Source | Examples of extracted context | Lands in | | ------------------------------------ | -------------------------------------------------------------------------------------------------------- | -------------- | | **Chat History Import** | Past preferences, project decisions, technical stacks, recurring patterns across months of conversations | Memory | | **Agent Conversations** | New preferences, decisions made during the session, project details discussed in real time | Memory | | **Chat in Dashboard** | Durable personal context or factual reference material you ask Chat to save | Memory or Wiki | | **Gmail** | Project updates, action items, team communication, client context | Memory | | **Google Calendar** | Meeting outcomes, deadlines, scheduling patterns, recurring events | Memory | | **Slack** | Team discussions, channel updates, thread summaries, shared decisions | Memory | | **Notion live sync** | Source-backed pages, docs, and notes selected during Notion setup | Wiki | | **Notion/Obsidian/Markdown imports** | Reference docs, specs, personal notes, linked concept pages | Wiki | | **Agent transcript capture** | Original user/assistant conversation transcripts from supported plugins | Wiki | Memory holds your personal context and connects it as entities and episodes in a knowledge graph. The wiki holds factual, reference-style knowledge as linked markdown documents. Agents can search both through MCP. ## Next Steps <CardGroup> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Learn how to retrieve and interact with your stored knowledge. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Explore Projects, backlinks, Notion sync, and imports. </Card> <Card title="How Membase Works" icon="gear" href="/core-concepts/how-membase-works"> Understand the full digesting and retrieval pipeline. </Card> </CardGroup> # Quickstart Source: https://docs.membase.so/getting-started/quickstart Connect your first AI agent to Membase in 3 simple steps. Get persistent memory across sessions in under 5 minutes with one-click or CLI setup. Give your AI agent persistent memory in just a few minutes. Watch the video for a quick overview, or jump straight to the step-by-step guide below. ## How to Start Watch a quick walkthrough to see the full setup in action. <iframe title="Membase Quickstart" /> ## 3-Step Guide Follow these steps to connect your first AI agent to Membase. ### Step 1: Create Your Account Go to [app.membase.so](https://app.membase.so) and create your account. <Frame> <img alt="Membase sign-up page" /> <img alt="Membase sign-up page" /> </Frame> <Tip> Membase is currently in **open beta**. Anyone can create an account and start using it while we continue improving the product. </Tip> ### Step 2: Connect Your Agent From the dashboard, go to the **Agents** tab and click **+ Add Agent**, then pick your client. <Frame> <img alt="Add agent dialog" /> <img alt="Add agent dialog" /> </Frame> Most agents connect with a single command or one-click setup. Some plugin-based clients ask you to run a login command inside the agent after installation. <Tabs> <Tab title="Cursor"> Click **"Add to Cursor"** in the dashboard. Cursor installs Membase automatically. </Tab> <Tab title="ChatGPT"> Go to **Settings > Apps > Advanced Settings**, click **Create app**, and enter the MCP URL: ``` https://mcp.membase.so/mcp ``` </Tab> <Tab title="Claude"> Go to [Claude connector settings](https://claude.ai/settings/connectors), click **Add custom connector**, and enter: ``` https://mcp.membase.so/mcp ``` Name the connector `Membase`, then click **Connect** and complete authentication. </Tab> <Tab title="Claude Code"> Install the Claude Code plugin: ```bash theme={null} claude plugin marketplace add aristoapp/claude-membase && claude plugin install membase@membase-plugins ``` If Claude Code is already open, run: ```text theme={null} /reload-plugins ``` Then connect your Membase account: ```text theme={null} /membase:login ``` </Tab> <Tab title="Codex"> Run this command in your terminal: ```bash theme={null} npx -y membase@latest --client codex ``` </Tab> <Tab title="VS Code"> Click **"Add to VS Code"** in the dashboard. VS Code installs Membase automatically. </Tab> <Tab title="Poke"> Go to [Integrations](https://poke.com/integrations/new) and add the MCP URL: ``` https://mcp.membase.so/mcp ``` </Tab> <Tab title="Gemini CLI"> Run this command in your terminal: ```bash theme={null} npx -y membase@latest --client gemini-cli ``` </Tab> <Tab title="OpenCode"> Run this command in your terminal: ```bash theme={null} npx -y membase@latest --client opencode ``` Then authenticate: ```bash theme={null} opencode mcp auth membase ``` </Tab> <Tab title="OpenClaw"> Run this command in your terminal: ```bash theme={null} openclaw plugins install @membase/openclaw-membase ``` Then log in: ```bash theme={null} openclaw membase login ``` </Tab> <Tab title="Hermes"> Run this command in your terminal: ```bash theme={null} uv tool install hermes-membase && hermes-membase install ``` Requires Python 3.11+. If you prefer `pip`, `pip install hermes-membase && hermes-membase install` also works. </Tab> <Tab title="MCP URL"> For any MCP-compatible client, use the server URL directly: ``` https://mcp.membase.so/mcp ``` </Tab> </Tabs> <Tip> For detailed step-by-step instructions, see the [Agents guide](/connectors/agents/cursor) for MCP clients, [Claude Code](/connectors/agents/claude-code) for the Claude Code plugin, plus the dedicated plugin pages for [OpenClaw](/connectors/openclaw) and [Hermes](/connectors/hermes). </Tip> ### Step 3: Start Using Memory Once connected, your agent can read from and write to Membase. There are two core operations: **saving** memory and **retrieving** it. #### Saving memory (`add_memory`) Tell your agent something worth remembering. Your agent calls `add_memory` to store it in Membase. ```text Your prompt theme={null} I prefer TypeScript over JavaScript, and I use Bun as my package manager. My current project is a Next.js app with Supabase for auth. ``` ```text add_memory theme={null} ✓ Saves the conversation as an episode ✓ Extracts entities: TypeScript, Bun, Next.js, Supabase ✓ Links related entities and episodes in your knowledge graph ``` #### Retrieving memory (`search_memory`) Next time you (or any connected agent) need context, your agent calls `search_memory` to pull relevant memories. ```text Your prompt theme={null} Set up a new project for me. ``` ```text search_memory → results theme={null} ✓ Found: "Prefers TypeScript over JavaScript" ✓ Found: "Uses Bun as package manager" ✓ Found: "Current project uses Next.js + Supabase" → Agent sets up the project with TypeScript, Bun, and Next.js without you repeating anything. ``` You don't need to trigger any of this manually. Your agent decides when to save and when to search. Just chat normally. <Tip> The same agent can also write and search **factual knowledge** via `add_wiki` and `search_wiki`. Memory is for personal context; the wiki is for reference material (docs, specs, stable notes). See the [Knowledge Wiki guide](/features/wiki) for details. </Tip> <Check> **You're all set!** Your agent now has persistent memory powered by Membase. Memories are automatically created, updated, and shared as you interact. </Check> ## Next Steps <CardGroup> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history, connect Gmail, Calendar, and Slack. </Card> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Chat with Memory, agent retrieval, and dashboard exploration. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge and import Notion, Obsidian, or Markdown files. </Card> <Card title="All Agents" icon="robot" href="/connectors/agents/cursor"> Full setup guides for all supported clients. </Card> </CardGroup> # Use Your Context in Membase Source: https://docs.membase.so/getting-started/use-context How to interact with your stored knowledge: Chat in Dashboard, agent retrieval across memory and wiki, and dashboard exploration for both stores. Once your context is in Membase, there are three ways to use it: **Chat in Dashboard** for direct conversations with your knowledge base, **Agent Retrieval** by your connected agents, and **Dashboard Exploration** in either the Memory or Wiki views. ## Chat in Dashboard The most direct way to interact with your knowledge base. Chat lets you ask questions and get answers grounded in your stored context, without going through an external agent. When stored context is relevant, it can search **both** your memory and your wiki and weave results into a single answer. <Frame> <img alt="Chat with Memory" /> </Frame> * **Ask anything**: "What did we decide about the auth flow?", "What's my meeting schedule this week?", "What does our deployment runbook say about rollbacks?" * **Citations**: Responses that use stored context link back to the exact memories and wiki documents they drew from * **Graph panel**: See how referenced items connect to each other * **Session history**: Pick up past conversations from the sidebar Chat is available in [Chat](https://app.membase.so/chat). See [Chat in Dashboard](/features/chat) for details. ## Agent Retrieval Your connected agents retrieve context from Membase when they need it. When past context or reference knowledge would improve the response, the agent can call `search_memory` (personal context) and `search_wiki` (factual knowledge) and combine the results before responding. ```text Your prompt theme={null} Set up a new API route for user profiles. ``` ```text What happens behind the scenes theme={null} → Agent calls search_memory: "project tech stack, API conventions" Found: "Uses Next.js with TypeScript" Found: "Prefers RESTful conventions with Zod validation" Found: "Supabase for auth" → Agent calls search_wiki: "user profile API schema, auth middleware" Found (doc): "User Profile Data Model" with fields, constraints, relations Found (doc): "Auth Middleware" with how to require a session on a route → Agent generates the route using the right stack, schema, and middleware. ``` This works across all connected agents. Context stored by Cursor is available to Claude, ChatGPT, and every other agent on your account. The same is true for wiki documents. <Tip> You don't need to tell your agent to search. Agents call `search_memory` and `search_wiki` automatically whenever past context or reference knowledge would improve their response. </Tip> ## Dashboard Exploration You can explore your knowledge directly in the dashboard. Memory and Wiki are two separate tabs, each with its own views. <Tabs> <Tab title="Memory Exploration"> The **Memories** tab has two views for exploring personal context. * **Graph View**: Explore your knowledge as an interactive network of entities (people, concepts, tools, projects) and relationships. Click any node to see connected entities and related episodes. * **Table View**: Browse all memories in a structured list. Filter by source, project, and time period. Use the table search to text-filter the loaded memory list, then bulk-select rows to move them to a project or delete them. <Frame> <video> <source type="video/mp4" /> </video> <video> <source type="video/mp4" /> </video> </Frame> For the full walkthrough, see [Memory](/features/memory). </Tab> <Tab title="Wiki Exploration"> The **Wiki** tab has two views for exploring factual knowledge. * **Graph View**: A force-directed network of documents connected by `[[wikilinks]]`. Project styling helps related documents visually cluster. * **Table View**: A sortable, filterable list of every document. Filter by Project or search query. Bulk-select rows to move or delete. Projects in the Wiki navigation let you scope the list, graph, and search to a single group of documents. Documents without a Project live in Basic. For the full walkthrough, see [Knowledge Wiki](/features/wiki). </Tab> </Tabs> ## Other Dashboard Tabs Beyond Chat, Memory, and Wiki, the dashboard has a few more tabs: | Tab | Purpose | | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Agents** | Manage connected AI agents: connection status, last activity, add new agents | | **Sources** | Connect app integrations (Gmail, Calendar, Slack, Notion, and more), import Wiki files, and import past chat history | | **Recipes** | Pre-built prompt templates that run directly in Chat, powered by your synced memories | | **Settings** | Tabbed settings page with **Profile** (name, role, interests, custom instructions, timezone; shared with agents via `membase://profile`) and **Billing** (current plan, usage including wiki document quota, and invoices) | ## Next Steps <CardGroup> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history and connect apps to enrich your knowledge base. </Card> <Card title="Memory" icon="brain" href="/features/memory"> Explore and manage your memories. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Explore and manage your wiki documents. </Card> <Card title="Attached vs Universal" icon="share-nodes" href="/core-concepts/attached-vs-universal"> Understand why shared memory across agents matters. </Card> </CardGroup> # Overview Source: https://docs.membase.so/index Persistent, shared personal memory for your AI agents, so they keep important context across sessions. ## What is Membase? Membase is a **universal knowledge layer for AI agents**. It gives your agents two persistent, shared stores that survive across sessions, tools, and platforms, so they can keep important context about you. * **Memory**: Personal context (preferences, decisions, habits, meetings, emails) organized as a knowledge graph * **Knowledge Wiki**: Factual knowledge as markdown documents linked with `[[wikilinks]]`, organized into Projects, with Notion sync, Obsidian/Markdown import, and hybrid search * **Cross-agent sharing**: Context stored by one agent is available to other connected agents on your account * **External integrations**: Connect Gmail, Calendar, Slack, Notion, and other data sources to enrich Memory and Wiki * **Chat history import**: Bring in past conversations from ChatGPT, Claude, and Gemini to bootstrap your knowledge base * **Chat with Memory**: Talk directly to your knowledge base from the dashboard, without going through an external agent * **Smart digesting**: Raw conversations are automatically processed into structured, retrievable memories ## How does it work? <Frame> <img alt="Membase architecture diagram" /> <img alt="Membase architecture diagram" /> </Frame> <Steps> <Step title="Connect agents and data sources"> Connect your AI agents (Cursor, Claude, ChatGPT, etc.) via MCP, import past conversations, and link external data sources like Gmail, Google Calendar, Slack, and Notion. Optionally import Notion exports, Obsidian vaults, or Markdown files to bootstrap your Wiki. </Step> <Step title="Two knowledge stores: Memory and Wiki"> Incoming context lands in the right place automatically. Personal context (preferences, decisions, meetings) becomes **Memory**, organized as a knowledge graph. Reference material (docs, specs, notes, transcripts) becomes **Wiki**, organized as linked markdown documents in Projects or Basic. </Step> <Step title="Retrieval when your agent (or Chat) needs it"> When an agent needs context to respond, it can call `search_memory` for personal context and `search_wiki` for factual knowledge, then combine the results. Chat with Memory in the dashboard can use the same knowledge stores when you ask a question directly. </Step> </Steps> ## Why Membase? Today's AI agents have three fundamental problems: <CardGroup> <Card title="Session Memory Loss" icon="plug-circle-xmark"> Agents forget everything when a session ends. </Card> <Card title="Cross-Agent Isolation" icon="circle-nodes"> Context doesn't carry over between agents. </Card> <Card title="Context Rot" icon="recycle"> More context doesn't mean better responses. </Card> </CardGroup> Every new conversation starts from scratch. You re-explain preferences, past decisions, and project context over and over. Worse, what you told Cursor doesn't exist in Claude, so you end up manually copy-pasting the same information across tools. Even when you try to fix this by stuffing more context into prompts, it backfires. Without structure, the agent can't tell what's important and what's noise. Signal gets buried under volume. Membase solves all three. Instead of dumping raw text, Membase builds a **relational knowledge graph** from your conversations and external data. When an agent needs context, it retrieves only the relevant pieces, keeping responses accurate and grounded. ## Get Started <CardGroup> <Card title="Quickstart" icon="rocket" href="/getting-started/quickstart"> Connect your first agent in 3 simple steps. </Card> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history, connect apps, import Notion/Obsidian/Markdown files, and build your knowledge base. </Card> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Chat with Memory, agent retrieval, and dashboard exploration. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge as linked markdown documents that agents can search. </Card> </CardGroup> # Contributing Source: https://docs.membase.so/support/contributing How to contribute to Membase. Report bugs, improve docs, add connectors, and submit pull requests. Membase's connector kit (the MCP server and client integrations) is open source. Contributions of all sizes are welcome, from typo fixes to new connectors. <CardGroup> <Card title="Contributing Guide" icon="book" href="https://github.com/aristoapp/membase/blob/main/CONTRIBUTING.md"> Development setup, PR workflow, and project conventions. </Card> <Card title="Report an Issue" icon="bug" href="https://github.com/aristoapp/membase/issues"> File a bug report or request a feature on GitHub. </Card> <Card title="Code of Conduct" icon="handshake" href="https://github.com/aristoapp/membase/blob/main/CODE_OF_CONDUCT.md"> What we expect from everyone in the community. </Card> <Card title="Discord Community" icon="discord" href="https://discord.gg/vHgtDd6UTK"> Ask questions and discuss changes with maintainers before you start. </Card> </CardGroup> ## Ways to contribute * **Report bugs** or request features via [GitHub Issues](https://github.com/aristoapp/membase/issues). * **Improve documentation** — install guides, architecture docs, or these pages. * **Add or improve a connector** for a new or existing MCP host. * **Report a security issue** privately — see [SECURITY.md](https://github.com/aristoapp/membase/blob/main/SECURITY.md). Full setup steps and PR requirements live in [CONTRIBUTING.md](https://github.com/aristoapp/membase/blob/main/CONTRIBUTING.md) on GitHub. # Support & Troubleshooting Source: https://docs.membase.so/support/faqs Get help with Membase. Chat with us from the dashboard, report bugs, suggest features, find troubleshooting tips, and connect with the Membase community on Discord. ## Get Help <CardGroup> <Card title="In-Dashboard Support Chat" icon="comments" href="https://app.membase.so"> Open the support chat widget in your dashboard to message the Membase team directly. This is a separate chat from Chat with Memory. Ask account questions, report issues, and get fast responses without leaving the product. </Card> <Card title="Discord Community" icon="discord" href="https://discord.gg/vHgtDd6UTK"> Join 800+ members to discuss Membase, get help, and share ideas. </Card> <Card title="Product Roadmap" icon="map" href="https://membase.canny.io/"> See what's planned, suggest features, and vote on what gets built next. </Card> <Card title="Bug Reports & Feedback" icon="flag" href="https://membase.canny.io/feature-requests"> Report bugs, share feedback, and track the status of your submissions. </Card> </CardGroup> ## FAQs <AccordionGroup> <Accordion title="What AI agents does Membase support?"> Membase supports Cursor, ChatGPT, Claude, Claude Code, Codex, VS Code, Poke, Gemini CLI, and OpenCode, plus plugins for [OpenClaw](/connectors/openclaw) and [Hermes](/connectors/hermes). For Claude Code, use the [Membase Claude Code plugin](/connectors/agents/claude-code); MCP remains available as a fallback. </Accordion> <Accordion title="Is my data secure?"> Yes. Membase uses industry-standard encryption for data in transit and at rest. Your memories are private to your account and are never shared with other users or used for training. </Accordion> <Accordion title="Can I delete all my data?"> Yes. You control deletion at several levels: * **Memories**: Delete individual rows from the **Memories** table, or select multiple rows for bulk delete. See [Memory](/features/memory#deleting-memories). * **Wiki documents**: Delete a single document from its page, or bulk-select rows in the Wiki Table View. See [Knowledge Wiki](/features/wiki#managing-wiki-documents). * **All memories from a source**: Use the **Delete memories** action on the **Sources** page to remove every memory that came from that source (for example, all Slack memories). Disconnecting an integration only stops future sync; existing memories remain until you delete them. * **Notion live-synced Wiki documents**: Use the Notion source card on the **Sources** page to remove synced Wiki documents. This removes documents created by Notion live sync, but does not remove one-time Notion file imports. If you keep Notion connected, future syncs can recreate source-backed documents. When prompted, you can also choose whether to remove synced documents that were edited in Membase. * **Entire account**: Message us from the in-dashboard support chat or email **[support@aristo.so](mailto:support@aristo.so)** and we will delete your account and all associated data. </Accordion> <Accordion title="How does automatic memory creation work?"> When you interact with a connected agent or ask Chat in Dashboard to save durable context, Membase processes the conversation to extract key facts, preferences, and decisions. These are stored as structured memories in a knowledge graph. See [How Membase Works](/core-concepts/how-membase-works) for details. </Accordion> <Accordion title="How do I reach the Membase team?"> The fastest way is to open the **in-dashboard support chat widget** in your [dashboard](https://app.membase.so) and message us directly. Note that this is a separate chat from Chat with Memory. You can also reach us on [Discord](https://discord.gg/vHgtDd6UTK) or by email at **[support@aristo.so](mailto:support@aristo.so)** for account-related issues. </Accordion> <Accordion title="Can I use Membase with multiple agents at the same time?"> Absolutely. All agents connected to the same Membase account share the same memory pool. See [How Membase Works](/core-concepts/how-membase-works) for details on how context is shared across agents. </Accordion> <Accordion title="What happens if two agents write conflicting memories?"> Membase automatically detects conflicts and resolves them by prioritizing the most recent information. You can also manually delete conflicting memories from the dashboard. </Accordion> <Accordion title="Is there a free tier?"> Yes. Membase offers a **Free** plan and a **Pro** plan. * **Free**: Connect agents, sync integrations, store up to **1,000 memories** and **200 wiki documents**, run **40 dashboard chats per month**, and use **1,000 MCP memory searches per month**. * **Pro**: Higher limits including **5,000 memories**, **2,000 wiki documents**, **200 dashboard chats per month**, and unlimited MCP memory searches. You can see your current plan and usage on the **Billing** tab in your [dashboard](https://app.membase.so), and upgrade or manage your subscription from there. Sign up at [app.membase.so](https://app.membase.so) and connect your first agent in under a minute. </Accordion> </AccordionGroup> ## Troubleshooting <AccordionGroup> <Accordion title="My agent can't connect to Membase"> For Claude Code plugin issues, see the Claude Code troubleshooting steps below. For MCP clients: 1. Ensure the npx command is using the latest package version. 2. Restart your agent after updating the MCP configuration. 3. Check that your network allows outbound connections to `mcp.membase.so`. 4. If using OAuth, try logging out and re-authenticating. </Accordion> <Accordion title="Claude Code does not show Membase commands"> Confirm the plugin is installed: ```bash theme={null} claude plugin marketplace add aristoapp/claude-membase && claude plugin install membase@membase-plugins ``` If Claude Code is already open, run `/reload-plugins` inside Claude Code. Then run `/membase:login` and verify the connection with `/membase:status`. </Accordion> <Accordion title="I connected the wrong Membase account in Claude Code"> Run `/membase:logout`, then `/membase:login` and verify the account with `/membase:status`. If the old account context is still visible in the current conversation, run `/clear` or start a new Claude Code session. </Accordion> <Accordion title="Memories aren't being created automatically"> 1. Verify the connection is active. In Claude Code, run `/membase:status`; in MCP clients, check your agent's MCP status. 2. Ensure the conversation contains extractable information. Simple greetings may not generate memories. 3. Check the dashboard for any sync errors. </Accordion> <Accordion title="Search results are not relevant"> 1. Try rephrasing your search query with more specific terms. 2. Ensure the relevant memories exist in your dashboard. 3. If the issue persists, report it on [Discord](https://discord.gg/vHgtDd6UTK) or via [feedback](https://membase.canny.io/feature-requests). </Accordion> </AccordionGroup> ## Contact For urgent issues or account-related requests, email us. For general questions, join our Discord. <CardGroup> <Card title="Email Support" icon="envelope" href="mailto:support@aristo.so"> Reach our support team at **[support@aristo.so](mailto:support@aristo.so)**. </Card> <Card title="Discord Community" icon="discord" href="https://discord.gg/vHgtDd6UTK"> Join 800+ members for discussions and live support. </Card> </CardGroup>

# Changelog Source: https://docs.membase.so/changelog/index Latest updates, new features, and improvements to Membase. Stay up to date with product releases, bug fixes, and new integrations. Stay up to date with the latest changes to Membase. *** *June 25, 2026* ## v0.6.0: Self-improving Wiki, Notion Integration, and Agent Conversation Capture Wiki is becoming an active knowledge workspace. Membase can now help organize and improve your Wiki through reviewable suggestions, sync Notion pages into Wiki, and preserve agent conversations as searchable Wiki documents for later reference. ### New Features Wiki now helps keep itself organized. Membase can suggest updates, merges, and source-driven changes, then routes them through Inbox Review so you can inspect, edit, accept, or undo changes before they become part of your knowledge base. The Wiki workspace is easier to review at a glance, with clearer document organization and graph views that help you understand related knowledge before applying changes. If you were using Wiki as a static document store, you can still download your previous Wiki snapshot from **Wiki > More actions > Download previous Wiki**. Self-improving Wiki Inbox Review

Self-improving Wiki Inbox Review in dark mode

Connect Notion from Sources and bring selected pages into Wiki. Membase keeps your Notion knowledge available as searchable, reviewable context for your dashboard and connected agents. Notion Live-Synced source

Auto-Capture now keeps conversations between you and your agent in Wiki. Hermes, OpenClaw, and Claude Code can preserve agent sessions as searchable Wiki documents, so important work is easier to revisit and build on later. ### Improvements Hermes, OpenClaw, Claude Code, and MCP clients now work better with Project-based Wiki filing. Wiki saves, updates, and search results more clearly report whether content landed in a Project, Basic, or another destination. Wiki and chat imports are more resilient for larger files and archives. Import progress is clearer, Markdown and Obsidian uploads follow the newer background import flow, and table-like files are handled more intentionally. *** *May 19, 2026* ## v0.5.0: Open Beta, Referral Program, and Inline Citations Membase is now in open beta. Anyone can sign up without an invite code. This release also introduces the referral program, a redesigned chat experience, a public privacy page, and expanded sign-in and agent support. ### New Features Membase is no longer invite-gated. Create an account and start building your memory from day one. Invite a friend to Membase and you both get **1 month of Pro free**. Share your referral link from the dashboard, or send an email invite directly. When your friend signs up, the reward is applied automatically. Referral Program

Chat received a major upgrade across the board. * **Inline citations**: Answers now link directly to the memories and wiki docs they came from, so you can verify context without leaving the thread. * **Sources visibility**: The sources panel shows where each answer drew from, with a clearer layout and quick navigation to the original content. * **Reasoning and tool calling**: See how the assistant thinks through a question and which tools it calls along the way. * **Feedback**: Rate individual messages to help us improve response quality. * **Export chat**: Download a conversation as Markdown for sharing or archiving. * **Mobile view**: Chat, sources, and the graph panel now work properly on smaller screens. Chat UX

We added a dedicated privacy page on the website that explains what data Membase collects, how it is used, and how you stay in control. We believe transparency builds trust, and we want that to be visible before you sign up. You can now read how we protect your data [here](https://membase.so/privacy). ### Improvements Imported frontmatter metadata is now preserved instead of dropped during import. Edit metadata inline on the document page, move documents between collections, and search by simple metadata fields. Agents can read and write wiki metadata through MCP. Sign in or sign up with Apple or GitHub alongside email. The auth flow is now two-step: enter your email first, then confirm with a magic link or OAuth provider. Apple and GitHub Sign In

Membase MCP now works with Codex alongside Cursor, Claude Code, OpenClaw, and Hermes. Connect from the Agents tab and your Codex sessions get the same persistent memory and wiki access as every other supported client. Codex Agent Support

*** *April 17, 2026* ## v0.4.0: Wiki, Pro Plan, and Projects Wiki is now live. Write notes, docs, and structured knowledge, all searchable and available to your agents through MCP. This release also brings Obsidian import, a Pro Plan, Projects and Collections, Recipes, and a smoother onboarding flow. ### New Features Your memory stores what happened. Wiki stores what you know. Write documentation, meeting notes, and structured knowledge, anything you want to keep reusable and easy to reference. Write with `[[backlinks]]` to link ideas across documents. Membase resolves the connections automatically and keeps them in sync as you edit. See everything in the graph view and find anything instantly with full-text search. Your agents can read and write to Wiki through MCP, so the knowledge you build here is available to every agent connected to Membase. Wiki

Already have notes in Obsidian? Drop your vault as a zip and Membase imports your notes with `[[backlinks]]` intact. No need to rebuild connections from scratch. Obsidian Import

The free plan stays free. For users who need more room, Pro unlocks unlimited MCP searches, 5,000 memories, 2,000 wiki docs, and 200 dashboard chats per month. Upgrade from [Settings > Billing](https://app.membase.so/settings?tab=billing). Pro Plan

Memories and wiki docs can now be scoped to a project or collection. When you search or chat, you can target exactly the context you want instead of pulling from everything at once. Recipes are curated prompts built around how we actually use Membase. Morning Briefing, Weekly Recap, Slack Digest, Pre-Meeting Brief, and more. Run any of them directly from chat. The more integrations you connect, the more useful they become. Recipes

Hermes Agent is now available as a native Membase plugin. Install it with a single command, connect through OAuth, and give Hermes persistent memory, wiki retrieval, and built-in `MEMORY.md` mirroring across sessions. Hermes Agent Plugin

First-time setup now walks you through use cases, privacy settings, and profile configuration step by step, so your workspace is ready to go from day one. Already signed up? Revisit anytime from Help > Quick Guide. New Onboarding

Use the chat widget in the bottom corner to reach the team directly. Bug reports, feedback, and questions are all welcome. ### Improvements Large imports now work with resumable uploads and background processing, so you can bring in big chat archives without running into upload failures. Recall and search flows are more reliable, source filtering now works consistently, and the plugin handles edge cases around authentication and token storage more gracefully. Search results from Membase via MCP now include a relative relevance score alongside each memory. Your agent can use this to prioritize what is most on-point rather than treating every result the same. *** *March 21, 2026* ## v0.3.0: Chat History Import, Chat with Memory, and Slack Integration This update tackles the memory cold-start problem with chat history import, introduces Chat with Memory so you can talk directly to your Membase knowledge base without connecting an agent, and adds live-sync with Slack where most of your work context lives. ### New Features Your insights are scattered across ChatGPT, Claude, Gemini, and a dozen other tools. Every time you switch, that context disappears. Chat History Import brings it all into one place. Import your conversation history from any major LLM client and Membase turns it into a unified memory you can search, reference, and build on.

Ask about a decision you made last month, a conversation from last week, or a pattern across everything you've worked on. Chat with Memory connects your AI to your full Membase context, so responses can be grounded in what actually matters to you. Session history lives in the sidebar so you can pick up any conversation where you left off. Citations link back to the memories used for an answer, and the graph panel shows how everything connects. Chat with Memory

Connect Slack from the Integrations tab. Membase syncs your messages in the background and generates readable summaries from thread and channel content. Incremental updates run automatically, so your workspace stays current as new messages come in. Slack Integration

### Improvements * **MCP Session Recovery**: Improved stability for session reconnection. * **Google Sync**: More reliable sync process for Calendar and Gmail. * **OpenClaw**: Stability fixes for the OpenClaw plugin. * Password sign-in support. * Mobile UI polish across the dashboard. *** *March 3, 2026* ## v0.2.3: Gmail Sync, OpenClaw Plugin, and Invite Codes Connect Gmail, use Membase with OpenClaw, invite people directly from your dashboard, and explore a clearer memory graph. ### New Features Now you can connect Gmail directly from the Integrations tab. Membase syncs your emails in the background and generates clean, readable memory summaries from email content. Google Calendar works alongside it, so both channels feed into your workspace together. Gmail Sync

OpenClaw is now available in the Agents tab, with a built-in step-by-step setup. Support has also expanded to OpenCode and additional clients through the same guided installation flow. OpenClaw Plugin

Every user now has a limited set of invite codes in their dashboard. Each code is single-use. Share a code or a direct link to bring anyone into your memory network.

### Improvements The graph view now renders entities with connections. You can follow related context, jump into detail views, and move across nodes fluidly.

Table View now supports filtering by period and source. You can select multiple sources too. Filter by Source

* **Context Management**: More accurate context digestion from Google Calendar and Gmail. * **Sync Process UI**: Polished sync progress bar with more accurate completion handling. * **Model Upgrade**: Faster ingestion refresh and improved loading reliability. * **Auto Refresh**: Automatically refreshes whenever new memory is added. *** *February 20, 2026* ## v0.2.0: Memory Graph, Calendar Sync, and Agent Management Explore your memories in an interactive 3D graph, sync Google Calendar into Membase, and manage connected agents in real time. This release also includes major performance, stability, and reliability improvements. ### New Features Explore your memories in an interactive 3D graph. Click any node to zoom in, search to highlight what matters, and discover connections across your memory. 3D Memory Graph

Connect Google Calendar in one click. Membase keeps your events in sync automatically: grouping recurring meetings and turning everything into clean, concise summaries. Google Calendar Integration

The Agents tab now shows every AI client connected to your Membase in real time. Step-by-step installation guides are also included to make setup faster. Agent Management

### Improvements * Improved MCP OAuth reliability (disconnects and stale tokens fixed). * Faster memory ingestion and search. * Memory source tracking (Cursor, ChatGPT, Calendar, and more). * Memory deletion in both graph and table views. * Improved loading performance and reduced data loading errors. * Dashboard UI polish. *** Follow us on [X/Twitter](https://x.com/intent/follow?screen_name=mem_base) or join our [Discord](https://discord.gg/vHgtDd6UTK) for the latest announcements. # ChatGPT Source: https://docs.membase.so/connectors/agents/chatgpt Connect Membase to ChatGPT as a custom app using MCP. Give ChatGPT persistent memory that remembers your preferences and context across every conversation. ChatGPT custom apps/connectors require a ChatGPT plan that supports custom connectors. If the Apps settings are not available, check your ChatGPT plan. Go to **Settings > Apps > Advanced Settings** in ChatGPT. ChatGPT Advanced Settings

| Field | Value | | -------------- | ----------------------------------- | | Name | `Membase` | | Description | `Membase memory and wiki connector` | | URL | `https://mcp.membase.so/mcp` | | Authentication | `OAuth` | ChatGPT app configuration

Try something like: `@membase Brief me on my tasks for today.` Using Membase in ChatGPT

## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # Claude Code Source: https://docs.membase.so/connectors/agents/claude-code Connect Membase to Claude Code with the Membase Claude Code plugin. Add persistent memory, wiki retrieval, slash commands, hooks, and project-aware context to your coding sessions. The Membase Claude Code plugin is the recommended way to use Membase in Claude Code. It runs locally with Claude Code, connects to your Membase Cloud account through OAuth, and exposes memory and wiki workflows through both slash commands and MCP tools. ```bash theme={null} claude plugin marketplace add aristoapp/claude-membase && claude plugin install membase@membase-plugins ``` Open Claude Code. If Claude Code is already open, run: ```text theme={null} /reload-plugins ``` In Claude Code, run: ```text theme={null} /membase:login ``` The login flow opens browser OAuth and asks you to choose an auto-capture mode: * `wiki`: enable Wiki auto-capture for user/assistant conversation transcripts * `off`: disable hook-based auto-capture Run: ```text theme={null} /membase:status ``` Confirm the connected account before saving memory or wiki data. ## What the Plugin Adds * **Slash commands**: `/membase:login`, `/membase:status`, `/membase:recall`, `/membase:remember`, `/membase:wiki`, `/membase:index-project`, and `/membase:project-config` * **Automatic recall**: Searches Membase before prompts when auto-recall is enabled and injects relevant context as untrusted reference data * **Wiki retrieval**: Lets Claude Code search, add, update, and delete factual wiki documents through Membase tools * **Hooks**: Supports session start context, prompt-time recall, and opt-in Wiki capture for durable conversation source material * **Project-aware workflows**: Can scope memories to the current git repository when project mode is enabled * **Local credential storage**: OAuth tokens are stored in Claude Code's plugin data directory, not in plugin user settings Auto-capture only controls hook-based capture. Claude can still write memories or Wiki docs through Membase tools when appropriate. ## Auto-Capture Privacy Auto-capture is opt-in during `/membase:login`. Wiki capture stores the user/assistant conversation transcript as original source material in Membase Wiki, not as extracted Memory. The plugin redacts secrets, `.env` values, private key blocks, and content wrapped in `` or `` before capture. ## Session Start Context Session start context (`sessionStartContext`) is separate from auto-capture. When configured, the plugin can provide relevant Membase context at the beginning of a Claude Code session so Claude starts with project background before your first prompt. That context is read-only reference material. It does not write new memories or Wiki documents by itself, and Claude should treat retrieved content as untrusted context that still needs user intent before taking action. ## MCP Fallback If Claude Code plugins are not available in your environment, you can still connect Membase as a standard MCP server: ```bash theme={null} npx -y membase@latest --client claude-code ``` The MCP fallback provides the core memory and wiki tools, but it does not include Claude Code plugin slash commands, hooks, or project-aware workflows. ## Troubleshooting Run `/reload-plugins` inside Claude Code. If the commands still do not appear, run `claude plugin marketplace add aristoapp/claude-membase && claude plugin install membase@membase-plugins` again and start a new Claude Code session. Run `/membase:logout`, then `/membase:login` and verify the account with `/membase:status`. For the cleanest context after switching accounts, run `/clear` or start a new Claude Code session. Keep the Claude Code plugin as the primary path. You can leave the remote MCP setup as a fallback, but if duplicate tools are confusing, remove the older MCP configuration after confirming the plugin works. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # Claude Source: https://docs.membase.so/connectors/agents/claude-desktop Connect Membase to Claude as a custom connector. Give Claude persistent memory that carries your context, preferences, and decisions across conversations. Go to [Claude connector settings](https://claude.ai/settings/connectors) and click **Add custom connector**. Fill in the connector details: | Field | Value | | --------------------- | ---------------------------- | | Name | `Membase` | | Remote MCP server URL | `https://mcp.membase.so/mcp` | Click **Connect** and complete the Membase OAuth flow in your browser. Membase tools are now available in Claude wherever custom connectors are supported. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # Codex Source: https://docs.membase.so/connectors/agents/codex Connect Membase to Codex via CLI setup. Give Codex persistent memory for coding preferences, project context, and past decisions. ```bash theme={null} npx -y membase@latest --client codex ``` A browser window opens automatically for authentication. After logging in, Membase is ready to use immediately. # Cursor Source: https://docs.membase.so/connectors/agents/cursor Connect Membase to Cursor with one-click MCP setup. You can also use the Membase Cursor plugin for packaged rules and skills. Cursor supports **one-click MCP setup** from the Membase dashboard. This is the default setup path and gives Cursor access to Membase memory and wiki tools through the hosted Membase MCP server. From the [Membase dashboard](https://app.membase.so), select Cursor and click the **"Add to Cursor"** badge. Cursor will show a confirmation dialog. Click **Install** to proceed. Cursor install dialog

After installation, find Membase in the MCP Servers section and click **Connect**. Connect Membase in Cursor

A browser window opens automatically. Log in to complete authentication. Membase is now ready in Cursor. ## Cursor Plugin Membase also has a [Cursor plugin](https://github.com/aristoapp/cursor-membase). The plugin uses the same hosted Membase MCP server and Cursor OAuth flow, but packages additional Cursor guidance with the connection: * **MCP tools**: `search_memory`, `add_memory`, `get_current_date`, `search_wiki`, `add_wiki`, `update_wiki`, and `delete_wiki` * **Resources**: `membase://profile` for stable user settings and `membase://recent` for recent memory context * **Always-on rule**: Guides Cursor to search and save Membase context when it is relevant * **Skills**: Helps Cursor choose between memory and wiki workflows for searching, saving, and managing knowledge Install it from the [Cursor Marketplace](https://cursor.com/marketplace) when available in your workspace, then click **Connect** next to the Membase MCP server in Cursor settings. No npm package, CLI login, or API key is required. ## Troubleshooting Use the one-click MCP setup from the Membase dashboard. It connects Cursor to the same hosted Membase MCP server and supports memory and wiki tools. Click **Connect** next to the Membase MCP server in Cursor settings and complete browser OAuth. Cursor owns the OAuth connection for this setup. You can keep that setup. If you later install the Cursor plugin, remove duplicate Membase MCP entries if Cursor shows the same tools twice. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # Gemini CLI Source: https://docs.membase.so/connectors/agents/gemini-cli Connect Membase to Gemini CLI with a single command. Give Gemini persistent memory across sessions for smarter, context-aware responses. ```bash theme={null} npx -y membase@latest --client gemini-cli ``` A browser window opens automatically for authentication. After logging in, Membase is ready to use. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # Generic MCP URL Source: https://docs.membase.so/connectors/agents/mcp-url Connect any MCP-compatible AI client to Membase using a generic server URL. Works with any tool that supports the Model Context Protocol. For any MCP-compatible client not listed in the other guides, use the server URL directly: ``` https://mcp.membase.so/mcp ``` ``` https://mcp.membase.so/mcp ``` Set the transport type to **Streamable HTTP** and authentication to **OAuth**. Complete the OAuth flow when prompted. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # OpenCode Source: https://docs.membase.so/connectors/agents/opencode Connect Membase to OpenCode via CLI setup. Add persistent memory to OpenCode for context-aware coding that remembers your preferences across sessions. ```bash theme={null} npx -y membase@latest --client opencode ``` This registers Membase as an MCP server in OpenCode. ```bash theme={null} opencode mcp auth membase ``` A browser window opens automatically for OAuth authentication. Membase is ready to use after authentication completes. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # Poke Source: https://docs.membase.so/connectors/agents/poke Connect Membase to Poke via MCP integration. Add persistent, cross-session memory to your Poke AI assistant for smarter, context-aware responses. Navigate to [Poke.com > Integrations](https://poke.com/integrations/new). | Field | Value | | ---------- | ---------------------------- | | Name | `Membase` | | Server URL | `https://mcp.membase.so/mcp` | The API Key field is optional. You can leave it empty since Membase uses OAuth for authentication. Poke integration setup

Complete the OAuth flow in the browser. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # VS Code Source: https://docs.membase.so/connectors/agents/vscode Connect Membase to VS Code with one-click install. Add persistent memory to your VS Code AI assistant for context-aware coding across sessions. VS Code supports **one-click install** via deep link. From the [Membase dashboard](https://app.membase.so), select VS Code and click the **"Add to VS Code"** button. VS Code will show a confirmation dialog. Click **Install** to proceed. VS Code install dialog

A browser window opens. Log in to complete authentication. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge alongside your memories. See every MCP tool your agent can call. # App Integrations Source: https://docs.membase.so/connectors/apps Connect external applications and imports to Membase. Enrich Memory and Wiki with data from Gmail, Calendar, Slack, Notion, Obsidian, and more. Membase app integrations feed external data into the right knowledge store for that source. Gmail, Google Calendar, and Slack build Memory; Notion live sync plus Notion export, Obsidian, and Markdown imports build Wiki. From [Sources](https://app.membase.so/sources), connect live integrations or start a one-time import. Membase Sources page with active app integrations

Membase Sources page with active app integrations

## Why Use App Integrations? | Feature | Direct API | Membase Integration | | ----------------------------------------- | ---------- | ------------------- | | Raw data access | Yes | Yes | | Automatic structuring into Memory or Wiki | No | Yes | | Cross-agent availability | No | Yes | | Deduplication & structuring | No | Yes | | Relationship mapping | No | Yes | | Persistent across sessions | Manual | Automatic | Membase integrations don't just pipe raw data. They **process, structure, and integrate** external data into Memory or Wiki, making it accessible to your dashboard and connected agents. ## Available Apps } href="#notion-live-sync"> Live-sync selected Notion pages into Wiki while keeping source-backed changes reviewable. } href="#slack"> Sync your Slack messages, threads, and channels. Membase generates readable summaries and keeps your workspace current with incremental updates. } href="#google-calendar"> Sync your schedule to help agents manage your time and meetings.

} href="#wiki-imports"> Import Obsidian vaults or Markdown files as Wiki documents. } href="#gmail"> Connect your email to let agents draft replies and organize your inbox. } href="#google-drive">

Seamlessly connect your team's cloud files and storage with current project work.

Coming Soon

} href="#github">

Streamline software projects, issues, and pull requests with your development workflow.

Coming Soon

## App Details ### Notion Live Sync Connect Notion from [Sources](https://app.membase.so/sources) to bring selected Notion pages into Wiki. During setup, choose which Notion pages Membase can access, then choose the target Wiki Project for synced pages. From the Notion card, you can sync now, change the target Project, disconnect future syncs, or remove documents created by Notion live sync. Removing synced docs protects documents edited inside Membase by default. For one-time Notion exports, use Wiki imports instead of live sync. ### Slack Connect Slack from [Sources](https://app.membase.so/sources) to sync messages, threads, and channels into Memory. Membase turns workspace activity into readable memory context so Chat and connected agents can recall past discussions, decisions, and team updates. ### Google Calendar Connect Google Calendar from [Sources](https://app.membase.so/sources) to sync schedule context into Memory. Calendar context helps agents understand meetings, timing, and commitments when answering questions or helping you plan. ### Wiki Imports Use [Wiki](https://app.membase.so/wiki) > **Add > Import files** for one-time imports from Notion exports, Obsidian vaults, or generic Markdown files: | Source | Accepted files | What happens | | ---------------- | -------------------------- | ---------------------------------------------------------------------------- | | Notion export | `.zip`, `.md`, `.markdown` | Creates normal Wiki documents from exported Notion pages | | Obsidian vault | `.zip`, `.md`, `.markdown` | Preserves `[[wikilinks]]` and imports notes into the target Project or Basic | | Generic Markdown | `.zip`, `.md`, `.markdown` | Imports loose Markdown files into a target Project or Basic | For each import, choose a target Project or Basic. Archive and multi-file imports keep source path information where available, but imported documents start in the destination you choose. ### Gmail Connect Gmail from [Sources](https://app.membase.so/sources) to bring email context into Memory. Agents can use that context to help draft replies, organize follow-ups, and answer questions about past email conversations. ### Google Drive Google Drive is listed as Coming Soon. It is not an active integration yet. ### GitHub GitHub is listed as Coming Soon. It is not an active integration yet. ## Next Steps Explore and manage the memories created from app integrations. Explore Projects, Basic, imports, live sync, and Wiki search. Learn about all available MCP tools. # Hermes Agent Source: https://docs.membase.so/connectors/hermes Add persistent long-term memory, Wiki retrieval, transcript capture, and built-in memory mirroring to Hermes Agent with Membase. Hermes Agent x Membase

Persistent long-term memory for Hermes Agent, powered by Membase. The plugin can recall both memories and Wiki documents, preserve conversation transcripts as Wiki source material, and mirror Hermes's built-in `MEMORY.md` into Membase for cross-session persistence. ## How It Works Once installed, the plugin runs automatically during Hermes sessions: * **Auto-Capture** *(on by default)*: Buffers user and assistant turns and writes original conversation transcripts to Membase Wiki. * **Auto-Recall** *(off by default)*: Searches past memories before the next response and injects relevant context. * **Auto Wiki Recall** *(off by default)*: Searches wiki documents and injects stable reference material alongside memories. * **Mirror Built-in** *(on by default)*: Mirrors Hermes built-in memory writes from `MEMORY.md` into Membase in the background. * **Knowledge Graph**: Membase organizes entities, relationships, and facts alongside vector search for richer retrieval. ## Setup ```bash theme={null} uv tool install hermes-membase && hermes-membase install ``` Requires **Python 3.11+**. If you prefer `pip`, `pip install hermes-membase && hermes-membase install` also works. The install command copies the plugin into `~/.hermes/plugins/membase/`, sets `memory.provider: membase` in `~/.hermes/config.yaml`, writes default config to `~/.hermes/membase.json`, and opens a browser for OAuth login. ```bash theme={null} hermes-membase login ``` Tokens are stored automatically in `~/.hermes/credentials/membase.json`, so there are no API keys to manage manually. ```bash theme={null} hermes ``` Conversation transcripts are captured to Wiki automatically. To inject memories or Wiki docs before each response, enable `autoRecall` and/or `autoWikiRecall` in `~/.hermes/membase.json`. ## AI Tools The AI uses these tools autonomously during conversations. These `membase_*` tools are Hermes plugin-side wrappers around the corresponding [Membase MCP tools](/features/membase-mcp). | Tool | Wraps | Description | | --------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `membase_search` | `search_memory` | Search memories by semantic similarity. Supports date filtering (`date_from`, `date_to`, `timezone`) and source filtering (`sources`). Defaults to 20 results and caps at 30. Returns a compact OpenClaw-compatible text list with related facts. | | `membase_store` | `add_memory` | Save important conversational context to long-term memory. Useful for preferences, goals, decisions, and project context. Requires a display summary and supports content up to 50,000 characters. | | `membase_forget` | `delete_memory` | Delete a memory. Shows candidate matches first, then deletes after confirmation. | | `membase_profile` | `membase://profile` | Retrieve the user profile and related memories for session context. | | `membase_search_wiki` | `search_wiki` | Search Wiki documents for stable factual references. Defaults to 10 results and caps at 20. Results label Project, Basic, or Unknown destinations. | | `membase_add_wiki` | `add_wiki` | Create a Wiki document from full markdown content and an optional Project filing location. Reports the returned destination. | | `membase_update_wiki` | `update_wiki` | Update the title, content, or Project of an existing Wiki document. Set Project to `null` to move a document to Basic. | | `membase_delete_wiki` | `delete_wiki` | Delete a Wiki document. Shows candidate matches first, then deletes after confirmation. | Hermes supports both memory tools and [Knowledge Wiki](/features/wiki) tools, and also mirrors Hermes built-in `MEMORY.md` into Membase for cross-session persistence. ## CLI Commands ```bash theme={null} hermes-membase install # One-shot install and OAuth login hermes-membase login # OAuth login (PKCE) hermes-membase logout # Remove stored tokens hermes-membase status # Check API connectivity and profile hermes-membase resync # Rebuild mirror index from MEMORY.md hermes-membase resync --dry-run # Preview mirror resync without writing ``` After installation, these commands are also available inside Hermes as `hermes membase `. ## Auto-Recall When enabled, Hermes prepares relevant Memory and Wiki context before the next AI turn and injects the result into the conversation. Casual chat and short operational messages are skipped to keep recall focused. Both recall modes are **disabled by default**: ```json theme={null} { "autoRecall": true, "autoWikiRecall": true } ``` ## Auto-Capture Auto-Capture buffers user and assistant messages during the session and stores original transcripts as Wiki documents. * During an active session, buffers flush after **5 minutes of silence** or **20 buffered messages**, whichever comes first. * At least **50+ characters** are required before content is captured, which avoids storing tiny one-off messages. * Only the **primary** Hermes agent context is captured, so subagents and background contexts do not create noisy Wiki transcripts. ## Mirror Built-in Memory When Hermes writes to its built-in `MEMORY.md`, the plugin mirrors those writes to Membase in the background. A local `mirror_index.json` file prevents duplicate uploads. If you need to rebuild the mirror index from an existing `MEMORY.md`, run: ```bash theme={null} hermes-membase resync ``` ## Configuration Main plugin config is stored in `~/.hermes/membase.json`. Hermes itself is pointed at Membase through `~/.hermes/config.yaml`: ```yaml theme={null} memory: provider: membase ``` All keys in `~/.hermes/membase.json` are optional: | Key | Type | Default | Description | | ---------------- | ------- | ------------------------------------ | ----------------------------------------------------------------------------------- | | `apiUrl` | string | `https://api.membase.so` | Membase API URL. Override only if instructed by Membase support. | | `tokenFile` | string | `~/.hermes/credentials/membase.json` | OAuth token cache path. Stored outside the plugin directory so it survives updates. | | `autoRecall` | boolean | `false` | Inject relevant memories before each response. | | `autoWikiRecall` | boolean | `false` | Inject relevant wiki documents before each response. | | `autoCapture` | boolean | `true` | Automatically store user/assistant conversation transcripts to Wiki. | | `mirrorBuiltin` | boolean | `true` | Mirror Hermes built-in memory writes into Membase. | | `maxRecallChars` | number | `4000` | Max characters of recalled context per turn (500–16000). | | `debug` | boolean | `false` | Enable verbose debug logging. | OAuth login stores rotating tokens in `tokenFile` and also persists the generated OAuth `clientId` automatically, so you normally do not need to edit auth-related keys by hand. Example config: ```json theme={null} { "autoRecall": true, "autoWikiRecall": true, "autoCapture": true, "mirrorBuiltin": true, "maxRecallChars": 4000 } ``` ## Updating the Plugin To upgrade to the latest version: ```bash theme={null} uv tool upgrade hermes-membase hermes-membase install --skip-login ``` If you installed with `pip`, `pip install --upgrade hermes-membase` also works. If you want to re-authenticate as part of the upgrade, rerun `hermes-membase install` without `--skip-login`. ## How Membase Differs | | Simple vector memory | **Membase** | | ------------------ | ---------------------- | --------------------------------------------------------- | | **Storage** | Flat embeddings | Hybrid: vector embeddings + knowledge graph | | **Search** | Vector similarity only | Vector + graph traversal (entities, relationships, facts) | | **Extraction** | Store raw text | AI-powered entity/relationship extraction | | **Knowledge base** | Usually memory-only | Memory + wiki documents in one system | | **Auth** | API key | OAuth 2.0 with PKCE (no secrets to manage) | | **Ingest** | Synchronous | Asynchronous processing | ## GitHub Repository Want to inspect the plugin source, track releases, or contribute improvements? Browse the source code, open issues, and follow plugin updates in the standalone repository. ## Next Steps Import chat history, connect apps, and more. Chat with Memory, agent retrieval, and dashboard exploration. Store factual knowledge as wiki documents that Hermes can search directly. See every memory and wiki tool available across clients. # OpenClaw Source: https://docs.membase.so/connectors/openclaw Add persistent long-term memory and Wiki transcript capture to OpenClaw across Telegram, WhatsApp, Discord, Slack, and more with Membase's universal knowledge layer. Membase x OpenClaw

Persistent long-term memory for OpenClaw, powered by Membase. Works across **Telegram, WhatsApp, Discord, Slack**, and any other channel OpenClaw supports. The plugin can preserve conversation transcripts in Wiki, recall relevant Memory and Wiki context, and use Membase's hybrid retrieval layer across sessions. ## How It Works Once installed, **Auto-Capture** runs automatically with no extra configuration: * **Auto-Capture** *(on by default)*: After conversations, user and assistant messages are buffered and saved as original transcript documents in Membase Wiki. * **Auto-Recall** *(off by default)*: When enabled, the plugin searches memory context before every AI turn and injects relevant snippets. Casual chat is skipped to keep things focused. * **Auto Wiki Recall** *(off by default)*: When enabled, the plugin also prefetches wiki documents before every AI turn for factual context and references. * **Knowledge Graph**: Unlike simple vector memory, Membase organizes entities, relationships, and facts into a knowledge graph. Search results include related context for richer responses. ## Setup ```bash theme={null} openclaw plugins install @membase/openclaw-membase ``` Restart OpenClaw after installing. ```bash theme={null} openclaw membase login ``` A browser window opens automatically for OAuth authentication. Tokens are saved automatically, so there are no API keys to manage. Membase is now active. Conversation transcripts are automatically captured to Wiki. To also inject memories before each AI response, enable Auto-Recall by asking your AI: `"Enable auto-recall for Membase"`. ## Configuring Membase The simplest way to change Membase settings is to just ask your AI in a conversation. No need to edit config files manually. **Auto-Recall** (inject past memories before each response): ``` "Enable auto-recall for Membase" "Turn off auto-recall" ``` **Auto Wiki Recall** (inject wiki docs before each response): ``` "Enable auto wiki recall for Membase" "Turn off auto wiki recall" ``` **Auto-Capture** (automatically save conversation transcripts to Wiki): ``` "Stop capturing my conversations to Membase" "Re-enable auto-capture" ``` **Memory context size** (how much memory is injected per turn, 500–16000 chars): ``` "Set my Membase recall limit to 8000 characters" "Reduce the memory context to 2000 characters" ``` The AI will update `~/.openclaw/openclaw.json` and ask you to restart the OpenClaw gateway for the change to take effect. Alternatively, you can edit the config directly. See the [Configuration](#configuration) section below. ## AI Tools The AI uses these tools autonomously during conversations. The `membase_*` names below are OpenClaw's plugin-side wrappers around the corresponding [Membase MCP tools](/features/membase-mcp). | Tool | Wraps | Description | | --------------------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `membase_search` | `search_memory` | Search memories by semantic similarity. Supports date filtering (`date_from`, `date_to`, `timezone`) and source filtering (`sources`, e.g. `slack`, `gmail`). Each result includes a **relevance score** (0–1). Returns episode bundles with related facts. | | `membase_store` | `add_memory` | Save important information to long-term memory. Proactively stores preferences, goals, and context. | | `membase_forget` | `delete_memory` | Delete a memory. Shows matches first, then deletes after user confirmation (two-step). | | `membase_profile` | `membase://profile` | Retrieve user profile and related memories for session context. | | `membase_search_wiki` | `search_wiki` | Search Wiki documents for factual references and stable knowledge. Results label Project, Basic, or Unknown destinations. | | `membase_add_wiki` | `add_wiki` | Create a Wiki document from full markdown content and an optional Project filing location. Reports the returned destination. | | `membase_update_wiki` | `update_wiki` | Update title, content, or Project for an existing Wiki document. Set Project to `null` to move to Basic. | | `membase_delete_wiki` | `delete_wiki` | Delete a Wiki document with a confirmation flow. | ## CLI Commands ```bash theme={null} openclaw membase login # OAuth login (PKCE) openclaw membase logout # Remove stored tokens openclaw membase search # Search memories openclaw membase search -s slack,gmail # Filter by source openclaw membase wiki-search # Search wiki documents openclaw membase wiki-search --project "Docs" # Filter by Project openclaw membase wiki-search --collection-id # Filter by Project UUID openclaw membase wiki-add "" --content "<markdown>" # Add wiki doc openclaw membase wiki-add "<title>" --content "<markdown>" --project "Docs" openclaw membase wiki-update <docId> --title "<new title>" # Update wiki doc openclaw membase wiki-update <docId> --clear-project # Move to Basic openclaw membase wiki-delete <docId> # Delete wiki doc openclaw membase status # Check API connectivity ``` ## Auto-Recall Runs before every AI response (`before_agent_start` hook) when enabled. Queries Membase for relevant memories and wiki docs and injects them as context when enabled. Casual chat (greetings, acknowledgments) is skipped. The injected context respects a `maxRecallChars` budget to avoid oversized prompts. Auto-Recall is **disabled by default**. Enable it in your plugin config: ```json theme={null} { "plugins": { "entries": { "openclaw-membase": { "config": { "autoRecall": true } } } } } ``` ## Auto-Capture Runs after every AI response (`agent_end` hook). Buffers user and assistant messages per channel and flushes original transcripts to Membase Wiki. Buffers flush after **5 minutes of silence** or **20 messages**, whichever comes first. The last 2 messages are kept as overlap for continuity across batches. ## Configuration All configuration is managed through OpenClaw's plugin settings or `~/.openclaw/openclaw.json`: | Key | Type | Default | Description | | ---------------- | ------- | ----------------------------------------------- | ---------------------------------------------------------------------------------------- | | `apiUrl` | string | `https://api.membase.so` | Membase API URL. Override only if instructed by Membase support. | | `tokenFile` | string | `~/.openclaw/credentials/openclaw-membase.json` | OAuth token cache file path. Stored outside the plugin directory so it survives updates. | | `autoRecall` | boolean | `false` | Inject relevant memories before every AI turn. | | `autoWikiRecall` | boolean | `false` | Inject relevant wiki documents before every AI turn. | | `autoCapture` | boolean | `true` | Automatically store user/assistant conversation transcripts to Wiki. | | `maxRecallChars` | number | `4000` | Max characters of memory context per turn (500–16000). | | `debug` | boolean | `false` | Enable verbose debug logs. | OAuth login keeps stable plugin config in `~/.openclaw/openclaw.json` and stores rotating tokens in `tokenFile`. Legacy keys (`accessToken`, `refreshToken`) are migrated automatically when present. ### Enabling AI Tools The plugin automatically adds itself to `tools.alsoAllow` on first load. If it doesn't take effect, restart the gateway once. If you prefer to configure it manually, use `tools.alsoAllow` (not `tools.allow`) to avoid breaking your existing profile allowlist: ```json theme={null} { "tools": { "profile": "coding", "alsoAllow": ["openclaw-membase"] }, "plugins": { "entries": { "openclaw-membase": { "enabled": true, "config": { "autoRecall": false, "autoWikiRecall": false, "autoCapture": true, "maxRecallChars": 4000, "debug": false } } } } } ``` `"openclaw-membase"` in `tools.alsoAllow` expands to all tools registered by this plugin and is appended on top of the active profile. Using `tools.allow` instead can silently break your profile allowlist. Without this entry, the AI still receives memory context via auto-recall but cannot call the tools explicitly. ## Managing Plugins Use `openclaw plugins` to manage installed plugins, check status, and update versions. <Frame> <img alt="OpenClaw plugins list" /> </Frame> ### Updating the Plugin To update Membase to the latest version: ```bash theme={null} openclaw plugins update openclaw-membase ``` Restart OpenClaw after updating to apply the new version. ## How Membase Differs | | Simple vector memory | **Membase** | | -------------- | ---------------------- | --------------------------------------------------------- | | **Storage** | Flat embeddings | Hybrid: vector embeddings + knowledge graph | | **Search** | Vector similarity only | Vector + graph traversal (entities, relationships, facts) | | **Extraction** | Store raw text | AI-powered entity/relationship extraction | | **Auth** | API key | OAuth 2.0 with PKCE (no secrets to manage) | | **Ingest** | Synchronous | Asynchronous processing | ## GitHub Repository Want to inspect the plugin source, track releases, or contribute improvements? <Card title="openclaw-membase on GitHub" icon="github" href="https://github.com/aristoapp/openclaw-membase"> Browse the source code, open issues, and follow plugin updates in the standalone repository. </Card> ## Next Steps <CardGroup> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history, connect apps, and more. </Card> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Chat with Memory, agent retrieval, and dashboard exploration. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge as wiki documents that OpenClaw can search directly. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See every MCP tool your agent can call. </Card> </CardGroup> # Attached vs Universal Source: https://docs.membase.so/core-concepts/attached-vs-universal Understand why AI memory should be shared across agents, not isolated within individual tools. Learn the difference between attached and universal memory in Membase. ## Attached Memory The AI agents you use every day, ChatGPT, Claude, Gemini, Cursor, and others, each have their own form of memory. But every one of them keeps that memory **isolated**. What you told ChatGPT doesn't exist in Claude. Your Cursor project context is invisible to Gemini. Even within the same agent, switching sessions often means starting from scratch. This is **attached memory**: memory that is bound to a specific agent, session, or tool. <Frame> <img alt="Attached memory: every agent is an island" /> <img alt="Attached memory: every agent is an island" /> </Frame> This means: * **You repeat yourself constantly.** Every new session, every new agent, you re-explain the same preferences and context. * **Knowledge disappears.** When a session ends, valuable context is gone. * **Agents contradict each other.** Different agents may have conflicting or outdated understanding of your preferences. * **No cross-pollination.** A decision made in Claude never benefits your Cursor workflow. ## Universal Memory **Universal memory** is a fundamentally different approach. Instead of each agent maintaining its own isolated memory, all your agents share a **single brain** that is persistent, automatically updated, and grows with you over time. Membase takes this one step further: the universal knowledge layer has **two complementary stores**. **Memory** holds personal context (preferences, decisions, habits, meetings) as a knowledge graph. **Knowledge Wiki** holds factual, reference-style knowledge (docs, specs, stable notes) as linked markdown documents. Both stores are shared across every connected agent. ```mermaid theme={null} graph TB CH[ChatGPT] <--> M((Membase<br/>Universal Memory)) CL[Claude] <--> M GE[Gemini] <--> M C[Cursor] <--> M OC[OpenClaw] <--> M M <--> GM[Gmail] M <--> CAL[Calendar] M <--> SL[Slack] M <--> NO[Notion] M <--> OB[Obsidian] M <--> MD[Markdown] style M fill:#09090B,stroke:#27272A,color:#fff ``` All agents read from and write to both stores. External data sources feed the right store: conversations and integrations such as Gmail, Calendar, and Slack build Memory, while Notion sync, Obsidian imports, Markdown imports, and factual documents build Wiki. * **One brain, shared everywhere.** Tell one agent something, and every agent knows it. No silos, no repetition. * **Two stores, one layer.** Personal context lives in Memory, factual knowledge lives in the Wiki, and agents can search both when a task benefits from them. * **Permanent knowledge.** Context persists across sessions, days, weeks, and months. Nothing is lost when you close a tab. * **Stays current where sources sync.** Conversations, synced emails, calendar events, Slack, and live Notion sources keep context current; one-time imports such as Obsidian and Markdown bootstrap the Wiki. * **Grows with you.** The more you use your agents, the richer your knowledge graph and your wiki become. Your AI gets smarter over time, not just within a single session. ## Comparison | | **Attached Memory** | **Universal Memory** | | ----------------------- | ------------------------------------------- | ---------------------------------------- | | **Scope** | Isolated per agent | Shared across all agents | | **Persistence** | Lost between sessions | Permanent and growing | | **Context setup** | Manual, repeated in every tool | Automatic from past interactions | | **Cross-agent sharing** | None | Instant | | **External data** | Manual setup per agent, if supported at all | Connected once, shared across all agents | | **Consistency** | Agents may contradict each other | Single source of truth | | **Growth** | Resets with each session | Compounds over time | <Info> Membase doesn't replace your agents' built-in context features. It **augments** them with a shared, persistent layer that works across everything you use. </Info> ## Next Steps <CardGroup> <Card title="How Membase Works" icon="gear" href="/core-concepts/how-membase-works"> Dive into the technical architecture. </Card> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history and connect apps to build your knowledge base. </Card> </CardGroup> # How Membase Works Source: https://docs.membase.so/core-concepts/how-membase-works How context flows into Membase's two knowledge stores (Memory and Wiki), gets structured, and comes back to your agents. Membase transforms raw context into structured, retrievable knowledge that your agents can pull from across sessions. This page walks through the full lifecycle. ## Architecture Overview Membase keeps **two complementary knowledge stores**, each optimized for a different shape of information. Agents can read and write both through MCP, and Chat in Dashboard can consult both when stored context helps. <Frame> <img alt="Membase architecture diagram" /> <img alt="Membase architecture diagram" /> </Frame> | | **Memory** | **Wiki** | | ----------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **What it stores** | Personal context: preferences, decisions, habits, meetings, emails | Factual knowledge: docs, specs, references, stable notes | | **How it's structured** | Episodes and entities in a knowledge graph | Markdown documents linked with `[[wikilinks]]`, organized into Projects or Basic | | **Primary input** | Agent conversations (`add_memory`), Chat in Dashboard, chat history import, app integrations (Gmail, Calendar, Slack) | You writing documents in the dashboard, Chat in Dashboard, `add_wiki` calls from agents, Notion live sync, Notion/Obsidian/Markdown imports, supported agent transcript capture | | **Primary retrieval** | `search_memory` (semantic), Chat in Dashboard, graph and table views | `search_wiki` (hybrid: keyword + semantic), Chat in Dashboard, graph and table views | Context from either store flows through three stages: **ingest → process → retrieve**. The rest of this page walks through each stage for both stores. ## 1. Context to Membase How context enters each store. <Tabs> <Tab title="Memory"> Memory receives context from imports, agents, Chat in Dashboard, and integrations. <Steps> <Step title="Chat History Import (bootstrap)"> Already have months of conversations in ChatGPT, Claude, or Gemini? Export your chat history and upload it in [Sources](https://app.membase.so/sources) under the **Chat History** section. The entire archive goes through the same digesting pipeline as live conversations. <Frame> <img alt="Chat History Import" /> </Frame> </Step> <Step title="Live agent conversation"> You talk to your agent normally. During the conversation the agent picks up on preferences, decisions, project details, and other durable context, and calls `add_memory` via MCP. ```text Example theme={null} You: "Let's use Zustand instead of Redux for this project. Also, I prefer functional components over class components." → Agent calls add_memory with this context ``` </Step> <Step title="Chat in Dashboard"> While talking directly to your knowledge base in the dashboard, Chat can save durable personal context as memory when you share something worth keeping. </Step> <Step title="App integration sync"> Connected sources (Gmail, Google Calendar, Slack) sync new data automatically in the background. Each message, event, or email becomes an episode. </Step> <Step title="Membase receives the context"> Membase accepts the incoming context for processing so the agent or sync can keep moving. </Step> </Steps> </Tab> <Tab title="Wiki"> Wiki receives documents directly from you, Chat in Dashboard, or agent tool calls. <Steps> <Step title="Wiki import (bootstrap)"> Already have a markdown knowledge base? Use **Wiki > Add > Import files** to import Notion exports, Obsidian vaults, or Markdown files into a target Project or Basic. `[[wikilinks]]` are preserved where available, and documents upload through the background import flow. See [Importing Documents](/features/wiki#importing-documents). </Step> <Step title="Write a document in the dashboard"> Open the Wiki tab, click **Add > Write document**, choose a Project or Basic, and write in markdown. Manual save and unsaved-changes warnings keep your content safe. </Step> <Step title="Notion live sync"> Connect Notion from Sources, choose the Notion pages available to Membase, then choose a target Wiki Project. Synced pages become source-backed Wiki documents. See [App Integrations](/connectors/apps#notion-live-sync). </Step> <Step title="Agent calls add_wiki"> Your connected agent can call `add_wiki` when you share factual, reference-style knowledge worth keeping. Example: "Write up our deployment rollback checklist" results in a new wiki document instead of a memory. </Step> <Step title="Supported plugin captures transcript"> Supported agent plugins can preserve user/assistant conversation transcripts as original source material in Wiki, separate from extracted personal Memory. </Step> <Step title="Chat creates a document"> Chat in Dashboard can also create wiki documents when you ask it to save factual, reference-style material. </Step> <Step title="Membase receives the document"> The Wiki document is saved directly or prepared for background processing, depending on whether it came from a direct write, sync, or import. </Step> </Steps> </Tab> </Tabs> ## 2. Digesting and Structure How raw input becomes structured, searchable knowledge. <Tabs> <Tab title="Memory"> Every memory (from agents or integrations) goes through the same pipeline. <Steps> <Step title="Episode creation"> The raw input is saved as an **episode**, a snapshot of a conversation or data event. Episodes are the building blocks of memory. </Step> <Step title="Entity extraction"> Membase identifies key entities from the episode: people, projects, tools, preferences, decisions, dates, and other meaningful concepts. ```text Example entities from a conversation theme={null} "Let's use Zustand instead of Redux" → Entities: Zustand, Redux, state management decision ``` </Step> <Step title="Graph construction"> Extracted entities are added to your knowledge graph. New entities connect to existing ones when they overlap, so "Zustand" mentioned in two different conversations becomes one entity with two linked episodes. </Step> <Step title="Deduplication and merging"> If the same fact appears in multiple episodes, Membase merges them. When new information contradicts an existing memory, the latest data takes priority. </Step> </Steps> The result is a continuously growing knowledge graph where entities, relationships, and episodes are all interconnected. <Frame> <img alt="Membase knowledge graph" /> <img alt="Membase knowledge graph" /> </Frame> </Tab> <Tab title="Wiki"> Wiki documents are stored as markdown plus structural metadata for fast retrieval. <Steps> <Step title="Document storage"> The document's title and markdown content are saved to the Wiki store, filed into a Project or Basic. </Step> <Step title="Wikilink parsing"> Membase parses `[[wikilinks]]` in the content and maintains a bidirectional link graph. This is what powers backlinks, the force-directed graph view, and instant `[[` autocomplete in the editor. </Step> <Step title="Search indexing"> Each document is indexed for **hybrid search**: a full-text index (BM25-style) for keyword queries and a semantic embedding for meaning-based queries. Both are fused with Reciprocal Rank Fusion (RRF) at query time. </Step> <Step title="Source provenance and review"> Imported and synced documents keep source provenance when available. When a source update or generated change needs review, Membase can route it through Inbox Review so you can inspect, edit, accept, reject, or undo the change. </Step> </Steps> </Tab> </Tabs> ## 3. Membase to Your Agent How context flows back when an agent or Chat needs it. <Tabs> <Tab title="Memory"> <Steps> <Step title="Agent calls search_memory"> The agent sends a query describing what personal context it needs. This happens automatically when prior context would improve the response. ```text Example theme={null} You: "Set up a new component for the settings page." → Agent calls search_memory: "project tech stack, component preferences" ``` </Step> <Step title="Membase searches the knowledge graph"> The query is matched against your graph using semantic search. Relevant episodes and their connected entities are retrieved. Relevant results might include: * "Uses Next.js with TypeScript" * "Prefers functional components" * "State management: Zustand" * "Styling: Tailwind CSS" </Step> <Step title="Ranked results returned"> Results are scored by relevance and returned as episode-centric bundles. Only the most useful context is included, keeping the agent's context window clean. </Step> <Step title="Agent responds with full context"> The agent generates a response grounded in your actual preferences and project details, without you having to repeat any of it. </Step> </Steps> Here's a real example: Claude retrieving a git workflow from Membase during a conversation. <Frame> <video> <source type="video/mp4" /> </video> </Frame> </Tab> <Tab title="Wiki"> <Steps> <Step title="Agent calls search_wiki"> The agent sends a query describing what factual knowledge it needs. ```text Example theme={null} You: "Remind me how our auth middleware handles expired tokens." → Agent calls search_wiki: "auth middleware expired token" ``` </Step> <Step title="Membase runs hybrid search"> The query is matched with both full-text keyword search and semantic similarity. The two rankings are fused with Reciprocal Rank Fusion, so you get solid results whether the query is literal or conceptual. </Step> <Step title="Full document bodies returned"> Unlike memory episodes, wiki results include the **full document body**, so the agent has enough context to answer directly instead of juggling fragments. </Step> <Step title="Agent responds with full context"> The agent grounds its answer in the retrieved documents and cites them if your prompt encourages citations. </Step> </Steps> </Tab> </Tabs> <Tip> Chat in Dashboard can use both `search_memory` and `search_wiki` when stored context could help, then combine the results into a single answer with citations. Your agents should do the same when the user's question could benefit from either store. </Tip> This entire cycle (ingest → structure → retrieve) runs continuously as you use Membase. The more you interact, the richer both stores become, and the smarter your agents get. ## Next Steps <CardGroup> <Card title="Attached vs Universal" icon="share-nodes" href="/core-concepts/attached-vs-universal"> Understand why shared memory matters. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> Learn about the MCP tools available to your agents. </Card> <Card title="Memory" icon="brain" href="/features/memory"> Dive into memory exploration and management. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Dive into Wiki documents, Projects, imports, and Inbox Review. </Card> </CardGroup> # Chat in Dashboard Source: https://docs.membase.so/features/chat Talk directly to your Membase knowledge base without going through an external agent. Chat with Memory answers questions using your stored memories and wiki documents, with citations and a linked graph panel. **Chat in Dashboard** (also known as "Chat with Memory") lets you talk to your Membase knowledge base directly from the dashboard, without having to open an external agent. Ask about a decision you made last month, a conversation from last week, or a pattern across everything you've worked on, and Chat can ground the answer in your own memories and wiki documents when stored context is relevant. <Frame> <img alt="Chat with Memory interface" /> </Frame> ## What Chat Pulls From When stored context is relevant, Chat can pull from both knowledge stores: * **Memory**: Personal context captured through your agents, Chat in Dashboard, and integrations (preferences, decisions, meetings, emails, and so on). * **Wiki**: Factual knowledge you or your agents stored as wiki documents. Chat uses a focused set of tools under the hood: `search_memory`, `add_memory`, `search_wiki`, and `add_wiki`. The underlying model decides which search tools to call based on your question and weaves the results into a single grounded answer. Chat can also write back to Membase: it can save durable personal context as memory, or create wiki documents when you ask it to save factual reference material. <Note> Dashboard Chat is not the full Wiki CRUD surface. It can create Wiki documents with `add_wiki`, but editing or deleting existing Wiki documents happens in the Wiki dashboard or through connected agents that expose MCP tools such as `update_wiki` and `delete_wiki`. </Note> ## Highlights * **Context-grounded responses**: Answers are grounded in your actual memories and wiki documents when stored context is relevant * **Citations**: Responses that use stored context link back to the exact memories and wiki documents they drew from, so you can verify and explore further * **Graph panel**: See how referenced memories and documents connect to each other * **Session history**: Past conversations are saved in the sidebar so you can pick up where you left off * **Write back to Memory and Wiki**: Chat can save durable personal context as memory and create wiki documents for stable reference material * **Model picker**: Switch between Standard and Advanced models from the model dropdown in the composer <Note> Free plans include 40 dashboard chats per month, and Pro includes 200. Advanced models cost **2x usage** per message compared to Standard models. You will see a `(2x)` suffix next to Advanced model names in the picker. </Note> <Tip> Chat in Dashboard is useful for exploring your own knowledge base, verifying what your agents know about you, and quickly looking up past decisions or reference material without switching to an external agent. </Tip> ## When to Use Chat vs an Agent | You want to... | Use | | ------------------------------------------------------- | --------------------------------------------------- | | Recall a decision, preference, or past conversation | **Chat in Dashboard** | | Look up factual knowledge you stored in the wiki | **Chat in Dashboard** | | Verify what an agent knows about you | **Chat in Dashboard** | | Save durable personal context or a wiki document | **Chat in Dashboard** | | Do real work (code, draft, plan) with memory-aware help | **Connected agent** (Cursor, Claude, ChatGPT, etc.) | | Save context while working inside another tool | **Connected agent** | ## Next Steps <CardGroup> <Card title="Memory" icon="brain" href="/features/memory"> Explore and manage the memories Chat can use. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Explore and manage the wiki documents Chat can use. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See the broader MCP tool set available to connected agents. </Card> <Card title="Connect Agents" icon="robot" href="/connectors/agents/cursor"> Use Membase through external agents like Cursor or Claude. </Card> </CardGroup> # Membase MCP Source: https://docs.membase.so/features/membase-mcp Explore the MCP tools, resources, and prompts that power Membase agent integration. Learn how agents store, search, and retrieve Memory and Wiki context through the Model Context Protocol. Membase connects to AI agents via the **Model Context Protocol (MCP)**, providing a standard way for agents to store, search, and retrieve Memory and Wiki context. ## At a Glance | Type | Name | What it does | Who uses it | | ------------ | ------------------- | -------------------------------------------- | -------------------------------------------------------------------- | | **Tool** | `add_memory` | Save personal context to long-term memory | Agent calls automatically when it learns something worth remembering | | **Tool** | `search_memory` | Search past memories by meaning | Agent calls when past context would help its response | | **Tool** | `get_current_date` | Get current date and time in a timezone | Agent calls before date-filtered memory search | | **Tool** | `add_wiki` | Add a factual knowledge document to the wiki | Agent calls when user shares stable, reference-style knowledge | | **Tool** | `search_wiki` | Hybrid search across wiki documents | Agent calls when factual knowledge would improve its response | | **Tool** | `update_wiki` | Edit an existing wiki document | Agent calls to keep a document current | | **Tool** | `delete_wiki` | Permanently remove a wiki document | Agent calls with user confirmation | | **Resource** | `membase://profile` | Read-only user settings profile | Agent reads when stable profile context matters | | **Resource** | `membase://recent` | Read-only recent memory timeline | Agent reads for latest updates and recency checks | | **Prompt** | `start` | Guidance for memory workflow and safety | Agent can load at session start | You don't need to call any of these yourself. Your agent handles everything automatically based on the conversation. ## Memory vs Wiki Membase exposes two complementary stores through MCP: * **Memory** (`add_memory`, `search_memory`): Personal context that describes the user: preferences, decisions, habits, ongoing projects. * **Wiki** (`add_wiki`, `search_wiki`, `update_wiki`, `delete_wiki`): Factual knowledge that the user wants to keep as reference material: docs, specs, notes, and anything else that is stable and addressable by title. For user questions, agents should generally call **both** `search_memory` and `search_wiki`, then combine the results. See the [Knowledge Wiki guide](/features/wiki) for details. ## MCP Server Membase runs a remote MCP server accessible at: ``` https://mcp.membase.so/mcp ``` | Property | Value | | ------------------ | --------------------- | | **Transport** | Streamable HTTP | | **Authentication** | OAuth (browser-based) | | **Package** | `membase` (npm) | For MCP setups, the `npx -y membase@latest --client <client>` CLI command handles registration and auth automatically for supported clients. See the [Agents guide](/connectors/agents/cursor) for per-client setup. <Note> Claude Code users should start with the [Membase Claude Code plugin](/connectors/agents/claude-code). The plugin exposes the same Membase memory and wiki tools directly inside Claude Code, plus slash commands, hooks, and project-aware workflows. The remote MCP server remains available for other clients and as a Claude Code fallback. </Note> ## Tools Membase exposes tools that agents can call during conversations. They split into two groups: memory tools for personal context and wiki tools for factual knowledge. ### Memory Tools <AccordionGroup> <Accordion title="add_memory" icon="plus"> Stores long-term memory that persists across sessions. Agents use this **proactively** when the user shares durable context worth remembering: preferences, recurring habits, ongoing projects, goals, constraints, etc. Transient one-off information is skipped unless the user explicitly asks to save it. | Parameter | Type | Required | Description | | ---------- | ------------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `content` | string (max 50,000 chars) | Yes | The memory content to store | | `project` | string (max 60 chars) | No | Project or category slug to file this memory under. Agents should only set this when the user **explicitly** mentions a project name, tag, label, or category (e.g. "save this under project X", "tag this as Y"). Do not guess or infer. See [Projects](#projects). | | `metadata` | object | No | Leave empty for normal agent usage. | </Accordion> <Accordion title="search_memory" icon="magnifying-glass"> Searches stored memories by **semantic similarity**. Agents use this when the user asks to recall something from a previous session, or proactively when past context would improve their response. Results are returned as episode-centric bundles with related context. | Parameter | Type | Required | Description | | ----------- | ------------------------ | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `query` | string (max 1,000 chars) | Yes | Natural-language search query. Use empty string to fetch recent memories. | | `limit` | integer (1-30) | No | Max results to return (default: 20) | | `offset` | integer | No | Pagination offset (default: 0) | | `date_from` | ISO date/datetime string | No | Inclusive lower bound for date filtering | | `date_to` | ISO date/datetime string | No | Inclusive upper bound for date filtering | | `timezone` | IANA timezone string | No | Date-only parsing timezone, for example `America/Los_Angeles` | | `sources` | array of strings | No | Filter by source. Supports integrations (Slack, Gmail, Google Calendar), AI clients (Cursor, Claude, Claude Code, VS Code, ChatGPT, Codex, Gemini CLI, OpenCode, Poke, OpenClaw, Hermes), imports (ChatGPT, Claude, Gemini), and dashboard-created memories. If omitted, all sources are searched. | | `project` | string (max 60 chars) | No | Restrict search to a single project slug (exact match). Use only when the user explicitly asks for a project or category scope. See [Projects](#projects). | Results can include a **relevance score** (0–1) when available, indicating how closely each match fits the query. </Accordion> <Accordion title="get_current_date" icon="calendar"> Returns the current date and time in the user's Membase timezone (and UTC). Agents call this before `search_memory` to resolve relative phrases like "today", "yesterday", "this week", or "next weekend" into ISO 8601 `date_from`/`date_to` values. This tool takes no input parameters. The response contains four fields: | Field | Description | | ------------ | ------------------------------------------------------------------------- | | `now_utc` | Current UTC timestamp in ISO 8601 (e.g., `2025-01-15T02:30:00.000Z`) | | `timezone` | The effective IANA timezone used (from the user's saved Membase timezone) | | `local_date` | Local date in that timezone (e.g., `2025-01-15`) | | `local_time` | Local time in that timezone (e.g., `11:30:00`) | </Accordion> </AccordionGroup> #### Projects Memories can be grouped into **projects** (lightweight category/tag slugs). Both `add_memory` and `search_memory` accept an optional `project` field. * **User-driven, not inferred**: Agents should set `project` on `add_memory` **only** when the user explicitly mentions a project, tag, label, or category (for example, "save this under `acme-rewrite`", "tag this as `personal`"). Agents must not guess or invent a project. * **Known projects hint**: The Membase MCP server injects the current user's existing project slugs into each tool's description, so agents can reuse existing slugs instead of creating new ones for the same concept. * **Filtered search**: Pass `project: "acme-rewrite"` to `search_memory` to restrict results to that project. Exact slug match only. * **Managed in the dashboard**: Users can move memories between projects and filter by project from the **Memories** tab. See the [Memory guide](/features/memory#projects). <Tip> Users who want hands-off project tagging can drop a line in their profile instructions such as "When I mention `acme` or `side-project`, tag those memories under the corresponding project." The agent will then apply the tag automatically during matching conversations. </Tip> ### Wiki Tools <AccordionGroup> <Accordion title="add_wiki" icon="file-plus"> Creates a new document in the user's knowledge wiki. Agents use this for **factual, reference-style knowledge** (documentation, specs, stable notes). Personal preferences and habits should go through `add_memory` instead. | Parameter | Type | Required | Description | | --------- | -------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `title` | string (1-500 chars) | Yes | Title of the wiki document | | `content` | string (max 100,000 chars) | Yes | Complete markdown content. Preserve reports, discussions, analyses, tables, examples, and decisions unless the user explicitly asks to save a summary. | | `project` | string (max 200 chars) | No | Project name to file this document under. New Projects are created on first use. Leave empty when the user does not name a Project; Membase routes safely or falls back to Basic. | Document creation respects the user's [plan quota](/features/wiki#document-quotas). If the limit is reached the call returns a quota error. When the tool succeeds, agents should tell the user the returned destination when present, such as `Saved to Project: Docs` or `Saved to Basic`. </Accordion> <Accordion title="search_wiki" icon="magnifying-glass"> Searches the user's wiki using **hybrid search**: a full-text keyword index (BM25-style) and semantic similarity, fused with Reciprocal Rank Fusion (RRF). Results include each document's full body so the agent has enough context to answer immediately. | Parameter | Type | Required | Description | | ------------ | ------------------------ | -------- | ----------------------------------------------------------------------------------------------------- | | `query` | string (max 1,000 chars) | Yes | Natural-language or keyword search query. Use empty string `""` to fetch recent wiki documents. | | `limit` | integer (1-20) | No | Max results to return (default: 10) | | `project` | string (max 200 chars) | No | Restrict results to a specific Wiki Project by name. If omitted, all Projects and Basic are searched. | | `collection` | string (max 200 chars) | No | Legacy alias for `project`. Prefer `project` for new clients. | </Accordion> <Accordion title="update_wiki" icon="pen-to-square"> Edits an existing wiki document. Use `search_wiki` first to resolve the document ID. | Parameter | Type | Required | Description | | ------------ | -------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------- | | `doc_id` | UUID | Yes | ID of the document to update | | `title` | string (1-500 chars) | No | New title | | `content` | string (max 100,000 chars) | No | Complete replacement markdown content. Preserve the full updated artifact unless the user explicitly asked for summarization. | | `project` | string or `null` (max 200 chars) | No | Move the document to a Project by name. New Projects are created on first use. Set `project` to `null` to move it to Basic. | | `collection` | string or `null` (max 200 chars) | No | Legacy alias for `project`. Prefer `project` for new clients. Set to `null` to move to Basic. | When the result includes a destination such as `Moved to Project: Docs`, `Moved to Basic`, or `Current destination: Basic`, agents should report it to the user. </Accordion> <Accordion title="delete_wiki" icon="trash"> Permanently deletes a wiki document. This action cannot be undone; agents should ask for user confirmation before calling it. | Parameter | Type | Required | Description | | --------- | ---- | -------- | ---------------------------- | | `doc_id` | UUID | Yes | ID of the document to delete | </Accordion> </AccordionGroup> ## Resources MCP resources provide **read-only data** that agents can pull into their context: | Resource | URI | Description | | ------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------- | | **User Profile** | `membase://profile` | Read-only MCP resource that mirrors **Settings > Profile** (`display_name`, `role`, `interests`, `instructions`, `timezone`) | | **Recent Memories** | `membase://recent` | Top 10 recent memories, ordered by event time when available and capture time otherwise | <Frame> <img alt="Membase MCP resources in Claude" /> </Frame> ## Prompts MCP prompts inject pre-built instructions and context into the agent's system prompt: | Prompt | Description | | --------- | --------------------------------------------------------------------------------------------------------------------- | | **start** | Teaches the agent when to use `search_memory`, when to use resources, when to save memory, and what to avoid storing. | The `start` prompt can be used at session start to provide: 1. **Workflow guidance** for memory retrieval and memory write behavior 2. **Safety guidance** for secrets and transient information 3. **Resource usage guidance** for profile versus recent timeline reads ## Recommended Agent Behavior Use these patterns for best results: 1. For questions about saved knowledge, past conversations, documents, decisions, or user-specific context, search Memory and Wiki together when both could matter. Use Memory for personal context and Wiki for factual/reference knowledge. 2. For stable user settings, agents can read the MCP resource `membase://profile`. It mirrors the dashboard Profile settings: display name, role, interests, custom instructions, and timezone. 3. For latest memory context or recent-memory timeline questions, agents can read `membase://recent`. This is a Memory timeline, not a Wiki or integration changelog. 4. For date-filtered memory searches, call `get_current_date` when needed, then pass explicit ISO date filters to `search_memory`. 5. Save durable user context with `add_memory`; skip secrets and one-off transient data unless explicitly requested. 6. Save factual, reference-style knowledge with `add_wiki`. Preserve the full artifact unless the user explicitly asks for a summary. If the user names a Project, pass it in `project`; otherwise leave it empty and report the returned destination. ## Connection Setup For detailed setup instructions for each agent, see the [Agents guide](/connectors/agents/cursor). <CardGroup> <Card title="Cursor" icon="code" href="/connectors/agents/cursor"> One-click install </Card> <Card title="Claude Code" icon="terminal" href="/connectors/agents/claude-code"> Plugin recommended </Card> <Card title="Claude" icon="robot" href="/connectors/agents/claude-desktop"> Custom connector </Card> <Card title="ChatGPT" icon="message" href="/connectors/agents/chatgpt"> Manual config </Card> </CardGroup> ## Next Steps <CardGroup> <Card title="Memory" icon="brain" href="/features/memory"> Explore and manage memories. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Deep dive on Wiki documents, Projects, imports, and search. </Card> <Card title="Chat in Dashboard" icon="comments" href="/features/chat"> Talk to your knowledge base without an external agent. </Card> </CardGroup> # Memory Source: https://docs.membase.so/features/memory Explore and manage memories in Membase. Browse the knowledge graph and table view, filter by source and project, and understand how memories are created, updated, and deleted. **Memory** is where Membase stores personal context: preferences, decisions, habits, ongoing projects, meetings, emails, and other episodic information captured from your agents, Chat in Dashboard, and integrations. This page covers how to explore memories in the dashboard and how they are created, updated, and deleted. <Tip> Looking for factual knowledge (docs, specs, stable notes)? That lives in the [Knowledge Wiki](/features/wiki). Memory and Wiki are two separate stores, and agents can search both. </Tip> ## Exploring Memory The [Memories](https://app.membase.so/memories) tab offers two views for browsing your knowledge. | View | What you see | Interactions | | -------------- | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Graph View** | Entities as nodes, relationships as edges | Click an entity to open a detail panel with the episodes that mention it. Click an episode in the panel to jump to Table View. | | **Table View** | Episodes (memories) with source, project, and time | Click an episode to open a detail panel with the episode content. Filter by source, project, or time. Select rows to move them to a project or delete them. | ### Graph View The graph view visualizes your knowledge as an interactive network of **entities** (people, concepts, tools, projects) and the relationships between them. <Frame> <video> <source type="video/mp4" /> </video> <video> <source type="video/mp4" /> </video> </Frame> * **Entity-centric visualization**: Each node represents an entity extracted from your memories * **Interactive navigation**: Click, drag, zoom, and use the zoom controls to explore the graph * **Search**: Search for an entity name to dim unrelated nodes in the graph * **Side panel**: Click any entity to open a detail panel with **Related Episodes**, the memories that mention this entity. Click an episode to switch to Table View focused on it. ### Table View The table view lists all your **episodes** (memories) in a structured, searchable format with source and project attribution. <Frame> <video> <source type="video/mp4" /> </video> <video> <source type="video/mp4" /> </video> </Frame> * **Episode list**: Browse all memories with content previews, source tags, and project labels * **Sorting**: Sort by date or source * **Source filtering**: Filter memories by source (Cursor, Claude, Gmail, Slack, etc.) * **Project filtering**: Filter memories by project slug (see [Projects](#projects)) * **Time range filtering**: Preset ranges (Today, This Week, This Month, This Year, All Time) or a custom date range * **Search**: Text filter over the currently loaded memories (client-side substring match; not semantic) * **Pagination**: Choose 10, 20, or 50 rows per page * **Bulk actions**: Select multiple rows to move them to a project or delete them. * **Side panel**: Click any episode to open a detail panel with the full memory content and the option to change its project. ## Creating Memories Memories enter Membase through agents, Chat in Dashboard, and integrations. Creating memories directly from the Memories tab is not supported yet; use a connected agent or Chat when you want Membase to save new personal context. <CardGroup> <Card title="Agent Conversations" icon="robot"> Your connected agent calls the `add_memory` MCP tool during conversations to save relevant context: preferences, decisions, project details, meetings, and more. </Card> <Card title="Chat in Dashboard" icon="comments"> Chat can also call `add_memory` when you share durable personal context inside the dashboard. </Card> <Card title="Integrations" icon="plug"> Connected data sources like Gmail, Google Calendar, and Slack automatically sync new data into Membase as memories. </Card> </CardGroup> <Info> Manual memory creation from the Memories tab is not available yet. New memories originate from agent interactions, Chat in Dashboard, or integrations. </Info> ## Updating Memories Memories are updated through your agents, not directly edited from the dashboard. When existing context becomes outdated, your agent calls `add_memory` to register the updated information and flags the old memory as outdated. For example, if you switch from Redux to Zustand, the agent saves "uses Zustand" as a new memory and marks the old "uses Redux" memory as no longer valid so it no longer surfaces in future searches. Behind the scenes, Membase also handles updates automatically during digesting: * **Deduplication**: Similar memories from different sources are merged to avoid redundancy. * **Conflict resolution**: When new information contradicts an existing memory, the latest data takes priority. * **Relationship updates**: New connections between entities are added to the knowledge graph as they are discovered. ## Projects Projects are lightweight category tags for memories (slugs up to 60 characters). They let you scope agent searches and browse memories by topic without juggling sources. <Frame> <img alt="Inline project picker on the Memories table" /> </Frame> ### How projects get attached * **Explicit user request**: Agents set the `project` field on `add_memory` only when you explicitly mention a project, tag, label, or category during the conversation (for example, "save this under `acme-rewrite`" or "file this under `personal`"). Agents do not guess or infer a project. * **Profile instructions**: If you want certain projects to be applied automatically, add a rule in your profile instructions (for example, "When I mention `acme`, tag the memory under the `acme` project"). The agent will follow this during matching conversations. * **Dashboard assignment**: Assign or move memory projects directly from the Memories table. Click the project cell on one row, or select multiple rows and use **Move to project** to update them together. ### Filtering and scoped search * **Dashboard filter**: Filter the Memories table by project slug from the toolbar. * **Agent search**: Agents pass `project: "acme"` to `search_memory` when you explicitly ask for a project-scoped recall (for example, "what have I decided on the `acme` project?"). See [Membase MCP: Projects](/features/membase-mcp#projects). * **Known projects sync**: Your current project list is available to connected agents so they can reuse existing slugs instead of creating duplicates. <Tip> Projects are intentionally flat and slug-based. Use short, consistent identifiers (`acme`, `side-project`, `personal`) rather than long descriptive names. </Tip> ## Deleting Memories ### Delete a single memory Delete individual memories from the **Table View**. 1. Switch to Table View. 2. Click the **Delete** icon next to the memory you want to remove. 3. Click **Delete** and confirm. <Frame> <img alt="Delete memory confirmation dialog" /> <img alt="Delete memory confirmation dialog" /> </Frame> ### Delete multiple memories Bulk-delete selected memories from the Table View. 1. Switch to Table View. 2. Tick the checkboxes on the rows you want to remove (or use the header checkbox to select all rows on the page). 3. Click **Delete All** in the bulk-actions bar that appears at the bottom of the table. 4. Confirm in the dialog, which shows how many memories will be removed. <Frame> <img alt="Bulk-delete action on the Memories table" /> </Frame> ### Delete all memories from a source To remove all memories from a specific integration (for example, all Slack memories), go to the **Sources** page in the dashboard and click **Delete memories** on that integration. You will be asked to confirm before deletion. <Note> Disconnecting an integration by itself keeps your existing memories. Use the **Delete memories** action on the Sources page when you want to remove them, which is a separate step from disconnect. </Note> <Warning> Deleted memories cannot be recovered. Make sure you want to permanently remove a memory before deleting. </Warning> ## Next Steps <CardGroup> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge alongside your memories. </Card> <Card title="Chat in Dashboard" icon="comments" href="/features/chat"> Ask questions and get answers grounded in your memories. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See the MCP tools agents use to read and write memory. </Card> <Card title="Connect Apps" icon="plug" href="/connectors/apps"> Enrich memory with Gmail, Calendar, Slack, and more. </Card> </CardGroup> # Knowledge Wiki Source: https://docs.membase.so/features/wiki Store factual knowledge in Membase alongside your memories. Create Wiki documents with markdown and [[wikilinks]], organize them into Projects, import Notion/Obsidian/Markdown sources, and let agents retrieve knowledge through MCP. The **Knowledge Wiki** is your durable knowledge base inside Membase. While Memory captures personal context such as preferences, decisions, and habits, Wiki stores stable reference material: documentation, specs, meeting notes, research, runbooks, source-backed transcripts, and anything else you want to retrieve by title. ## Memory vs Wiki Membase keeps two complementary knowledge stores. Agents can search both, but each is optimized for a different kind of context. | | Memory | Wiki | | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | **What it stores** | Personal context: preferences, decisions, habits, ongoing projects | Factual knowledge: docs, references, specs, stable notes, source transcripts | | **How you capture it** | Agents call `add_memory`, Chat in Dashboard can save durable context, and integrations like Gmail, Calendar, and Slack sync in the background | You write documents, import Notion/Obsidian/Markdown files, live-sync Notion pages, ask Chat to save reference material, or your agent calls `add_wiki` | | **How you retrieve it** | `search_memory`, Chat in Dashboard, graph and table views | `search_wiki`, Chat in Dashboard, Wiki search, graph, and table views | | **Structure** | Episodes and entities in a knowledge graph | Markdown documents linked with `[[wikilinks]]`, filed into Projects or Basic | <Tip> For user questions, agents should usually call both `search_memory` and `search_wiki`: memory for personal context, Wiki for factual knowledge. </Tip> ## Projects Projects are the main way to organize Wiki documents. They keep related docs together, make the Wiki graph easier to scan, and give agents a user-facing filing destination for `add_wiki`, `search_wiki`, and `update_wiki`. The Wiki root opens a Project overview. Each Project card shows its name, description, icon, color, document count, and recent activity, so you can scan the shape of your knowledge base before opening a specific Project. <Frame> <img alt="Wiki Project overview showing Projects and Basic" /> <img alt="Wiki Project overview showing Projects and Basic in dark mode" /> </Frame> When Membase cannot confidently place a document into a Project, it can land in Basic so you can organize it later. Basic is the fallback for documents that have not been assigned to a Project yet. From the Wiki page, you can: * Open the Project overview, search across Projects, and filter by name, description, or document title * Create, rename, reorder, and delete Projects * Edit a Project name, description, icon, and color * Add or import documents into a Project * Move documents between Projects or back to Basic * Scope the document list, graph, and search to a Project ## Documents Wiki documents are markdown files with source awareness and bidirectional links. * **Markdown editor**: Headings, lists, tables, code blocks, and other standard markdown formatting * **`[[Wikilinks]]`**: Type `[[` in the editor to get suggestions from existing document titles * **Linked Mentions**: See documents that reference the current document, with snippets around each mention * **Manual save**: Save from the editor when you are ready * **Unsaved changes warning**: Membase warns before discarding pending edits * **Source provenance**: Imported and synced documents show where they came from when source data is available <Note> Inline image attachments in Wiki documents are not supported yet. External image URLs in markdown can render, but there is no uploader inside the editor today. </Note> ## Inbox Review Wiki can suggest and route changes through **Inbox Review** when an automated update needs your attention. Review items can come from source changes, merge suggestions, larger rewrites, or conflict resolution work. <Frame> <img alt="Self-improving Wiki Inbox Review" /> <img alt="Self-improving Wiki Inbox Review in dark mode" /> </Frame> In Inbox Review, you can: * Inspect the current and proposed content * Accept the proposed change * Edit the proposed title, content, or metadata before accepting * Reject a proposal * Undo supported applied or auto-applied changes The **Updates** tab in Inbox shows recent Wiki activity so you can tell what changed without hunting through individual documents. ## Graph View The Wiki graph visualizes documents as a network. Each node is a document, each edge is a `[[wikilink]]` or derived connection, and Project styling helps related knowledge stand out. * **Force layout**: Drag nodes, zoom, and follow relationships * **Project styling**: Project colors make clusters easier to scan * **Project scope**: View all Wiki documents or one Project at a time * **Click a node**: Open the document from the graph ## Table View The table view is a structured list of documents with sorting, filtering, and bulk actions. * **Sort** by title, Project, updated date, or created date * **Filter** by Project or search query * **Pagination** for large knowledge bases * **Bulk actions**: Move selected documents to a Project or delete them ## Importing Documents Use **Wiki > Add > Import files** to import documents from a file or archive. Supported import formats: | Format | Accepted files | Notes | | ------------ | -------------------------------------- | ----------------------------------------------------------------------------------------------------- | | **Notion** | Notion `.zip` export or Markdown files | One-time import. Use [Notion live sync](/connectors/apps#notion-live-sync) for source-backed updates. | | **Obsidian** | Vault `.zip` or Markdown files | Preserves `[[wikilinks]]` and imports notes into the target Project or Basic. | | **Markdown** | `.md`, `.markdown`, or Markdown ZIPs | Use for generic markdown knowledge bases. | Imports run in the background. The dialog shows upload and processing progress, then reports documents created, documents skipped, update candidates, backlinks created, and errors. ### Target Project When importing files, choose a target Project or Basic. Archive and multi-file imports keep source path information where available, but imported documents start in the destination you choose and can be moved later. See [App Integrations](/connectors/apps) for Notion live sync, Obsidian vault imports, and generic Markdown imports. ## Search Wiki search uses hybrid retrieval: keyword matching plus semantic similarity. This lets you search with exact phrases such as `"OAuth PKCE"` or conceptual queries such as `"how do we authenticate users"`. Search is available in three places: * **Chat in Dashboard**: Chat can pull from Memory and Wiki when stored context is relevant * **Wiki page**: Search filters documents in the current Wiki scope * **Agents via MCP**: Connected agents call `search_wiki` during conversations ### Scoping Search to a Project You can restrict search to one Project: * **Dashboard**: Click a Project in the Wiki navigation to scope the list, graph, and search * **MCP**: Pass `project` to `search_wiki`. Existing Projects are surfaced to agents so they can reuse names. `collection` remains a legacy alias for older clients. ## Managing Wiki Documents Unlike memories, Wiki documents are fully editable from both the dashboard and connected agents. ### Create * **Dashboard**: Click **Add > Write document**, choose a Project or Basic, and write in markdown * **Import**: Use **Add > Import files** for Notion exports, Obsidian vaults, or Markdown files * **Notion live sync**: Connect Notion from Sources and choose a target Project * **Agent**: Ask your connected agent to save a factual artifact; it can call `add_wiki` ### Edit * **Dashboard**: Open any document and edit it inline * **Agent**: Your agent can call `update_wiki` with a document ID to change title, content, or Project * **Inbox Review**: Source-backed or generated proposals can be edited before accepting ### Delete * **Dashboard**: Delete one document from its document view, or bulk-delete selected rows from the table * **Sources**: Remove Notion live-synced documents or imported Obsidian/Markdown documents from the source card * **Agent**: Your agent can call `delete_wiki` with a document ID. Agents should ask for confirmation before deleting. <Warning> Deleted Wiki documents cannot be recovered. Make sure you want to permanently remove a document before deleting. </Warning> ## MCP Tools Your connected agents can read and write Wiki documents using these MCP tools. See the [Membase MCP reference](/features/membase-mcp) for full parameters. | Tool | What it does | | ------------- | -------------------------------------------------------------------------------------------------- | | `add_wiki` | Create a complete Wiki document with title, markdown content, and optional Project filing location | | `search_wiki` | Search Wiki documents and optionally scope results to a Project | | `update_wiki` | Edit an existing document's title, content, or Project | | `delete_wiki` | Permanently remove a document | <Tip> Tell your agent that `add_wiki` is for factual knowledge and `add_memory` is for personal context. Most agents pick this up from the tool descriptions automatically, but repeating it in your system prompt can help. </Tip> ## Document Quotas Wiki documents are counted against your plan. | Plan | Wiki documents | | -------- | -------------- | | **Free** | 200 | | **Pro** | 2,000 | The current usage is shown on the **Billing** tab and at the top of the Wiki page. When you reach the limit, creating, syncing, or importing new documents returns a quota error until you delete existing documents or upgrade your plan. ## Next Steps <CardGroup> <Card title="Memory" icon="brain" href="/features/memory"> Personal context that complements the Wiki. </Card> <Card title="Chat in Dashboard" icon="comments" href="/features/chat"> Ask questions across both Memory and Wiki. </Card> <Card title="Membase MCP" icon="link" href="/features/membase-mcp"> See full parameters for the Wiki MCP tools. </Card> <Card title="Connect Apps" icon="plug" href="/connectors/apps"> Bring more sources into your knowledge base. </Card> </CardGroup> # Bring Your Context Into Membase Source: https://docs.membase.so/getting-started/bring-context Main ways to feed context into Membase: chat history import, agent conversations, Chat in Dashboard, app integrations, Notion sync, and Wiki imports. Membase gets smarter the more context it has. The main ways to bring your context in are: import past conversations, let your agents capture context as you work, save context from Chat in Dashboard, connect external apps, live-sync Notion pages, and import an existing knowledge base into Wiki. ## Chat History Import The fastest way to bootstrap your knowledge base. If you've been using ChatGPT, Claude, or Gemini, you already have months of context in those tools. Chat History Import brings it all into Membase at once. <Frame> <img alt="Chat History Import" /> </Frame> <Steps> <Step title="Export from your LLM client"> Download your conversation history using each platform's export feature (ChatGPT Settings > Data controls > Export data, etc.). </Step> <Step title="Upload to Membase"> Open [Sources](https://app.membase.so/sources), scroll to the **Chat History** section, and upload the exported file. Membase accepts the native export formats from each platform. </Step> <Step title="Membase digests your history"> Your conversations are processed through the same pipeline as live interactions. Preferences, decisions, project context, and relationships are extracted and added to your knowledge graph. </Step> </Steps> <Tip> You don't have to choose between import and live sync. Import your history first to bootstrap, and then let your agents or Chat in Dashboard continue building your knowledge base as you work. </Tip> ## Live Agent Conversations Once you've connected an agent via the [Quickstart](/getting-started/quickstart), context is captured automatically as you chat. Your agent calls `add_memory` whenever it detects something worth remembering: preferences, decisions, project details, and more. <Frame> <img alt="Live agent sync via MCP: Add Memory being called during an agent conversation" /> </Frame> Agents can also call `add_wiki` when you share factual, reference-style knowledge worth keeping as a document (specs, runbooks, stable notes). The two tools route context to the right store automatically. Some agent plugins can also preserve conversation transcripts as Wiki documents. This keeps the original source material searchable without turning every transcript into extracted Memory. You don't need to do anything special. Just chat normally, and your knowledge base grows in the background. ## Chat in Dashboard Chat in Dashboard can also save durable personal context as memory, or create wiki documents when you ask it to save factual reference material. This is useful when you want to add or clarify context without opening an external agent. ## App Integrations Your context doesn't only live in AI conversations. Connect external apps from the **Sources** page to bring in context from the tools you use every day. <CardGroup> <Card title="Gmail" icon="envelope"> Project updates, team discussions, and action items from your inbox. </Card> <Card title="Google Calendar" icon="calendar"> Meetings, deadlines, and schedule context. </Card> <Card title="Slack" icon="hashtag"> Messages, threads, and channel discussions from your workspace. </Card> <Card title="Notion" icon="book"> Selected Notion pages live-synced into Wiki. </Card> <Card title="Obsidian / Markdown" icon="file-lines"> Existing notes, vaults, and Markdown files imported into Wiki. </Card> </CardGroup> <Frame> <img alt="Sources page with app integrations and Wiki imports" /> <img alt="Sources page with app integrations and Wiki imports in dark mode" /> </Frame> Live integrations sync automatically after connection. One-time Wiki imports run in the background and report progress until processing finishes. <Info> For the full list of supported and upcoming integrations, see the [Apps guide](/connectors/apps). </Info> ## Wiki Imports If you already keep notes in Notion, Obsidian, or Markdown files, you can import them as **Wiki documents**. Choose **Wiki > Add > Import files**, select Notion, Obsidian, or Markdown, then choose a target Project or Basic. For Obsidian vaults, `[[wikilinks]]` are preserved and documents land in the Wiki tab instead of the memory graph. Choose a target Project or Basic during import, then reorganize documents from the Wiki table when needed. See [App Integrations](/connectors/apps#wiki-imports) for import formats and destination behavior. For Notion, use [App Integrations](/connectors/apps#notion-live-sync) to choose between live sync and one-time export imports. ## What Gets Captured | Source | Examples of extracted context | Lands in | | ------------------------------------ | -------------------------------------------------------------------------------------------------------- | -------------- | | **Chat History Import** | Past preferences, project decisions, technical stacks, recurring patterns across months of conversations | Memory | | **Agent Conversations** | New preferences, decisions made during the session, project details discussed in real time | Memory | | **Chat in Dashboard** | Durable personal context or factual reference material you ask Chat to save | Memory or Wiki | | **Gmail** | Project updates, action items, team communication, client context | Memory | | **Google Calendar** | Meeting outcomes, deadlines, scheduling patterns, recurring events | Memory | | **Slack** | Team discussions, channel updates, thread summaries, shared decisions | Memory | | **Notion live sync** | Source-backed pages, docs, and notes selected during Notion setup | Wiki | | **Notion/Obsidian/Markdown imports** | Reference docs, specs, personal notes, linked concept pages | Wiki | | **Agent transcript capture** | Original user/assistant conversation transcripts from supported plugins | Wiki | Memory holds your personal context and connects it as entities and episodes in a knowledge graph. The wiki holds factual, reference-style knowledge as linked markdown documents. Agents can search both through MCP. ## Next Steps <CardGroup> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Learn how to retrieve and interact with your stored knowledge. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Explore Projects, backlinks, Notion sync, and imports. </Card> <Card title="How Membase Works" icon="gear" href="/core-concepts/how-membase-works"> Understand the full digesting and retrieval pipeline. </Card> </CardGroup> # Quickstart Source: https://docs.membase.so/getting-started/quickstart Connect your first AI agent to Membase in 3 simple steps. Get persistent memory across sessions in under 5 minutes with one-click or CLI setup. Give your AI agent persistent memory in just a few minutes. Watch the video for a quick overview, or jump straight to the step-by-step guide below. ## How to Start Watch a quick walkthrough to see the full setup in action. <iframe title="Membase Quickstart" /> ## 3-Step Guide Follow these steps to connect your first AI agent to Membase. ### Step 1: Create Your Account Go to [app.membase.so](https://app.membase.so) and create your account. <Frame> <img alt="Membase sign-up page" /> <img alt="Membase sign-up page" /> </Frame> <Tip> Membase is currently in **open beta**. Anyone can create an account and start using it while we continue improving the product. </Tip> ### Step 2: Connect Your Agent From the dashboard, go to the **Agents** tab and click **+ Add Agent**, then pick your client. <Frame> <img alt="Add agent dialog" /> <img alt="Add agent dialog" /> </Frame> Most agents connect with a single command or one-click setup. Some plugin-based clients ask you to run a login command inside the agent after installation. <Tabs> <Tab title="Cursor"> Click **"Add to Cursor"** in the dashboard. Cursor installs Membase automatically. </Tab> <Tab title="ChatGPT"> Go to **Settings > Apps > Advanced Settings**, click **Create app**, and enter the MCP URL: ``` https://mcp.membase.so/mcp ``` </Tab> <Tab title="Claude"> Go to [Claude connector settings](https://claude.ai/settings/connectors), click **Add custom connector**, and enter: ``` https://mcp.membase.so/mcp ``` Name the connector `Membase`, then click **Connect** and complete authentication. </Tab> <Tab title="Claude Code"> Install the Claude Code plugin: ```bash theme={null} claude plugin marketplace add aristoapp/claude-membase && claude plugin install membase@membase-plugins ``` If Claude Code is already open, run: ```text theme={null} /reload-plugins ``` Then connect your Membase account: ```text theme={null} /membase:login ``` </Tab> <Tab title="Codex"> Run this command in your terminal: ```bash theme={null} npx -y membase@latest --client codex ``` </Tab> <Tab title="VS Code"> Click **"Add to VS Code"** in the dashboard. VS Code installs Membase automatically. </Tab> <Tab title="Poke"> Go to [Integrations](https://poke.com/integrations/new) and add the MCP URL: ``` https://mcp.membase.so/mcp ``` </Tab> <Tab title="Gemini CLI"> Run this command in your terminal: ```bash theme={null} npx -y membase@latest --client gemini-cli ``` </Tab> <Tab title="OpenCode"> Run this command in your terminal: ```bash theme={null} npx -y membase@latest --client opencode ``` Then authenticate: ```bash theme={null} opencode mcp auth membase ``` </Tab> <Tab title="OpenClaw"> Run this command in your terminal: ```bash theme={null} openclaw plugins install @membase/openclaw-membase ``` Then log in: ```bash theme={null} openclaw membase login ``` </Tab> <Tab title="Hermes"> Run this command in your terminal: ```bash theme={null} uv tool install hermes-membase && hermes-membase install ``` Requires Python 3.11+. If you prefer `pip`, `pip install hermes-membase && hermes-membase install` also works. </Tab> <Tab title="MCP URL"> For any MCP-compatible client, use the server URL directly: ``` https://mcp.membase.so/mcp ``` </Tab> </Tabs> <Tip> For detailed step-by-step instructions, see the [Agents guide](/connectors/agents/cursor) for MCP clients, [Claude Code](/connectors/agents/claude-code) for the Claude Code plugin, plus the dedicated plugin pages for [OpenClaw](/connectors/openclaw) and [Hermes](/connectors/hermes). </Tip> ### Step 3: Start Using Memory Once connected, your agent can read from and write to Membase. There are two core operations: **saving** memory and **retrieving** it. #### Saving memory (`add_memory`) Tell your agent something worth remembering. Your agent calls `add_memory` to store it in Membase. ```text Your prompt theme={null} I prefer TypeScript over JavaScript, and I use Bun as my package manager. My current project is a Next.js app with Supabase for auth. ``` ```text add_memory theme={null} ✓ Saves the conversation as an episode ✓ Extracts entities: TypeScript, Bun, Next.js, Supabase ✓ Links related entities and episodes in your knowledge graph ``` #### Retrieving memory (`search_memory`) Next time you (or any connected agent) need context, your agent calls `search_memory` to pull relevant memories. ```text Your prompt theme={null} Set up a new project for me. ``` ```text search_memory → results theme={null} ✓ Found: "Prefers TypeScript over JavaScript" ✓ Found: "Uses Bun as package manager" ✓ Found: "Current project uses Next.js + Supabase" → Agent sets up the project with TypeScript, Bun, and Next.js without you repeating anything. ``` You don't need to trigger any of this manually. Your agent decides when to save and when to search. Just chat normally. <Tip> The same agent can also write and search **factual knowledge** via `add_wiki` and `search_wiki`. Memory is for personal context; the wiki is for reference material (docs, specs, stable notes). See the [Knowledge Wiki guide](/features/wiki) for details. </Tip> <Check> **You're all set!** Your agent now has persistent memory powered by Membase. Memories are automatically created, updated, and shared as you interact. </Check> ## Next Steps <CardGroup> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history, connect Gmail, Calendar, and Slack. </Card> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Chat with Memory, agent retrieval, and dashboard exploration. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge and import Notion, Obsidian, or Markdown files. </Card> <Card title="All Agents" icon="robot" href="/connectors/agents/cursor"> Full setup guides for all supported clients. </Card> </CardGroup> # Use Your Context in Membase Source: https://docs.membase.so/getting-started/use-context How to interact with your stored knowledge: Chat in Dashboard, agent retrieval across memory and wiki, and dashboard exploration for both stores. Once your context is in Membase, there are three ways to use it: **Chat in Dashboard** for direct conversations with your knowledge base, **Agent Retrieval** by your connected agents, and **Dashboard Exploration** in either the Memory or Wiki views. ## Chat in Dashboard The most direct way to interact with your knowledge base. Chat lets you ask questions and get answers grounded in your stored context, without going through an external agent. When stored context is relevant, it can search **both** your memory and your wiki and weave results into a single answer. <Frame> <img alt="Chat with Memory" /> </Frame> * **Ask anything**: "What did we decide about the auth flow?", "What's my meeting schedule this week?", "What does our deployment runbook say about rollbacks?" * **Citations**: Responses that use stored context link back to the exact memories and wiki documents they drew from * **Graph panel**: See how referenced items connect to each other * **Session history**: Pick up past conversations from the sidebar Chat is available in [Chat](https://app.membase.so/chat). See [Chat in Dashboard](/features/chat) for details. ## Agent Retrieval Your connected agents retrieve context from Membase when they need it. When past context or reference knowledge would improve the response, the agent can call `search_memory` (personal context) and `search_wiki` (factual knowledge) and combine the results before responding. ```text Your prompt theme={null} Set up a new API route for user profiles. ``` ```text What happens behind the scenes theme={null} → Agent calls search_memory: "project tech stack, API conventions" Found: "Uses Next.js with TypeScript" Found: "Prefers RESTful conventions with Zod validation" Found: "Supabase for auth" → Agent calls search_wiki: "user profile API schema, auth middleware" Found (doc): "User Profile Data Model" with fields, constraints, relations Found (doc): "Auth Middleware" with how to require a session on a route → Agent generates the route using the right stack, schema, and middleware. ``` This works across all connected agents. Context stored by Cursor is available to Claude, ChatGPT, and every other agent on your account. The same is true for wiki documents. <Tip> You don't need to tell your agent to search. Agents call `search_memory` and `search_wiki` automatically whenever past context or reference knowledge would improve their response. </Tip> ## Dashboard Exploration You can explore your knowledge directly in the dashboard. Memory and Wiki are two separate tabs, each with its own views. <Tabs> <Tab title="Memory Exploration"> The **Memories** tab has two views for exploring personal context. * **Graph View**: Explore your knowledge as an interactive network of entities (people, concepts, tools, projects) and relationships. Click any node to see connected entities and related episodes. * **Table View**: Browse all memories in a structured list. Filter by source, project, and time period. Use the table search to text-filter the loaded memory list, then bulk-select rows to move them to a project or delete them. <Frame> <video> <source type="video/mp4" /> </video> <video> <source type="video/mp4" /> </video> </Frame> For the full walkthrough, see [Memory](/features/memory). </Tab> <Tab title="Wiki Exploration"> The **Wiki** tab has two views for exploring factual knowledge. * **Graph View**: A force-directed network of documents connected by `[[wikilinks]]`. Project styling helps related documents visually cluster. * **Table View**: A sortable, filterable list of every document. Filter by Project or search query. Bulk-select rows to move or delete. Projects in the Wiki navigation let you scope the list, graph, and search to a single group of documents. Documents without a Project live in Basic. For the full walkthrough, see [Knowledge Wiki](/features/wiki). </Tab> </Tabs> ## Other Dashboard Tabs Beyond Chat, Memory, and Wiki, the dashboard has a few more tabs: | Tab | Purpose | | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Agents** | Manage connected AI agents: connection status, last activity, add new agents | | **Sources** | Connect app integrations (Gmail, Calendar, Slack, Notion, and more), import Wiki files, and import past chat history | | **Recipes** | Pre-built prompt templates that run directly in Chat, powered by your synced memories | | **Settings** | Tabbed settings page with **Profile** (name, role, interests, custom instructions, timezone; shared with agents via `membase://profile`) and **Billing** (current plan, usage including wiki document quota, and invoices) | ## Next Steps <CardGroup> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history and connect apps to enrich your knowledge base. </Card> <Card title="Memory" icon="brain" href="/features/memory"> Explore and manage your memories. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Explore and manage your wiki documents. </Card> <Card title="Attached vs Universal" icon="share-nodes" href="/core-concepts/attached-vs-universal"> Understand why shared memory across agents matters. </Card> </CardGroup> # Overview Source: https://docs.membase.so/index Persistent, shared personal memory for your AI agents, so they keep important context across sessions. ## What is Membase? Membase is a **universal knowledge layer for AI agents**. It gives your agents two persistent, shared stores that survive across sessions, tools, and platforms, so they can keep important context about you. * **Memory**: Personal context (preferences, decisions, habits, meetings, emails) organized as a knowledge graph * **Knowledge Wiki**: Factual knowledge as markdown documents linked with `[[wikilinks]]`, organized into Projects, with Notion sync, Obsidian/Markdown import, and hybrid search * **Cross-agent sharing**: Context stored by one agent is available to other connected agents on your account * **External integrations**: Connect Gmail, Calendar, Slack, Notion, and other data sources to enrich Memory and Wiki * **Chat history import**: Bring in past conversations from ChatGPT, Claude, and Gemini to bootstrap your knowledge base * **Chat with Memory**: Talk directly to your knowledge base from the dashboard, without going through an external agent * **Smart digesting**: Raw conversations are automatically processed into structured, retrievable memories ## How does it work? <Frame> <img alt="Membase architecture diagram" /> <img alt="Membase architecture diagram" /> </Frame> <Steps> <Step title="Connect agents and data sources"> Connect your AI agents (Cursor, Claude, ChatGPT, etc.) via MCP, import past conversations, and link external data sources like Gmail, Google Calendar, Slack, and Notion. Optionally import Notion exports, Obsidian vaults, or Markdown files to bootstrap your Wiki. </Step> <Step title="Two knowledge stores: Memory and Wiki"> Incoming context lands in the right place automatically. Personal context (preferences, decisions, meetings) becomes **Memory**, organized as a knowledge graph. Reference material (docs, specs, notes, transcripts) becomes **Wiki**, organized as linked markdown documents in Projects or Basic. </Step> <Step title="Retrieval when your agent (or Chat) needs it"> When an agent needs context to respond, it can call `search_memory` for personal context and `search_wiki` for factual knowledge, then combine the results. Chat with Memory in the dashboard can use the same knowledge stores when you ask a question directly. </Step> </Steps> ## Why Membase? Today's AI agents have three fundamental problems: <CardGroup> <Card title="Session Memory Loss" icon="plug-circle-xmark"> Agents forget everything when a session ends. </Card> <Card title="Cross-Agent Isolation" icon="circle-nodes"> Context doesn't carry over between agents. </Card> <Card title="Context Rot" icon="recycle"> More context doesn't mean better responses. </Card> </CardGroup> Every new conversation starts from scratch. You re-explain preferences, past decisions, and project context over and over. Worse, what you told Cursor doesn't exist in Claude, so you end up manually copy-pasting the same information across tools. Even when you try to fix this by stuffing more context into prompts, it backfires. Without structure, the agent can't tell what's important and what's noise. Signal gets buried under volume. Membase solves all three. Instead of dumping raw text, Membase builds a **relational knowledge graph** from your conversations and external data. When an agent needs context, it retrieves only the relevant pieces, keeping responses accurate and grounded. ## Get Started <CardGroup> <Card title="Quickstart" icon="rocket" href="/getting-started/quickstart"> Connect your first agent in 3 simple steps. </Card> <Card title="Bring Your Context" icon="download" href="/getting-started/bring-context"> Import chat history, connect apps, import Notion/Obsidian/Markdown files, and build your knowledge base. </Card> <Card title="Use Your Context" icon="comment-dots" href="/getting-started/use-context"> Chat with Memory, agent retrieval, and dashboard exploration. </Card> <Card title="Knowledge Wiki" icon="book" href="/features/wiki"> Store factual knowledge as linked markdown documents that agents can search. </Card> </CardGroup> # Contributing Source: https://docs.membase.so/support/contributing How to contribute to Membase. Report bugs, improve docs, add connectors, and submit pull requests. Membase's connector kit (the MCP server and client integrations) is open source. Contributions of all sizes are welcome, from typo fixes to new connectors. <CardGroup> <Card title="Contributing Guide" icon="book" href="https://github.com/aristoapp/membase/blob/main/CONTRIBUTING.md"> Development setup, PR workflow, and project conventions. </Card> <Card title="Report an Issue" icon="bug" href="https://github.com/aristoapp/membase/issues"> File a bug report or request a feature on GitHub. </Card> <Card title="Code of Conduct" icon="handshake" href="https://github.com/aristoapp/membase/blob/main/CODE_OF_CONDUCT.md"> What we expect from everyone in the community. </Card> <Card title="Discord Community" icon="discord" href="https://discord.gg/vHgtDd6UTK"> Ask questions and discuss changes with maintainers before you start. </Card> </CardGroup> ## Ways to contribute * **Report bugs** or request features via [GitHub Issues](https://github.com/aristoapp/membase/issues). * **Improve documentation** — install guides, architecture docs, or these pages. * **Add or improve a connector** for a new or existing MCP host. * **Report a security issue** privately — see [SECURITY.md](https://github.com/aristoapp/membase/blob/main/SECURITY.md). Full setup steps and PR requirements live in [CONTRIBUTING.md](https://github.com/aristoapp/membase/blob/main/CONTRIBUTING.md) on GitHub. # Support & Troubleshooting Source: https://docs.membase.so/support/faqs Get help with Membase. Chat with us from the dashboard, report bugs, suggest features, find troubleshooting tips, and connect with the Membase community on Discord. ## Get Help <CardGroup> <Card title="In-Dashboard Support Chat" icon="comments" href="https://app.membase.so"> Open the support chat widget in your dashboard to message the Membase team directly. This is a separate chat from Chat with Memory. Ask account questions, report issues, and get fast responses without leaving the product. </Card> <Card title="Discord Community" icon="discord" href="https://discord.gg/vHgtDd6UTK"> Join 800+ members to discuss Membase, get help, and share ideas. </Card> <Card title="Product Roadmap" icon="map" href="https://membase.canny.io/"> See what's planned, suggest features, and vote on what gets built next. </Card> <Card title="Bug Reports & Feedback" icon="flag" href="https://membase.canny.io/feature-requests"> Report bugs, share feedback, and track the status of your submissions. </Card> </CardGroup> ## FAQs <AccordionGroup> <Accordion title="What AI agents does Membase support?"> Membase supports Cursor, ChatGPT, Claude, Claude Code, Codex, VS Code, Poke, Gemini CLI, and OpenCode, plus plugins for [OpenClaw](/connectors/openclaw) and [Hermes](/connectors/hermes). For Claude Code, use the [Membase Claude Code plugin](/connectors/agents/claude-code); MCP remains available as a fallback. </Accordion> <Accordion title="Is my data secure?"> Yes. Membase uses industry-standard encryption for data in transit and at rest. Your memories are private to your account and are never shared with other users or used for training. </Accordion> <Accordion title="Can I delete all my data?"> Yes. You control deletion at several levels: * **Memories**: Delete individual rows from the **Memories** table, or select multiple rows for bulk delete. See [Memory](/features/memory#deleting-memories). * **Wiki documents**: Delete a single document from its page, or bulk-select rows in the Wiki Table View. See [Knowledge Wiki](/features/wiki#managing-wiki-documents). * **All memories from a source**: Use the **Delete memories** action on the **Sources** page to remove every memory that came from that source (for example, all Slack memories). Disconnecting an integration only stops future sync; existing memories remain until you delete them. * **Notion live-synced Wiki documents**: Use the Notion source card on the **Sources** page to remove synced Wiki documents. This removes documents created by Notion live sync, but does not remove one-time Notion file imports. If you keep Notion connected, future syncs can recreate source-backed documents. When prompted, you can also choose whether to remove synced documents that were edited in Membase. * **Entire account**: Message us from the in-dashboard support chat or email **[support@aristo.so](mailto:support@aristo.so)** and we will delete your account and all associated data. </Accordion> <Accordion title="How does automatic memory creation work?"> When you interact with a connected agent or ask Chat in Dashboard to save durable context, Membase processes the conversation to extract key facts, preferences, and decisions. These are stored as structured memories in a knowledge graph. See [How Membase Works](/core-concepts/how-membase-works) for details. </Accordion> <Accordion title="How do I reach the Membase team?"> The fastest way is to open the **in-dashboard support chat widget** in your [dashboard](https://app.membase.so) and message us directly. Note that this is a separate chat from Chat with Memory. You can also reach us on [Discord](https://discord.gg/vHgtDd6UTK) or by email at **[support@aristo.so](mailto:support@aristo.so)** for account-related issues. </Accordion> <Accordion title="Can I use Membase with multiple agents at the same time?"> Absolutely. All agents connected to the same Membase account share the same memory pool. See [How Membase Works](/core-concepts/how-membase-works) for details on how context is shared across agents. </Accordion> <Accordion title="What happens if two agents write conflicting memories?"> Membase automatically detects conflicts and resolves them by prioritizing the most recent information. You can also manually delete conflicting memories from the dashboard. </Accordion> <Accordion title="Is there a free tier?"> Yes. Membase offers a **Free** plan and a **Pro** plan. * **Free**: Connect agents, sync integrations, store up to **1,000 memories** and **200 wiki documents**, run **40 dashboard chats per month**, and use **1,000 MCP memory searches per month**. * **Pro**: Higher limits including **5,000 memories**, **2,000 wiki documents**, **200 dashboard chats per month**, and unlimited MCP memory searches. You can see your current plan and usage on the **Billing** tab in your [dashboard](https://app.membase.so), and upgrade or manage your subscription from there. Sign up at [app.membase.so](https://app.membase.so) and connect your first agent in under a minute. </Accordion> </AccordionGroup> ## Troubleshooting <AccordionGroup> <Accordion title="My agent can't connect to Membase"> For Claude Code plugin issues, see the Claude Code troubleshooting steps below. For MCP clients: 1. Ensure the npx command is using the latest package version. 2. Restart your agent after updating the MCP configuration. 3. Check that your network allows outbound connections to `mcp.membase.so`. 4. If using OAuth, try logging out and re-authenticating. </Accordion> <Accordion title="Claude Code does not show Membase commands"> Confirm the plugin is installed: ```bash theme={null} claude plugin marketplace add aristoapp/claude-membase && claude plugin install membase@membase-plugins ``` If Claude Code is already open, run `/reload-plugins` inside Claude Code. Then run `/membase:login` and verify the connection with `/membase:status`. </Accordion> <Accordion title="I connected the wrong Membase account in Claude Code"> Run `/membase:logout`, then `/membase:login` and verify the account with `/membase:status`. If the old account context is still visible in the current conversation, run `/clear` or start a new Claude Code session. </Accordion> <Accordion title="Memories aren't being created automatically"> 1. Verify the connection is active. In Claude Code, run `/membase:status`; in MCP clients, check your agent's MCP status. 2. Ensure the conversation contains extractable information. Simple greetings may not generate memories. 3. Check the dashboard for any sync errors. </Accordion> <Accordion title="Search results are not relevant"> 1. Try rephrasing your search query with more specific terms. 2. Ensure the relevant memories exist in your dashboard. 3. If the issue persists, report it on [Discord](https://discord.gg/vHgtDd6UTK) or via [feedback](https://membase.canny.io/feature-requests). </Accordion> </AccordionGroup> ## Contact For urgent issues or account-related requests, email us. For general questions, join our Discord. <CardGroup> <Card title="Email Support" icon="envelope" href="mailto:support@aristo.so"> Reach our support team at **[support@aristo.so](mailto:support@aristo.so)**. </Card> <Card title="Discord Community" icon="discord" href="https://discord.gg/vHgtDd6UTK"> Join 800+ members for discussions and live support. </Card> </CardGroup>