From 89e786a88e9b3bd85234c3fb8e23a3224451bdbd Mon Sep 17 00:00:00 2001
From: Prateek Chhikara <46902268+prateekchhikara@users.noreply.github.com>
Date: Tue, 11 Mar 2025 13:36:20 -0700
Subject: [PATCH] Added agentic tool in docs (#2361)
---
docs/docs.json | 3 +-
docs/examples/mem0-agentic-tool.mdx | 226 ++++++++++++++++++++++++++++
docs/examples/overview.mdx | 4 +
3 files changed, 232 insertions(+), 1 deletion(-)
create mode 100644 docs/examples/mem0-agentic-tool.mdx
diff --git a/docs/docs.json b/docs/docs.json
index c4b4f738..cad869c1 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -186,7 +186,8 @@
"examples/chrome-extension",
"examples/document-writing",
"examples/multimodal-demo",
- "examples/personalized-deep-research"
+ "examples/personalized-deep-research",
+ "examples/mem0-agentic-tool"
]
}
]
diff --git a/docs/examples/mem0-agentic-tool.mdx b/docs/examples/mem0-agentic-tool.mdx
new file mode 100644
index 00000000..d146d2ec
--- /dev/null
+++ b/docs/examples/mem0-agentic-tool.mdx
@@ -0,0 +1,226 @@
+---
+title: Mem0 as an Agentic Tool
+---
+
+Integrate Mem0's memory capabilities with OpenAI's Agents SDK to create AI agents with persistent memory.
+You can create agents that remember past conversations and use that context to provide better responses.
+
+## Installation
+
+First, install the required packages:
+```bash
+pip install mem0ai pydantic openai-agents
+```
+
+You'll also need a custom agents framework for this implementation.
+
+## Setting Up Environment Variables
+
+Store your Mem0 API key as an environment variable:
+
+```bash
+export MEM0_API_KEY="your_mem0_api_key"
+```
+
+Or in your Python script:
+
+```python
+import os
+os.environ["MEM0_API_KEY"] = "your_mem0_api_key"
+```
+
+## Code Structure
+
+The integration consists of three main components:
+
+1. **Context Manager**: Defines user context for memory operations
+2. **Memory Tools**: Functions to add, search, and retrieve memories
+3. **Memory Agent**: An agent configured to use these memory tools
+
+## Step-by-Step Implementation
+
+### 1. Import Dependencies
+
+```python
+from __future__ import annotations
+import os
+import asyncio
+from pydantic import BaseModel
+try:
+ from mem0 import AsyncMemoryClient
+except ImportError:
+ raise ImportError("mem0 is not installed. Please install it using 'pip install mem0ai'.")
+from agents import (
+ Agent,
+ ItemHelpers,
+ MessageOutputItem,
+ RunContextWrapper,
+ Runner,
+ ToolCallItem,
+ ToolCallOutputItem,
+ TResponseInputItem,
+ function_tool,
+)
+```
+
+### 2. Define Memory Context
+
+```python
+class Mem0Context(BaseModel):
+ user_id: str | None = None
+```
+
+### 3. Initialize the Mem0 Client
+
+```python
+client = AsyncMemoryClient(api_key=os.getenv("MEM0_API_KEY"))
+```
+
+### 4. Create Memory Tools
+
+#### Add to Memory
+
+```python
+@function_tool
+async def add_to_memory(
+ context: RunContextWrapper[Mem0Context],
+ content: str,
+) -> str:
+ """
+ Add a message to Mem0
+ Args:
+ content: The content to store in memory.
+ """
+ messages = [{"role": "user", "content": content}]
+ user_id = context.context.user_id or "default_user"
+ await client.add(messages, user_id=user_id)
+ return f"Stored message: {content}"
+```
+
+#### Search Memory
+
+```python
+@function_tool
+async def search_memory(
+ context: RunContextWrapper[Mem0Context],
+ query: str,
+) -> str:
+ """
+ Search for memories in Mem0
+ Args:
+ query: The search query.
+ """
+ user_id = context.context.user_id or "default_user"
+ memories = await client.search(query, user_id=user_id, output_format="v1.1")
+ results = '\n'.join([result["memory"] for result in memories["results"]])
+ return str(results)
+```
+
+#### Get All Memories
+
+```python
+@function_tool
+async def get_all_memory(
+ context: RunContextWrapper[Mem0Context],
+) -> str:
+ """Retrieve all memories from Mem0"""
+ user_id = context.context.user_id or "default_user"
+ memories = await client.get_all(user_id=user_id, output_format="v1.1")
+ results = '\n'.join([result["memory"] for result in memories["results"]])
+ return str(results)
+```
+
+### 5. Configure the Memory Agent
+
+```python
+memory_agent = Agent[Mem0Context](
+ name="Memory Assistant",
+ instructions="""You are a helpful assistant with memory capabilities. You can:
+ 1. Store new information using add_to_memory
+ 2. Search existing information using search_memory
+ 3. Retrieve all stored information using get_all_memory
+ When users ask questions:
+ - If they want to store information, use add_to_memory
+ - If they're searching for specific information, use search_memory
+ - If they want to see everything stored, use get_all_memory""",
+ tools=[add_to_memory, search_memory, get_all_memory],
+)
+```
+
+### 6. Implement the Main Runtime Loop
+
+```python
+async def main():
+ current_agent: Agent[Mem0Context] = memory_agent
+ input_items: list[TResponseInputItem] = []
+ context = Mem0Context()
+ while True:
+ user_input = input("Enter your message (or 'quit' to exit): ")
+ if user_input.lower() == 'quit':
+ break
+ input_items.append({"content": user_input, "role": "user"})
+ result = await Runner.run(current_agent, input_items, context=context)
+ for new_item in result.new_items:
+ agent_name = new_item.agent.name
+ if isinstance(new_item, MessageOutputItem):
+ print(f"{agent_name}: {ItemHelpers.text_message_output(new_item)}")
+ elif isinstance(new_item, ToolCallItem):
+ print(f"{agent_name}: Calling a tool")
+ elif isinstance(new_item, ToolCallOutputItem):
+ print(f"{agent_name}: Tool call output: {new_item.output}")
+ else:
+ print(f"{agent_name}: Skipping item: {new_item.__class__.__name__}")
+ input_items = result.to_input_list()
+
+if __name__ == "__main__":
+ asyncio.run(main())
+```
+
+## Usage Examples
+
+### Storing Information
+
+```
+User: Remember that my favorite color is blue
+Agent: Calling a tool
+Agent: Tool call output: Stored message: my favorite color is blue
+Agent: I've stored that your favorite color is blue in my memory. I'll remember that for future conversations.
+```
+
+### Searching Memory
+
+```
+User: What's my favorite color?
+Agent: Calling a tool
+Agent: Tool call output: my favorite color is blue
+Agent: Your favorite color is blue, based on what you've told me earlier.
+```
+
+### Retrieving All Memories
+
+```
+User: What do you know about me?
+Agent: Calling a tool
+Agent: Tool call output: favorite color is blue
+my birthday is on March 15
+Agent: Based on our previous conversations, I know that:
+1. Your favorite color is blue
+2. Your birthday is on March 15
+```
+
+## Advanced Configuration
+
+### Custom User IDs
+
+You can specify different user IDs to maintain separate memory stores for multiple users:
+
+```python
+context = Mem0Context(user_id="user123")
+```
+
+
+## Resources
+
+- [Mem0 Documentation](https://docs.mem0.ai)
+- [Mem0 Dashboard](https://app.mem0.ai/dashboard)
+- [API Reference](https://docs.mem0.ai/api-reference)
diff --git a/docs/examples/overview.mdx b/docs/examples/overview.mdx
index 9914e709..5566d4cb 100644
--- a/docs/examples/overview.mdx
+++ b/docs/examples/overview.mdx
@@ -58,4 +58,8 @@ Explore how **Mem0** can power real-world applications and bring personalized, i
Build a **Deep Research AI** that remembers your research goals and compiles insights from vast information sources.
+
+
+ Integrate Mem0's memory capabilities with OpenAI's Agents SDK to create AI agents with persistent memory.
+