diff --git a/docs/docs.json b/docs/docs.json index 80faa1c9..71b1f0b0 100644 --- a/docs/docs.json +++ b/docs/docs.json @@ -252,6 +252,7 @@ "integrations/agno", "integrations/autogen", "integrations/crewai", + "integrations/openai-agents-sdk", "integrations/mastra", "integrations/vercel-ai-sdk", "integrations/livekit", diff --git a/docs/integrations/openai-agents-sdk.mdx b/docs/integrations/openai-agents-sdk.mdx new file mode 100644 index 00000000..6b9a3e48 --- /dev/null +++ b/docs/integrations/openai-agents-sdk.mdx @@ -0,0 +1,234 @@ +--- +title: OpenAI Agents SDK +--- + + + +Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [OpenAI Agents SDK](https://github.com/openai/openai-agents-python), a lightweight framework for building multi-agent workflows. This integration enables agents to access persistent memory across conversations, enhancing context retention and personalization. + +## Overview + +1. Store and retrieve memories from Mem0 within OpenAI agents +2. Multi-agent workflows with shared memory +3. Semantic search for relevant past conversations +4. Personalized responses based on user history + +## Prerequisites + +Before setting up Mem0 with OpenAI Agents SDK, ensure you have: + +1. Installed the required packages: +```bash +pip install openai-agents mem0ai +``` + +2. Valid API keys: + - [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys) + - [OpenAI API Key](https://platform.openai.com/api-keys) + +## Basic Integration Example + +The following example demonstrates how to create an OpenAI agent with Mem0 memory integration: + +```python +import os +from agents import Agent, Runner, function_tool +from mem0 import MemoryClient + +# Set up environment variables +os.environ["OPENAI_API_KEY"] = "your-openai-api-key" +os.environ["MEM0_API_KEY"] = "your-mem0-api-key" + +# Initialize Mem0 client +mem0 = MemoryClient() + +# Define memory tools for the agent +@function_tool +def search_memory(query: str, user_id: str = "default") -> str: + """Search through past conversations and memories""" + memories = mem0.search(query, user_id=user_id, limit=3) + if memories: + return "\n".join([f"- {mem['memory']}" for mem in memories]) + return "No relevant memories found." + +@function_tool +def save_memory(content: str, user_id: str = "default") -> str: + """Save important information to memory""" + mem0.add([{"role": "user", "content": content}], user_id=user_id) + return "Information saved to memory." + +# Create agent with memory capabilities +agent = Agent( + name="Personal Assistant", + instructions="""You are a helpful personal assistant with memory capabilities. + Use the search_memory tool to recall past conversations and user preferences. + Use the save_memory tool to store important information about the user. + Always personalize your responses based on available memory.""", + tools=[search_memory, save_memory], + model="gpt-4o" +) + +def chat_with_memory(user_input: str, user_id: str) -> str: + """ + Handle user input with automatic memory integration. + + Args: + user_input: The user's message + user_id: Unique identifier for the user + + Returns: + The agent's response + """ + # Run the agent (it will automatically use memory tools when needed) + result = Runner.run_sync(agent, user_input) + + # Store the conversation in memory + conversation = [ + {"role": "user", "content": user_input}, + {"role": "assistant", "content": result.final_output} + ] + mem0.add(conversation, user_id=user_id) + + return result.final_output + +# Example usage +if __name__ == "__main__": + response = chat_with_memory( + "I love Italian food and I'm planning a trip to Rome next month", + user_id="alice" + ) + print(response) +``` + +## Multi-Agent Workflow with Handoffs + +Create multiple specialized agents with proper handoffs and shared memory: + +```python +from agents import Agent, Runner, handoffs, function_tool + +# Specialized agents +travel_agent = Agent( + name="Travel Planner", + instructions="""You are a travel planning specialist. Use get_user_context to + understand the user's travel preferences and history before making recommendations. + After providing your response, use store_conversation to save important details.""", + tools=[search_memory, save_memory], + model="gpt-4o" +) + +health_agent = Agent( + name="Health Advisor", + instructions="""You are a health and wellness advisor. Use get_user_context to + understand the user's health goals and dietary preferences. + After providing advice, use store_conversation to save relevant information.""", + tools=[search_memory, save_memory], + model="gpt-4o" +) + +# Triage agent with handoffs +triage_agent = Agent( + name="Personal Assistant", + instructions="""You are a helpful personal assistant that routes requests to specialists. + For travel-related questions (trips, hotels, flights, destinations), hand off to Travel Planner. + For health-related questions (fitness, diet, wellness, exercise), hand off to Health Advisor. + For general questions, you can handle them directly using available tools.""", + tools=[get_user_context], + handoffs=[travel_agent, health_agent], + model="gpt-4o" +) + +def chat_with_handoffs(user_input: str, user_id: str = "default") -> str: + """ + Handle user input with automatic agent handoffs and memory integration. + + Args: + user_input: The user's message + user_id: Unique identifier for the user + + Returns: + The agent's response + """ + # Run the triage agent (it will automatically handoff when needed) + result = Runner.run_sync(triage_agent, user_input) + + # Store the original conversation in memory + conversation = [ + {"role": "user", "content": user_input}, + {"role": "assistant", "content": result.final_output} + ] + mem0.add(conversation, user_id=user_id) + + return result.final_output + +# Example usage +response = chat_with_handoffs("Plan a healthy meal for my Italy trip", user_id="alex") +print(response) +``` + +## Quick Start Chat Interface + +Simple interactive chat with memory: + +```python +def interactive_chat(): + """Interactive chat interface with memory and handoffs""" + user_id = input("Enter your user ID: ") or "demo_user" + print(f"Chat started for user: {user_id}") + print("Type 'quit' to exit\n") + + while True: + user_input = input("You: ") + if user_input.lower() == 'quit': + break + + response = chat_with_handoffs(user_input, user_id) + print(f"Assistant: {response}\n") + +if __name__ == "__main__": + interactive_chat() +``` + +## Key Features + +### 1. Automatic Memory Integration +- **Tool-Based Memory**: Agents use function tools to search and save memories +- **Conversation Storage**: All interactions are automatically stored +- **Context Retrieval**: Agents can access relevant past conversations + +### 2. Multi-Agent Memory Sharing +- **Shared Context**: Multiple agents access the same memory store +- **Specialized Agents**: Create domain-specific agents with shared memory +- **Seamless Handoffs**: Agents maintain context across handoffs + +### 3. Flexible Memory Operations +- **Retrieve Capabilities**: Retrieve relevant memories from previous conversation +- **User Segmentation**: Organize memories by user ID +- **Memory Management**: Built-in tools for saving and retrieving information + +## Configuration Options + +Customize memory behavior: + +```python +# Configure memory search +memories = mem0.search( + query="travel preferences", + user_id="alex", + limit=5 # Number of memories to retrieve +) + +# Add metadata to memories +mem0.add( + messages=[{"role": "user", "content": "I prefer luxury hotels"}], + user_id="alex", + metadata={"category": "travel", "importance": "high"} +) +``` + +## Help + +- [OpenAI Agents SDK Documentation](https://openai.github.io/openai-agents-python/) +- [Mem0 Platform](https://app.mem0.ai/) + + \ No newline at end of file