From 6cebddebbe32d23442175d392737be3e1a37bb13 Mon Sep 17 00:00:00 2001 From: Dev Khant Date: Fri, 23 May 2025 16:10:47 +0530 Subject: [PATCH] Doc: Mastra and Raycast (#2781) --- docs/docs.json | 4 +- docs/integrations.mdx | 56 ++++++++++++++ docs/integrations/mastra.mdx | 136 ++++++++++++++++++++++++++++++++++ docs/integrations/raycast.mdx | 47 ++++++++++++ 4 files changed, 242 insertions(+), 1 deletion(-) create mode 100644 docs/integrations/mastra.mdx create mode 100644 docs/integrations/raycast.mdx diff --git a/docs/docs.json b/docs/docs.json index 3273f7aa..d3a97d34 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -248,7 +248,9 @@ "integrations/elevenlabs", "integrations/pipecat", "integrations/agno", - "integrations/keywords" + "integrations/keywords", + "integrations/raycast", + "integrations/mastra" ] } ] diff --git a/docs/integrations.mdx b/docs/integrations.mdx index 02206ac9..d54cacf0 100644 --- a/docs/integrations.mdx +++ b/docs/integrations.mdx @@ -322,4 +322,60 @@ Here are the available integrations for Mem0: > Build AI applications with persistent memory and comprehensive LLM observability. + + + + } + href="/integrations/raycast" + > + Mem0 Raycast extension for intelligent memory management and retrieval. + + + + + + + } + href="/integrations/mastra" + > + Build AI agents with persistent memory using Mastra's framework and tools. + diff --git a/docs/integrations/mastra.mdx b/docs/integrations/mastra.mdx new file mode 100644 index 00000000..78bccc76 --- /dev/null +++ b/docs/integrations/mastra.mdx @@ -0,0 +1,136 @@ +--- +title: Mastra +--- + + + +The [**Mastra**](https://mastra.ai/) 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: +1. Uses Mem0 to store information using a memory tool +2. Retrieves relevant memories using a search tool +3. Provides personalized responses based on past interactions +4. Maintains context across conversations and sessions + +## Setup and Configuration + +Install the required libraries: + +```bash +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](https://app.mem0.ai). + +```bash +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: + +```typescript +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: + +```typescript +// 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: + +```typescript +// 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-4o'), + tools: { mem0RememberTool, mem0MemorizeTool }, +}); +``` + + +## Key Features + +1. **Tool-based Memory Control**: The agent decides when to save and retrieve information using specific tools +2. **Semantic Search**: Mem0 finds relevant memories based on semantic similarity, not just exact matches +3. **User-specific Memory Spaces**: Each user_id maintains separate memory contexts +4. **Asynchronous Saving**: Memories are saved in the background to reduce response latency +5. **Cross-conversation Persistence**: Memories persist across different conversation threads +6. **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. + +## Help + +- For more details on Mastra, visit the [Mastra documentation](https://docs.mastra.ai/). +- For Mem0 documentation, refer to the [Mem0 Platform](https://app.mem0.ai/). +- If you need further assistance, please feel free to reach out to us through the following methods: + + \ No newline at end of file diff --git a/docs/integrations/raycast.mdx b/docs/integrations/raycast.mdx new file mode 100644 index 00000000..fc12cda0 --- /dev/null +++ b/docs/integrations/raycast.mdx @@ -0,0 +1,47 @@ +--- +title: "Raycast Extension" +description: "Mem0 Raycast extension for intelligent memory management" +--- + +# Mem0 + +Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. This extension lets you store and retrieve text snippets using Mem0's intelligent memory system. Find Mem0 in [Raycast Store](https://www.raycast.com/dev_khant/mem0) for using it. + +## 🚀 Getting Started + +**Get your API Key**: You'll need a Mem0 API key to use this extension: + +a. Sign up at [app.mem0.ai](https://app.mem0.ai) + +b. Navigate to your API Keys page + +c. Copy your API key + +d. Enter this key in the extension preferences + +**Basic Usage**: + +- Store memories and text snippets +- Retrieve context-aware information +- Manage persistent user preferences +- Search through stored memories + +## ✨ Features + +**Remember Everything**: Never lose important information - store notes, preferences, and conversations that your AI can recall later + +**Smart Connections**: Automatically links related topics, just like your brain does - helping you discover useful connections + +**Cost Saver**: Spend less on AI usage by efficiently retrieving relevant information instead of regenerating responses + +## 🔑 How This Helps You + +**More Personal Experience**: Your AI remembers your preferences and past conversations, making interactions feel more natural + +**Learn Your Style**: Adapts to how you work and what you like, becoming more helpful over time + +**No More Repetition**: Stop explaining the same things over and over - your AI remembers your context and preferences + +--- + +