Mem0 Docs

Mem0 home page

Search...

Ctrl KAsk AI

Search...

Navigation

Agent Frameworks

Mastra

Welcome Mem0 Platform Open Source Cookbooks Integrations API Reference Release Notes

Documentation

Overview

Overview

Agent Frameworks

Voice & Real-time

Cloud & Infrastructure

AWS Bedrock

Developer Tools

On this page

The Mastra integration demonstrates how to use Mastra’s agent system with Mem0 as the memory backend through custom tools. This enables agents to remember and recall information across conversations.

Overview

In this guide, we’ll create a Mastra agent that:

Uses Mem0 to store information using a memory tool
Retrieves relevant memories using a search tool
Provides personalized responses based on past interactions
Maintains context across conversations and sessions

Setup and Configuration

Install the required libraries:

npm install @mastra/core @mastra/mem0 @ai-sdk/openai zod

Set up your environment variables:

Remember to get the Mem0 API key from Mem0 Platform.

MEM0_API_KEY=your-mem0-api-key
OPENAI_API_KEY=your-openai-api-key

Initialize Mem0 Integration

Import required modules and set up the Mem0 integration:

import { Mem0Integration } from '@mastra/mem0';
import { createTool } from '@mastra/core/tools';
import { Agent } from '@mastra/core/agent';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

// Initialize Mem0 integration
const mem0 = new Mem0Integration({
  config: {
    apiKey: process.env.MEM0_API_KEY || '',
    user_id: 'alice', // Unique user identifier
  },
});

Create Memory Tools

Set up tools for memorizing and remembering information:

// Tool for remembering saved memories
const mem0RememberTool = createTool({
  id: 'Mem0-remember',
  description: "Remember your agent memories that you've previously saved using the Mem0-memorize tool.",
  inputSchema: z.object({
    question: z.string().describe('Question used to look up the answer in saved memories.'),
  }),
  outputSchema: z.object({
    answer: z.string().describe('Remembered answer'),
  }),
  execute: async ({ context }) => {
    console.log(`Searching memory "${context.question}"`);
    const memory = await mem0.searchMemory(context.question);
    console.log(`\nFound memory "${memory}"\n`);

    return {
      answer: memory,
    };
  },
});

// Tool for saving new memories
const mem0MemorizeTool = createTool({
  id: 'Mem0-memorize',
  description: 'Save information to mem0 so you can remember it later using the Mem0-remember tool.',
  inputSchema: z.object({
    statement: z.string().describe('A statement to save into memory'),
  }),
  execute: async ({ context }) => {
    console.log(`\nCreating memory "${context.statement}"\n`);
    // To reduce latency, memories can be saved async without blocking tool execution
    void mem0.createMemory(context.statement).then(() => {
      console.log(`\nMemory "${context.statement}" saved.\n`);
    });
    return { success: true };
  },
});

Create Mastra Agent

Initialize an agent with memory tools and clear instructions:

// Create an agent with memory tools
const mem0Agent = new Agent({
  name: 'Mem0 Agent',
  instructions: `
    You are a helpful assistant that has the ability to memorize and remember facts using Mem0.
    Use the Mem0-memorize tool to save important information that might be useful later.
    Use the Mem0-remember tool to recall previously saved information when answering questions.
  `,
  model: openai('gpt-4.1-nano'),
  tools: { mem0RememberTool, mem0MemorizeTool },
});

Key Features

Tool-based Memory Control: The agent decides when to save and retrieve information using specific tools
Semantic Search: Mem0 finds relevant memories based on semantic similarity, not just exact matches
User-specific Memory Spaces: Each user_id maintains separate memory contexts
Asynchronous Saving: Memories are saved in the background to reduce response latency
Cross-conversation Persistence: Memories persist across different conversation threads
Transparent Operations: Memory operations are visible through tool usage

Conclusion

By integrating Mastra with Mem0, you can build intelligent agents that learn and remember information across conversations. The tool-based approach provides transparency and control over memory operations, making it easy to create personalized and context-aware AI experiences.

Mastra Agent Cookbook \ \ Build a complete Mastra agent with persistent memory

Vercel AI SDK Integration \ \ Create web applications with Vercel AI SDK

Was this page helpful?

YesNo

Suggest edits Raise issue

Google ADK\ \ Previous Vercel AI SDK\ \ Next

Ctrl+I

Assistant

Responses are generated using AI and may contain mistakes.

Suggestions

Can agents recall past conversations?How do I set up Mem0?How do I create memory tools?

Contact support