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.
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.
Memory
Wiki
What it stores
Personal context: preferences, decisions, habits, meetings, emails
Memory receives context from imports, agents, Chat in Dashboard, and integrations.
1
Chat History Import (bootstrap)
Already have months of conversations in ChatGPT, Claude, or Gemini? Export your chat history and upload it in the Sources page of your dashboard under the Chat History section. The entire archive goes through the same digesting pipeline as live conversations.
2
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.
Example
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
3
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.
4
App integration sync
Connected sources (Gmail, Google Calendar, Slack) sync new data automatically in the background. Each message, event, or email becomes an episode.
5
Membase receives and queues
Membase queues the incoming memory for processing so the agent or background sync can keep moving.
Wiki receives documents directly from you, Chat in Dashboard, or agent tool calls.
1
Obsidian vault import (bootstrap)
Already have a markdown knowledge base? Drop a vault .zip onto the Wiki page. Folders become collections, [[wikilinks]] are preserved, and documents upload via resumable TUS so large vaults go through safely. See Importing an Obsidian Vault.
2
Write a document in the dashboard
Open the Wiki tab, click + New Document, pick a collection, and write in markdown. Manual save and unsaved-changes warnings keep your content safe.
3
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.
4
Chat creates a document
Chat in Dashboard can also create wiki documents when you ask it to save factual, reference-style material.
5
Membase receives and queues
The wiki document is saved immediately. Optional LLM summarization runs asynchronously when requested.
How raw input becomes structured, searchable knowledge.
Memory
Wiki
Every memory (from agents or integrations) goes through the same pipeline.
1
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.
2
Entity extraction
Membase identifies key entities from the episode: people, projects, tools, preferences, decisions, dates, and other meaningful concepts.
Example entities from a conversation
"Let's use Zustand instead of Redux"→ Entities: Zustand, Redux, state management decision
3
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.
4
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.
The result is a continuously growing knowledge graph where entities, relationships, and episodes are all interconnected.
Wiki documents are stored as markdown plus structural metadata for fast retrieval.
1
Document storage
The document’s title and markdown content are saved to the wiki store, scoped to its collection.
2
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.
3
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.
4
Optional LLM summarization
When imports or add_wiki calls set summarize: true, Membase runs a context-aware summarization pass to produce a structured version of the document before saving.
How context flows back when an agent or Chat needs it.
Memory
Wiki
1
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.
Example
You: "Set up a new component for the settings page."→ Agent calls search_memory: "project tech stack, component preferences"
2
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”
3
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.
4
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.
Here’s a real example: Claude retrieving a git workflow from Membase during a conversation.
1
Agent calls search_wiki
The agent sends a query describing what factual knowledge it needs.
Example
You: "Remind me how our auth middleware handles expired tokens."→ Agent calls search_wiki: "auth middleware expired token"
2
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.
3
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.
4
Agent responds with full context
The agent grounds its answer in the retrieved documents and cites them if your prompt encourages citations.
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.
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.
