Skip to main content
Membase transforms raw conversations and external data into structured, retrievable context. This page walks through the full lifecycle: how context enters Membase, how it gets processed, and how your agents use it.

​
Architecture Overview

Membase architecture diagram
Context flows into Membase from two channels: your AI agents (live via MCP, or bulk via chat history import) and external app integrations (Gmail, Calendar, Slack). Membase digests everything into a knowledge graph, and when an agent needs context, it retrieves only what’s relevant.

​
1. Agent to Membase

Context from AI agents enters Membase in two ways: live capture during conversations, and bulk import from past chat history.
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. Membase processes the entire archive through the same digesting pipeline, so your knowledge base starts rich instead of empty.
Chat History Import
2

You have a conversation

You talk to your agent normally. During the conversation, the agent picks up on preferences, decisions, project details, and other important context.
3

Agent calls add_memory

The agent sends the relevant context to Membase via MCP. This happens automatically as part of the conversation flow.
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
4

Membase receives and acknowledges

The MCP server receives the memory and queues it for processing. The agent can continue the conversation immediately.

​
2. External Sources to Membase

External data sources like Gmail, Google Calendar, and Slack feed context into Membase independently of your agent conversations.
1

You connect a data source

From the Sources page in your dashboard, authorize Membase to access a data source (e.g., Gmail, Google Calendar, Slack).
2

Membase syncs automatically

Membase syncs with connected sources in real time. Emails, calendar events, Slack messages, and other data are ingested as they arrive, without any manual action.
3

Data is queued for processing

Incoming data is treated the same as agent conversations: it goes through the same digesting pipeline to extract structured context.
External data enriches your agents’ context beyond what you explicitly tell them. Your agent can reference an email thread, know about an upcoming meeting, or recall a Slack discussion without you bringing it up.

​
3. Digesting and Graph Construction

This is where raw text becomes structured knowledge. Every piece of incoming context (from agents or external sources) 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 your 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. Membase creates connections between them and links new entities to existing ones when they overlap.For example, if “Zustand” was mentioned before in a different context, the new episode gets linked to the existing entity rather than creating a duplicate.
4

Deduplication and merging

If the same fact appears in multiple episodes, Membase merges them. When information conflicts (e.g., you changed a preference), the latest data takes priority.
The result is a continuously growing knowledge graph where entities, relationships, and episodes are all interconnected.
Membase knowledge graph

​
4. Membase to Your Agent

When an agent needs context to respond, it calls search_memory to query Membase.
1

Agent calls search_memory

The agent sends a query describing what context it needs. This happens automatically when the agent determines that prior context would improve its 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 knowledge graph using semantic search. Membase finds relevant episodes, entities, and their connections.Relevant results might include:
  • “Uses Next.js with TypeScript”
  • “Prefers functional components”
  • “State management: Zustand”
  • “Styling: Tailwind CSS”
3

Ranked results returned to agent

Results are scored by relevance and returned to the agent. Only the most useful context is included, keeping the agent’s context window clean and focused.
4

Agent responds with full context

The agent uses the retrieved context to generate a response that’s 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’s knowledge graph during a conversation.
This entire cycle (save → digest → retrieve) happens continuously as you use your agents. The more you interact, the richer your knowledge graph becomes, and the smarter your agents get.

​
Next Steps

Attached vs Universal

Understand why shared memory matters.

Membase MCP

Learn about the MCP tools available to your agents.