Skip to content
Membase
Introducing Membase: One Memory for AI Agents and AI Tools

Introducing Membase: One Memory for AI Agents and AI Tools

Research
MembaseMembase Team
View the original post on Medium

You’ve already told one AI about your project. Then you switch tools and have to explain it all again.

Membase lets you save those notes, requirements, and decisions so the AI tools you connect can look them up. Here’s how it works, how to connect your AI tools, and how to use it in your own application.

1. What Is Membase?

Membase is the memory layer for AI agents. It keeps what you and your agents learn in one place, so the AI tools you connect can use it: ChatGPT, Claude, Claude Code, Cursor, Codex, and your own agents.

You stop re-explaining yourself each time you switch models or tools.

  • Add. Save facts, documents, web pages, and chat exports from Claude or ChatGPT.
  • Manage. Keep projects in separate Memories. Search them, review what Membase learned, and remove outdated information.
  • Use. Your code accesses memory through the SDK. Your AI tools access it through MCP. You choose which Memories each app can read.

Membase is made by Unibase. It is free in beta, with paid plans coming soon.

2. What Can You Use Membase For?

Suppose a customer tells you they need single sign-on (SSO) before starting a pilot. You save the meeting notes in Membase.

Later, you open a connected AI tool and ask:

What does the customer need before starting the pilot?

The assistant can search Membase and retrieve the SSO requirement. You don’t have to find the meeting notes and paste them into another chat.

You can also save:

  • Project decisions: which database you chose and why.
  • Research notes: findings you want to use when writing or planning.
  • Project background: requirements and constraints you keep explaining to different assistants.

3. Benchmark Results

93.1% on LoCoMo, 92.6% on LongMemEval_S and 92.2% on DMR, using about 3× fewer tokens than the full history on LoCoMo and 11× fewer on LongMemEval_S. Method and results.

4. How to Use Membase with Your AI Tools

4.1. Create a Memory

Open the Membase app and create a Memory for a project, such as “Customer pilot.”

A Memory keeps information about one topic together.

4.2. Add Your Material

Add relevant notes or documents, then select Update now to let Membase learn from them.

Processing needs to finish before new information can appear in search. See how learning works.

4.3. Connect Your AI Tool

Follow the setup guide for your AI tool. During authorization, choose which Memories it may read.

Membase connects through MCP, a standard that lets AI applications call external tools. Its remote MCP address is:

https://api.app.membase.com/mcp-http

The standard OAuth connection is read-only. It lets the assistant retrieve information from the Memories you selected. See the MCP guide for details.

4.4. Ask a Question

Start with a question you can check:

Search Membase for the customer’s pilot requirements. What needs to be ready first? Tell me which Memory the information came from.

Compare the answer with your original note to confirm that the assistant found the right information.

5. How to Integrate Membase into Your Application

The Membase GitHub repository includes Python and TypeScript SDKs, a CLI, and an MCP server.

Your application can search Membase when it needs background information, then pass the retrieved passages to its model.

The example below uses the hosted Python SDK.

5.1. Create a Memory and API Key

In the Membase app:

  1. Create a Memory for this example.
  2. Configure an available model in AI Setup.
  3. Open Connect and create a developer key.
  4. Give the key Read & write access to exactly one Memory.

The API quickstart walks through the setup.

Keep the key on your server, outside browser code and source control.

5.2. Install the Python SDK

Use Python 3.10 or newer:

pip install unibaseio-membase
export MEMBASE_API_KEY="your_developer_key"

The package is unibaseio-membase; the Python import is membase. The package named membase on PyPI is unrelated.

For TypeScript and CLI installation, see the GitHub quickstart.

Save this as quickstart.py:

import time
from membase import Membase

client = Membase()

# A container is one Memory in the API.
containers = client.containers.list()["containers"]

if len(containers) != 1:
    raise RuntimeError(
        "Authorize exactly one Memory for this example."
    )

container = containers[0]["id"]

# Add the customer requirement.
added = client.add(
    "The customer requires SSO before starting the pilot.",
    container=container,
    title="Customer pilot requirements",
    custom_id="customer-pilot-requirements-v1",
)

document_id = added.get("document_id")

if not document_id:
    raise RuntimeError(
        "Document ID is pending. Inspect the add response."
    )

# Wait for learning to finish.
for _ in range(60):
    document = client.documents.get(document_id)

    if document.get("learned"):
        break

    status = (document.get("learning_run") or {}).get("status")

    if status in {"failed", "refused", "canceled"}:
        raise RuntimeError(
            "Learning stopped. Check the Memory's Report."
        )

    time.sleep(5)
else:
    raise TimeoutError(
        "Check the learning status and model settings."
    )

# Search for the requirement.
found = client.search(
    "What does the customer need before starting the pilot?",
    container=container,
)

errors = [
    item for item in found["containers"]
    if item.get("error")
]

if errors:
    raise RuntimeError(f"Search errors: {errors}")

for hit in found["results"]:
    print(hit["container_name"], "·", hit["content"])

if not found["results"]:
    print("No matching passages found.")

Run it:

python quickstart.py

You should receive a passage identifying SSO as a requirement, along with the Memory it came from. Exact wording may vary.

Adding a document starts background learning. The example checks learned before searching and checks errors before reporting an empty result.

See the API quickstart for more detail.

5.4. Pass Search Results to Your Model

search returns passages your application can supply to its model.

For example, a planning assistant can retrieve the customer’s requirements before recommending what to build next:

User asks what to prioritize
        ↓
Your app searches Membase
        ↓
The model receives the retrieved requirements
        ↓
The assistant proposes a plan

Your application decides when to search and how to use the results. Tell the model to base its response on the retrieved information and say when it doesn’t have enough context.

See the SDK reference for methods and configuration, and Memory operations for working with documents, facts, and profiles.

6. How to Manage App Permissions

You choose which Memories a connected application may use.

Developer keys also have permission levels and expiry settings. Give each integration the access it needs. See Authentication for details.

If you’re building for multiple users, use each person’s own account and credentials. Containers separate topics within an account; they do not isolate different users. The SDK reference explains this account model.

Revoking a credential stops future access through it. It does not erase information an external application has already received.

7. CLI, Local Mode, and Framework Integrations

  • CLI: use Membase from the terminal. See the CLI examples.
  • Local mode: run the memory engine on your machine. Model calls depend on your provider configuration. See the local engine guide.
  • Framework integrations: connect Membase to an agent framework. See the integration examples.

8. Get Started

Create your first Memory in the Membase app, add a few notes, and connect your AI tool. Building an application? Start with the GitHub repository or follow the API quickstart.

Back to all posts