diff --git a/docs/docs.json b/docs/docs.json
index aafc9f099..1540eb477 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -399,8 +399,6 @@
"integrations/langgraph",
"integrations/llama-index",
"integrations/crewai",
- "integrations/autogen",
- "integrations/agno",
"integrations/camel-ai",
"integrations/openai-agents-sdk",
"integrations/google-ai-adk",
@@ -429,12 +427,7 @@
"group": "Developer Tools",
"icon": "wrench",
"pages": [
- "integrations/dify",
- "integrations/flowise",
- "integrations/langchain-tools",
- "integrations/agentops",
- "integrations/keywords",
- "integrations/raycast"
+ "integrations/langchain-tools"
]
}
]
@@ -1101,6 +1094,34 @@
"source": "/v0x/faqs",
"destination": "/platform/faqs"
},
+ {
+ "source": "/integrations/raycast",
+ "destination": "/integrations"
+ },
+ {
+ "source": "/integrations/autogen",
+ "destination": "/integrations"
+ },
+ {
+ "source": "/integrations/keywords",
+ "destination": "/integrations"
+ },
+ {
+ "source": "/integrations/agentops",
+ "destination": "/integrations"
+ },
+ {
+ "source": "/integrations/flowise",
+ "destination": "/integrations"
+ },
+ {
+ "source": "/integrations/agno",
+ "destination": "/integrations"
+ },
+ {
+ "source": "/integrations/dify",
+ "destination": "/integrations"
+ },
{
"source": "/integrations/multion",
"destination": "/integrations"
diff --git a/docs/integrations.mdx b/docs/integrations.mdx
index e07a8394c..9866ae966 100644
--- a/docs/integrations.mdx
+++ b/docs/integrations.mdx
@@ -20,23 +20,6 @@ Here are the available integrations for Mem0:
## Integrations
-
-
-
- }
- href="/integrations/agentops"
- >
- Monitor and analyze Mem0 operations with comprehensive AI agent analytics and LLM observability.
-
Build RAG applications with LlamaIndex and Mem0.
-
-
-
-
- }
- href="/integrations/autogen"
- >
- Build multi-agent systems with persistent memory capabilities.
-
Use Mem0 with LangChain Tools for enhanced agent capabilities.
-
-
-
- }
- href="/integrations/dify"
- >
- Build AI applications with persistent memory using Dify and Mem0.
-
Build conversational AI agents with memory using Pipecat.
-
-
-
- }
- href="/integrations/agno"
- >
- Build autonomous agents with memory using Agno framework.
-
-
-
-
-
- }
- href="/integrations/keywords"
- >
- Build AI applications with persistent memory and comprehensive LLM observability.
-
-
-
-
- }
- href="/integrations/raycast"
- >
- Mem0 Raycast extension for intelligent memory management and retrieval.
-
Integrate Mem0 with Google Agent Development Kit for persistent memory across multi-agent workflows.
-
- Add persistent Mem0 memory to Flowise chatflows for context-aware conversations in the low-code builder.
- Mem0 API Key (optional, for cloud operations)
-
-## Basic Integration Example
-
-The following example demonstrates how to integrate Mem0 with AgentOps monitoring for comprehensive memory operation tracking:
-
-```python
-#Import the required libraries for local memory management with Mem0
-from mem0 import Memory, AsyncMemory
-import os
-import asyncio
-import logging
-from dotenv import load_dotenv
-import agentops
-import openai
-
-load_dotenv()
-#Set up environment variables for API keys
-os.environ["AGENTOPS_API_KEY"] = os.getenv("AGENTOPS_API_KEY")
-os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
-
-#Set up the configuration for local memory storage and define sample user data.
-local_config = {
- "llm": {
- "provider": "openai",
- "config": {
- "model": "gpt-5-mini",
- "temperature": 0.1,
- "max_tokens": 2000,
- },
- }
-}
-user_id = "alice_demo"
-agent_id = "assistant_demo"
-run_id = "session_001"
-
-sample_messages = [
- {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
- {"role": "assistant", "content": "How about a thriller? They can be quite engaging."},
- {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
- {
- "role": "assistant",
- "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future.",
- },
-]
-
-sample_preferences = [
- "I prefer dark roast coffee over light roast",
- "I exercise every morning at 6 AM",
- "I'm vegetarian and avoid all meat products",
- "I love reading science fiction novels",
- "I work in software engineering",
-]
-
-#This function demonstrates sequential memory operations using the synchronous Memory class
-def demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id):
- """
- Demonstrate synchronous Memory class operations.
- """
-
- agentops.start_trace("mem0_memory_example", tags=["mem0_memory_example"])
- try:
-
- memory = Memory.from_config(local_config)
-
- result = memory.add(
- sample_messages, user_id=user_id, metadata={"category": "movie_preferences", "session": "demo"}
- )
-
- for i, preference in enumerate(sample_preferences):
- result = memory.add(preference, user_id=user_id, metadata={"type": "preference", "index": i})
-
- search_queries = [
- "What movies does the user like?",
- "What are the user's food preferences?",
- "When does the user exercise?",
- ]
-
- for query in search_queries:
- results = memory.search(query, filters={"user_id": user_id})
-
- if results and "results" in results:
- for j, result in enumerate(results['results']):
- print(f"Result {j+1}: {result.get('memory', 'N/A')}")
- else:
- print("No results found")
-
- all_memories = memory.get_all(filters={"user_id": user_id})
- if all_memories and "results" in all_memories:
- print(f"Total memories: {len(all_memories['results'])}")
-
- delete_all_result = memory.delete_all(user_id=user_id)
- print(f"Delete all result: {delete_all_result}")
-
- agentops.end_trace(end_state="success")
- except Exception as e:
- agentops.end_trace(end_state="error")
-
-# Execute sync demonstrations
-demonstrate_sync_memory(local_config, sample_messages, sample_preferences, user_id)
-
-```
-
-For detailed information on this integration, refer to the official [Agentops Mem0 integration documentation](https://docs.agentops.ai/v2/integrations/mem0).
-
-
-## Key Features
-
-### 1. Automatic Operation Tracking
-
-AgentOps automatically monitors all Mem0 operations:
-
-- **Memory Operations**: Track add, search, get_all, delete operations and much more
-- **Performance Metrics**: Monitor response times and success rates
-- **Error Tracking**: Capture and analyze operation failures
-
-### 2. Real-time Analytics Dashboard
-
-Access comprehensive analytics through the AgentOps dashboard:
-
-- **Usage Patterns**: Visualize memory usage trends over time
-- **User Behavior**: Analyze how different users interact with memory
-- **Performance Insights**: Identify bottlenecks and optimization opportunities
-
-### 3. Session Management
-
-Organize your monitoring with structured sessions:
-
-- **Session Tracking**: Group related operations into logical sessions
-- **Success/Failure Rates**: Track session outcomes for reliability monitoring
-- **Custom Metadata**: Add context to sessions for better analysis
-
-## Best Practices
-
-1. **Initialize Early**: Always initialize AgentOps before importing Mem0 classes
-2. **Session Management**: Use meaningful session names and end sessions appropriately
-3. **Error Handling**: Wrap operations in try-catch blocks and report failures
-4. **Tagging**: Use tags to organize different types of memory operations
-5. **Environment Separation**: Use different projects or tags for dev/staging/prod
-
-
-
- Monitor multi-agent CrewAI systems
-
-
- Track LangChain agent performance
-
-
-
diff --git a/docs/integrations/agno.mdx b/docs/integrations/agno.mdx
deleted file mode 100644
index 2dbf967f7..000000000
--- a/docs/integrations/agno.mdx
+++ /dev/null
@@ -1,207 +0,0 @@
----
-title: Agno
-description: "Add persistent multimodal memory to Agno-based agents using Mem0 for text and image interactions."
----
-
-This integration of [**Mem0**](https://github.com/mem0ai/mem0) with [Agno](https://github.com/agno-agi/agno) enables persistent, multimodal memory for Agno-based agents - improving personalization, context awareness, and continuity across conversations.
-
-## Overview
-
-1. Store and retrieve memories from Mem0 within Agno agents
-2. Support for multimodal interactions (text and images)
-3. Semantic search for relevant past conversations
-4. Personalized responses based on user history
-5. One-line memory integration via `Mem0Tools`
-
-## Prerequisites
-
-Before setting up Mem0 with Agno, ensure you have:
-
-1. Installed the required packages:
-```bash
-pip install agno mem0ai python-dotenv
-```
-
-2. Valid API keys:
- - Mem0 API Key
- - OpenAI API Key (for the agent model)
-
-## Quick Integration (Using `Mem0Tools`)
-
-The simplest way to integrate Mem0 with Agno Agents is to use Mem0 as a tool using built-in `Mem0Tools`:
-
-```python
-from agno.agent import Agent
-from agno.models.openai import OpenAIChat
-from agno.tools.mem0 import Mem0Tools
-
-agent = Agent(
- name="Memory Agent",
- model=OpenAIChat(id="gpt-5-mini"),
- tools=[Mem0Tools()],
- description="An assistant that remembers and personalizes using Mem0 memory."
-)
-```
-
-This enables memory functionality out of the box:
-
-- **Persistent memory writing**: `Mem0Tools` uses `MemoryClient.add(...)` to store messages from user-agent interactions, including optional metadata such as user ID or session.
-- **Contextual memory search**: Compatible queries use `MemoryClient.search(...)` to retrieve relevant past messages, improving contextual understanding.
-- **Multimodal support**: Both text and image inputs are supported, allowing richer memory records.
-
-> `Mem0Tools` uses the `MemoryClient` under the hood and requires no additional setup. You can customize its behavior by modifying your tools list or extending it in code.
-
-## Full Manual Example
-
-> Note: Mem0 can also be used with Agno Agents as a separate memory layer.
-
-The following example demonstrates how to create an Agno agent with Mem0 memory integration, including support for image processing:
-
-```python
-import base64
-from pathlib import Path
-from typing import Optional
-
-from agno.agent import Agent
-from agno.media import Image
-from agno.models.openai import OpenAIChat
-from mem0 import MemoryClient
-
-# Initialize the Mem0 client
-client = MemoryClient()
-
-# Define the agent
-agent = Agent(
- name="Personal Agent",
- model=OpenAIChat(id="gpt-4"),
- description="You are a helpful personal agent that helps me with day to day activities."
- "You can process both text and images.",
- markdown=True
-)
-
-
-def chat_user(
- user_input: Optional[str] = None,
- user_id: str = "alex",
- image_path: Optional[str] = None
-) -> str:
- """
- Handle user input with memory integration, supporting both text and images.
-
- Args:
- user_input: The user's text input
- user_id: Unique identifier for the user
- image_path: Path to an image file if provided
-
- Returns:
- The agent's response as a string
- """
- if image_path:
- # Convert image to base64
- with open(image_path, "rb") as image_file:
- base64_image = base64.b64encode(image_file.read()).decode("utf-8")
-
- # Create message objects for text and image
- messages = []
-
- if user_input:
- messages.append({
- "role": "user",
- "content": user_input
- })
-
- messages.append({
- "role": "user",
- "content": {
- "type": "image_url",
- "image_url": {
- "url": f"data:image/jpeg;base64,{base64_image}"
- }
- }
- })
-
- # Store messages in memory
- client.add(messages, user_id=user_id)
- print("✅ Image and text stored in memory.")
-
- if user_input:
- # Search for relevant memories
- memories = client.search(user_input, filters={"user_id": user_id})
- memory_context = "\n".join(f"- {m['memory']}" for m in memories['results'])
-
- # Construct the prompt
- prompt = f"""
-You are a helpful personal assistant who helps users with their day-to-day activities and keeps track of everything.
-
-Your task is to:
-1. Analyze the given image (if present) and extract meaningful details to answer the user's question.
-2. Use your past memory of the user to personalize your answer.
-3. Combine the image content and memory to generate a helpful, context-aware response.
-
-Here is what I remember about the user:
-{memory_context}
-
-User question:
-{user_input}
-"""
- # Get response from agent
- if image_path:
- response = agent.run(prompt, images=[Image(filepath=Path(image_path))])
- else:
- response = agent.run(prompt)
-
- # Store the interaction in memory
- interaction_message = [{"role": "user", "content": f"User: {user_input}\nAssistant: {response.content}"}]
- client.add(interaction_message, user_id=user_id)
- return response.content
-
- return "No user input or image provided."
-
-
-# Example Usage
-if __name__ == "__main__":
- response = chat_user(
- "I like to travel and my favorite destination is London",
- image_path="travel_items.jpeg",
- user_id="alex"
- )
- print(response)
-```
-
-## Key Features
-
-### 1. Multimodal Memory Storage
-
-The integration supports storing both text and image data:
-
-- **Text Storage**: Conversation history is saved in a structured format
-- **Image Analysis**: Agents can analyze images and store visual information
-- **Combined Context**: Memory retrieval combines both text and visual data
-
-### 2. Personalized Agent Responses
-
-Improve your agent's context awareness:
-
-- **Memory Retrieval**: Semantic search finds relevant past interactions
-- **User Preferences**: Personalize responses based on stored user information
-- **Continuity**: Maintain conversation threads across multiple sessions
-
-### 3. Flexible Configuration
-
-Customize the integration to your needs:
-
-- **Use `Mem0Tools()`** for drop-in memory support
-- **Use `MemoryClient` directly** for advanced control
-- **User Identification**: Organize memories by user ID
-- **Memory Search**: Configure search relevance and result count
-- **Memory Formatting**: Support for various OpenAI message formats
-
-
-
- Build agents with OpenAI SDK and Mem0
-
-
- Create intelligent agents with Mastra framework
-
-
-
diff --git a/docs/integrations/autogen.mdx b/docs/integrations/autogen.mdx
deleted file mode 100644
index 18192c11c..000000000
--- a/docs/integrations/autogen.mdx
+++ /dev/null
@@ -1,142 +0,0 @@
----
-title: AutoGen
-description: "Build conversational AI agents with AutoGen and Mem0 for context-aware, personalized interactions."
----
-
-Build conversational AI agents with memory capabilities. This integration combines AutoGen for creating AI agents with Mem0 for memory management, enabling context-aware and personalized interactions.
-
-## Overview
-
-This guide demonstrates creating a conversational AI system with memory. We'll build a customer service bot that can recall previous interactions and provide personalized responses.
-
-## Setup and Configuration
-
-Install necessary libraries:
-
-```bash
-pip install autogen mem0ai openai python-dotenv
-```
-
-First, we'll import the necessary libraries and set up our configurations.
-
-Remember to get the Mem0 API key from Mem0 Platform.
-
-```python
-import os
-from autogen import ConversableAgent
-from mem0 import MemoryClient
-from openai import OpenAI
-from dotenv import load_dotenv
-
-load_dotenv()
-
-# Configuration
-# OPENAI_API_KEY = 'sk-xxx' # Replace with your actual OpenAI API key
-# MEM0_API_KEY = 'your-mem0-key' # Replace with your actual Mem0 API key from https://app.mem0.ai
-USER_ID = "alice"
-
-# Set up OpenAI API key
-OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY')
-# os.environ['MEM0_API_KEY'] = MEM0_API_KEY
-
-# Initialize Mem0 and AutoGen agents
-memory_client = MemoryClient()
-agent = ConversableAgent(
- "chatbot",
- llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
- code_execution_config=False,
- human_input_mode="NEVER",
-)
-```
-
-## Storing Conversations in Memory
-
-Add conversation history to Mem0 for future reference:
-
-```python
-conversation = [
- {"role": "assistant", "content": "Hi, I'm Best Buy's chatbot! How can I help you?"},
- {"role": "user", "content": "I'm seeing horizontal lines on my TV."},
- {"role": "assistant", "content": "I'm sorry to hear that. Can you provide your TV model?"},
- {"role": "user", "content": "It's a Sony - 77\" Class BRAVIA XR A80K OLED 4K UHD Smart Google TV"},
- {"role": "assistant", "content": "Thank you for the information. Let's troubleshoot this issue..."}
-]
-
-memory_client.add(messages=conversation, user_id=USER_ID)
-print("Conversation added to memory.")
-```
-
-## Retrieving and Using Memory
-
-Create a function to get context-aware responses based on user's question and previous interactions:
-
-```python
-def get_context_aware_response(question):
- relevant_memories = memory_client.search(question, filters={"user_id": USER_ID})
- context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])])
-
- prompt = f"""Answer the user question considering the previous interactions:
- Previous interactions:
- {context}
-
- Question: {question}
- """
-
- reply = agent.generate_reply(messages=[{"content": prompt, "role": "user"}])
- return reply
-
-# Example usage
-question = "What was the issue with my TV?"
-answer = get_context_aware_response(question)
-print("Context-aware answer:", answer)
-```
-
-## Multi-Agent Conversation
-
-For more complex scenarios, you can create multiple agents:
-
-```python
-manager = ConversableAgent(
- "manager",
- system_message="You are a manager who helps in resolving complex customer issues.",
- llm_config={"config_list": [{"model": "gpt-4", "api_key": OPENAI_API_KEY}]},
- human_input_mode="NEVER"
-)
-
-def escalate_to_manager(question):
- relevant_memories = memory_client.search(question, filters={"user_id": USER_ID})
- context = "\n".join([m["memory"] for m in relevant_memories.get('results', [])])
-
- prompt = f"""
- Context from previous interactions:
- {context}
-
- Customer question: {question}
-
- As a manager, how would you address this issue?
- """
-
- manager_response = manager.generate_reply(messages=[{"content": prompt, "role": "user"}])
- return manager_response
-
-# Example usage
-complex_question = "I'm not satisfied with the troubleshooting steps. What else can be done?"
-manager_answer = escalate_to_manager(complex_question)
-print("Manager's response:", manager_answer)
-```
-
-## Conclusion
-
-By integrating AutoGen with Mem0, you've created a conversational AI system with memory capabilities. This example demonstrates a customer service bot that can recall previous interactions and provide context-aware responses, with the ability to escalate complex issues to a manager agent.
-
-This integration enables the creation of more intelligent and personalized AI agents for various applications, such as customer support, virtual assistants, and interactive chatbots.
-
-
-
- Build multi-agent systems with CrewAI and Mem0
-
-
- Create stateful workflows with LangGraph
-
-
-
diff --git a/docs/integrations/chatdev.mdx b/docs/integrations/chatdev.mdx
index 4e33d1ad5..90d1c5a4c 100644
--- a/docs/integrations/chatdev.mdx
+++ b/docs/integrations/chatdev.mdx
@@ -237,7 +237,7 @@ By adding Mem0 as a memory store in ChatDev, your multi-agent workflows gain per
Build multi-agent systems with CrewAI and Mem0
-
- Build conversational agents with AutoGen and Mem0
+
+ Build conversational agents with OpenAI Agents SDK and Mem0
diff --git a/docs/integrations/crewai.mdx b/docs/integrations/crewai.mdx
index aeef25783..a13260d78 100644
--- a/docs/integrations/crewai.mdx
+++ b/docs/integrations/crewai.mdx
@@ -162,8 +162,8 @@ if __name__ == "__main__":
By combining CrewAI with Mem0, you can create sophisticated AI systems that maintain context and provide personalized experiences while leveraging the power of autonomous agents.
-
- Build multi-agent systems with AutoGen and Mem0
+
+ Build multi-agent systems with OpenAI Agents SDK and Mem0
Create stateful agent workflows with memory
diff --git a/docs/integrations/dify.mdx b/docs/integrations/dify.mdx
deleted file mode 100644
index 84f00a20a..000000000
--- a/docs/integrations/dify.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Dify
-description: "Integrate Mem0 as a plugin in Dify AI workflows for persistent conversation storage and retrieval."
----
-
-# Integrating Mem0 with Dify AI
-
-Mem0 brings a robust memory layer to Dify AI, empowering your AI agents with persistent conversation storage and retrieval capabilities. With Mem0, your Dify applications gain the ability to recall past interactions and maintain context, ensuring more natural and insightful conversations.
-
----
-
-## How to Integrate Mem0 in Your Dify Workflow
-
-1. **Install the Mem0 Plugin:**
- Head to the [Dify Marketplace](https://marketplace.dify.ai/plugins/yevanchen/mem0) and install the Mem0 plugin. This is your first step toward adding intelligent memory to your AI applications.
-
-2. **Create or Open Your Dify Project:**
- Whether you're starting fresh or updating an existing project, simply create or open your Dify workspace.
-
-3. **Add the Mem0 Plugin to Your Project:**
- Within your project, add the Mem0 plugin. This integration connects Mem0’s memory management capabilities directly to your Dify application.
-
-4. **Configure Your Mem0 Settings:**
- Customize Mem0 to suit your needs—set preferences for how conversation history is stored, the search parameters, and any other context-aware features.
-
-5. **Leverage Mem0 in Your Workflow:**
- Use Mem0 to store every conversation turn and retrieve past interactions seamlessly. This integration ensures that your AI agents can refer back to important context, making multi-turn dialogues more effective and user-centric.
-
----
-
-
-
-Enhance your Dify-powered AI with Mem0 and transform your conversational experiences. Start integrating intelligent memory management today and give your agents the context they need to excel!
-
-
-
- Build visual AI workflows with Flowise
-
-
- Create LangChain-powered applications
-
-
diff --git a/docs/integrations/flowise.mdx b/docs/integrations/flowise.mdx
deleted file mode 100644
index 6438cb61b..000000000
--- a/docs/integrations/flowise.mdx
+++ /dev/null
@@ -1,127 +0,0 @@
----
-title: Flowise
-description: "Add persistent Mem0 memory to Flowise chatflows for context-aware conversations in the low-code builder."
----
-
-The [**Mem0 Memory**](https://github.com/mem0ai/mem0) integration with [Flowise](https://github.com/FlowiseAI/Flowise) enables persistent memory capabilities for your AI chatflows. [Flowise](https://flowiseai.com/) is an open-source low-code tool for developers to build customized LLM orchestration flows & AI agents using a drag & drop interface.
-
-## Overview
-
-1. Provides persistent memory storage for Flowise chatflows
-2. Seamless integration with existing Flowise templates
-3. Compatible with various LLM nodes in Flowise
-4. Supports custom memory configurations
-5. Easy to set up and manage
-
-## Prerequisites
-
-Before setting up Mem0 with Flowise, ensure you have:
-
-1. [Flowise installed](https://github.com/FlowiseAI/Flowise#⚡quick-start) (NodeJS >= 18.15.0 required):
-```bash
-npm install -g flowise
-npx flowise start
-```
-
-2. Access to the Flowise UI at http://localhost:3000
-3. Basic familiarity with [Flowise's LLM orchestration](https://flowiseai.com/#features) concepts
-
-## Setup and Configuration
-
-### 1. Set Up Flowise
-
-1. Open the Flowise application and create a new canvas, or select a template from the Flowise marketplace.
-2. In this example, we use the **Conversation Chain** template.
-3. Replace the default **Buffer Memory** with **Mem0 Memory**.
-
-
-
-### 2. Obtain Your Mem0 API Key
-
-1. Navigate to the Mem0 API Key dashboard.
-2. Generate or copy your existing Mem0 API Key.
-
-
-
-### 3. Configure Mem0 Credentials
-
-1. Enter the **Mem0 API Key** in the Mem0 Credentials section.
-2. Configure additional settings as needed:
-
-```typescript
-{
- "apiKey": "m0-xxx",
- "userId": "user-123", // Optional: Specify user ID
- "projectId": "proj-xxx", // Optional: Specify project ID
- "orgId": "org-xxx" // Optional: Specify organization ID
-}
-```
-
-
-
- Configure API Credentials
-
-
-## Memory Features
-
-### 1. Basic Memory Storage
-
-Test your memory configuration:
-
-1. Save your Flowise configuration
-2. Run a test chat and store some information
-3. Verify the stored memories in the Mem0 Dashboard
-
-
-
-### 2. Memory Retention
-
-Validate memory persistence:
-
-1. Clear the chat history in Flowise
-2. Ask a question about previously stored information
-3. Confirm that the AI remembers the context
-
-
-
-## Advanced Configuration
-
-### Memory Settings
-
-
-
-Available settings include:
-
-1. **Search Only Mode**: Enable memory retrieval without creating new memories
-2. **Mem0 Entities**: Configure identifiers:
- - `user_id`: Unique identifier for each user
- - `run_id`: Specific conversation session ID
- - `app_id`: Application identifier
- - `agent_id`: AI agent identifier
-3. **Project ID**: Assign memories to specific projects
-4. **Organization ID**: Organize memories by organization
-
-### Platform Configuration
-
-Additional settings available in Mem0 Project Settings:
-
-1. **Custom Instructions**: Define memory extraction rules
-2. **Expiration Date**: Set automatic memory cleanup periods
-
-
-
-## Best Practices
-
-1. **User Identification**: Use consistent `user_id` values for reliable memory retrieval
-2. **Memory Organization**: Utilize projects and organizations for better memory management
-3. **Regular Maintenance**: Monitor and clean up unused memories periodically
-
-
-
- Build LangChain-powered flows with memory
-
-
- Create AI workflows with Dify platform
-
-
-
diff --git a/docs/integrations/keywords.mdx b/docs/integrations/keywords.mdx
deleted file mode 100644
index 0b19c825a..000000000
--- a/docs/integrations/keywords.mdx
+++ /dev/null
@@ -1,142 +0,0 @@
----
-title: Keywords AI
-description: "Combine Mem0 persistent memory with Keywords AI observability for tracked, cost-optimized AI applications."
----
-
-Build AI applications with persistent memory and comprehensive LLM observability by integrating Mem0 with Keywords AI.
-
-## Overview
-
-Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Keywords AI provides complete LLM observability.
-
-Combining Mem0 with Keywords AI allows you to:
-1. Add persistent memory to your AI applications
-2. Track interactions across sessions
-3. Monitor memory usage and retrieval with Keywords AI observability
-4. Optimize token usage and reduce costs
-
-
-You can get your Mem0 API key from the Mem0 dashboard.
-
-
-## Setup and Configuration
-
-Install the necessary libraries:
-
-```bash
-pip install mem0ai keywordsai-sdk
-```
-
-Set up your environment variables:
-
-```python
-import os
-
-# Set your API keys
-os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
-os.environ["KEYWORDSAI_API_KEY"] = "your-keywords-api-key"
-os.environ["KEYWORDSAI_BASE_URL"] = "https://api.keywordsai.co/api/"
-```
-
-## Basic Integration Example
-
-Here's a simple example of using Mem0 with Keywords AI:
-
-```python
-from mem0 import Memory
-import os
-
-# Configuration
-api_key = os.getenv("MEM0_API_KEY")
-keywordsai_api_key = os.getenv("KEYWORDSAI_API_KEY")
-base_url = os.getenv("KEYWORDSAI_BASE_URL") # "https://api.keywordsai.co/api/"
-
-# Set up Mem0 with Keywords AI as the LLM provider
-config = {
- "llm": {
- "provider": "openai",
- "config": {
- "model": "gpt-5-mini",
- "temperature": 0.0,
- "api_key": keywordsai_api_key,
- "openai_base_url": base_url,
- },
- }
-}
-
-# Initialize Memory
-memory = Memory.from_config(config)
-
-# Add a memory
-result = memory.add(
- "I like to take long walks on weekends.",
- user_id="alice",
- metadata={"category": "hobbies"},
-)
-
-print(result)
-```
-
-## Advanced Integration with OpenAI SDK
-
-For more advanced use cases, you can integrate Keywords AI with Mem0 through the OpenAI SDK:
-
-```python
-from openai import OpenAI
-import os
-import json
-
-# Initialize client
-client = OpenAI(
- api_key=os.environ.get("KEYWORDSAI_API_KEY"),
- base_url=os.environ.get("KEYWORDSAI_BASE_URL"),
-)
-
-# Sample conversation messages
-messages = [
- {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
- {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
- {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
- {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
-]
-
-# Add memory and generate a response
-response = client.chat.completions.create(
- model="openai/gpt-4.1-nano",
- messages=messages,
- extra_body={
- "mem0_params": {
- "user_id": "test_user",
- "api_key": os.environ.get("MEM0_API_KEY"),
- "add_memories": {
- "messages": messages,
- },
- }
- },
-)
-
-print(json.dumps(response.model_dump(), indent=4))
-```
-
-For detailed information on this integration, refer to the official [Keywords AI Mem0 integration documentation](https://docs.keywordsai.co/integration/development-frameworks/mem0).
-
-## Key Features
-
-1. **Memory Integration**: Store and retrieve relevant information from past interactions
-2. **LLM Observability**: Track memory usage and retrieval patterns with Keywords AI
-3. **Session Persistence**: Maintain context across multiple user sessions
-4. **Cost Optimization**: Reduce token usage through efficient memory retrieval
-
-## Conclusion
-
-Integrating Mem0 with Keywords AI provides a powerful combination for building AI applications with persistent memory and comprehensive observability. This integration enables more personalized user experiences while providing insights into your application's memory usage.
-
-
-
- Build monitored agents with OpenAI SDK
-
-
- Monitor agent performance with AgentOps
-
-
-
diff --git a/docs/integrations/raycast.mdx b/docs/integrations/raycast.mdx
deleted file mode 100644
index df1f69865..000000000
--- a/docs/integrations/raycast.mdx
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "Raycast Extension"
-description: "Mem0 Raycast extension for intelligent memory management"
----
-
-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
-
-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, 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 repeatedly. Your AI remembers your context and preferences.
-
-
-
- Build desktop AI agents with OpenAI SDK
-
-
- Create intelligent desktop workflows
-
-
diff --git a/docs/llms.txt b/docs/llms.txt
index 54ded1e07..b27ce9573 100644
--- a/docs/llms.txt
+++ b/docs/llms.txt
@@ -231,8 +231,6 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
- [LangChain Tools](https://docs.mem0.ai/integrations/langchain-tools) [Both]: Use when Mem0 should be exposed as a LangChain tool.
- [LlamaIndex](https://docs.mem0.ai/integrations/llama-index) [Both]: Use when layering memory on a LlamaIndex RAG app.
- [CrewAI](https://docs.mem0.ai/integrations/crewai) [Both]: Use when building CrewAI multi-agent systems.
-- [AutoGen](https://docs.mem0.ai/integrations/autogen) [Both]: Use when the user is on Microsoft AutoGen.
-- [Agno](https://docs.mem0.ai/integrations/agno) [Both]: Use when the user is on Agno.
- [Camel AI](https://docs.mem0.ai/integrations/camel-ai) [Both]: Use when the user is on Camel AI.
- [ChatDev](https://docs.mem0.ai/integrations/chatdev) [Both]: Use when the user is on ChatDev.
- [Hermes](https://docs.mem0.ai/integrations/hermes) [Both]: Use when the user is on Hermes.
@@ -255,12 +253,6 @@ If the user is on a pre-current major (Python < 2, TS < 3, or Platform `output_f
### Cloud & Infrastructure
- [AWS Bedrock](https://docs.mem0.ai/integrations/aws-bedrock) [Both]: Use when the user is on AWS Bedrock managed AI services.
-### Developer Tools
-- [Dify](https://docs.mem0.ai/integrations/dify) [Both]: Use when the user is on Dify LLMOps.
-- [Flowise](https://docs.mem0.ai/integrations/flowise) [Both]: Use when the user is on Flowise no-code.
-- [AgentOps](https://docs.mem0.ai/integrations/agentops) [Both]: Use when tracking agent observability with memory metadata.
-- [Keywords AI](https://docs.mem0.ai/integrations/keywords) [Both]: Use when monitoring with Keywords AI.
-- [Raycast](https://docs.mem0.ai/integrations/raycast) [Both]: Use when the user wants quick memory access via Raycast.
## Cookbooks
-