About mem0 MCP Server

What is mem0 MCP Server: Developer-Friendly Integration Hub?

mem0 MCP Server is a TypeScript-based implementation of the Model Context Protocol (MCP) designed to simplify integration with Mem0's memory management capabilities. This server acts as a developer-friendly hub for creating, managing, and accessing memory streams, leveraging Mem0’s semantic search and persistent storage. It offers a streamlined interface for building applications that require contextual memory handling, such as chatbots, AI agents, or collaborative tools.

How to use mem0 MCP Server: Developer-Friendly Integration Hub?

Install dependencies via npm install.
Set your Mem0 API key using export MEM0_API_KEY=your-key.
Build the server with npm run build.
Start the server using npm start.
Test functionality with npm test or interact via the MCP API endpoints.

Interact with core tools like create-memory-stream and search-memories programmatically or access memory streams directly via resource URLs like memory://{streamId}.

mem0 MCP Server Features

Key Features of mem0 MCP Server: Developer-Friendly Integration Hub?

Memory Stream Management: Create, append, read, and delete streams with optional user/agent IDs for context tracking.
Semantic Search: Leverage Mem0’s advanced search to retrieve relevant memories using natural language queries.
Resource-Based Access: Directly reference streams via URLs for seamless integration into existing workflows.
Flexibility: Optional parameters (e.g., content roles, thresholds) let you fine-tune memory operations.

Use Cases of mem0 MCP Server: Developer-Friendly Integration Hub?

Typical applications include:

Chatbots: Maintain conversation history across sessions using memory streams.
Knowledge Bases: Enable semantic search for contextual data retrieval in enterprise systems.
Agent Workflows: Track agent interactions and user sessions for personalized responses.
Data Analysis: Store and query time-series data streams for analytics platforms.

mem0 MCP Server FAQ

FAQ from mem0 MCP Server: Developer-Friendly Integration Hub?

Q: How do I get a Mem0 API key?
Visit mem0.ai to sign up and generate your API key.
Q: Does this support other programming languages?
The server is TypeScript-based, but the MCP protocol ensures compatibility with any language through REST/JSON interfaces.
Q: What if I encounter errors during API calls?
Check the server logs first. For persistent issues, review error codes returned by Mem0’s API or open an issue on GitHub.
Q: Can I customize memory storage?
Extend the server by adding features like metadata tagging or cloud storage hooks in the development phase.
Q: Is authentication enforced?
Basic access control is included via resource permissions, but developers must implement authentication layers for production use.

Content

mem0 MCP Server

A TypeScript implementation of the Model Context Protocol (MCP) server for mem0, providing memory stream functionality with Mem0 integration.

Features

Create memory streams with Mem0 integration
Append content to memory streams
Search memories using Mem0's semantic search
Read from memory streams
Resource-based access to memory streams
Delete memory streams

Prerequisites

Node.js and npm installed
Mem0 API key (get one from mem0.ai)

Installation

npm install

Configuration

Set your Mem0 API key as an environment variable:

export MEM0_API_KEY=your-api-key-here

Building

npm run build

Running the Server

npm start

Testing

Run the test client to verify server functionality:

npm test

API

Tools

create-memory-stream

* Parameters: 
  * `name`: string
  * `initialContent`: string (optional)
  * `userId`: string (optional) - Mem0 user ID
  * `agentId`: string (optional) - Mem0 agent ID
* Returns: Stream ID and metadata

append-to-stream

* Parameters: 
  * `streamId`: string
  * `content`: string
  * `role`: "user" | "assistant" (optional)
* Returns: Success confirmation

search-memories

* Parameters: 
  * `query`: string
  * `userId`: string
  * `agentId`: string (optional)
  * `threshold`: number (optional)
* Returns: Search results from Mem0

read-stream

* Parameters: 
  * `streamId`: string
  * `startIndex`: number (optional)
  * `endIndex`: number (optional)
* Returns: Stream content

delete-stream

* Parameters: 
  * `streamId`: string
* Returns: Deletion confirmation

Resources

memory://{streamId} - Access memory stream content directly
memory:// - List all memory streams

Development

The server is implemented using the MCP TypeScript SDK and provides integration with Mem0 for persistent memory storage and semantic search. To extend the implementation:

Add more Mem0 features (e.g., memory tagging, metadata)
Implement proper error handling
Add authentication and authorization
Add additional memory operations

License

MIT

Related MCP Servers & Clients

mem0 mcp-server

mem0 MCP Server: Developer-Friendly Integration Hub