Membase MCP Server

What does “Membase” MCP Server do?

The Membase MCP (Model Context Protocol) Server acts as a lightweight, decentralized memory gateway for AI agents, connecting them to Membase for secure, persistent, and verifiable multi-session memory. Powered by Unibase, it allows AI assistants to upload and retrieve conversation history, interaction records, and knowledge, ensuring agent continuity, personalization, and traceability. By integrating with the Membase protocol, the server enables seamless storage and retrieval of memory data from the Unibase decentralized network, supporting use cases where persistent, tamper-proof memory is vital for AI-driven workflows.

List of Prompts

No prompt templates are mentioned in the repository.

List of Resources

No explicit MCP resources are described in the repository.

List of Tools

• get_conversation_id: Retrieves the current conversation ID, enabling agents to identify or reference the ongoing session.
• switch_conversation: Switches the active context to a different conversation, supporting multi-session workflows.
• save_message: Stores a message or memory into the current conversation, ensuring persistence and traceability.
• get_messages: Fetches the last n messages from the current conversation, allowing agents to recall recent context or history.

Use Cases of this MCP Server

• Persistent Conversation Memory: Store and retrieve entire conversation histories, ensuring continuous context for AI agents across sessions.
• Multi-session Management: Seamlessly switch between different conversations, enabling an agent to handle multiple users or projects.
• Verifiable Audit Trails: All interactions are stored on a decentralized network, making them tamper-proof and auditable for compliance or debugging.
• Personalization: Retrieve past user interactions to tailor responses and actions based on historical preferences.
• Knowledge Retention: Save and recall knowledge snippets or decisions, building a knowledge base over time for smarter AI behaviors.

How to set it up

Windsurf

1. Ensure prerequisites are installed (e.g., Python, uv runner).
2. Clone the repository:
   git clone https://github.com/unibaseio/membase-mcp.git
3. Locate your Windsurf configuration file.
4. Add the Membase MCP Server configuration:

{
  "mcpServers": {
    "membase": {
      "command": "uv",
      "args": [
        "--directory",
        "path/to/membase-mcp",
        "run", 
        "src/membase_mcp/server.py"
      ],
      "env": {
        "MEMBASE_ACCOUNT": "your account, 0x...",
        "MEMBASE_CONVERSATION_ID": "your conversation id, should be unique",
        "MEMBASE_ID": "your sub account, any string"
      }
    }
  }
}

5. Save and restart Windsurf to apply changes.

Securing API Keys:
Use environment variables in the env block to keep credentials secure.

Claude

1. Install dependencies (uv runner and Python).
2. Clone the membase-mcp repository.
3. Edit Claude’s MCP configuration file.
4. Insert the following JSON snippet:

{
  "mcpServers": {
    "membase": {
      "command": "uv",
      "args": [
        "--directory",
        "path/to/membase-mcp",
        "run", 
        "src/membase_mcp/server.py"
      ],
      "env": {
        "MEMBASE_ACCOUNT": "your account, 0x...",
        "MEMBASE_CONVERSATION_ID": "your conversation id, should be unique",
        "MEMBASE_ID": "your sub account, any string"
      }
    }
  }
}

5. Save and restart Claude.

Note: Store sensitive info as environment variables.

Cursor

1. Install prerequisites (Python, uv).
2. Clone the membase-mcp repo.
3. Find and open your Cursor configuration file.
4. Add the server as shown:

{
  "mcpServers": {
    "membase": {
      "command": "uv",
      "args": [
        "--directory",
        "path/to/membase-mcp",
        "run", 
        "src/membase_mcp/server.py"
      ],
      "env": {
        "MEMBASE_ACCOUNT": "your account, 0x...",
        "MEMBASE_CONVERSATION_ID": "your conversation id, should be unique",
        "MEMBASE_ID": "your sub account, any string"
      }
    }
  }
}

5. Save, then restart Cursor.

Cline

1. Install dependencies (uv, Python).
2. Clone the repository.
3. Open Cline’s configuration file.
4. Add the server configuration:

{
  "mcpServers": {
    "membase": {
      "command": "uv",
      "args": [
        "--directory",
        "path/to/membase-mcp",
        "run", 
        "src/membase_mcp/server.py"
      ],
      "env": {
        "MEMBASE_ACCOUNT": "your account, 0x...",
        "MEMBASE_CONVERSATION_ID": "your conversation id, should be unique",
        "MEMBASE_ID": "your sub account, any string"
      }
    }
  }
}

5. Save and restart Cline.

Securing API Keys:
All sensitive credentials should be passed in the env object as shown above to avoid hardcoding them.

How to use this MCP inside flows

Using MCP in FlowHunt

To integrate MCP servers into your FlowHunt workflow, start by adding the MCP component to your flow and connecting it to your AI agent:

Click on the MCP component to open the configuration panel. In the system MCP configuration section, insert your MCP server details using this JSON format:

{
  "MCP-name": {
    "transport": "streamable_http",
    "url": "https://yourmcpserver.example/pathtothemcp/url"
  }
}

Once configured, the AI agent is now able to use this MCP as a tool with access to all its functions and capabilities. Remember to change “MCP-name” to whatever the actual name of your MCP server is (e.g., “github-mcp”, “weather-api”, etc.) and replace the URL with your own MCP server URL.

Overview

Based on the available information, Membase MCP Server provides core memory tools and clear setup instructions, but lacks prompt templates, explicit MCP resources, and mention of sampling or roots support. This makes it functional for memory-centric workflows but limited in extensibility and advanced MCP features. Overall, it is practical but basic.

MCP Score