Fix mem0-migrations issue (#2597 )

Removed Grok3 Announcement (#2593 )
Docs Update (#2591 )
2025-05-01 01:14:57 +05:30 · 2025-04-29 08:23:13 -07:00 · 2025-04-29 08:15:25 -07:00 · 2025-04-28 12:53:52 +05:30 · 2025-04-26 16:40:56 +05:30 · 2025-04-26 16:22:20 +05:30
325 changed files with 35972 additions and 3869 deletions
@@ -13,7 +13,8 @@ install:
 install_all:
 	poetry install
 	poetry run pip install groq together boto3 litellm ollama chromadb weaviate weaviate-client sentence_transformers vertexai \
-	                        google-generativeai elasticsearch opensearch-py vecs pinecone pinecone-text
+	                        google-generativeai elasticsearch opensearch-py vecs pinecone pinecone-text faiss-cpu langchain-community \
+							upstash-vector azure-search-documents langchain-memgraph

 # Format code with ruff
 format:
@@ -1,24 +1,20 @@
 <p align="center">
  <a href="https://github.com/mem0ai/mem0">
-  <img src="docs/images/banner-sm.png" width="800px" alt="Mem0 - The Memory Layer for Personalized AI">
+    <img src="docs/images/banner-sm.png" width="800px" alt="Mem0 - The Memory Layer for Personalized AI">
  </a>
+</p>
 <p align="center" style="display: flex; justify-content: center; gap: 20px; align-items: center;">
-  <a href="https://trendshift.io/repositories/11194" target="_blank">
-    <img src="https://trendshift.io/api/badge/repositories/11194" alt="mem0ai%2Fmem0 | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/>
-  </a>
-  <a href="https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps" target="_blank">
-    <img alt="Launch YC: Mem0 - Open Source Memory Layer for AI Apps" src="https://www.ycombinator.com/launches/LpA-mem0-open-source-memory-layer-for-ai-apps/upvote_embed.svg"/>
+  <a href="https://trendshift.io/repositories/11194" target="blank">
+    <img src="https://trendshift.io/api/badge/repositories/11194" alt="mem0ai%2Fmem0 | Trendshift" width="250" height="55"/>
  </a>
 </p>

-
-  <p align="center">
-    <a href="https://mem0.ai">Learn more</a>
-    ·
-    <a href="https://mem0.dev/DiG">Join Discord</a>
-    ·
-    <a href="https://mem0.dev/demo">Demo</a>
-  </p>
+<p align="center">
+  <a href="https://mem0.ai">Learn more</a>
+  ·
+  <a href="https://mem0.dev/DiG">Join Discord</a>
+  ·
+  <a href="https://mem0.dev/demo">Demo</a>
 </p>

 <p align="center">
@@ -26,55 +22,71 @@
    <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Mem0 Discord">
  </a>
  <a href="https://pepy.tech/project/mem0ai">
-    <img src="https://img.shields.io/pypi/dm/mem0ai" alt="Mem0 PyPI - Downloads" >
+    <img src="https://img.shields.io/pypi/dm/mem0ai" alt="Mem0 PyPI - Downloads">
  </a>
  <a href="https://github.com/mem0ai/mem0">
    <img src="https://img.shields.io/github/commit-activity/m/mem0ai/mem0?style=flat-square" alt="GitHub commit activity">
  </a>
-  <a href="https://pypi.org/project/mem0ai" target="_blank">
-        <img src="https://img.shields.io/pypi/v/mem0ai?color=%2334D058&label=pypi%20package" alt="Package version">
-    </a>
-    <a href="https://www.npmjs.com/package/mem0ai" target="_blank">
-        <img src="https://img.shields.io/npm/v/mem0ai" alt="Npm package">
-    </a>
+  <a href="https://pypi.org/project/mem0ai" target="blank">
+    <img src="https://img.shields.io/pypi/v/mem0ai?color=%2334D058&label=pypi%20package" alt="Package version">
+  </a>
+  <a href="https://www.npmjs.com/package/mem0ai" target="blank">
+    <img src="https://img.shields.io/npm/v/mem0ai" alt="Npm package">
+  </a>
  <a href="https://www.ycombinator.com/companies/mem0">
    <img src="https://img.shields.io/badge/Y%20Combinator-S24-orange?style=flat-square" alt="Y Combinator S24">
  </a>
 </p>

+<p align="center">
+  <a href="https://mem0.ai/research"><strong>📄 Building Production-Ready AI Agents with Scalable Long-Term Memory →</strong></a>
+</p>
+<p align="center">
+  <strong>⚡ +26% Accuracy vs. OpenAI Memory • 🚀 91% Faster • 💰 90% Fewer Tokens</strong>
+</p>
+
+##  🔥 Research Highlights
+- **+26% Accuracy** over OpenAI Memory on the LOCOMO benchmark
+- **91% Faster Responses** than full-context, ensuring low-latency at scale
+- **90% Lower Token Usage** than full-context, cutting costs without compromise
+- [Read the full paper](https://mem0.ai/research)

 # Introduction

-[Mem0](https://mem0.ai) (pronounced as "mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. Mem0 remembers user preferences, adapts to individual needs, and continuously improves over time, making it ideal for customer support chatbots, AI assistants, and autonomous systems.
+[Mem0](https://mem0.ai) ("mem-zero") enhances AI assistants and agents with an intelligent memory layer, enabling personalized AI interactions. It remembers user preferences, adapts to individual needs, and continuously learns over time—ideal for customer support chatbots, AI assistants, and autonomous systems.

-### Features & Use Cases
+### Key Features & Use Cases

-Core Capabilities:
- **Multi-Level Memory**: User, Session, and AI Agent memory retention with adaptive personalization
- **Developer-Friendly**: Simple API integration, cross-platform consistency, and hassle-free managed service
+**Core Capabilities:**
+- **Multi-Level Memory**: Seamlessly retains User, Session, and Agent state with adaptive personalization
+- **Developer-Friendly**: Intuitive API, cross-platform SDKs, and a fully managed service option

-Applications:
- **AI Assistants**: Seamless conversations with context and personalization
- **Learning & Support**: Tailored content recommendations and context-aware customer assistance
- **Healthcare & Companions**: Patient history tracking and deeper relationship building
- **Productivity & Gaming**: Streamlined workflows and adaptive environments based on user behavior
+**Applications:**
+- **AI Assistants**: Consistent, context-rich conversations
+- **Customer Support**: Recall past tickets and user history for tailored help
+- **Healthcare**: Track patient preferences and history for personalized care
+- **Productivity & Gaming**: Adaptive workflows and environments based on user behavior

-## Get Started
+## 🚀 Quickstart Guide <a name="quickstart"></a>

-Get started quickly with [Mem0 Platform](https://app.mem0.ai) - our fully managed solution that provides automatic updates, advanced analytics, enterprise security, and dedicated support. [Create a free account](https://app.mem0.ai) to begin.
+Choose between our hosted platform or self-hosted package:

-For complete control, you can self-host Mem0 using our open-source package. See the [Quickstart guide](#quickstart) below to set up your own instance.
+### Hosted Platform

-## Quickstart Guide <a name="quickstart"></a>
+Get up and running in minutes with automatic updates, analytics, and enterprise security.

-Install the Mem0 package via pip:
+1. Sign up on [Mem0 Platform](https://app.mem0.ai)
+2. Embed the memory layer via SDK or API keys
+
+### Self-Hosted (Open Source)
+
+Install the sdk via pip:

 ```bash
 pip install mem0ai
 ```

-Install the Mem0 package via npm:
-
+Install sdk via npm:
 ```bash
 npm install mem0ai
 ```
@@ -96,7 +108,7 @@ def chat_with_memories(message: str, user_id: str = "default_user") -> str:
    # Retrieve relevant memories
    relevant_memories = memory.search(query=message, user_id=user_id, limit=3)
    memories_str = "\n".join(f"- {entry['memory']}" for entry in relevant_memories["results"])
-    
+
    # Generate Assistant response
    system_prompt = f"You are a helpful AI. Answer the question based on query and memories.\nUser Memories:\n{memories_str}"
    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": message}]
@@ -122,68 +134,21 @@ if __name__ == "__main__":
    main()
 ```

-See the example for [Node.js](https://docs.mem0.ai/examples/ai_companion_js).
+For detailed integration steps, see the [Quickstart](https://docs.mem0.ai/quickstart) and [API Reference](https://docs.mem0.ai).

-For more advanced usage and API documentation, visit our [documentation](https://docs.mem0.ai).
+## 🔗 Integrations & Demos

-> [!TIP]
-> For a hassle-free experience, try our [hosted platform](https://app.mem0.ai) with automatic updates and enterprise features.
+- **ChatGPT with Memory**: Personalized chat powered by Mem0 ([Live Demo](https://mem0.dev/demo))
+- **Browser Extension**: Store memories across ChatGPT, Perplexity, and Claude ([Chrome Extension](https://chromewebstore.google.com/detail/mem0))
+- **Langgraph Support**: Build a customer bot with Langgraph + Mem0 ([Guide](https://docs.mem0.ai/integrations/langgraph))
+- **CrewAI Integration**: Tailor CrewAI outputs with Mem0 ([Example](https://docs.mem0.ai/integrations/crewai))

-## Demos
+## 📚 Documentation & Support

- Mem0 - ChatGPT with Memory: A personalized AI chat app powered by Mem0 that remembers your preferences, facts, and memories.
+- Full docs: https://docs.mem0.ai
+- Community: [Discord](https://mem0.dev/DiG) · [Twitter](https://x.com/mem0ai)
+- Contact: founders@mem0.ai

-[Mem0 - ChatGPT with Memory](https://github.com/user-attachments/assets/cebc4f8e-bdb9-4837-868d-13c5ab7bb433)
+## ⚖️ License

-Try live [demo](https://mem0.dev/demo/)
-
-<br/><br/>
-
- AI Companion: Experience personalized conversations with an AI that remembers your preferences and past interactions
-
-[AI Companion Demo](https://github.com/user-attachments/assets/3fc72023-a72c-4593-8be0-3cee3ba744da)
-
-<br/><br/>
-
- Enhance your AI interactions by storing memories across ChatGPT, Perplexity, and Claude using our browser extension. Get [chrome extension](https://chromewebstore.google.com/detail/mem0/onihkkbipkfeijkadecaafbgagkhglop?hl=en).
-
-
-[Chrome Extension Demo](https://github.com/user-attachments/assets/ca92e40b-c453-4ff6-b25e-739fb18a8650)
-
-<br/><br/>
-
- Customer support bot using <strong>Langgraph and Mem0</strong>. Get the complete code from [here](https://docs.mem0.ai/integrations/langgraph)
-
-
-[Langgraph: Customer Bot](https://github.com/user-attachments/assets/ca6b482e-7f46-42c8-aa08-f88d1d93a5f4)
-
-<br/><br/>
-
- Use Mem0 with CrewAI to get personalized results. Full example [here](https://docs.mem0.ai/integrations/crewai)
-
-[CrewAI Demo](https://github.com/user-attachments/assets/69172a79-ccb9-4340-91f1-caa7d2dd4213)
-
-
-
-## Documentation
-
-For detailed usage instructions and API reference, visit our [documentation](https://docs.mem0.ai). You'll find:
- Complete API reference
- Integration guides
- Advanced configuration options
- Best practices and examples
- More details about:
-  - Open-source version
-  - [Hosted Mem0 Platform](https://app.mem0.ai)
-
-## Support
-
-Join our community for support and discussions. If you have any questions, feel free to reach out to us using one of the following methods:
-
- [Join our Discord](https://mem0.dev/DiG)
- [Follow us on Twitter](https://x.com/mem0ai)
- [Email founders](mailto:founders@mem0.ai)
-
-## License
-
-This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.
+Apache 2.0 — see the [LICENSE](LICENSE) file for details.
@@ -0,0 +1,3 @@
+<Note type="info">
+  📢 Announcing our research paper: Mem0 achieves <strong>26%</strong> higher accuracy than OpenAI Memory, <strong>91%</strong> lower latency, and <strong>90%</strong> token savings! [Read the paper](https://mem0.ai/research) to learn how we're revolutionizing AI agent memory.
+</Note>
@@ -4,6 +4,8 @@ icon: "info"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 provides a powerful set of APIs that allow you to integrate advanced memory management capabilities into your applications. Our APIs are designed to be intuitive, efficient, and scalable, enabling you to create, retrieve, update, and delete memories across various entities such as users, agents, apps, and runs.

 ## Key Features
@@ -0,0 +1,4 @@
+---
+title: 'Feedback'
+openapi: post /v1/feedback/
+---
@@ -1,6 +1,6 @@
 ---
 title: 'Get Memory Export'
-openapi: get /v1/exports/
+openapi: post /v1/exports/get
 ---

 Retrieve the latest structured memory export after submitting an export job. You can filter the export by `user_id`, `run_id`, `session_id`, or `app_id` to get the most recent export matching your filters.
@@ -14,7 +14,7 @@ The v2 search API is powerful and flexible, allowing for more precise memory ret

  <CodeGroup>
  ```python Code
-  related_memories = m.vsearch(
+  related_memories = m.search(
      query="What are Alice's hobbies?",
      version="v2",
      filters={
@@ -0,0 +1,461 @@
+---
+title: "Product Updates"
+mode: "wide"
+---
+
+<Snippet file="paper-release.mdx" />
+
+<Tabs>
+<Tab title="Python">
+
+<Update label="2025-04-26" description="v0.1.94">
+
+**New Features:**
+- **Integrations:** Added Memgraph integration
+- **Memory:** Added timestamp support
+- **Vector Stores:** Added reset function for VectorDBs
+
+**Improvements:**
+- **Documentation:** 
+  - Updated timestamp and expiration_date documentation
+  - Fixed v2 search documentation
+  - Added "memory" in EC "Custom config" section
+  - Fixed typos in the json config sample
+
+</Update>
+
+<Update label="2025-04-21" description="v0.1.93">
+
+**Improvements:**
+- **Vector Stores:** Initialized embedding_model_dims in all vectordbs
+
+**Bug Fixes:**
+- **Documentation:** Fixed agno link
+
+</Update>
+
+<Update label="2025-04-18" description="v0.1.92">
+
+**New Features:**
+- **Memory:** Added Memory Reset functionality
+- **Client:** Added support for Custom Instructions
+- **Examples:** Added Fitness Checker powered by memory
+
+**Improvements:**
+- **Core:** Updated capture_event
+- **Documentation:** Fixed curl for v2 get_all
+
+**Bug Fixes:**
+- **Vector Store:** Fixed user_id functionality
+- **Client:** Various client improvements
+
+</Update>
+
+<Update label="2025-04-16" description="v0.1.91">
+
+**New Features:**
+- **LLM Integrations:** Added Azure OpenAI Embedding Model
+- **Examples:** 
+  - Added movie recommendation using grok3
+  - Added Voice Assistant using Elevenlabs
+
+**Improvements:**
+- **Documentation:** 
+  - Added keywords AI
+  - Reformatted navbar page URLs
+  - Updated changelog
+  - Updated openai.mdx
+- **FAISS:** Silenced FAISS info logs
+
+</Update>
+
+<Update label="2025-04-11" description="v0.1.90">
+
+**New Features:**
+- **LLM Integrations:** Added Mistral AI as LLM provider
+
+**Improvements:**
+- **Documentation:** 
+  - Updated changelog
+  - Fixed memory exclusion example
+  - Updated xAI documentation
+  - Updated YouTube Chrome extension example documentation
+
+**Bug Fixes:**
+- **Core:** Fixed EmbedderFactory.create() in GraphMemory
+- **Azure OpenAI:** Added patch to fix Azure OpenAI
+- **Telemetry:** Fixed telemetry issue
+
+</Update>
+
+<Update label="2025-04-11" description="v0.1.89">
+
+**New Features:**
+- **Langchain Integration:** Added support for Langchain VectorStores
+- **Examples:** 
+  - Added personal assistant example
+  - Added personal study buddy example
+  - Added YouTube assistant Chrome extension example
+  - Added agno example
+  - Updated OpenAI Responses API examples
+- **Vector Store:** Added capability to store user_id in vector database
+- **Async Memory:** Added async support for OSS
+
+**Improvements:**
+- **Documentation:** Updated formatting and examples
+
+</Update>
+
+<Update label="2025-04-09" description="v0.1.87">
+
+**New Features:**
+- **Upstash Vector:** Added support for Upstash Vector store
+
+**Improvements:**
+- **Code Quality:** Removed redundant code lines
+- **Build:** Updated MAKEFILE
+- **Documentation:** Updated memory export documentation
+
+</Update>
+
+<Update label="2025-04-07" description="v0.1.86">
+
+**Improvements:**
+- **FAISS:** Added embedding_dims parameter to FAISS vector store
+
+</Update>
+
+<Update label="2025-04-07" description="v0.1.84">
+
+**New Features:**
+- **Langchain Embedder:** Added Langchain embedder integration
+
+**Improvements:**
+- **Langchain LLM:** Updated Langchain LLM integration to directly pass the Langchain object LLM
+</Update>
+
+<Update label="2025-04-07" description="v0.1.83">
+
+**Bug Fixes:**
+- **Langchain LLM:** Fixed issues with Langchain LLM integration
+</Update>
+
+<Update label="2025-04-07" description="v0.1.82">
+
+**New Features:**
+- **LLM Integrations:** Added support for Langchain LLMs, Google as new LLM and embedder
+- **Development:** Added development docker compose
+
+**Improvements:**
+- **Output Format:** Set output_format='v1.1' and updated documentation
+
+**Documentation:**
+- **Integrations:** Added LMStudio and Together.ai documentation
+- **API Reference:** Updated output_format documentation
+- **Integrations:** Added PipeCat integration documentation
+- **Integrations:** Added Flowise integration documentation for Mem0 memory setup
+
+**Bug Fixes:**
+- **Tests:** Fixed failing unit tests
+</Update>
+
+<Update label="2025-04-02" description="v0.1.79">
+
+**New Features:**
+- **FAISS Support:** Added FAISS vector store support
+
+</Update>
+
+<Update label="2025-04-02" description="v0.1.78">
+
+**New Features:**
+- **Livekit Integration:** Added Mem0 livekit example
+- **Evaluation:** Added evaluation framework and tools
+
+**Documentation:**
+- **Multimodal:** Updated multimodal documentation
+- **Examples:** Added examples for email processing
+- **API Reference:** Updated API reference section
+- **Elevenlabs:** Added Elevenlabs integration example
+
+**Bug Fixes:**
+- **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
+- **Deployment Errors:** Added `package.json` file to fix deployment errors
+- **Tools:** Fixed tools issues and improved formatting
+- **Docs:** Updated API reference section for `expiration date`
+</Update>
+
+<Update label="2025-03-26" description="v0.1.77">
+
+**Bug Fixes:**
+- **OpenAI Environment Variables:** Fixed issues with OpenAI environment variables
+- **Deployment Errors:** Added `package.json` file to fix deployment errors
+- **Tools:** Fixed tools issues and improved formatting
+- **Docs:** Updated API reference section for `expiration date`
+</Update>
+
+<Update label="2025-03-19" description="v0.1.76">
+**New Features:**
+- **Supabase Vector Store:** Added support for Supabase Vector Store
+- **Supabase History DB:** Added Supabase History DB to run Mem0 OSS on Serverless
+- **Feedback Method:** Added feedback method to client
+
+**Bug Fixes:**
+- **Azure OpenAI:** Fixed issues with Azure OpenAI
+- **Azure AI Search:** Fixed test cases for Azure AI Search
+</Update>
+
+</Tab>
+
+<Tab title="TypeScript">
+
+<Update label="2025-04-28" description="v2.1.20">
+**Improvements:**
+- **Client:** Fixed `organizationId` and `projectId` being asssigned to default in `ping` method
+</Update>
+
+<Update label="2025-04-22" description="v2.1.19">
+**Improvements:**
+- **Client:** Added support for `timestamps`
+</Update>
+
+<Update label="2025-04-17" description="v2.1.18">
+**Improvements:**
+- **Client:** Added support for custom instructions
+</Update>
+
+<Update label="2025-04-15" description="v2.1.17">
+**New Features:**
+- **OSS SDK:** Added support for Langchain LLM
+- **OSS SDK:** Added support for Langchain Embedder
+- **OSS SDK:** Added support for Langchain Vector Store
+- **OSS SDK:** Added support for Azure OpenAI Embedder
+
+
+**Improvements:**
+- **OSS SDK:** Changed `model` in LLM and Embedder to use type any from `string` to use langchain llm models
+- **OSS SDK:** Added client to vector store config for langchain vector store
+- **OSS SDK:** - Updated Azure OpenAI to use new OpenAI SDK
+</Update>
+
+<Update label="2025-04-11" description="v2.1.16-patch.1">
+**Bug Fixes:**
+- **Azure OpenAI:** Fixed issues with Azure OpenAI
+</Update>
+
+<Update label="2025-04-11" description="v2.1.16">
+**New Features:**
+- **Azure OpenAI:** Added support for Azure OpenAI
+- **Mistral LLM:** Added Mistral LLM integration in OSS
+
+**Improvements:**
+- **Zod:** Updated Zod to 3.24.1 to avoid conflicts with other packages
+</Update>
+
+<Update label="2025-04-09" description="v2.1.15">
+**Improvements:**
+- **Client:** Added support for Mem0 to work with Chrome Extensions
+</Update>
+
+<Update label="2025-04-01" description="v2.1.14">
+**New Features:**
+- **Mastra Example:** Added Mastra example
+- **Integrations:** Added Flowise integration documentation for Mem0 memory setup
+
+**Improvements:**
+- **Demo:** Updated Demo Mem0AI
+- **Client:** Enhanced Ping method in Mem0 Client
+- **AI SDK:** Updated AI SDK implementation
+</Update>
+
+<Update label="2025-03-29" description="v2.1.13">
+**Improvements:**
+- **Introuced `ping` method to check if API key is valid and populate org/project id**
+</Update>
+
+<Update label="2025-03-29" description="AI SDK v1.0.0">
+**New Features:**
+- **Vercel AI SDK Update:** Support threshold and rerank
+
+**Improvements:**
+- **Made add calls async to avoid blocking**
+- **Bump `mem0ai` to use `2.1.12`**
+
+</Update>
+
+<Update label="2025-03-26" description="v2.1.12">
+**New Features:**
+- **Mem0 OSS:** Support infer param
+
+**Improvements:**
+- **Updated Supabase TS Docs**
+- **Made package size smaller**
+
+</Update>
+
+<Update label="2025-03-19" description="v2.1.11">
+**New Features:**
+- **Supabase Vector Store Integration**
+- **Feedback Method**
+</Update>
+
+</Tab>
+
+<Tab title="Platform">
+
+<Update label="2025-04-26" description="">
+
+**Improvements:**
+- **Performance:** Parallelized embedding calls
+- **Monitoring:** Added timing for LLM calls
+- **Search:** Added category checking in Search V2
+- **Bug Fixes:** Fixed issues with ADD filters
+- **Graph:** Implemented new graph updates
+
+</Update>
+
+<Update label="2025-04-25" description="">
+
+**Improvements:**
+- **Memory:** Fixed memory export functionality
+- **Analytics:** Added logging for project
+
+</Update>
+
+<Update label="2025-04-24" description="">
+
+**Improvements:**
+- **Output:** Added memory_type display for ADD output
+
+</Update>
+
+<Update label="2025-04-23" description="">
+
+**New Features:**
+- **UI:** Added new Pricing Component
+- **Memory:** Implemented Long/Short term memory categorization
+- **Output:** Modified serializer to hide memory_type
+
+**Documentation:**
+- Updated README for deployment
+
+</Update>
+
+<Update label="2025-04-22" description="">
+
+**New Features:**
+- **Memory:** Added timestamp to ADD call
+
+**Bug Fixes:**
+- Fixed issues with coreV2
+
+</Update>
+
+<Update label="2025-04-21" description="">
+
+**New Features:**
+- **Memory:** Implemented backdating with migrations and backfilling script
+
+</Update>
+
+<Update label="2025-04-17" description="">
+
+**New Features:**
+- **Billing:** Integrated Stripe Billing Dashboard
+- **Admin:** Added webhook creation functionality
+
+**Bug Fixes:**
+- Fixed Users Page issues
+- Fixed Custom Categories
+- Fixed Table components
+- Updated Stripe configuration
+
+</Update>
+
+<Update label="2025-04-16" description="">
+
+**Improvements:**
+- **Performance:** Made Admin panel and Memory Page faster
+- **Security:** Implemented active session cancellation
+- **Analytics:** Added Stripe customer ID capture
+
+</Update>
+
+<Update label="2025-04-12" description="">
+
+**New Features:**
+- **Memory Management:** 
+  - Added ability to delete memories from Project level with filters
+  - Added delete memories capability on Memories Page
+- **Memory Visualization:** Released V1 Graph Memory Visualization
+- **Graph Playground:** Enabled for @mem0.ai users
+- **Notifications:** Added email alerts to organization owners when new members join
+- **Memory Export:** Added date support for filtering memory exports
+
+**Improvements:**
+- **Performance:** 
+  - Optimized graph for better performance
+  - Optimized database calls in ADD method
+- **Analytics:** Added flagging of paid users in Posthog
+- **CI/CD:** Improved CI pipeline and fixed lint issues
+
+</Update>
+
+<Update label="2025-04-10" description="">
+
+**New Features:**
+- **Notifications:** Implemented email notifications for organization owners when new members join
+
+**Improvements:**
+- **CI/CD:** Fixed Dockerfile for CI tests
+
+</Update>
+
+<Update label="2025-04-09" description="">
+
+**Improvements:**
+- **Integrations:** Updated chat model for Together Qwen
+- **Platform:** Removed older platforms
+- **Bug Fixes:** Fixed FILTER_MAPPING
+
+</Update>
+
+<Update label="2025-04-03" description="">
+
+**New Features:**
+- **Memory:** Added implicit memory capabilities
+- **API:** Improved implicit lambda and get_all v2 functionality
+
+</Update>
+
+<Update label="2025-04-02" description="">
+
+**New Features:**
+- **Integrations:** Added Clay integration
+
+**Improvements:**
+- **Integrations:** Removed deepseek coder from Together
+- **API:** Added custom instructions for add v2
+
+</Update>
+
+<Update label="2025-03-31" description="">
+
+**Security:**
+- **Validation:** Added key validation in messages
+
+</Update>
+
+<Update label="2025-03-28" description="">
+- **Updated Playground Prompt**
+- **Send Email on User Addition to Org/Proj**
+- **Fix Search Entity**
+</Update>
+
+<Update label="2025-03-19" description="">
+- **General Stability & Performance Improvements**
+</Update>
+
+</Tab>
+</Tabs>
+
@@ -4,6 +4,8 @@ icon: "gear"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Config in mem0 is a dictionary that specifies the settings for your embedding models. It allows you to customize the behavior and connection details of your chosen embedder.

 ## How to define configurations?
@@ -84,6 +86,7 @@ Here's a comprehensive list of all parameters that can be used across different
 | `memory_add_embedding_type` | The type of embedding to use for the add memory action                       | VertexAI            |
 | `memory_update_embedding_type` | The type of embedding to use for the update memory action                       | VertexAI            |
 | `memory_search_embedding_type` | The type of embedding to use for the search memory action                       | VertexAI            |
+| `lmstudio_base_url` | Base URL for LM Studio API                    | LM Studio         |
 </Tab>
 <Tab title="TypeScript">
 | Parameter | Description | Provider |
@@ -6,7 +6,8 @@ To use Azure OpenAI embedding models, set the `EMBEDDING_AZURE_OPENAI_API_KEY`,

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -46,6 +47,36 @@ messages = [
 m.add(messages, user_id="john")
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+    embedder: {
+        provider: "azure_openai",
+        config: {
+            model: "text-embedding-3-large",
+            modelProperties: {
+                endpoint: "your-api-base-url",
+                deployment: "your-deployment-name",
+                apiVersion: "version-to-use",
+            }
+        }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+
+await memory.add(messages, { userId: "john" });
+```
+</CodeGroup>
+
 ### Config

 Here are the parameters available for configuring Azure OpenAI embedder:
@@ -0,0 +1,146 @@
+---
+title: LangChain
+---
+
+Mem0 supports LangChain as a provider to access a wide range of embedding models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various embedding providers through a consistent interface.
+
+For a complete list of available embedding models supported by LangChain, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/).
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+from langchain_openai import OpenAIEmbeddings
+
+# Set necessary environment variables for your chosen LangChain provider
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+# Initialize a LangChain embeddings model directly
+openai_embeddings = OpenAIEmbeddings(
+    model="text-embedding-3-small",
+    dimensions=1536
+)
+
+# Pass the initialized model to the config
+config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": openai_embeddings
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from "mem0ai";
+import { OpenAIEmbeddings } from "@langchain/openai";
+
+const embeddings = new OpenAIEmbeddings();
+const config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": embeddings
+        }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+    { role: "assistant", content: "How about a 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." }
+]
+
+memory.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+## Supported LangChain Embedding Providers
+
+LangChain supports a wide range of embedding providers, including:
+
+- OpenAI (`OpenAIEmbeddings`)
+- Cohere (`CohereEmbeddings`)
+- Google (`VertexAIEmbeddings`)
+- Hugging Face (`HuggingFaceEmbeddings`)
+- Sentence Transformers (`HuggingFaceEmbeddings`)
+- Azure OpenAI (`AzureOpenAIEmbeddings`)
+- Ollama (`OllamaEmbeddings`)
+- Together (`TogetherEmbeddings`)
+- And many more
+
+You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available embedding providers, refer to the [LangChain Text Embedding documentation](https://python.langchain.com/docs/integrations/text_embedding/).
+
+## Provider-Specific Configuration
+
+When using LangChain as an embedder provider, you'll need to:
+
+1. Set the appropriate environment variables for your chosen embedding provider
+2. Import and initialize the specific model class you want to use
+3. Pass the initialized model instance to the config
+
+### Examples with Different Providers
+
+#### HuggingFace Embeddings
+
+```python
+from langchain_huggingface import HuggingFaceEmbeddings
+
+# Initialize a HuggingFace embeddings model
+hf_embeddings = HuggingFaceEmbeddings(
+    model_name="BAAI/bge-small-en-v1.5",
+    encode_kwargs={"normalize_embeddings": True}
+)
+
+config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": hf_embeddings
+        }
+    }
+}
+```
+
+#### Ollama Embeddings
+
+```python
+from langchain_ollama import OllamaEmbeddings
+
+# Initialize an Ollama embeddings model
+ollama_embeddings = OllamaEmbeddings(
+    model="nomic-embed-text"
+)
+
+config = {
+    "embedder": {
+        "provider": "langchain",
+        "config": {
+            "model": ollama_embeddings
+        }
+    }
+}
+```
+
+<Note>
+  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
+</Note>
+
+## Config
+
+All available parameters for the `langchain` embedder config are present in [Master List of All Params in Config](../config).
@@ -0,0 +1,38 @@
+You can use embedding models from LM Studio to run Mem0 locally.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your_api_key" # For LLM
+
+config = {
+    "embedder": {
+        "provider": "lmstudio",
+        "config": {
+            "model": "nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+m.add(messages, user_id="john")
+```
+
+### Config
+
+Here are the parameters available for configuring Ollama embedder:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `model` | The name of the OpenAI model to use | `nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f16.gguf` |
+| `embedding_dims` | Dimensions of the embedding model | `1536` |
+| `lmstudio_base_url` | Base URL for LM Studio connection | `http://localhost:1234/v1` |
@@ -4,6 +4,8 @@ icon: "info"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 offers support for various embedding models, allowing users to choose the one that best suits their needs.

 ## Supported Embedders
@@ -22,6 +24,8 @@ See the list of supported embedders below.
  <Card title="Gemini" href="/components/embedders/models/gemini"></Card>
  <Card title="Vertex AI" href="/components/embedders/models/vertexai"></Card>
  <Card title="Together" href="/components/embedders/models/together"></Card>
+  <Card title="LM Studio" href="/components/embedders/models/lmstudio"></Card>
+  <Card title="Langchain" href="/components/embedders/models/langchain"></Card>
 </CardGroup>

 ## Usage
@@ -4,6 +4,8 @@ icon: "gear"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## How to define configurations?

 <Tabs>
@@ -29,7 +31,7 @@ iconType: "solid"
 Config values are applied in the following order of precedence (from highest to lowest):

 1. Values explicitly set in the `config` object/dictionary
-2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_API_BASE`)
+2. Environment variables (e.g., `OPENAI_API_KEY`, `OPENAI_BASE_URL`)
 3. Default values defined in the LLM implementation

 This means that values specified in the `config` will override corresponding environment variables, which in turn override default values.
@@ -108,6 +110,7 @@ Here's a comprehensive list of all parameters that can be used across different
    | `azure_kwargs`       | Azure LLM args for initialization             | AzureOpenAI       |
    | `deepseek_base_url`  | Base URL for DeepSeek API                     | DeepSeek          |
    | `xai_base_url`       | Base URL for XAI API                          | XAI               |
+    | `lmstudio_base_url`  | Base URL for LM Studio API                    | LM Studio         |
  </Tab>
  <Tab title="TypeScript">
    | Parameter            | Description                                   | Provider          |
@@ -2,6 +2,8 @@
 title: Anthropic
 ---

+<Snippet file="paper-release.mdx" />
+
 To use anthropic's models, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys).

 ## Usage
@@ -2,6 +2,8 @@
 title: AWS Bedrock
 ---

+<Snippet file="paper-release.mdx" />
+
 ### Setup
 - Before using the AWS Bedrock LLM, make sure you have the appropriate model access from [Bedrock Console](https://us-east-1.console.aws.amazon.com/bedrock/home?region=us-east-1#/modelaccess).
 - You will also need to authenticate the `boto3` client by using a method in the [AWS documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html#configuring-credentials)
@@ -2,11 +2,19 @@
 title: Azure OpenAI
 ---

+<Snippet file="paper-release.mdx" />
+
+<Note> Mem0 Now Supports Azure OpenAI Models in TypeScript SDK </Note>
+
 To use Azure OpenAI models, you have to set the `LLM_AZURE_OPENAI_API_KEY`, `LLM_AZURE_ENDPOINT`, `LLM_AZURE_DEPLOYMENT` and `LLM_AZURE_API_VERSION` environment variables. You can obtain the Azure API key from the [Azure](https://azure.microsoft.com/).

+> **Note**: The following are currently unsupported with reasoning models `Parallel tool calling`,`temperature`, `top_p`, `presence_penalty`, `frequency_penalty`, `logprobs`, `top_logprobs`, `logit_bias`, `max_tokens`
+
+
 ## Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -45,7 +53,38 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

-We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model.
+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'azure_openai',
+    config: {
+      apiKey: process.env.AZURE_OPENAI_API_KEY || '',
+      modelProperties: {
+        endpoint: 'https://your-api-base-url',
+        deployment: 'your-deployment-name',
+        modelName: 'your-model-name',
+        apiVersion: 'version-to-use',
+        // Any other parameters you want to pass to the Azure OpenAI API
+      },
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+
+We also support the new [OpenAI structured-outputs](https://platform.openai.com/docs/guides/structured-outputs/introduction) model. Typescript SDK does not support the `azure_openai_structured` model yet.

 ```python
 import os
@@ -2,6 +2,8 @@
 title: DeepSeek
 ---

+<Snippet file="paper-release.mdx" />
+
 To use DeepSeek LLM models, you have to set the `DEEPSEEK_API_KEY` environment variable. You can also optionally set `DEEPSEEK_API_BASE` if you need to use a different API endpoint (defaults to "https://api.deepseek.com").

 ## Usage
@@ -2,6 +2,8 @@
 title: Gemini
 ---

+<Snippet file="paper-release.mdx" />
+
 To use Gemini model, you have to set the `GEMINI_API_KEY` environment variable. You can obtain the Gemini API key from the [Google AI Studio](https://aistudio.google.com/app/apikey)

 ## Usage
@@ -2,6 +2,8 @@
 title: Google AI
 ---

+<Snippet file="paper-release.mdx" />
+
 To use Google AI model, you have to set the `GOOGLE_API_KEY` environment variable. You can obtain the Google API key from the [Google Maker Suite](https://makersuite.google.com/app/apikey)

 ## Usage
@@ -2,6 +2,8 @@
 title: Groq
 ---

+<Snippet file="paper-release.mdx" />
+
 [Groq](https://groq.com/) is the creator of the world's first Language Processing Unit (LPU), providing exceptional speed performance for AI workloads running on their LPU Inference Engine.

 In order to use LLMs from Groq, go to their [platform](https://console.groq.com/keys) and get the API key. Set the API key as `GROQ_API_KEY` environment variable to use the model as given below in the example.
@@ -0,0 +1,110 @@
+---
+title: LangChain
+---
+
+<Snippet file="paper-release.mdx" />
+
+Mem0 supports LangChain as a provider to access a wide range of LLM models. LangChain is a framework for developing applications powered by language models, making it easy to integrate various LLM providers through a consistent interface.
+
+For a complete list of available chat models supported by LangChain, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat).
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+from langchain_openai import ChatOpenAI
+
+# Set necessary environment variables for your chosen LangChain provider
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+# Initialize a LangChain model directly
+openai_model = ChatOpenAI(
+    model="gpt-4o",
+    temperature=0.2,
+    max_tokens=2000
+)
+
+# Pass the initialized model to the config
+config = {
+    "llm": {
+        "provider": "langchain",
+        "config": {
+            "model": openai_model
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from "mem0ai";
+import { ChatOpenAI } from "@langchain/openai";
+
+const openai_model = new ChatOpenAI({
+    model: "gpt-4o",
+    temperature: 0.2,
+    max_tokens: 2000
+})
+
+const config = {
+    "llm": {
+        "provider": "langchain",
+        "config": {
+            "model": openai_model
+        }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+    { role: "assistant", content: "How about a 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." }
+]
+
+memory.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+## Supported LangChain Providers
+
+LangChain supports a wide range of LLM providers, including:
+
+- OpenAI (`ChatOpenAI`)
+- Anthropic (`ChatAnthropic`)
+- Google (`ChatGoogleGenerativeAI`, `ChatGooglePalm`)
+- Mistral (`ChatMistralAI`)
+- Ollama (`ChatOllama`)
+- Azure OpenAI (`AzureChatOpenAI`)
+- HuggingFace (`HuggingFaceChatEndpoint`)
+- And many more
+
+You can use any of these model instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Chat Models documentation](https://python.langchain.com/docs/integrations/chat).
+
+## Provider-Specific Configuration
+
+When using LangChain as a provider, you'll need to:
+
+1. Set the appropriate environment variables for your chosen LLM provider
+2. Import and initialize the specific model class you want to use
+3. Pass the initialized model instance to the config
+
+<Note>
+  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
+</Note>
+
+## Config
+
+All available parameters for the `langchain` config are present in [Master List of All Params in Config](../config).
@@ -1,3 +1,5 @@
+<Snippet file="paper-release.mdx" />
+
 [Litellm](https://litellm.vercel.app/docs/) is compatible with over 100 large language models (LLMs), all using a standardized input/output format. You can explore the [available models](https://litellm.vercel.app/docs/providers) to use with Litellm. Ensure you set the `API_KEY` for the model you choose to use.

 ## Usage
@@ -0,0 +1,84 @@
+---
+title: LM Studio
+---
+
+<Snippet file="paper-release.mdx" />
+
+To use LM Studio with Mem0, you'll need to have LM Studio running locally with its server enabled. LM Studio provides a way to run local LLMs with an OpenAI-compatible API.
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key" # used for embedding model
+
+config = {
+    "llm": {
+        "provider": "lmstudio",
+        "config": {
+            "model": "lmstudio-community/Meta-Llama-3.1-70B-Instruct-GGUF/Meta-Llama-3.1-70B-Instruct-IQ2_M.gguf",
+            "temperature": 0.2,
+            "max_tokens": 2000,
+            "lmstudio_base_url": "http://localhost:1234/v1", # default LM Studio API URL
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+### Running Completely Locally
+
+You can also use LM Studio for both LLM and embedding to run Mem0 entirely locally:
+
+```python
+from mem0 import Memory
+
+# No external API keys needed!
+config = {
+    "llm": {
+        "provider": "lmstudio"
+    },
+    "embedder": {
+        "provider": "lmstudio"
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+m.add(messages, user_id="alice123", metadata={"category": "movies"})
+```
+
+<Note>
+  When using LM Studio for both LLM and embedding, make sure you have:
+  1. An LLM model loaded for generating responses
+  2. An embedding model loaded for vector embeddings
+  3. The server enabled with the correct endpoints accessible
+</Note>
+
+<Note>
+  To use LM Studio, you need to:
+  1. Download and install [LM Studio](https://lmstudio.ai/)
+  2. Start a local server from the "Server" tab
+  3. Set the appropriate `lmstudio_base_url` in your configuration (default is usually http://localhost:1234/v1)
+</Note>
+
+## Config
+
+All available parameters for the `lmstudio` config are present in [Master List of All Params in Config](../config).
@@ -2,11 +2,14 @@
 title: Mistral AI
 ---

-To use mistral's models, please Obtain the Mistral AI api key from their [console](https://console.mistral.ai/). Set the `MISTRAL_API_KEY` environment variable to use the model as given below in the example.
+<Snippet file="paper-release.mdx" />
+
+To use mistral's models, please obtain the Mistral AI api key from their [console](https://console.mistral.ai/). Set the `MISTRAL_API_KEY` environment variable to use the model as given below in the example.

 ## Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -34,6 +37,32 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript TypeScript
+import { Memory } from 'mem0ai/oss';
+
+const config = {
+  llm: {
+    provider: 'mistral',
+    config: {
+      apiKey: process.env.MISTRAL_API_KEY || '',
+      model: 'mistral-tiny-latest', // Or 'mistral-small-latest', 'mistral-medium-latest', etc.
+      temperature: 0.1,
+      maxTokens: 2000,
+    },
+  },
+};
+
+const memory = new Memory(config);
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
 ## Config

 All available parameters for the `litellm` config are present in [Master List of All Params in Config](../config).
@@ -1,3 +1,5 @@
+<Snippet file="paper-release.mdx" />
+
 You can use LLMs from Ollama to run Mem0 locally. These [models](https://ollama.com/search?c=tools) support tool support.

 ## Usage
@@ -2,6 +2,8 @@
 title: OpenAI
 ---

+<Snippet file="paper-release.mdx" />
+
 To use OpenAI LLM models, you have to set the `OPENAI_API_KEY` environment variable. You can obtain the OpenAI API key from the [OpenAI Platform](https://platform.openai.com/account/api-keys).

 ## Usage
@@ -92,10 +94,6 @@ config = {
 m = Memory.from_config(config)
 ```

-<Note>
-  OpenAI structured-outputs is currently only available in the Python implementation.
-</Note>
-
 ## Config

-All available parameters for the `openai` config are present in [Master List of All Params in Config](../config).
+All available parameters for the `openai` config are present in [Master List of All Params in Config](../config).
@@ -1,3 +1,5 @@
+<Snippet file="paper-release.mdx" />
+
 To use TogetherAI LLM models, you have to set the `TOGETHER_API_KEY` environment variable. You can obtain the TogetherAI API key from their [Account settings page](https://api.together.xyz/settings/api-keys).

 ## Usage
@@ -2,6 +2,8 @@
 title: xAI
 ---

+<Snippet file="paper-release.mdx" />
+
 [xAI](https://x.ai/) is a new AI company founded by Elon Musk that develops large language models, including Grok. Grok is trained on real-time data from X (formerly Twitter) and aims to provide accurate, up-to-date responses with a touch of wit and humor.

 In order to use LLMs from xAI, go to their [platform](https://console.x.ai) and get the API key. Set the API key as `XAI_API_KEY` environment variable to use the model as given below in the example.
@@ -19,7 +21,7 @@ config = {
    "llm": {
        "provider": "xai",
        "config": {
-            "model": "grok-2-latest",
+            "model": "grok-3-beta",
            "temperature": 0.1,
            "max_tokens": 2000,
        }
@@ -4,6 +4,8 @@ icon: "info"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 includes built-in support for various popular large language models. Memory can utilize the LLM provided by the user, ensuring efficient use for specific needs.

 ## Usage
@@ -32,6 +34,8 @@ To view all supported llms, visit the [Supported LLMs](./models).
  <Card title="Gemini" href="/components/llms/models/gemini" />
  <Card title="DeepSeek" href="/components/llms/models/deepseek" />
  <Card title="xAI" href="/components/llms/models/xAI" />
+  <Card title="LM Studio" href="/components/llms/models/lmstudio" />
+  <Card title="Langchain" href="/components/llms/models/langchain" />
 </CardGroup>

 ## Structured vs Unstructured Outputs
@@ -4,11 +4,13 @@ icon: "gear"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## How to define configurations?

 The `config` is defined as an object with two main keys:
 - `vector_store`: Specifies the vector database provider and its configuration
-  - `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus","azure_ai_search", "vertex_ai_vector_search")
+  - `provider`: The name of the vector database (e.g., "chroma", "pgvector", "qdrant", "milvus", "upstash_vector", "azure_ai_search", "vertex_ai_vector_search")
  - `config`: A nested dictionary containing provider-specific settings


@@ -1,4 +1,6 @@
-# Azure AI Search
+---
+title: Azure AI Search
+---

 [Azure AI Search](https://learn.microsoft.com/azure/search/search-what-is-azure-search/) (formerly known as "Azure Cognitive Search") provides secure information retrieval at scale over user-owned content in traditional and generative AI search applications.

@@ -50,6 +52,24 @@ config = {
 }
 ```

+## Using hybrid search
+
+```python
+config = {
+    "vector_store": {
+        "provider": "azure_ai_search",
+        "config": {
+            "service_name": "ai-search-test",
+            "api_key": "*****",
+            "collection_name": "mem0", 
+            "embedding_model_dims": 1536,
+            "hybrid_search": True,
+            "vector_filter_mode": "postFilter"
+        }
+    }
+}
+```
+
 ## Configuration Parameters

 | Parameter | Description | Default Value | Options |
@@ -60,6 +80,8 @@ config = {
 | `embedding_model_dims` | Dimensions of the embedding model | `1536` | Any integer value |
 | `compression_type` | Type of vector compression to use | `none` | `none`, `scalar`, `binary` |
 | `use_float16` | Store vectors in half precision (Edm.Half) | `False` | `True`, `False` |
+| `vector_filter_mode` | Vector filter mode to use | `preFilter` | `postFilter`, `preFilter` |
+| `hybrid_search` | Use hybrid search | `False` | `True`, `False` |

 ## Notes on Configuration Options

@@ -68,6 +90,10 @@ config = {
  - `scalar`: Scalar quantization with reasonable balance of speed and accuracy
  - `binary`: Binary quantization for maximum compression with some accuracy trade-off

+- **vector_filter_mode**:
+  - `preFilter`: Applies filters before vector search (faster)
+  - `postFilter`: Applies filters after vector search (may provide better relevance)
+
 - **use_float16**: Using half precision (float16) reduces storage requirements but may slightly impact accuracy. Useful for very large vector collections.

 - **Filterable Fields**: The implementation automatically extracts `user_id`, `run_id`, and `agent_id` fields from payloads for filtering.
@@ -0,0 +1,72 @@
+[FAISS](https://github.com/facebookresearch/faiss) is a library for efficient similarity search and clustering of dense vectors. It is designed to work with large-scale datasets and provides a high-performance search engine for vector data. FAISS is optimized for memory usage and search speed, making it an excellent choice for production environments.
+
+### Usage
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "sk-xx"
+
+config = {
+    "vector_store": {
+        "provider": "faiss",
+        "config": {
+            "collection_name": "test",
+            "path": "/tmp/faiss_memories",
+            "distance_strategy": "euclidean"
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+### Installation
+
+To use FAISS in your mem0 project, you need to install the appropriate FAISS package for your environment:
+
+```bash
+# For CPU version
+pip install faiss-cpu
+
+# For GPU version (requires CUDA)
+pip install faiss-gpu
+```
+
+### Config
+
+Here are the parameters available for configuring FAISS:
+
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collection_name` | The name of the collection | `mem0` |
+| `path` | Path to store FAISS index and metadata | `/tmp/faiss/<collection_name>` |
+| `distance_strategy` | Distance metric strategy to use (options: 'euclidean', 'inner_product', 'cosine') | `euclidean` |
+| `normalize_L2` | Whether to normalize L2 vectors (only applicable for euclidean distance) | `False` |
+
+### Performance Considerations
+
+FAISS offers several advantages for vector search:
+
+1. **Efficiency**: FAISS is optimized for memory usage and speed, making it suitable for large-scale applications.
+2. **Offline Support**: FAISS works entirely locally, with no need for external servers or API calls.
+3. **Storage Options**: Vectors can be stored in-memory for maximum speed or persisted to disk.
+4. **Multiple Index Types**: FAISS supports different index types optimized for various use cases (though mem0 currently uses the basic flat index).
+
+### Distance Strategies
+
+FAISS in mem0 supports three distance strategies:
+
+- **euclidean**: L2 distance, suitable for most embedding models
+- **inner_product**: Dot product similarity, useful for some specialized embeddings
+- **cosine**: Cosine similarity, best for comparing semantic similarity regardless of vector magnitude
+
+When using `cosine` or `inner_product` with normalized vectors, you may want to set `normalize_L2=True` for better results.
@@ -0,0 +1,112 @@
+---
+title: LangChain
+---
+
+Mem0 supports LangChain as a provider for vector store integration. LangChain provides a unified interface to various vector databases, making it easy to integrate different vector store providers through a consistent API.
+
+<Note>
+  When using LangChain as your vector store provider, you must set the collection name to "mem0". This is a required configuration for proper integration with Mem0.
+</Note>
+
+## Usage
+
+<CodeGroup>
+```python Python
+import os
+from mem0 import Memory
+from langchain_community.vectorstores import Chroma
+from langchain_openai import OpenAIEmbeddings
+
+# Initialize a LangChain vector store
+embeddings = OpenAIEmbeddings()
+vector_store = Chroma(
+    persist_directory="./chroma_db",
+    embedding_function=embeddings,
+    collection_name="mem0"  # Required collection name
+)
+
+# Pass the initialized vector store to the config
+config = {
+    "vector_store": {
+        "provider": "langchain",
+        "config": {
+            "client": vector_store
+        }
+    }
+}
+
+m = Memory.from_config(config)
+messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+m.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+
+```typescript TypeScript
+import { Memory } from "mem0ai";
+import { OpenAIEmbeddings } from "@langchain/openai";
+import { MemoryVectorStore as LangchainMemoryStore } from "langchain/vectorstores/memory";
+
+const embeddings = new OpenAIEmbeddings();
+const vectorStore = new LangchainVectorStore(embeddings);
+
+const config = {
+    "vector_store": {
+        "provider": "langchain",
+        "config": { "client": vectorStore }
+    }
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
+    { role: "assistant", content: "How about a 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." }
+]
+
+memory.add(messages, user_id="alice", metadata={"category": "movies"})
+```
+</CodeGroup>
+
+## Supported LangChain Vector Stores
+
+LangChain supports a wide range of vector store providers, including:
+
+- Chroma
+- FAISS
+- Pinecone
+- Weaviate
+- Milvus
+- Qdrant
+- And many more
+
+You can use any of these vector store instances directly in your configuration. For a complete and up-to-date list of available providers, refer to the [LangChain Vector Stores documentation](https://python.langchain.com/docs/integrations/vectorstores).
+
+## Limitations
+
+When using LangChain as a vector store provider, there are some limitations to be aware of:
+
+1. **Bulk Operations**: The `get_all` and `delete_all` operations are not supported when using LangChain as the vector store provider. This is because LangChain's vector store interface doesn't provide standardized methods for these bulk operations across all providers.
+
+2. **Provider-Specific Features**: Some advanced features may not be available depending on the specific vector store implementation you're using through LangChain.
+
+## Provider-Specific Configuration
+
+When using LangChain as a vector store provider, you'll need to:
+
+1. Set the appropriate environment variables for your chosen vector store provider
+2. Import and initialize the specific vector store class you want to use
+3. Pass the initialized vector store instance to the config
+
+<Note>
+  Make sure to install the necessary LangChain packages and any provider-specific dependencies.
+</Note>
+
+## Config
+
+All available parameters for the `langchain` vector store config are present in [Master List of All Params in Config](../config).
@@ -1,7 +1,7 @@
-# Pinecone
-
 [Pinecone](https://www.pinecone.io/) is a fully managed vector database designed for machine learning applications, offering high performance vector search with low latency at scale. It's particularly well-suited for semantic search, recommendation systems, and other AI-powered applications.

+> **Note**: Before configuring Pinecone, you need to select an embedding model (e.g., OpenAI, Cohere, or custom models) and ensure the `embedding_model_dims` in your config matches your chosen model's dimensions. For example, OpenAI's text-embedding-3-small uses 1536 dimensions.
+
 ### Usage

 ```python
@@ -11,13 +11,17 @@ from mem0 import Memory
 os.environ["OPENAI_API_KEY"] = "sk-xx"
 os.environ["PINECONE_API_KEY"] = "your-api-key"

+# Example using serverless configuration
 config = {
    "vector_store": {
        "provider": "pinecone",
        "config": {
-            "collection_name": "memory_index",
-            "embedding_model_dims": 1536,
-            "environment": "us-west1-gcp",
+            "collection_name": "testing",
+            "embedding_model_dims": 1536,  # Matches OpenAI's text-embedding-3-small
+            "serverless_config": {
+                "cloud": "aws",  # Choose between 'aws' or 'gcp' or 'azure'
+                "region": "us-east-1"
+            },
            "metric": "cosine"
        }
    }
@@ -40,28 +44,29 @@ Here are the parameters available for configuring Pinecone:
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `collection_name` | Name of the index/collection | Required |
-| `embedding_model_dims` | Dimensions of the embedding model | Required |
+| `embedding_model_dims` | Dimensions of the embedding model (must match your chosen embedding model) | Required |
 | `client` | Existing Pinecone client instance | `None` |
 | `api_key` | API key for Pinecone | Environment variable: `PINECONE_API_KEY` |
 | `environment` | Pinecone environment | `None` |
-| `serverless_config` | Configuration for serverless deployment | `None` |
+| `serverless_config` | Configuration for serverless deployment (AWS or GCP or Azure) | `None` |
 | `pod_config` | Configuration for pod-based deployment | `None` |
 | `hybrid_search` | Whether to enable hybrid search | `False` |
 | `metric` | Distance metric for vector similarity | `"cosine"` |
 | `batch_size` | Batch size for operations | `100` |

-#### Serverless Config Example
+> **Important**: You must choose either `serverless_config` or `pod_config` for your deployment, but not both.

+#### Serverless Config Example
 ```python
 config = {
    "vector_store": {
        "provider": "pinecone",
        "config": {
            "collection_name": "memory_index",
-            "embedding_model_dims": 1536,
+            "embedding_model_dims": 1536,  # For OpenAI's text-embedding-3-small
            "serverless_config": {
-                "cloud": "aws",
-                "region": "us-west-2"
+                "cloud": "aws",  # or "gcp" or "azure"
+                "region": "us-east-1"  # Choose appropriate region
            }
        }
    }
@@ -69,14 +74,13 @@ config = {
 ```

 #### Pod Config Example
-
 ```python
 config = {
    "vector_store": {
        "provider": "pinecone",
        "config": {
            "collection_name": "memory_index",
-            "embedding_model_dims": 1536,
+            "embedding_model_dims": 1536,  # For OpenAI's text-embedding-ada-002
            "pod_config": {
                "environment": "gcp-starter",
                "replicas": 1,
@@ -4,7 +4,8 @@ Create a [Supabase](https://supabase.com/dashboard/projects) account and project

 ### Usage

-```python
+<CodeGroup>
+```python Python
 import os
 from mem0 import Memory

@@ -32,10 +33,90 @@ messages = [
 m.add(messages, user_id="alice", metadata={"category": "movies"})
 ```

+```typescript Typescript
+import { Memory } from "mem0ai/oss";
+
+const config = {
+    vectorStore: {
+      provider: "supabase",
+      config: {
+        collectionName: "memories",
+        embeddingModelDims: 1536,
+        supabaseUrl: process.env.SUPABASE_URL || "",
+        supabaseKey: process.env.SUPABASE_KEY || "",
+        tableName: "memories",
+      },
+    },
+}
+
+const memory = new Memory(config);
+
+const messages = [
+    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
+    {"role": "assistant", "content": "How about a 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."}
+]
+
+await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
+```
+</CodeGroup>
+
+### SQL Migrations for TypeScript Implementation
+
+The following SQL migrations are required to enable the vector extension and create the memories table:
+
+```sql
+-- Enable the vector extension
+create extension if not exists vector;
+
+-- Create the memories table
+create table if not exists memories (
+  id text primary key,
+  embedding vector(1536),
+  metadata jsonb,
+  created_at timestamp with time zone default timezone('utc', now()),
+  updated_at timestamp with time zone default timezone('utc', now())
+);
+
+-- Create the vector similarity search function
+create or replace function match_vectors(
+  query_embedding vector(1536),
+  match_count int,
+  filter jsonb default '{}'::jsonb
+)
+returns table (
+  id text,
+  similarity float,
+  metadata jsonb
+)
+language plpgsql
+as $$
+begin
+  return query
+  select
+    t.id::text,
+    1 - (t.embedding <=> query_embedding) as similarity,
+    t.metadata
+  from memories t
+  where case
+    when filter::text = '{}'::text then true
+    else t.metadata @> filter
+  end
+  order by t.embedding <=> query_embedding
+  limit match_count;
+end;
+$$;
+```
+
+Goto [Supabase](https://supabase.com/dashboard/projects) and run the above SQL migrations inside the SQL Editor.
+
 ### Config

 Here are the parameters available for configuring Supabase:

+<Tabs>
+<Tab title="Python">
 | Parameter | Description | Default Value |
 | --- | --- | --- |
 | `connection_string` | PostgreSQL connection string (required) | None |
@@ -43,6 +124,17 @@ Here are the parameters available for configuring Supabase:
 | `embedding_model_dims` | Dimensions of the embedding model | `1536` |
 | `index_method` | Vector index method to use | `auto` |
 | `index_measure` | Distance measure for similarity search | `cosine_distance` |
+</Tab>
+<Tab title="TypeScript">
+| Parameter | Description | Default Value |
+| --- | --- | --- |
+| `collectionName` | Name for the vector collection | `mem0` |
+| `embeddingModelDims` | Dimensions of the embedding model | `1536` |
+| `supabaseUrl` | Supabase URL | None |
+| `supabaseKey` | Supabase key | None |
+| `tableName` | Name for the vector table | `memories` |
+</Tab>
+</Tabs>

 ### Index Methods

@@ -0,0 +1,70 @@
+[Upstash Vector](https://upstash.com/docs/vector) is a serverless vector database with built-in embedding models.
+
+### Usage with Upstash embeddings
+
+You can enable the built-in embedding models by setting `enable_embeddings` to `True`. This allows you to use Upstash's embedding models for vectorization.
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["UPSTASH_VECTOR_REST_URL"] = "..."
+os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "..."
+
+config = {
+    "vector_store": {
+        "provider": "upstash_vector",
+        "enable_embeddings": True,
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+<Note>
+    Setting `enable_embeddings` to `True` will bypass any external embedding provider you have configured.
+</Note>
+
+### Usage with external embedding providers
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "..."
+os.environ["UPSTASH_VECTOR_REST_URL"] = "..."
+os.environ["UPSTASH_VECTOR_REST_TOKEN"] = "..."
+
+config = {
+    "vector_store": {
+        "provider": "upstash_vector",
+    },
+    "embedder": {
+        "provider": "openai",
+        "config": {
+            "model": "text-embedding-3-large"
+        },
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+### Config
+
+Here are the parameters available for configuring Upstash Vector:
+
+| Parameter           | Description                        | Default Value |
+| ------------------- | ---------------------------------- | ------------- |
+| `url`               | URL for the Upstash Vector index   | `None`        |
+| `token`             | Token for the Upstash Vector index | `None`        |
+| `client`            | An `upstash_vector.Index` instance | `None`        |
+| `collection_name`   | The default namespace used         | `""`          |
+| `enable_embeddings` | Whether to use Upstash embeddings  | `False`       |
+
+<Note>
+  When `url` and `token` are not provided, the `UPSTASH_VECTOR_REST_URL` and
+  `UPSTASH_VECTOR_REST_TOKEN` environment variables are used.
+</Note>
@@ -1,4 +1,6 @@
-## Google Cloud Vertex AI Vector Search
+---
+title: Vertex AI Vector Search
+---


 ### Usage
@@ -4,6 +4,8 @@ icon: "info"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 includes built-in support for various popular databases. Memory can utilize the database provided by the user, ensuring efficient use for specific needs.

 ## Supported Vector Databases
@@ -18,15 +20,18 @@ See the list of supported vector databases below.
  <Card title="Qdrant" href="/components/vectordbs/dbs/qdrant"></Card>
  <Card title="Chroma" href="/components/vectordbs/dbs/chroma"></Card>
  <Card title="Pgvector" href="/components/vectordbs/dbs/pgvector"></Card>
+  <Card title="Upstash Vector" href="/components/vectordbs/dbs/upstash-vector"></Card>
  <Card title="Milvus" href="/components/vectordbs/dbs/milvus"></Card>
  <Card title="Pinecone" href="/components/vectordbs/dbs/pinecone"></Card>
-  <Card title="Azure AI Search" href="/components/vectordbs/dbs/azure_ai_search"></Card>
+  <Card title="Azure" href="/components/vectordbs/dbs/azure"></Card>
  <Card title="Redis" href="/components/vectordbs/dbs/redis"></Card>
  <Card title="Elasticsearch" href="/components/vectordbs/dbs/elasticsearch"></Card>
  <Card title="OpenSearch" href="/components/vectordbs/dbs/opensearch"></Card>
  <Card title="Supabase" href="/components/vectordbs/dbs/supabase"></Card>
-  <Card title="Vertex AI Vector Search" href="/components/vectordbs/dbs/vertex_ai_vector_search"></Card>
+  <Card title="Vertex AI" href="/components/vectordbs/dbs/vertex_ai"></Card>
  <Card title="Weaviate" href="/components/vectordbs/dbs/weaviate"></Card>
+  <Card title="FAISS" href="/components/vectordbs/dbs/faiss"></Card>
+  <Card title="LangChain" href="/components/vectordbs/dbs/langchain"></Card>
 </CardGroup>

 ## Usage
@@ -3,6 +3,8 @@ title: Development
 icon: "code"
 ---

+<Snippet file="paper-release.mdx" />
+
 # Development Contributions

 We strive to make contributions **easy, collaborative, and enjoyable**. Follow the steps below to ensure a smooth contribution process.
@@ -3,6 +3,8 @@ title: Documentation
 icon: "book"
 ---

+<Snippet file="paper-release.mdx" />
+
 # Documentation Contributions

 ## 📌 Prerequisites
@@ -5,6 +5,8 @@ icon: "gear"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 provides two core operations for managing memories in AI applications: adding new memories and searching existing ones. This guide covers how these operations work and how to use them effectively in your application.


@@ -4,6 +4,9 @@ description: Understanding different types of memory in AI Applications
 icon: "memory"
 iconType: "solid"
 ---
+
+<Snippet file="paper-release.mdx" />
+
 To build useful AI applications, we need to understand how different memory systems work together. This guide explores the fundamental types of memory in AI systems and shows how Mem0 implements these concepts.

 ## Why Memory Matters
@@ -49,6 +49,7 @@
                      "features/advanced-retrieval",
                      "features/contextual-add",
                      "features/multimodal-support",
+                      "features/timestamp",
                      "features/selective-memory",
                      "features/custom-categories",
                      "features/custom-instructions",
@@ -57,7 +58,8 @@
                      "features/memory-export",
                      "features/webhooks",
                      "features/graph-memory",
-                      "features/feedback-mechanism"
+                      "features/feedback-mechanism",
+                      "features/expiration-date"
                    ]
                  }
                ]
@@ -73,6 +75,7 @@
                    "group": "Features",
                    "icon": "wrench",
                    "pages": [
+                      "open-source/features/async-memory",
                      "features/openai_compatibility",
                      "features/custom-fact-extraction-prompt",
                      "features/custom-update-memory-prompt",
@@ -110,7 +113,9 @@
                          "components/llms/models/aws_bedrock",
                          "components/llms/models/gemini",
                          "components/llms/models/deepseek",
-                          "components/llms/models/xAI"
+                          "components/llms/models/xAI",
+                          "components/llms/models/lmstudio",
+                          "components/llms/models/langchain"
                        ]
                      }
                    ]
@@ -130,13 +135,15 @@
                          "components/vectordbs/dbs/pgvector",
                          "components/vectordbs/dbs/milvus",
                          "components/vectordbs/dbs/pinecone",
-                          "components/vectordbs/dbs/azure_ai_search",
+                          "components/vectordbs/dbs/azure",
                          "components/vectordbs/dbs/redis",
                          "components/vectordbs/dbs/elasticsearch",
                          "components/vectordbs/dbs/opensearch",
                          "components/vectordbs/dbs/supabase",
-                          "components/vectordbs/dbs/vertex_ai_vector_search",
-                          "components/vectordbs/dbs/weaviate"
+                          "components/vectordbs/dbs/vertex_ai",
+                          "components/vectordbs/dbs/weaviate",
+                          "components/vectordbs/dbs/faiss",
+                          "components/vectordbs/dbs/langchain"
                        ]
                      }
                    ]
@@ -156,7 +163,10 @@
                          "components/embedders/models/ollama",
                          "components/embedders/models/huggingface",
                          "components/embedders/models/vertexai",
-                          "components/embedders/models/gemini"
+                          "components/embedders/models/gemini",
+                          "components/embedders/models/lmstudio",
+                          "components/embedders/models/together",
+                          "components/embedders/models/langchain"
                        ]
                      }
                    ]
@@ -180,9 +190,10 @@
                "group": "💡 Examples",
                "icon": "lightbulb",
                "pages": [
-                  "examples/overview",
+                  "examples",
                  "examples/mem0-demo",
                  "examples/ai_companion_js",
+                  "examples/mem0-mastra",
                  "examples/mem0-with-ollama",
                  "examples/personal-ai-tutor",
                  "examples/customer-support-agent",
@@ -193,7 +204,10 @@
                  "examples/multimodal-demo",
                  "examples/personalized-deep-research",
                  "examples/mem0-agentic-tool",
-                  "examples/openai-inbuilt-tools"
+                  "examples/openai-inbuilt-tools",
+                  "examples/mem0-openai-voice-demo",
+                  "examples/email_processing",
+                  "examples/youtube-assistant"
                ]
              }
            ]
@@ -205,8 +219,9 @@
                "group": "Integrations",
                "icon": "plug",
                "pages": [
-                  "integrations/overview",
+                  "integrations",
                  "integrations/vercel-ai-sdk",
+                  "integrations/flowise",
                  "integrations/crewai",
                  "integrations/autogen",
                  "integrations/langchain",
@@ -214,7 +229,12 @@
                  "integrations/llama-index",
                  "integrations/langchain-tools",
                  "integrations/dify",
-                  "integrations/mcp-server"
+                  "integrations/mcp-server",
+                  "integrations/livekit",
+                  "integrations/elevenlabs",
+                  "integrations/pipecat",
+                  "integrations/agno",
+                  "integrations/keywords"
                ]
              }
            ]
@@ -227,7 +247,7 @@
                "group": "API Reference",
                "icon": "terminal",
                "pages": [
-                  "api-reference/overview",
+                  "api-reference",
                  {
                    "group": "Memory APIs",
                    "icon": "microchip",
@@ -245,7 +265,8 @@
                      "api-reference/memory/batch-delete",
                      "api-reference/memory/delete-memories",
                      "api-reference/memory/create-memory-export",
-                      "api-reference/memory/get-memory-export"
+                      "api-reference/memory/get-memory-export",
+                      "api-reference/memory/feedback"
                    ]
                  },
                  {
@@ -268,6 +289,18 @@
                      "api-reference/organization/delete-org"
                    ]
                  },
+                  {
+                    "group": "Project APIs",
+                    "icon": "folder",
+                    "pages": [
+                      "api-reference/project/create-project",
+                      "api-reference/project/get-projects",
+                      "api-reference/project/get-project",
+                      "api-reference/project/get-project-members",
+                      "api-reference/project/add-project-member",
+                      "api-reference/project/delete-project"
+                    ]
+                  },
                  {
                    "group": "Webhook APIs",
                    "icon": "webhook",
@@ -281,6 +314,19 @@
                ]
              }
            ]
+          },
+          {
+            "tab": "Changelog",
+            "icon": "clock",
+            "groups": [
+              {
+                "group": "Product Updates",
+                "icon": "rocket",
+                "pages": [
+                  "changelog"
+                ]
+              }
+            ]
          }
        ]
      },
@@ -3,6 +3,8 @@ title: Overview
 description: How to use mem0 in your existing applications?
 ---

+<Snippet file="paper-release.mdx" />
+

 With Mem0, you can create stateful LLM-based applications such as chatbots, virtual assistants, or AI agents. Mem0 enhances your applications by providing a memory layer that makes responses:

@@ -47,6 +49,10 @@ Explore how **Mem0** can power real-world applications and bring personalized, i
    Add **long-term memory** to ChatGPT, Claude, or Perplexity via the **Mem0 Chrome Extension** — personalize your AI chats anywhere.  
  </Card>  

+  <Card title="YouTube Assistant" icon="puzzle-piece" href="/examples/youtube-assistant">  
+    Integrate **Mem0** into **YouTube's** native UI, providing personalized responses with video context. 
+  </Card> 
+
  <Card title="Document Writing Assistant" icon="pen" href="/examples/document-writing">  
    Create a **Writing Assistant** that understands and adapts to your unique style, improving consistency and productivity.  
  </Card>  
@@ -55,7 +61,7 @@ Explore how **Mem0** can power real-world applications and bring personalized, i
    Supercharge AI with **Mem0's multimodal memory** — blend text, images, and more for richer, context-aware interactions.  
  </Card>  

-  <Card title="Personalized Research Agent" icon="robot" href="/examples/personalized-deep-research">  
+  <Card title="Personalized Research Agent" icon="magnifying-glass" href="/examples/personalized-deep-research">  
    Build a **Deep Research AI** that remembers your research goals and compiles insights from vast information sources.  
  </Card>  

@@ -66,4 +72,12 @@ Explore how **Mem0** can power real-world applications and bring personalized, i
  <Card title="OpenAI Inbuilt Tools" icon="robot" href="/examples/openai-inbuilt-tools">  
    Use Mem0's memory capabilities with OpenAI's Inbuilt Tools to create AI agents with persistent memory.  
  </Card>  
+
+  <Card title="Mem0 OpenAI Voice Demo" icon="microphone" href="/examples/mem0-openai-voice-demo">  
+    Use Mem0's memory capabilities with OpenAI's Inbuilt Tools to create AI agents with persistent memory.  
+  </Card> 
+
+  <Card title="Email Processing" icon="envelope" href="/examples/email_processing">  
+    Use Mem0's memory capabilities to process emails and create AI agents with persistent memory.  
+  </Card> 
 </CardGroup>
@@ -2,6 +2,8 @@
 title: AI Companion
 ---

+<Snippet file="paper-release.mdx" />
+
 You can create a personalised AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

 ## Overview
@@ -2,6 +2,8 @@
 title: AI Companion in Node.js
 ---

+<Snippet file="paper-release.mdx" />
+
 You can create a personalised AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

 ## Overview
@@ -1,5 +1,7 @@
 # Mem0 Chrome Extension

+<Snippet file="paper-release.mdx" />
+
 Enhance your AI interactions with **Mem0**, a Chrome extension that introduces a universal memory layer across platforms like `ChatGPT`, `Claude`, and `Perplexity`. Mem0 ensures seamless context sharing, making your AI experiences more personalized and efficient.

 <Note>
@@ -2,6 +2,8 @@
 title: Customer Support AI Agent
 ---

+<Snippet file="paper-release.mdx" />
+
 You can create a personalized Customer Support AI Agent using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

 ## Overview
@@ -1,6 +1,7 @@
 ---
 title: Document Editing with Mem0
 ---
+<Snippet file="paper-release.mdx" />

 This guide demonstrates how to leverage **Mem0** to edit documents efficiently, ensuring they align with your unique writing style and preferences.

@@ -0,0 +1,188 @@
+---
+title: Email Processing with Mem0
+---
+
+<Snippet file="paper-release.mdx" />
+
+This guide demonstrates how to build an intelligent email processing system using Mem0's memory capabilities. You'll learn how to store, categorize, retrieve, and analyze emails to create a smart email management solution.
+
+## Overview
+
+Email overload is a common challenge for many professionals. By leveraging Mem0's memory capabilities, you can build an intelligent system that:
+
+- Stores emails as searchable memories
+- Categorizes emails automatically
+- Retrieves relevant past conversations
+- Prioritizes messages based on importance
+- Generates summaries and action items
+
+## Setup
+
+Before you begin, ensure you have the required dependencies installed:
+
+```bash
+pip install mem0ai openai
+```
+
+## Implementation
+
+### Basic Email Memory System
+
+The following example shows how to create a basic email processing system with Mem0:
+
+```python
+import os
+from mem0 import MemoryClient
+from email.parser import Parser
+
+# Configure API keys
+os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
+
+# Initialize Mem0 client
+client = MemoryClient()
+
+class EmailProcessor:
+    def __init__(self):
+        """Initialize the Email Processor with Mem0 memory client"""
+        self.client = client
+        
+    def process_email(self, email_content, user_id):
+        """
+        Process an email and store it in Mem0 memory
+        
+        Args:
+            email_content (str): Raw email content
+            user_id (str): User identifier for memory association
+        """
+        # Parse email
+        parser = Parser()
+        email = parser.parsestr(email_content)
+        
+        # Extract email details
+        sender = email['from']
+        recipient = email['to']
+        subject = email['subject']
+        date = email['date']
+        body = self._get_email_body(email)
+        
+        # Create message object for Mem0
+        message = {
+            "role": "user",
+            "content": f"Email from {sender}: {subject}\n\n{body}"
+        }
+        
+        # Create metadata for better retrieval
+        metadata = {
+            "email_type": "incoming",
+            "sender": sender,
+            "recipient": recipient,
+            "subject": subject,
+            "date": date
+        }
+        
+        # Store in Mem0 with appropriate categories
+        response = self.client.add(
+            messages=[message],
+            user_id=user_id,
+            metadata=metadata,
+            categories=["email", "correspondence"],
+            version="v2"
+        )
+        
+        return response
+    
+    def _get_email_body(self, email):
+        """Extract the body content from an email"""
+        # Simplified extraction - in real-world, handle multipart emails
+        if email.is_multipart():
+            for part in email.walk():
+                if part.get_content_type() == "text/plain":
+                    return part.get_payload(decode=True).decode()
+        else:
+            return email.get_payload(decode=True).decode()
+    
+    def search_emails(self, query, user_id):
+        """
+        Search through stored emails
+        
+        Args:
+            query (str): Search query
+            user_id (str): User identifier
+        """
+        # Search Mem0 for relevant emails
+        results = self.client.search(
+            query=query,
+            user_id=user_id,
+            categories=["email"],
+            output_format="v1.1",
+            version="v2"
+        )
+        
+        return results
+        
+    def get_email_thread(self, subject, user_id):
+        """
+        Retrieve all emails in a thread based on subject
+        
+        Args:
+            subject (str): Email subject to match
+            user_id (str): User identifier
+        """
+        filters = {
+            "AND": [
+                {"user_id": user_id},
+                {"categories": {"contains": "email"}},
+                {"metadata": {"subject": {"contains": subject}}}
+            ]
+        }
+        
+        thread = self.client.get_all(
+            version="v2",
+            filters=filters,
+            output_format="v1.1"
+        )
+        
+        return thread
+
+# Initialize the processor
+processor = EmailProcessor()
+
+# Example raw email
+sample_email = """From: alice@example.com
+To: bob@example.com
+Subject: Meeting Schedule Update
+Date: Mon, 15 Jul 2024 14:22:05 -0700
+
+Hi Bob,
+
+I wanted to update you on the schedule for our upcoming project meeting.
+We'll be meeting this Thursday at 2pm instead of Friday.
+
+Could you please prepare your section of the presentation?
+
+Thanks,
+Alice
+"""
+
+# Process and store the email
+user_id = "bob@example.com"
+processor.process_email(sample_email, user_id)
+
+# Later, search for emails about meetings
+meeting_emails = processor.search_emails("meeting schedule", user_id)
+print(f"Found {len(meeting_emails['results'])} relevant emails")
+```
+
+## Key Features and Benefits
+
+- **Long-term Email Memory**: Store and retrieve email conversations across long periods
+- **Semantic Search**: Find relevant emails even if they don't contain exact keywords
+- **Intelligent Categorization**: Automatically sort emails into meaningful categories
+- **Action Item Extraction**: Identify and track tasks mentioned in emails
+- **Priority Management**: Focus on important emails based on AI-determined priority
+- **Context Awareness**: Maintain thread context for more relevant interactions
+
+## Conclusion
+
+By combining Mem0's memory capabilities with email processing, you can create intelligent email management systems that help users organize, prioritize, and act on their inbox effectively. The advanced capabilities like automatic categorization, action item extraction, and priority management can significantly reduce the time spent on email management, allowing users to focus on more important tasks.
+
@@ -1,6 +1,8 @@
 ---
 title: LlamaIndex ReAct Agent
 ---
+<Snippet file="paper-release.mdx" />
+
 Create a ReAct Agent with LlamaIndex which uses Mem0 as the memory store.

 ### Overview
@@ -2,6 +2,8 @@
 title: Mem0 as an Agentic Tool
 ---

+<Snippet file="paper-release.mdx" />
+
 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.

@@ -2,6 +2,9 @@
 title: Mem0 Demo
 ---

+
+<Snippet file="paper-release.mdx" />
+
 You can create a personalized AI Companion using Mem0. This guide will walk you through the necessary steps and provide the complete setup instructions to get you started.

 <video
@@ -0,0 +1,128 @@
+---
+title: Mem0 with Mastra
+---
+
+<Snippet file="paper-release.mdx" />
+
+In this example you'll learn how to use the Mem0 to add long-term memory capabilities to [Mastra's agent](https://mastra.ai/) via tool-use.
+This memory integration can work alongside Mastra's [agent memory features](https://mastra.ai/docs/agents/01-agent-memory).
+
+You can find the complete example code in the [Mastra repository](https://github.com/mastra-ai/mastra/tree/main/examples/memory-with-mem0).
+
+## Overview
+
+This guide will show you how to integrate Mem0 with Mastra to add long-term memory capabilities to your agents. We'll create tools that allow agents to save and retrieve memories using Mem0's API.
+
+### Installation
+
+1. **Install the Integration Package**
+
+To install the Mem0 integration, run:
+
+```bash
+npm install @mastra/mem0
+```
+
+2. **Add the Integration to Your Project**
+
+Create a new file for your integrations and import the integration:
+
+```typescript integrations/index.ts
+import { Mem0Integration } from "@mastra/mem0";
+
+export const mem0 = new Mem0Integration({
+  config: {
+    apiKey: process.env.MEM0_API_KEY!,
+    userId: "alice",
+  },
+});
+```
+
+3. **Use the Integration in Tools or Workflows**
+
+You can now use the integration when defining tools for your agents or in workflows.
+
+```typescript tools/index.ts
+import { createTool } from "@mastra/core";
+import { z } from "zod";
+import { mem0 } from "../integrations";
+
+export 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,
+    };
+  },
+});
+
+export 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 };
+  },
+});
+```
+
+4. **Create a new agent**
+
+```typescript agents/index.ts
+import { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+import { mem0MemorizeTool, mem0RememberTool } from '../tools';
+
+export const mem0Agent = new Agent({
+  name: 'Mem0 Agent',
+  instructions: `
+    You are a helpful assistant that has the ability to memorize and remember facts using Mem0.
+  `,
+  model: openai('gpt-4o'),
+  tools: { mem0RememberTool, mem0MemorizeTool },
+});
+```
+
+5. **Run the agent**
+
+```typescript index.ts
+import { Mastra } from '@mastra/core/mastra';
+import { createLogger } from '@mastra/core/logger';
+
+import { mem0Agent } from './agents';
+
+export const mastra = new Mastra({
+  agents: { mem0Agent },
+  logger: createLogger({
+    name: 'Mastra',
+    level: 'error',
+  }),
+});
+```
+
+In the example above:
+- We import the `@mastra/mem0` integration.
+- We define two tools that uses the Mem0 API client to create new memories and recall previously saved memories.
+- The tool accepts `question` as an input and returns the memory as a string.
@@ -0,0 +1,540 @@
+---
+title: 'Mem0 with OpenAI Agents SDK for Voice'
+description: 'Integrate memory capabilities into your voice agents using Mem0 and OpenAI Agents SDK'
+---
+
+<Snippet file="paper-release.mdx" />
+
+# Building Voice Agents with Memory using Mem0 and OpenAI Agents SDK
+
+This guide demonstrates how to combine OpenAI's Agents SDK for voice applications with Mem0's memory capabilities to create a voice assistant that remembers user preferences and past interactions.
+
+## Prerequisites
+
+Before you begin, make sure you have:
+
+1. Installed OpenAI Agents SDK with voice dependencies:
+```bash
+pip install 'openai-agents[voice]'
+```
+
+2. Installed Mem0 SDK:
+```bash
+pip install mem0ai
+```
+
+3. Installed other required dependencies:
+```bash
+pip install numpy sounddevice pydantic
+```
+
+4. Set up your API keys:
+   - OpenAI API key for the Agents SDK
+   - Mem0 API key from the Mem0 Platform
+
+## Code Breakdown
+
+Let's break down the key components of this implementation:
+
+### 1. Setting Up Dependencies and Environment
+
+```python
+# OpenAI Agents SDK imports
+from agents import (
+    Agent,
+    function_tool
+)
+from agents.voice import (
+    AudioInput,
+    SingleAgentVoiceWorkflow,
+    VoicePipeline
+)
+from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
+
+# Mem0 imports
+from mem0 import AsyncMemoryClient
+
+# Set up API keys (replace with your actual keys)
+os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
+os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
+
+# Define a global user ID for simplicity
+USER_ID = "voice_user"
+
+# Initialize Mem0 client
+mem0_client = AsyncMemoryClient()
+```
+
+This section handles:
+- Importing required modules from OpenAI Agents SDK and Mem0
+- Setting up environment variables for API keys
+- Defining a simple user identification system (using a global variable)
+- Initializing the Mem0 client that will handle memory operations
+
+### 2. Memory Tools with Function Decorators
+
+The `@function_tool` decorator transforms Python functions into callable tools for the OpenAI agent. Here are the key memory tools:
+
+#### Storing User Memories
+
+```python
+import logging
+
+# Set up logging at the top of your file
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    force=True
+)
+logger = logging.getLogger("memory_voice_agent")
+
+# Then use logger in your function tools
+@function_tool
+async def save_memories(
+    memory: str
+) -> str:
+    """Store a user memory in memory."""
+    # This will be visible in your console
+    logger.debug(f"Saving memory: {memory} for user {USER_ID}")
+    
+    # Store the preference in Mem0
+    memory_content = f"User memory - {memory}"
+    await mem0_client.add(
+        memory_content,
+        user_id=USER_ID,
+    )
+
+    return f"I've saved your memory: {memory}"
+```
+
+This function:
+- Takes a memory string
+- Creates a formatted memory string
+- Stores it in Mem0 using the `add()` method
+- Includes metadata to categorize the memory for easier retrieval
+- Returns a confirmation message that the agent will speak
+
+#### Finding Relevant Memories
+
+```python
+@function_tool
+async def search_memories(
+    query: str
+) -> str:
+    """
+    Find memories relevant to the current conversation.
+    Args:
+        query: The search query to find relevant memories
+    """
+    print(f"Finding memories related to: {query}")
+    results = await mem0_client.search(
+        query,
+        user_id=USER_ID,
+        limit=5,
+        threshold=0.7,  # Higher threshold for more relevant results
+        output_format="v1.1"
+    )
+    
+    # Format and return the results
+    if not results.get('results', []):
+        return "I don't have any relevant memories about this topic."
+    
+    memories = [f"• {result['memory']}" for result in results.get('results', [])]
+    return "Here's what I remember that might be relevant:\n" + "\n".join(memories)
+```
+
+This tool:
+- Takes a search query string
+- Passes it to Mem0's semantic search to find related memories
+- Sets a threshold for relevance to ensure quality results
+- Returns a formatted list of relevant memories or a default message
+
+### 3. Creating the Voice Agent
+
+```python
+def create_memory_voice_agent():
+    # Create the agent with memory-enabled tools
+    agent = Agent(
+        name="Memory Assistant",
+        instructions=prompt_with_handoff_instructions(
+            """You're speaking to a human, so be polite and concise.
+            Always respond in clear, natural English.
+            You have the ability to remember information about the user.
+            Use the save_memories tool when the user shares an important information worth remembering.
+            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
+            """,
+        ),
+        model="gpt-4o",
+        tools=[save_memories, search_memories],
+    )
+    
+    return agent
+```
+
+This function:
+- Creates an OpenAI Agent with specific instructions
+- Configures it to use gpt-4o (you can use other models)
+- Registers the memory-related tools with the agent
+- Uses `prompt_with_handoff_instructions` to include standard voice agent behaviors
+
+### 4. Microphone Recording Functionality
+
+```python
+async def record_from_microphone(duration=5, samplerate=24000):
+    """Record audio from the microphone for a specified duration."""
+    print(f"Recording for {duration} seconds...")
+    
+    # Create a buffer to store the recorded audio
+    frames = []
+    
+    # Callback function to store audio data
+    def callback(indata, frames_count, time_info, status):
+        frames.append(indata.copy())
+    
+    # Start recording
+    with sd.InputStream(samplerate=samplerate, channels=1, callback=callback, dtype=np.int16):
+        await asyncio.sleep(duration)
+    
+    # Combine all frames into a single numpy array
+    audio_data = np.concatenate(frames)
+    return audio_data
+```
+
+This function:
+- Creates a simple asynchronous microphone recording function
+- Uses the sounddevice library to capture audio input
+- Stores frames in a buffer during recording
+- Combines frames into a single numpy array when complete
+- Returns the audio data for processing
+
+### 5. Main Loop and Voice Processing
+
+```python
+async def main():
+    # Create the agent
+    agent = create_memory_voice_agent()
+    
+    # Set up the voice pipeline
+    pipeline = VoicePipeline(
+        workflow=SingleAgentVoiceWorkflow(agent)
+    )
+    
+    # Configure TTS settings
+    pipeline.config.tts_settings.voice = "alloy"
+    pipeline.config.tts_settings.speed = 1.0
+    
+    try:
+        while True:
+            # Get user input
+            print("\nPress Enter to start recording (or 'q' to quit)...")
+            user_input = input()
+            if user_input.lower() == 'q':
+                break
+            
+            # Record and process audio
+            audio_data = await record_from_microphone(duration=5)
+            audio_input = AudioInput(buffer=audio_data)
+            result = await pipeline.run(audio_input)
+            
+            # Play response and handle events
+            player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
+            player.start()
+            
+            agent_response = ""
+            print("\nAgent response:")
+            
+            async for event in result.stream():
+                if event.type == "voice_stream_event_audio":
+                    player.write(event.data)
+                elif event.type == "voice_stream_event_content":
+                    content = event.data
+                    agent_response += content
+                    print(content, end="", flush=True)
+            
+            # Save the agent's response to memory
+            if agent_response:
+                try:
+                    await mem0_client.add(
+                        f"Agent response: {agent_response}", 
+                        user_id=USER_ID,
+                        metadata={"type": "agent_response"}
+                    )
+                except Exception as e:
+                    print(f"Failed to store memory: {e}")
+    
+    except KeyboardInterrupt:
+        print("\nExiting...")
+```
+
+This main function orchestrates the entire process:
+1. Creates the memory-enabled voice agent
+2. Sets up the voice pipeline with TTS settings
+3. Implements an interactive loop for recording and processing voice input
+4. Handles streaming of response events (both audio and text)
+5. Automatically saves the agent's responses to memory
+6. Includes proper error handling and exit mechanisms
+
+## Create a Memory-Enabled Voice Agent
+
+Now that we've explained each component, here's the complete implementation that combines OpenAI Agents SDK for voice with Mem0's memory capabilities:
+
+```python
+import asyncio
+import os
+import logging
+from typing import Optional, List, Dict, Any
+import numpy as np
+import sounddevice as sd
+from pydantic import BaseModel
+
+# OpenAI Agents SDK imports
+from agents import (
+    Agent,
+    function_tool
+)
+from agents.voice import (
+    AudioInput,
+    SingleAgentVoiceWorkflow,
+    VoicePipeline
+)
+from agents.extensions.handoff_prompt import prompt_with_handoff_instructions
+
+# Mem0 imports
+from mem0 import AsyncMemoryClient
+
+# Set up API keys (replace with your actual keys)
+os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
+os.environ["MEM0_API_KEY"] = "your-mem0-api-key"
+
+# Define a global user ID for simplicity
+USER_ID = "voice_user"
+
+# Initialize Mem0 client
+mem0_client = AsyncMemoryClient()
+
+# Create tools that utilize Mem0's memory
+@function_tool
+async def save_memories(
+    memory: str
+) -> str:
+    """
+    Store a user memory in memory.
+    Args:
+        memory: The memory to save
+    """
+    print(f"Saving memory: {memory} for user {USER_ID}")
+
+    # Store the preference in Mem0
+    memory_content = f"User memory - {memory}"
+    await mem0_client.add(
+        memory_content,
+        user_id=USER_ID,
+    )
+
+    return f"I've saved your memory: {memory}"
+
+@function_tool
+async def search_memories(
+    query: str
+) -> str:
+    """
+    Find memories relevant to the current conversation.
+    Args:
+        query: The search query to find relevant memories
+    """
+    print(f"Finding memories related to: {query}")
+    results = await mem0_client.search(
+        query,
+        user_id=USER_ID,
+        limit=5,
+        threshold=0.7,  # Higher threshold for more relevant results
+        output_format="v1.1"
+    )
+    
+    # Format and return the results
+    if not results.get('results', []):
+        return "I don't have any relevant memories about this topic."
+    
+    memories = [f"• {result['memory']}" for result in results.get('results', [])]
+    return "Here's what I remember that might be relevant:\n" + "\n".join(memories)
+
+# Create the agent with memory-enabled tools
+def create_memory_voice_agent():
+    # Create the agent with memory-enabled tools
+    agent = Agent(
+        name="Memory Assistant",
+        instructions=prompt_with_handoff_instructions(
+            """You're speaking to a human, so be polite and concise.
+            Always respond in clear, natural English.
+            You have the ability to remember information about the user.
+            Use the save_memories tool when the user shares an important information worth remembering.
+            Use the search_memories tool when you need context from past conversations or user asks you to recall something.
+            """,
+        ),
+        model="gpt-4o",
+        tools=[save_memories, search_memories],
+    )
+    
+    return agent
+
+async def record_from_microphone(duration=5, samplerate=24000):
+    """Record audio from the microphone for a specified duration."""
+    print(f"Recording for {duration} seconds...")
+    
+    # Create a buffer to store the recorded audio
+    frames = []
+    
+    # Callback function to store audio data
+    def callback(indata, frames_count, time_info, status):
+        frames.append(indata.copy())
+    
+    # Start recording
+    with sd.InputStream(samplerate=samplerate, channels=1, callback=callback, dtype=np.int16):
+        await asyncio.sleep(duration)
+    
+    # Combine all frames into a single numpy array
+    audio_data = np.concatenate(frames)
+    return audio_data
+
+async def main():
+    print("Starting Memory Voice Agent")
+    
+    # Create the agent and context
+    agent = create_memory_voice_agent()
+    
+    # Set up the voice pipeline
+    pipeline = VoicePipeline(
+        workflow=SingleAgentVoiceWorkflow(agent)
+    )
+    
+    # Configure TTS settings
+    pipeline.config.tts_settings.voice = "alloy"
+    pipeline.config.tts_settings.speed = 1.0
+    
+    try:
+        while True:
+            # Get user input
+            print("\nPress Enter to start recording (or 'q' to quit)...")
+            user_input = input()
+            if user_input.lower() == 'q':
+                break
+            
+            # Record and process audio
+            audio_data = await record_from_microphone(duration=5)
+            audio_input = AudioInput(buffer=audio_data)
+            
+            print("Processing your request...")
+            
+            # Process the audio input
+            result = await pipeline.run(audio_input)
+            
+            # Create an audio player
+            player = sd.OutputStream(samplerate=24000, channels=1, dtype=np.int16)
+            player.start()
+            
+            # Store the agent's response for adding to memory
+            agent_response = ""
+            
+            print("\nAgent response:")
+            # Play the audio stream as it comes in
+            async for event in result.stream():
+                if event.type == "voice_stream_event_audio":
+                    player.write(event.data)
+                elif event.type == "voice_stream_event_content":
+                    # Accumulate and print the text response
+                    content = event.data
+                    agent_response += content
+                    print(content, end="", flush=True)
+            
+            print("\n")
+            
+            # Example of saving the conversation to Mem0 after completion
+            if agent_response:
+                try:
+                    await mem0_client.add(
+                        f"Agent response: {agent_response}", 
+                        user_id=USER_ID,
+                        metadata={"type": "agent_response"}
+                    )
+                except Exception as e:
+                    print(f"Failed to store memory: {e}")
+    
+    except KeyboardInterrupt:
+        print("\nExiting...")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Key Features of This Implementation
+
+This implementation offers several key features:
+
+1. **Simplified User Management**: Uses a global `USER_ID` variable for simplicity, but can be extended to manage multiple users.
+
+2. **Real Microphone Input**: Includes a `record_from_microphone()` function that captures actual voice input from your microphone.
+
+3. **Interactive Voice Loop**: Implements a continuous interaction loop, allowing for multiple back-and-forth exchanges.
+
+4. **Memory Management Tools**:
+   - `save_memories`: Stores user memories in Mem0
+   - `search_memories`: Searches for relevant past information
+
+5. **Voice Configuration**: Demonstrates how to configure TTS settings for the voice response.
+
+## Running the Example
+
+To run this example:
+
+1. Replace the placeholder API keys with your actual keys
+2. Make sure your microphone is properly connected
+3. Run the script with Python 3.8 or newer
+4. Press Enter to start recording, then speak your request
+5. Press 'q' to quit the application
+
+The agent will listen to your request, process it through the OpenAI model, utilize Mem0 for memory operations as needed, and respond both through text output and voice speech.
+
+## Best Practices for Voice Agents with Memory
+
+1. **Optimizing Memory for Voice**: Keep memories concise and relevant for voice responses.
+
+2. **Forgetting Mechanism**: Implement a way to delete or expire memories that are no longer relevant.
+
+3. **Context Preservation**: Store enough context with each memory to make retrieval effective.
+
+4. **Error Handling**: Implement robust error handling for memory operations, as voice interactions should continue smoothly even if memory operations fail.
+
+## Conclusion
+
+By combining OpenAI's Agents SDK with Mem0's memory capabilities, you can create voice agents that maintain persistent memory of user preferences and past interactions. This significantly enhances the user experience by making conversations more natural and personalized.
+
+As you build your voice application, experiment with different memory strategies and filtering approaches to find the optimal balance between comprehensive memory and efficient retrieval for your specific use case.
+
+## Debugging Function Tools
+
+When working with the OpenAI Agents SDK, you might notice that regular `print()` statements inside `@function_tool` decorated functions don't appear in your console output. This is because the Agents SDK captures and redirects standard output when executing these functions.
+
+To effectively debug your function tools, use Python's `logging` module instead:
+
+```python
+import logging
+
+# Set up logging at the top of your file
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    force=True
+)
+logger = logging.getLogger("memory_voice_agent")
+
+# Then use logger in your function tools
+@function_tool
+async def save_memories(
+    memory: str
+) -> str:
+    """Store a user memory in memory."""
+    # This will be visible in your console
+    logger.debug(f"Saving memory: {memory} for user {USER_ID}")
+    
+    # Rest of your function...
+```
@@ -2,6 +2,8 @@
 title: Mem0 with Ollama
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Running Mem0 Locally with Ollama

 Mem0 can be utilized entirely locally by leveraging Ollama for both the embedding model and the language model (LLM). This guide will walk you through the necessary steps and provide the complete code to get you started.
@@ -2,6 +2,8 @@
 title: Multimodal Demo with Mem0
 ---

+<Snippet file="paper-release.mdx" />
+
 Enhance your AI interactions with **Mem0**'s multimodal capabilities. Mem0 now supports image understanding, allowing for richer context and more natural interactions across supported AI platforms.

 > 🎉 Experience the power of multimodal AI! Test out Mem0's image understanding capabilities at [multimodal-demo.mem0.ai](https://multimodal-demo.mem0.ai)
@@ -2,6 +2,8 @@
 title: OpenAI Inbuilt Tools
 ---

+<Snippet file="paper-release.mdx" />
+
 Integrate Mem0’s memory capabilities with OpenAI’s Inbuilt Tools to create AI agents with persistent memory.

 ## Getting Started
@@ -2,6 +2,8 @@
 title: Personalized AI Tutor
 ---

+<Snippet file="paper-release.mdx" />
+
 You can create a personalized AI Tutor using Mem0. This guide will walk you through the necessary steps and provide the complete code to get you started.

 ## Overview
@@ -20,6 +22,7 @@ pip install openai mem0ai
 Below is the complete code to create and interact with a Personalized AI Tutor using Mem0:

 ```python
+import os 
 from openai import OpenAI
 from mem0 import Memory

@@ -54,22 +57,21 @@ class PersonalAITutor:
        :param question: The question to ask the AI.
        :param user_id: Optional user ID to associate with the memory.
        """
-        # Start a streaming chat completion request to the AI
-        stream = self.client.chat.completions.create(
-            model="gpt-4",
-            stream=True,
-            messages=[
-                {"role": "system", "content": "You are a personal AI Tutor."},
-                {"role": "user", "content": question}
-            ]
+        # Start a streaming response request to the AI
+        response = self.client.responses.create(
+            model="gpt-4o",
+            instructions="You are a personal AI Tutor.",
+            input=question,
+            stream=True
        )
+
        # Store the question in memory
        self.memory.add(question, user_id=user_id, metadata={"app_id": self.app_id})

        # Print the response from the AI in real-time
-        for chunk in stream:
-            if chunk.choices[0].delta.content is not None:
-                print(chunk.choices[0].delta.content, end="")
+        for event in response:
+            if event.type == "response.output_text.delta":
+                print(event.delta, end="")

    def get_memories(self, user_id=None):
        """
@@ -1,6 +1,9 @@
 ---
 title: Personal AI Travel Assistant
 ---
+
+<Snippet file="paper-release.mdx" />
+
 Create a personalized AI Travel Assistant using Mem0. This guide provides step-by-step instructions and the complete code to get you started.

 ## Overview
@@ -63,18 +66,23 @@ class PersonalTravelAssistant:
    def ask_question(self, question, user_id):
        # Fetch previous related memories
        previous_memories = self.search_memories(question, user_id=user_id)
-        prompt = question
-        if previous_memories:
-            prompt = f"User input: {question}\n Previous memories: {previous_memories}"
-        self.messages.append({"role": "user", "content": prompt})

-        # Generate response using GPT-4o
-        response = self.client.chat.completions.create(
+        # Build the prompt
+        system_message = "You are a personal AI Assistant."
+
+        if previous_memories:
+            prompt = f"{system_message}\n\nUser input: {question}\nPrevious memories: {', '.join(previous_memories)}"
+        else:
+            prompt = f"{system_message}\n\nUser input: {question}"
+
+        # Generate response using Responses API
+        response = self.client.responses.create(
            model="gpt-4o",
-            messages=self.messages
+            input=prompt
        )
-        answer = response.choices[0].message.content
-        self.messages.append({"role": "assistant", "content": answer})
+
+        # Extract answer from the response
+        answer = response.output[0].content[0].text

        # Store the question in memory
        self.memory.add(question, user_id=user_id)
@@ -2,6 +2,8 @@
 title: Personalized Deep Research
 ---

+<Snippet file="paper-release.mdx" />
+
 Deep Research is an intelligent agent that synthesizes large amounts of online data and completes complex research tasks, customized to your unique preferences and insights. Built on Mem0's technology, it enhances AI-driven online exploration with personalized memories.

 ## Overview
@@ -0,0 +1,58 @@
+---
+title: YouTube Assistant Extension
+---
+
+<Snippet file="paper-release.mdx" />
+
+Enhance your YouTube experience with Mem0's **YouTube Assistant**, a Chrome extension that brings AI-powered chat directly to your YouTube videos. Get instant, personalized answers about video content while leveraging your own knowledge and memories - all without leaving the page.
+
+## Features
+
+- **Contextual AI Chat**: Ask questions about videos you're watching
+- **Seamless Integration**: Chat interface sits alongside YouTube's native UI
+- **Memory Integration**: Personalized responses based on your knowledge through Mem0
+- **Real-Time Memory**: Memories are updated in real-time based on your interactions
+
+## Demo Video
+
+<video
+  autoPlay
+  muted
+  loop
+  playsInline
+  width="700"
+  height="400"
+  src="https://github.com/user-attachments/assets/c0334ccd-311b-4dd7-8034-ef88204fc751"
+></video>
+
+## Installation
+
+This extension is not available on the Chrome Web Store yet. You can install it manually using below method:
+
+### Manual Installation (Developer Mode)
+
+1. **Download the Extension**: Clone or download the extension files from the [Mem0 GitHub repository](https://github.com/mem0ai/mem0/tree/main/examples).
+2. **Build**: Run `npm install` followed by `npm run build` to install the dependencies and build the extension.
+3. **Access Chrome Extensions**: Open Google Chrome and navigate to `chrome://extensions`.
+4. **Enable Developer Mode**: Toggle the "Developer mode" switch in the top right corner.
+5. **Load Unpacked Extension**: Click "Load unpacked" and select the directory containing the extension files.
+6. **Confirm Installation**: The Mem0 YouTube Assistant Extension should now appear in your Chrome toolbar.
+
+## Setup
+
+1. **Configure API Settings**: Click the extension icon and enter your OpenAI API key (required to use the extension)
+2. **Customize Settings**: Configure additional settings such as model, temperature, and memory settings
+3. **Navigate to YouTube**: Start using the assistant on any YouTube video
+4. **Memories**: Enter your Mem0 API key to enable personalized responses, and feed initial memories from settings
+
+## Example Prompts
+
+- "Can you summarize the main points of this video?"
+- "Explain the concept they just mentioned"
+- "How does this relate to what I already know?"
+- "What are some practical applications of this topic related to my work?"
+
+
+## Privacy and Data Security
+
+Your API keys are stored locally in your browser. Your messages are sent to the Mem0 API for extracting and retrieving memories. Mem0 is committed to ensuring your data's privacy and security.
@@ -4,6 +4,7 @@ icon: "question"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />

 <AccordionGroup>
    <Accordion title="How does Mem0 work?">
@@ -125,6 +126,23 @@ iconType: "solid"
        This flexibility allows you to create highly contextually aware AI applications that can adapt to specific user needs and situations. Metadata provides an additional dimension for memory retrieval, enabling more precise and relevant responses.
    </Accordion>

+    <Accordion title="How do I disable telemetry in Mem0?">
+        To disable telemetry in Mem0, you can set the `MEM0_TELEMETRY` environment variable to `False`:
+
+        ```bash
+        MEM0_TELEMETRY=False
+        ```
+
+        You can also disable telemetry programmatically in your code:
+
+        ```python
+        import os
+        os.environ["MEM0_TELEMETRY"] = "False"
+        ```
+
+        Setting this environment variable will prevent Mem0 from collecting and sending any usage data, ensuring complete privacy for your application.
+    </Accordion>
+
 </AccordionGroup>


@@ -4,6 +4,8 @@ icon: "wrench"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Core features

 - **User, Session, and AI Agent Memory**: Retains information across sessions and interactions for users and AI agents, ensuring continuity and context.
@@ -4,6 +4,8 @@ icon: "magnifying-glass"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0's **Advanced Retrieval** feature delivers superior search results by leveraging state-of-the-art search algorithms. Beyond the default search functionality, Mem0 offers the following advanced retrieval modes:

 1. **Keyword Search**
@@ -5,6 +5,7 @@ icon: "bolt"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
 The `AsyncMemoryClient` is an asynchronous client for interacting with the Mem0 API. It provides similar functionality to the synchronous `MemoryClient` but allows for non-blocking operations, which can be beneficial in applications that require high concurrency.

 ## Initialization
@@ -4,6 +4,8 @@ icon: "square-plus"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 now supports an contextual add version (v2). To use it, set `version="v2"` during the add call. The default version is v1, which is deprecated now. We recommend migrating to `v2` for new applications.

 ## Key Differences Between v1 and v2
@@ -5,6 +5,8 @@ icon: "tags"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## How to set custom categories?

 You can now create custom categories tailored to your specific needs, instead of using the default categories such as travel, sports, music, and more (see [default categories](#default-categories) below). **When custom categories are provided, they will override the default categories.**
@@ -5,6 +5,8 @@ icon: "pencil"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Introduction to Custom Fact Extraction Prompt

 Custom fact extraction prompt allow you to tailor the behavior of your Mem0 instance to specific use cases or domains. 
@@ -5,6 +5,8 @@ icon: "pencil"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Introduction to Custom Instructions

 Custom instructions allow you to define specific guidelines for your project. This feature helps ensure consistency and provides clear direction for handling project-specific requirements.
@@ -3,9 +3,12 @@ title: Custom Update Memory Prompt
 icon: "pencil"
 iconType: "solid"
 ---
+
+<Snippet file="paper-release.mdx" />
+
 Update memory prompt is a prompt used to determine the action to be performed on the memory. 
 By customizing this prompt, you can control how the memory is updated.  
-  
+

 ## Introduction  
 Mem0 memory system compares the newly retrieved facts with the existing memory and determines the action to be performed on the memory.  
@@ -5,6 +5,8 @@ icon: "arrow-right"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## How to use Direct Import?
 The Direct Import feature allows users to skip the memory deduction phase and directly input pre-defined memories into the system for storage and retrieval.
 To enable this feature, you need to set the `infer` parameter to `False` in the `add` method.
@@ -0,0 +1,114 @@
+---
+title: Expiration Date
+description: 'Set time-bound memories in Mem0 with automatic expiration dates to manage temporal information effectively.'
+icon: "clock"
+iconType: "solid"
+---
+
+<Snippet file="paper-release.mdx" />
+
+## Benefits of Memory Expiration
+
+Setting expiration dates for memories offers several advantages:
+
+• **Time-Sensitive Information Management**: Handle information that's only relevant for a specific time period.
+
+• **Event-Based Memory**: Manage information related to upcoming events that becomes irrelevant after the event passes.
+
+These benefits enable more sophisticated memory management for applications where temporal context matters.
+
+## Setting Memory Expiration Date
+
+You can set an expiration date for memories, after which they will no longer be retrieved in searches. This is useful for creating temporary memories or memories that are only relevant for a specific time period.
+
+<CodeGroup>
+
+```python Python
+import datetime
+from mem0 import MemoryClient
+
+client = MemoryClient(api_key="your-api-key")
+
+messages = [
+    {
+        "role": "user", 
+        "content": "I'll be in San Francisco until end of this month."
+    }
+]
+
+# Set an expiration date for this memory
+client.add(messages=messages, user_id="alex", expiration_date=str(datetime.datetime.now().date() + datetime.timedelta(days=30)))
+
+# You can also use an explicit date string
+client.add(messages=messages, user_id="alex", expiration_date="2023-08-31")
+```
+
+```javascript JavaScript
+import MemoryClient from 'mem0ai';
+const client = new MemoryClient({ apiKey: 'your-api-key' });
+
+const messages = [
+    {
+        "role": "user", 
+        "content": "I'll be in San Francisco until end of this month."
+    }
+];
+
+// Set an expiration date 30 days from now
+const expirationDate = new Date();
+expirationDate.setDate(expirationDate.getDate() + 30);
+client.add(messages, { 
+    user_id: "alex", 
+    expiration_date: expirationDate.toISOString().split('T')[0] 
+})
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+
+// You can also use an explicit date string
+client.add(messages, { 
+    user_id: "alex", 
+    expiration_date: "2023-08-31" 
+})
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+```bash cURL
+curl -X POST "https://api.mem0.ai/v1/memories/" \
+     -H "Authorization: Token your-api-key" \
+     -H "Content-Type: application/json" \
+     -d '{
+         "messages": [
+             {
+                "role": "user", 
+                "content": "I'll be in San Francisco until end of this month."
+            }
+         ],
+         "user_id": "alex",
+         "expiration_date": "2023-08-31"
+     }'
+```
+
+```json Output
+{
+    "results": [
+        {
+            "id": "a1b2c3d4-e5f6-4g7h-8i9j-k0l1m2n3o4p5",
+            "data": {
+                "memory": "In San Francisco until end of this month"
+            },
+            "event": "ADD"
+        }
+    ]
+}
+```
+
+</CodeGroup>
+
+<Note>
+Once a memory reaches its expiration date, it won't be included in search or get results, though the data remains stored in the system.
+</Note>
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />
@@ -4,6 +4,8 @@ icon: "thumbs-up"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0's **Feedback Mechanism** allows you to provide feedback on the memories generated by your application. This feedback is used to improve the accuracy of the memories and the search results.

 ## How it works
@@ -17,9 +19,9 @@ You can give feedback on a memory by calling the `feedback` method on the Mem0 c
 <CodeGroup>

 ```python Python
-from mem0 import Mem0
+from mem0 import MemoryClient

-client = Mem0(api_key="your_api_key")
+client = MemoryClient(api_key="your_api_key")

 client.feedback(memory_id="your-memory-id", feedback="NEGATIVE", feedback_reason="I don't like this memory because it is not relevant.")
 ```
@@ -5,6 +5,8 @@ iconType: "solid"
 description: "Enable graph-based memory retrieval for more contextually relevant results"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Overview

 Graph Memory enhances memory pipeline by creating relationships between entities in your data. It builds a network of interconnected information for more contextually relevant search results.
@@ -5,6 +5,8 @@ icon: "file-export"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Overview

 The Memory Export feature allows you to create structured exports of memories using customizable Pydantic schemas. This process enables you to transform your stored memories into specific data formats that match your needs. You can apply various filters to narrow down which memories to export and define exactly how the data should be structured.
@@ -91,10 +93,17 @@ export_instructions = """
 5. Clearly distinguish between factual statements and inferences
 """

+# For create operation, using only user_id filter as requested
+filters = {
+    "AND": [
+        {"user_id": "alex"}
+    ]
+}
+
 response = client.create_memory_export(
    schema=json_schema,
-    user_id="alice",
-    export_instructions=export_instructions
+    filters=filters,
+    export_instructions=export_instructions  # Optional
 )

 print(response)
@@ -127,7 +136,15 @@ Once the export job is complete, you can retrieve the structured data:
 <CodeGroup>

 ```python Python
-response = client.get_memory_export(user_id="alice")
+# Corrected date range (assuming you meant July 10 to July 20)
+filters = {
+    "AND": [
+        {"created_at": {"gte": "2024-07-10", "lte": "2024-07-20"}},
+        {"user_id": "alex"}
+    ]
+}
+
+response = client.get_memory_export(filters=filters)
 print(response)
 ```

@@ -157,6 +174,7 @@ You can apply various filters to customize which memories are included in the ex
 - `agent_id`: Filter memories by specific agent
 - `run_id`: Filter memories by specific run
 - `session_id`: Filter memories by specific session
+- `created_at`: Filter memories by date

 <Note>
 The export process may take some time to complete, especially when dealing with a large number of memories or complex schemas.
@@ -1,15 +1,17 @@
 ---
 title: Multimodal Support
-description: Integrate images into your interactions with Mem0
+description: Integrate images and documents into your interactions with Mem0
 icon: "image"
 iconType: "solid"
 ---

-Mem0 extends its capabilities beyond text by supporting multimodal data, including images. With this feature, users can seamlessly integrate images into their interactions—allowing Mem0 to extract relevant information from visual content and enrich the memory system.
+<Snippet file="paper-release.mdx" />
+
+Mem0 extends its capabilities beyond text by supporting multimodal data, including images and documents. With this feature, users can seamlessly integrate visual and document content into their interactions—allowing Mem0 to extract relevant information from various media types and enrich the memory system.

 ## How It Works

-When a user submits an image, Mem0 processes it to extract textual information and other pertinent details. These details are then added to the user's memory, enhancing the system's ability to understand and recall visual inputs.
+When a user submits an image or document, Mem0 processes it to extract textual information and other pertinent details. These details are then added to the user's memory, enhancing the system's ability to understand and recall multimodal inputs.

 <CodeGroup>
 ```python Python
@@ -90,11 +92,18 @@ await client.add(messages, { user_id: "alice" })
 ```
 </CodeGroup>

-## Image Integration Methods
+## Supported Media Types

-Mem0 supports incorporating images into user interactions using two primary methods: by providing an image URL or by using a Base64-encoded image. The examples below demonstrate both approaches.
+Mem0 currently supports the following media types:

-## 1. Using an Image URL (Recommended)
+1. **Images** - JPG, PNG, and other common image formats
+2. **Documents** - MDX, TXT, and PDF files
+
+## Integration Methods
+
+### 1. Images
+
+#### Using an Image URL (Recommended)

 You can include an image by providing its direct URL. This method is simple and efficient for online images.

@@ -115,7 +124,7 @@ image_message = {
 client.add([image_message], user_id="alice")
 ```

-## 2. Using Base64 Image Encoding for Local Files
+#### Using Base64 Image Encoding for Local Files

 For local images—or when embedding the image directly is preferable—you can use a Base64-encoded string.

@@ -164,7 +173,134 @@ const imageMessage = {
 await client.add([imageMessage], { user_id: "alice" })
 ```
 </CodeGroup>
-Using these methods, you can seamlessly incorporate images into your interactions, further enhancing Mem0's multimodal capabilities.
+
+### 2. Text Documents (MDX/TXT)
+
+Mem0 supports both online and local text documents in MDX or TXT format.
+
+#### Using a Document URL
+
+```python
+# Define the document URL
+document_url = "https://www.w3.org/TR/2003/REC-PNG-20031110/iso_8859-1.txt"
+
+# Create the message dictionary with the document URL
+document_message = {
+    "role": "user",
+    "content": {
+        "type": "mdx_url",
+        "mdx_url": {
+            "url": document_url
+        }
+    }
+}
+client.add([document_message], user_id="alice")
+```
+
+#### Using Base64 Encoding for Local Documents
+
+```python
+import base64
+
+# Path to the document file
+document_path = "path/to/your/document.txt"
+
+# Function to convert file to Base64
+def file_to_base64(file_path):
+    with open(file_path, "rb") as file:
+        return base64.b64encode(file.read()).decode('utf-8')
+
+# Encode the document in Base64
+base64_document = file_to_base64(document_path)
+
+# Create the message dictionary with the Base64-encoded document
+document_message = {
+    "role": "user",
+    "content": {
+        "type": "mdx_url",
+        "mdx_url": {
+            "url": base64_document
+        }
+    }
+}
+client.add([document_message], user_id="alice")
+```
+
+### 3. PDF Documents
+
+Mem0 supports PDF documents via URL.
+
+```python
+# Define the PDF URL
+pdf_url = "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"
+
+# Create the message dictionary with the PDF URL
+pdf_message = {
+    "role": "user",
+    "content": {
+        "type": "pdf_url",
+        "pdf_url": {
+            "url": pdf_url
+        }
+    }
+}
+client.add([pdf_message], user_id="alice")
+```
+
+## Complete Example with Multiple File Types
+
+Here's a comprehensive example showing how to work with different file types:
+
+```python
+import base64
+from mem0 import MemoryClient
+
+client = MemoryClient()
+
+def file_to_base64(file_path):
+    with open(file_path, "rb") as file:
+        return base64.b64encode(file.read()).decode('utf-8')
+
+# Example 1: Using an image URL
+image_message = {
+    "role": "user",
+    "content": {
+        "type": "image_url",
+        "image_url": {
+            "url": "https://example.com/sample-image.jpg"
+        }
+    }
+}
+
+# Example 2: Using a text document URL
+text_message = {
+    "role": "user",
+    "content": {
+        "type": "mdx_url",
+        "mdx_url": {
+            "url": "https://www.w3.org/TR/2003/REC-PNG-20031110/iso_8859-1.txt"
+        }
+    }
+}
+
+# Example 3: Using a PDF URL
+pdf_message = {
+    "role": "user",
+    "content": {
+        "type": "pdf_url",
+        "pdf_url": {
+            "url": "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"
+        }
+    }
+}
+
+# Add each message to the memory system
+client.add([image_message], user_id="alice")
+client.add([text_message], user_id="alice")
+client.add([pdf_message], user_id="alice")
+```
+
+Using these methods, you can seamlessly incorporate various media types into your interactions, further enhancing Mem0's multimodal capabilities.

 If you have any questions, please feel free to reach out to us using one of the following methods:

@@ -4,6 +4,8 @@ icon: "code"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 can be easily integrated into chat applications to enhance conversational agents with structured memory. Mem0's APIs are designed to be compatible with OpenAI's, with the goal of making it easy to leverage Mem0 in applications you may have already built.

 If you have a `Mem0 API key`, you can use it to initialize the client. Alternatively, you can initialize Mem0 without an API key if you're using it locally.
@@ -4,6 +4,8 @@ icon: "info"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 Learn about the key features and capabilities that make Mem0 a powerful platform for memory management and retrieval.

 ## Core Features
@@ -5,6 +5,8 @@ icon: "filter"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Benefits of Memory Customization

 Memory customization offers several key benefits:
@@ -93,7 +95,7 @@ messages = [

 <CodeGroup>
 ```python Code
-client.add(messages, user_id="alice", includes=includes)
+client.add(messages, user_id="alice", excludes=excludes)
 ```

 ```json Stored Memories
@@ -0,0 +1,128 @@
+---
+title: Memory Timestamps
+description: 'Add timestamps to your memories to maintain chronological accuracy and historical context'
+icon: "clock"
+iconType: "solid"
+---
+
+<Snippet file="paper-release.mdx" />
+
+## Overview
+
+The Memory Timestamps feature allows you to specify when a memory was created, regardless of when it's actually added to the system. This powerful capability enables you to:
+
+- Maintain accurate chronological ordering of memories
+- Import historical data with proper timestamps
+- Create memories that reflect when events actually occurred
+- Build timelines with precise temporal information
+
+By leveraging custom timestamps, you can ensure that your memory system maintains an accurate representation of when information was generated or events occurred.
+
+## Benefits of Custom Timestamps
+
+Custom timestamps offer several important benefits:
+
+• **Historical Accuracy**: Preserve the exact timing of past events and information.
+
+• **Data Migration**: Seamlessly migrate existing data while maintaining original timestamps.
+
+• **Time-Sensitive Analysis**: Enable time-based analysis and pattern recognition across memories.
+
+• **Consistent Chronology**: Maintain proper ordering of memories for coherent storytelling.
+
+## Using Custom Timestamps
+
+When adding new memories, you can specify a custom timestamp to indicate when the memory was created. This timestamp will be used instead of the current time.
+
+### Adding Memories with Custom Timestamps
+
+<CodeGroup>
+
+```python Python
+import time
+from datetime import datetime, timedelta
+
+# Get the current time
+current_time = datetime.now()
+
+# Calculate 5 days ago
+five_days_ago = current_time - timedelta(days=5)
+
+# Convert to Unix timestamp (seconds since epoch)
+unix_timestamp = int(five_days_ago.timestamp())
+
+# Add memory with custom timestamp
+client.add("I'm travelling to SF", user_id="user1", timestamp=unix_timestamp)
+```
+
+```javascript JavaScript
+// Get the current time
+const currentTime = new Date();
+
+// Calculate 5 days ago
+const fiveDaysAgo = new Date();
+fiveDaysAgo.setDate(currentTime.getDate() - 5);
+
+// Convert to Unix timestamp (seconds since epoch)
+const unixTimestamp = Math.floor(fiveDaysAgo.getTime() / 1000);
+
+// Add memory with custom timestamp
+client.add("I'm travelling to SF", { user_id: "user1", timestamp: unixTimestamp })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+```bash cURL
+curl -X POST "https://api.mem0.ai/v1/memories/" \
+     -H "Authorization: Token your-api-key" \
+     -H "Content-Type: application/json" \
+     -d '{
+         "messages": [{"role": "user", "content": "I'm travelling to SF"}],
+         "user_id": "user1",
+         "timestamp": 1721577600
+     }'
+```
+
+```json Output
+{
+    "results": [
+        {
+            "id": "a1b2c3d4-e5f6-4g7h-8i9j-k0l1m2n3o4p5",
+            "data": {"memory": "Travelling to SF"},
+            "event": "ADD"
+        }
+    ]
+}
+```
+
+</CodeGroup>
+
+### Timestamp Format
+
+When specifying a custom timestamp, you should provide a Unix timestamp (seconds since epoch). This is an integer representing the number of seconds that have elapsed since January 1, 1970 (UTC).
+
+For example, to create a memory with a timestamp of January 1, 2023:
+
+<CodeGroup>
+
+```python Python
+# January 1, 2023 timestamp
+january_2023_timestamp = 1672531200  # Unix timestamp for 2023-01-01 00:00:00 UTC
+
+client.add("Important historical information", user_id="user1", timestamp=january_2023_timestamp)
+```
+
+```javascript JavaScript
+// January 1, 2023 timestamp
+const january2023Timestamp = 1672531200;  // Unix timestamp for 2023-01-01 00:00:00 UTC
+
+client.add("Important historical information", { user_id: "user1", timestamp: january2023Timestamp })
+    .then(response => console.log(response))
+    .catch(error => console.error(error));
+```
+
+</CodeGroup>
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />
@@ -5,6 +5,8 @@ icon: "webhook"
 iconType: "solid"
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Overview

 Webhooks enable real-time notifications for memory events in your Mem0 project. Webhooks are configured at the project level, meaning each webhook is tied to a specific project and receives events solely from that project. You can configure webhooks to send HTTP POST requests to your specified URLs whenever memories are created, updated, or deleted.
@@ -3,6 +3,8 @@ title: Overview
 description: How to integrate Mem0 into other frameworks
 ---

+<Snippet file="paper-release.mdx" />
+
 Mem0 seamlessly integrates with popular AI frameworks and tools to enhance your LLM-based applications with persistent memory capabilities. By integrating Mem0, your applications benefit from:

 - Enhanced context management across multiple frameworks
@@ -220,4 +222,104 @@ Here are the available integrations for Mem0:
  >
    Integrate Mem0 as an MCP Server in Cursor.
  </Card>
+  <Card
+    title="Livekit"
+    icon={
+      <svg
+        viewBox="0 0 24 24"
+        xmlns="http://www.w3.org/2000/svg"
+        width="24"
+        height="24"
+      >
+        <text
+          x="12"
+          y="16"
+          fontFamily="Arial"
+          fontSize="12"
+          textAnchor="middle"
+          fill="currentColor"
+          fontWeight="bold"
+        >
+          LK
+        </text>
+      </svg>
+    }
+    href="/integrations/livekit"
+  >
+    Integrate Mem0 with Livekit for voice agents.
+  </Card>
+  <Card
+    title="ElevenLabs"
+    icon={
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="24"
+        height="24"
+        viewBox="0 0 24 24"
+        fill="none"
+      >
+        <rect width="24" height="24" fill="white"/>
+        <rect x="8" y="4" width="2" height="16" fill="black"/>
+        <rect x="14" y="4" width="2" height="16" fill="black"/>
+      </svg>
+    }
+    href="/integrations/elevenlabs"
+  >
+    Build voice agents with memory using ElevenLabs Conversational AI.
+  </Card>
+  <Card
+    title="Pipecat"
+    icon={
+      <svg
+        viewBox="0 0 24 24"
+        xmlns="http://www.w3.org/2000/svg"
+        width="24"
+        height="24"
+      >
+        <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z" fill="currentColor"/>
+        <circle cx="8.5" cy="9" r="1.5" fill="currentColor"/>
+        <circle cx="15.5" cy="9" r="1.5" fill="currentColor"/>
+        <path d="M12 16c1.66 0 3-1.34 3-3H9c0 1.66 1.34 3 3 3z" fill="currentColor"/>
+        <path d="M17.5 12c-.83 0-1.5-.67-1.5-1.5s.67-1.5 1.5-1.5 1.5.67 1.5 1.5-.67 1.5-1.5 1.5z" fill="currentColor"/>
+        <path d="M6.5 12c-.83 0-1.5-.67-1.5-1.5S5.67 9 6.5 9s1.5.67 1.5 1.5S7.33 12 6.5 12z" fill="currentColor"/>
+      </svg>
+    } 
+    href="/integrations/pipecat"
+  >
+    Build conversational AI agents with memory using Pipecat.
+  </Card>
+  <Card
+    title="Agno"
+    icon={
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="24"
+        height="24"
+        viewBox="0 0 24 24"
+        fill="none"
+      >
+        <path d="M8 4h8v12h8" stroke="currentColor" strokeWidth="2" fill="none" transform="rotate(15, 12, 12)"/>
+      </svg>
+    }
+    href="/integrations/agno"
+  >
+    Build autonomous agents with memory using Agno framework.
+  </Card>
+  <Card
+    title="Keywords AI"
+    icon={
+      <svg
+        xmlns="http://www.w3.org/2000/svg"
+        width="24"
+        height="24"
+        viewBox="0 0 24 24"
+        fill="none"
+      >
+        <path fill-rule="evenodd" clip-rule="evenodd" d="M9.07513 1.1863C9.21663 1.07722 9.39144 1.01009 9.56624 1.01009C9.83261 1.01009 10.0823 1.12756 10.2405 1.33734L15.0101 7.4964V12.4136L16.4335 13.8401C16.7582 14.1673 16.7582 14.7043 16.4335 15.0316C16.1089 15.3588 15.5762 15.3588 15.2515 15.0316L13.3453 13.1016V8.07538L8.92529 2.36944V2.36105C8.64228 2.00024 8.70887 1.4716 9.07513 1.1863ZM18.976 14.4133C18.8344 14.3778 18.7003 14.3042 18.5894 14.1925L16.9163 12.5059C16.7249 12.3129 16.6416 12.0528 16.6749 11.8094V6.88385H16.6499L11.8553 0.691225C11.7282 0.529117 11.6716 0.333133 11.6803 0.140562C11.134 0.0481292 10.5726 0 10 0C4.47715 0 0 4.47715 0 10C0 15.5228 4.47715 20 10 20C13.9387 20 17.3456 17.7229 18.976 14.4133Z" fill="currentColor"></path>
+      </svg>
+    }
+    href="/integrations/keywords"
+  >
+    Build AI applications with persistent memory and comprehensive LLM observability.
+  </Card>
 </CardGroup>
@@ -0,0 +1,174 @@
+---
+title: Agno
+---
+<Snippet file="paper-release.mdx" />
+
+Integrate [**Mem0**](https://github.com/mem0ai/mem0) with [Agno](https://github.com/agno-agi/agno), a Python framework for building autonomous agents. This integration enables Agno agents to access persistent memory across conversations, enhancing context retention and personalization.
+
+## 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
+
+## Prerequisites
+
+Before setting up Mem0 with Agno, ensure you have:
+
+1. Installed the required packages:
+```bash
+pip install agno-ai mem0ai
+```
+
+2. Valid API keys:
+   - [Mem0 API Key](https://app.mem0.ai/dashboard/api-keys)
+   - OpenAI API Key (for the agent model)
+
+## Integration Example
+
+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 = "user_123",
+    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, user_id=user_id)
+        memory_context = "\n".join(f"- {m['memory']}" for m in memories)
+
+        # 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
+        client.add(f"User: {user_input}\nAssistant: {response.content}", user_id=user_id)
+        return response.content
+
+    return "No user input or image provided."
+
+
+# Example Usage
+if __name__ == "__main__":
+    response = chat_user(
+        "This is the picture of what I brought with me in the trip to Bahamas",
+        image_path="travel_items.jpeg",
+        user_id="user_123"
+    )
+    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:
+
+- **User Identification**: Organize memories by user ID
+- **Memory Search**: Configure search relevance and result count
+- **Memory Formatting**: Support for various OpenAI message formats
+
+## Help & Resources
+
+- [Agno Documentation](https://docs.agno.com/introduction)
+- [Mem0 Platform](https://app.mem0.ai/)
+
+<Snippet file="get-help.mdx" />
@@ -1,5 +1,7 @@
 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.

+<Snippet file="paper-release.mdx" />
+
 ## Overview

 In this guide, we'll explore an example of creating a conversational AI system with memory:
@@ -2,6 +2,8 @@
 title: CrewAI
 ---

+<Snippet file="paper-release.mdx" />
+
 Build an AI system that combines CrewAI's agent-based architecture with Mem0's memory capabilities. This integration enables persistent memory across agent interactions and personalized task execution based on user history.

 ## Overview
@@ -2,6 +2,8 @@
 title: Dify
 ---

+<Snippet file="paper-release.mdx" />
+
 # 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.
@@ -0,0 +1,456 @@
+---
+title: ElevenLabs
+---
+
+<Snippet file="paper-release.mdx" />
+
+Create voice-based conversational AI agents with memory capabilities by integrating ElevenLabs and Mem0. This integration enables persistent, context-aware voice interactions that remember past conversations.
+
+## Overview
+
+In this guide, we'll build a voice agent that:
+1. Uses ElevenLabs Conversational AI for voice interaction
+2. Leverages Mem0 to store and retrieve memories from past conversations
+3. Provides personalized responses based on user history
+
+## Setup and Configuration
+
+Install necessary libraries:
+
+```bash
+pip install elevenlabs mem0 python-dotenv
+```
+
+Configure your environment variables:
+
+<Note>You'll need both an ElevenLabs API key and a Mem0 API key to use this integration.</Note>
+
+```bash
+# Create a .env file with these variables
+AGENT_ID=your-agent-id
+USER_ID=unique-user-identifier
+ELEVENLABS_API_KEY=your-elevenlabs-api-key
+MEM0_API_KEY=your-mem0-api-key
+```
+
+## Integration Code Breakdown
+
+Let's break down the implementation into manageable parts:
+
+### 1. Imports and Environment Setup
+
+First, we import required libraries and set up the environment:
+
+```python
+import os
+import signal
+import sys
+from mem0 import AsyncMemoryClient
+
+from elevenlabs.client import ElevenLabs
+from elevenlabs.conversational_ai.conversation import Conversation
+from elevenlabs.conversational_ai.default_audio_interface import DefaultAudioInterface
+from elevenlabs.conversational_ai.conversation import ClientTools
+```
+
+These imports provide:
+- Standard Python libraries for system operations and signal handling
+- `AsyncMemoryClient` from Mem0 for memory operations
+- ElevenLabs components for voice interaction
+
+### 2. Environment Variables and Validation
+
+Next, we validate the required environment variables:
+
+```python
+def main():
+    # Required environment variables
+    AGENT_ID = os.environ.get('AGENT_ID')
+    USER_ID = os.environ.get('USER_ID')
+    API_KEY = os.environ.get('ELEVENLABS_API_KEY')
+    MEM0_API_KEY = os.environ.get('MEM0_API_KEY')
+
+    # Validate required environment variables
+    if not AGENT_ID:
+        sys.stderr.write("AGENT_ID environment variable must be set\n")
+        sys.exit(1)
+
+    if not USER_ID:
+        sys.stderr.write("USER_ID environment variable must be set\n")
+        sys.exit(1)
+
+    if not API_KEY:
+        sys.stderr.write("ELEVENLABS_API_KEY not set, assuming the agent is public\n")
+
+    if not MEM0_API_KEY:
+        sys.stderr.write("MEM0_API_KEY environment variable must be set\n")
+        sys.exit(1)
+
+    # Set up Mem0 API key in the environment
+    os.environ['MEM0_API_KEY'] = MEM0_API_KEY
+```
+
+This section:
+- Retrieves required environment variables
+- Performs validation to ensure required variables are present
+- Exits the application with an error message if required variables are missing
+- Sets the Mem0 API key in the environment for the Mem0 client to use
+
+### 3. Client Initialization
+
+Initialize both the ElevenLabs and Mem0 clients:
+
+```python
+    # Initialize ElevenLabs client
+    client = ElevenLabs(api_key=API_KEY)
+
+    # Initialize memory client and tools
+    client_tools = ClientTools()
+    mem0_client = AsyncMemoryClient()
+```
+
+Here we:
+- Create an ElevenLabs client with the API key
+- Initialize a ClientTools object for registering function tools
+- Create an AsyncMemoryClient instance for Mem0 interactions
+
+### 4. Memory Function Definitions
+
+Define the two key memory functions that will be registered as tools:
+
+```python
+    # Define memory-related functions for the agent
+    async def add_memories(parameters):
+        """Add a message to the memory store"""
+        message = parameters.get("message")
+        await mem0_client.add(
+            messages=message, 
+            user_id=USER_ID, 
+            output_format="v1.1", 
+            version="v2"
+        )
+        return "Memory added successfully"
+
+    async def retrieve_memories(parameters):
+        """Retrieve relevant memories based on the input message"""
+        message = parameters.get("message")
+
+        # Set up filters to retrieve memories for this specific user
+        filters = {
+            "AND": [
+                {
+                    "user_id": USER_ID
+                }
+            ]
+        }
+
+        # Search for relevant memories using the message as a query
+        results = await mem0_client.search(
+            query=message,
+            version="v2", 
+            filters=filters
+        )
+
+        # Extract and join the memory texts
+        memories = ' '.join([result["memory"] for result in results])
+        print("[ Memories ]", memories)
+
+        if memories:
+            return memories
+        return "No memories found"
+```
+
+These functions:
+
+#### `add_memories`:
+- Takes a message parameter containing information to remember
+- Stores the message in Mem0 using the `add` method
+- Associates the memory with the specific USER_ID
+- Returns a success message to the agent
+
+#### `retrieve_memories`:
+- Takes a message parameter as the search query
+- Sets up filters to only retrieve memories for the current user
+- Uses semantic search to find relevant memories
+- Joins all retrieved memories into a single text
+- Prints retrieved memories to the console for debugging
+- Returns the memories or a "No memories found" message if none are found
+
+### 5. Registering Memory Functions as Tools
+
+Register the memory functions with the ElevenLabs ClientTools system:
+
+```python
+    # Register the memory functions as tools for the agent
+    client_tools.register("addMemories", add_memories, is_async=True)
+    client_tools.register("retrieveMemories", retrieve_memories, is_async=True)
+```
+
+This allows the ElevenLabs agent to:
+- Access these functions through function calling
+- Wait for asynchronous results (is_async=True)
+- Call these functions by name ("addMemories" and "retrieveMemories")
+
+### 6. Conversation Setup
+
+Configure the conversation with ElevenLabs:
+
+```python
+    # Initialize the conversation
+    conversation = Conversation(
+        client,
+        AGENT_ID,
+        # Assume auth is required when API_KEY is set
+        requires_auth=bool(API_KEY),
+        audio_interface=DefaultAudioInterface(),
+        client_tools=client_tools,
+        callback_agent_response=lambda response: print(f"Agent: {response}"),
+        callback_agent_response_correction=lambda original, corrected: print(f"Agent: {original} -> {corrected}"),
+        callback_user_transcript=lambda transcript: print(f"User: {transcript}"),
+        # callback_latency_measurement=lambda latency: print(f"Latency: {latency}ms"),
+    )
+```
+
+This sets up the conversation with:
+- The ElevenLabs client and Agent ID
+- Authentication requirements based on API key presence
+- DefaultAudioInterface for handling audio I/O
+- The client_tools with our memory functions
+- Callback functions for:
+  - Displaying agent responses
+  - Showing corrected responses (when the agent self-corrects)
+  - Displaying user transcripts for debugging
+  - (Commented out) Latency measurements
+
+### 7. Conversation Management
+
+Start and manage the conversation:
+
+```python
+    # Start the conversation
+    print(f"Starting conversation with user_id: {USER_ID}")
+    conversation.start_session()
+
+    # Handle Ctrl+C to gracefully end the session
+    signal.signal(signal.SIGINT, lambda sig, frame: conversation.end_session())
+
+    # Wait for the conversation to end and get the conversation ID
+    conversation_id = conversation.wait_for_session_end()
+    print(f"Conversation ID: {conversation_id}")
+
+
+if __name__ == '__main__':
+    main()
+```
+
+This final section:
+- Prints a message indicating the conversation has started
+- Starts the conversation session
+- Sets up a signal handler to gracefully end the session on Ctrl+C
+- Waits for the session to end and gets the conversation ID
+- Prints the conversation ID for reference
+
+## Memory Tools Overview
+
+This integration provides two key memory functions to your conversational AI agent:
+
+### 1. Adding Memories (`addMemories`)
+
+The `addMemories` tool allows your agent to store important information during a conversation, including:
+- User preferences
+- Important facts shared by the user
+- Decisions or commitments made during the conversation
+- Action items to follow up on
+
+When the agent identifies information worth remembering, it calls this function to store it in the Mem0 database with the appropriate user ID.
+
+#### How it works:
+1. The agent identifies information that should be remembered
+2. It formats the information as a message string
+3. It calls the `addMemories` function with this message
+4. The function stores the memory in Mem0 linked to the user's ID
+5. Later conversations can retrieve this memory
+
+#### Example usage in agent prompt:
+```
+When the user shares important information like preferences or personal details, 
+use the addMemories function to store this information for future reference.
+```
+
+### 2. Retrieving Memories (`retrieveMemories`)
+
+The `retrieveMemories` tool allows your agent to search for and retrieve relevant memories from previous conversations. The agent can:
+- Search for context related to the current topic
+- Recall user preferences
+- Remember previous interactions on similar topics
+- Create continuity across multiple sessions
+
+#### How it works:
+1. The agent needs context for the current conversation
+2. It calls `retrieveMemories` with the current conversation topic or question
+3. The function performs a semantic search in Mem0
+4. Relevant memories are returned to the agent
+5. The agent incorporates these memories into its response
+
+#### Example usage in agent prompt:
+```
+At the beginning of each conversation turn, use retrieveMemories to check if we've 
+discussed this topic before or if the user has shared relevant preferences.
+```
+
+## Configuring Your ElevenLabs Agent
+
+To enable your agent to effectively use memory:
+
+1. Add function calling capabilities to your agent in the ElevenLabs platform:
+   - Go to your agent settings in the ElevenLabs platform
+   - Navigate to the "Tools" section
+   - Enable function calling for your agent
+   - Add the memory tools as described below
+
+2. Add the `addMemories` and `retrieveMemories` tools to your agent with these specifications:
+
+For `addMemories`:
+```json
+{
+  "name": "addMemories",
+  "description": "Stores important information from the conversation to remember for future interactions",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "message": {
+        "type": "string",
+        "description": "The important information to remember"
+      }
+    },
+    "required": ["message"]
+  }
+}
+```
+
+For `retrieveMemories`:
+```json
+{
+  "name": "retrieveMemories",
+  "description": "Retrieves relevant information from past conversations",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "message": {
+        "type": "string",
+        "description": "The query to search for in past memories"
+      }
+    },
+    "required": ["message"]
+  }
+}
+```
+
+3. Update your agent's prompt to instruct it to use these memory functions. For example:
+
+```
+You are a helpful voice assistant that remembers past conversations with the user.
+
+You have access to memory tools that allow you to remember important information:
+- Use retrieveMemories at the beginning of the conversation to recall relevant context from prior conversations
+- Use addMemories to store new important information such as:
+  * User preferences
+  * Personal details the user shares
+  * Important decisions made
+  * Tasks or follow-ups promised to the user
+
+Before responding to complex questions, always check for relevant memories first.
+When the user shares important information, make sure to store it for future reference.
+```
+
+## Example Conversation Flow
+
+Here's how a typical conversation with memory might flow:
+
+1. **User speaks**: "Hi, do you remember my favorite color?"
+
+2. **Agent retrieves memories**:
+   ```python
+   # Agent calls retrieve_memories
+   memories = retrieve_memories({"message": "user's favorite color"})
+   # If found: "The user's favorite color is blue"
+   ```
+
+3. **Agent processes with context**:
+   - If memories found: Prepares a personalized response
+   - If no memories: Prepares to ask and store the information
+
+4. **Agent responds**:
+   - With memory: "Yes, your favorite color is blue!"
+   - Without memory: "I don't think you've told me your favorite color before. What is it?"
+
+5. **User responds**: "It's actually green."
+
+6. **Agent stores new information**:
+   ```python
+   # Agent calls add_memories
+   add_memories({"message": "The user's favorite color is green"})
+   ```
+
+7. **Agent confirms**: "Thanks, I'll remember that your favorite color is green."
+
+## Example Use Cases
+
+- **Personal Assistant** - Remember user preferences, past requests, and important dates
+  ```
+  User: "What restaurants did I say I liked last time?"
+  Agent: *retrieves memories* "You mentioned enjoying Bella Italia and The Golden Dragon."
+  ```
+
+- **Customer Support** - Recall previous issues a customer has had
+  ```
+  User: "I'm having that same problem again!"
+  Agent: *retrieves memories* "Is this related to the login issue you reported last week?"
+  ```
+
+- **Educational AI** - Track student progress and tailor teaching accordingly
+  ```
+  User: "Let's continue our math lesson."
+  Agent: *retrieves memories* "Last time we were working on quadratic equations. Would you like to continue with that?"
+  ```
+
+- **Healthcare Assistant** - Remember symptoms, medications, and health concerns
+  ```
+  User: "Have I told you about my allergy medication?"
+  Agent: *retrieves memories* "Yes, you mentioned you're taking Claritin for your pollen allergies."
+  ```
+
+## Troubleshooting
+
+- **Missing API Keys**: 
+  - Error: "API_KEY environment variable must be set"
+  - Solution: Ensure all environment variables are set correctly in your .env file or system environment
+  
+- **Connection Issues**:
+  - Error: "Failed to connect to API"
+  - Solution: Check your network connection and API key permissions. Verify the API keys are valid and have the necessary permissions.
+  
+- **Empty Memory Results**:
+  - Symptom: Agent always responds with "No memories found"
+  - Solution: This is normal for new users. The memory database builds up over time as conversations occur. It's also possible your query isn't semantically similar to stored memories - try different phrasing.
+  
+- **Agent Not Using Memories**:
+  - Symptom: The agent retrieves memories but doesn't incorporate them in responses
+  - Solution: Update the agent's prompt to explicitly instruct it to use the retrieved memories in its responses
+
+## Conclusion
+
+By integrating ElevenLabs Conversational AI with Mem0, you can create voice agents that maintain context across conversations and provide personalized responses based on user history. This powerful combination enables:
+
+- More natural, context-aware conversations
+- Personalized user experiences that improve over time
+- Reduced need for users to repeat information
+- Long-term relationship building between users and AI agents
+
+## Help
+
+- For more details on ElevenLabs, visit the [ElevenLabs Conversational AI Documentation](https://elevenlabs.io/docs/api-reference/conversational-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:
+
+<Snippet file="get-help.mdx" /> 
@@ -0,0 +1,128 @@
+---
+title: Flowise
+---
+
+<Snippet file="paper-release.mdx" />
+
+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**.
+
+![Flowise Memory Integration](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-flow.png)
+
+### 2. Obtain Your Mem0 API Key
+
+1. Navigate to the [Mem0 API Key dashboard](https://app.mem0.ai/dashboard/api-keys).
+2. Generate or copy your existing Mem0 API Key.
+
+![Mem0 API Key](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/api-key.png)
+
+### 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
+}
+```
+
+<figure>
+  <img src="https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/creds.png" alt="Mem0 Credentials" />
+  <figcaption>Configure API Credentials</figcaption>
+</figure>
+
+## 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](https://app.mem0.ai/dashboard/requests)
+
+![Flowise Test Chat](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-1.png)
+
+### 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
+
+![Testing Memory Retention](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/flowise-chat-2.png)
+
+## Advanced Configuration
+
+### Memory Settings
+
+![Mem0 Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/settings.png)
+
+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](https://app.mem0.ai/dashboard/project-settings):
+
+1. **Custom Instructions**: Define memory extraction rules
+2. **Expiration Date**: Set automatic memory cleanup periods
+
+![Mem0 Project Settings](https://raw.githubusercontent.com/FlowiseAI/FlowiseDocs/main/en/.gitbook/assets/mem0/mem0-settings.png)
+
+## 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
+
+## Help & Resources
+
+- [Flowise Documentation](https://flowiseai.com/docs)
+- [Flowise GitHub Repository](https://github.com/FlowiseAI/Flowise)
+- [Flowise Website](https://flowiseai.com/)
+- [Mem0 Platform](https://app.mem0.ai/)
+- Need assistance? Reach out through:
+
+<Snippet file="get-help.mdx" /> 
@@ -0,0 +1,142 @@
+---
+title: Keywords AI
+---
+
+<Snippet file="paper-release.mdx" />
+
+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
+
+<Note>
+You can get your Mem0 API key, user_id, and org_id from the [Mem0 dashboard](https://app.mem0.ai/). These are required for proper integration.
+</Note>
+
+## Setup and Configuration
+
+Install the necessary libraries:
+
+```bash
+pip install mem0 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-4o-mini",
+            "temperature": 0.0,
+            "api_key": keywordsai_api_key,
+            "openai_base_url": base_url,
+        },
+    }
+}
+
+# Initialize Memory
+memory = Memory.from_config(config_dict=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 a 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-4o",
+    messages=messages,
+    extra_body={
+        "mem0_params": {
+            "user_id": "test_user",
+            "org_id": "org_1",
+            "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.
+
+## Help
+
+For more information on using Mem0 and Keywords AI together, refer to:
+- [Mem0 Documentation](https://docs.mem0.ai)
+- [Keywords AI Documentation](https://docs.keywordsai.co)
+
+<Snippet file="get-help.mdx" />
@@ -3,6 +3,8 @@ title: Langchain Tools
 description: 'Integrate Mem0 with LangChain tools to enable AI agents to store, search, and manage memories through structured interfaces'
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Overview

 Mem0 provides a suite of tools for storing, searching, and retrieving memories, enabling agents to maintain context and learn from past interactions. The tools are built as Langchain tools, making them easily integrable with any AI agent implementation.
@@ -2,6 +2,8 @@
 title: Langchain
 ---

+<Snippet file="paper-release.mdx" />
+
 Build a personalized Travel Agent AI using LangChain for conversation flow and Mem0 for memory retention. This integration enables context-aware and efficient travel planning experiences.

 ## Overview
@@ -2,6 +2,8 @@
 title: LangGraph
 ---

+<Snippet file="paper-release.mdx" />
+
 Build a personalized Customer Support AI Agent using LangGraph for conversation flow and Mem0 for memory retention. This integration enables context-aware and efficient support experiences.

 ## Overview
@@ -0,0 +1,355 @@
+---
+title: Livekit
+---
+
+<Snippet file="paper-release.mdx" />
+
+This guide demonstrates how to create a memory-enabled voice assistant using LiveKit, Deepgram, OpenAI, and Mem0, focusing on creating an intelligent, context-aware travel planning agent.
+
+## Prerequisites
+
+Before you begin, make sure you have:
+
+1. Installed Livekit Agents SDK with voice dependencies of silero and deepgram:
+```bash
+pip install livekit \
+livekit-agents \
+livekit-plugins-silero \
+livekit-plugins-deepgram \
+livekit-plugins-openai
+```
+
+2. Installed Mem0 SDK:
+```bash
+pip install mem0ai
+```
+
+3. Set up your API keys in a `.env` file:
+```sh
+LIVEKIT_URL=your_livekit_url
+LIVEKIT_API_KEY=your_livekit_api_key
+LIVEKIT_API_SECRET=your_livekit_api_secret
+DEEPGRAM_API_KEY=your_deepgram_api_key
+MEM0_API_KEY=your_mem0_api_key
+OPENAI_API_KEY=your_openai_api_key
+```
+
+> **Note**: Make sure to have a Livekit and Deepgram account. You can find these variables `LIVEKIT_URL` , `LIVEKIT_API_KEY` and `LIVEKIT_API_SECRET` from [LiveKit Cloud Console](https://cloud.livekit.io/) and for more information you can refer this website [LiveKit Documentation](https://docs.livekit.io/home/cloud/keys-and-tokens/). For `DEEPGRAM_API_KEY` you can get from [Deepgram Console](https://console.deepgram.com/) refer this website [Deepgram Documentation](https://developers.deepgram.com/docs/create-additional-api-keys) for more details.
+
+## Code Breakdown
+
+Let's break down the key components of this implementation:
+
+### 1. Setting Up Dependencies and Environment
+
+```python
+import asyncio
+import logging
+import os
+from typing import List, Dict, Any, Annotated
+
+import aiohttp
+from dotenv import load_dotenv
+from livekit.agents import (
+    AutoSubscribe,
+    JobContext,
+    JobProcess,
+    WorkerOptions,
+    cli,
+    llm,
+    metrics,
+)
+from livekit import rtc, api
+from livekit.agents.pipeline import VoicePipelineAgent
+from livekit.plugins import deepgram, openai, silero
+from mem0 import AsyncMemoryClient
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logger = logging.getLogger("memory-assistant")
+logger.setLevel(logging.INFO)
+
+# Define a global user ID for simplicity
+USER_ID = "voice_user"
+
+# Initialize Mem0 client
+mem0 = AsyncMemoryClient()
+```
+
+This section handles:
+- Importing required modules
+- Loading environment variables
+- Setting up logging
+- Extracting user identification
+- Initializing the Mem0 client
+
+### 2. Memory Enrichment Function
+
+```python
+async def _enrich_with_memory(agent: VoicePipelineAgent, chat_ctx: llm.ChatContext):
+    """Add memories and Augment chat context with relevant memories"""
+    if not chat_ctx.messages:
+        return
+    
+    # Store user message in Mem0
+    user_msg = chat_ctx.messages[-1]
+    await mem0.add(
+        [{"role": "user", "content": user_msg.content}], 
+        user_id=USER_ID
+    )
+    
+    # Search for relevant memories
+    results = await mem0.search(
+        user_msg.content, 
+        user_id=USER_ID,
+    )
+    
+    # Augment context with retrieved memories
+    if results:
+        memories = ' '.join([result["memory"] for result in results])
+        logger.info(f"Enriching with memory: {memories}")
+        
+        rag_msg = llm.ChatMessage.create(
+            text=f"Relevant Memory: {memories}\n",
+            role="assistant",
+        )
+        
+        # Modify chat context with retrieved memories
+        chat_ctx.messages[-1] = rag_msg
+        chat_ctx.messages.append(user_msg)
+```
+
+This function:
+- Stores user messages in Mem0
+- Performs semantic search for relevant memories
+- Augments the chat context with retrieved memories
+- Enables contextually aware responses
+
+### 3. Prewarm and Entrypoint Functions
+
+```python
+def prewarm_process(proc: JobProcess):
+    # Preload silero VAD in memory to speed up session start
+    proc.userdata["vad"] = silero.VAD.load()
+
+async def entrypoint(ctx: JobContext):
+    # Connect to LiveKit room
+    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)
+    
+    # Wait for participant
+    participant = await ctx.wait_for_participant()
+    
+    # Initialize Mem0 client
+    mem0 = AsyncMemoryClient()
+
+    # Define initial system context
+    initial_ctx = llm.ChatContext().append(
+        role="system",
+        text=(
+            """
+            You are a helpful voice assistant.
+            You are a travel guide named George and will help the user to plan a travel trip of their dreams. 
+            You should help the user plan for various adventures like work retreats, family vacations or solo backpacking trips. 
+            You should be careful to not suggest anything that would be dangerous, illegal or inappropriate.
+            You can remember past interactions and use them to inform your answers.
+            Use semantic memory retrieval to provide contextually relevant responses. 
+            """
+        ),
+    )
+
+    # Create VoicePipelineAgent with memory capabilities
+    agent = VoicePipelineAgent(
+        chat_ctx=initial_ctx,
+        vad=silero.VAD.load(),
+        stt=deepgram.STT(),
+        llm=openai.LLM(model="gpt-4o-mini"),
+        tts=openai.TTS(),
+        before_llm_cb=_enrich_with_memory,
+    )
+
+    # Start agent and initial greeting
+    agent.start(ctx.room, participant)
+    await agent.say(
+        "Hello! I'm George. Can I help you plan an upcoming trip? ",
+        allow_interruptions=True
+    )
+
+# Run the application
+if __name__ == "__main__":
+    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm_process))
+```
+
+The entrypoint function:
+- Connects to LiveKit room
+- Initializes Mem0 memory client
+- Sets up initial system context
+- Creates a VoicePipelineAgent with memory enrichment
+- Starts the agent with an initial greeting
+
+## Create a Memory-Enabled Voice Agent
+
+Now that we've explained each component, here's the complete implementation that combines OpenAI Agents SDK for voice with Mem0's memory capabilities:
+
+```python
+import asyncio
+import logging
+import os
+from typing import List, Dict, Any, Annotated
+
+import aiohttp
+from dotenv import load_dotenv
+from livekit.agents import (
+    AutoSubscribe,
+    JobContext,
+    JobProcess,
+    WorkerOptions,
+    cli,
+    llm,
+    metrics,
+)
+from livekit import rtc, api
+from livekit.agents.pipeline import VoicePipelineAgent
+from livekit.plugins import deepgram, openai, silero
+from mem0 import AsyncMemoryClient
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logger = logging.getLogger("memory-assistant")
+logger.setLevel(logging.INFO)
+
+# Define a global user ID for simplicity
+USER_ID = "voice_user"
+
+# Initialize Mem0 memory client
+mem0 = AsyncMemoryClient()
+
+def prewarm_process(proc: JobProcess):
+    # Preload silero VAD in memory to speed up session start
+    proc.userdata["vad"] = silero.VAD.load()
+
+async def entrypoint(ctx: JobContext):
+    # Connect to LiveKit room
+    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)
+    
+    # Wait for participant
+    participant = await ctx.wait_for_participant()
+    
+    async def _enrich_with_memory(agent: VoicePipelineAgent, chat_ctx: llm.ChatContext):
+        """Add memories and Augment chat context with relevant memories"""
+        if not chat_ctx.messages:
+            return
+        
+        # Store user message in Mem0
+        user_msg = chat_ctx.messages[-1]
+        await mem0.add(
+            [{"role": "user", "content": user_msg.content}], 
+            user_id=USER_ID
+        )
+        
+        # Search for relevant memories
+        results = await mem0.search(
+            user_msg.content, 
+            user_id=USER_ID,
+        )
+        
+        # Augment context with retrieved memories
+        if results:
+            memories = ' '.join([result["memory"] for result in results])
+            logger.info(f"Enriching with memory: {memories}")
+            
+            rag_msg = llm.ChatMessage.create(
+                text=f"Relevant Memory: {memories}\n",
+                role="assistant",
+            )
+            
+            # Modify chat context with retrieved memories
+            chat_ctx.messages[-1] = rag_msg
+            chat_ctx.messages.append(user_msg)
+
+    # Define initial system context
+    initial_ctx = llm.ChatContext().append(
+        role="system",
+        text=(
+            """
+            You are a helpful voice assistant.
+            You are a travel guide named George and will help the user to plan a travel trip of their dreams. 
+            You should help the user plan for various adventures like work retreats, family vacations or solo backpacking trips. 
+            You should be careful to not suggest anything that would be dangerous, illegal or inappropriate.
+            You can remember past interactions and use them to inform your answers.
+            Use semantic memory retrieval to provide contextually relevant responses. 
+            """
+        ),
+    )
+
+    # Create VoicePipelineAgent with memory capabilities
+    agent = VoicePipelineAgent(
+        chat_ctx=initial_ctx,
+        vad=silero.VAD.load(),
+        stt=deepgram.STT(),
+        llm=openai.LLM(model="gpt-4o-mini"),
+        tts=openai.TTS(),
+        before_llm_cb=_enrich_with_memory,
+    )
+
+    # Start agent and initial greeting
+    agent.start(ctx.room, participant)
+    await agent.say(
+        "Hello! I'm George. Can I help you plan an upcoming trip? ",
+        allow_interruptions=True
+    )
+
+# Run the application
+if __name__ == "__main__":
+    cli.run_app(WorkerOptions(entrypoint_fnc=entrypoint, prewarm_fnc=prewarm_process))
+```
+
+## Key Features of This Implementation
+
+1. **Semantic Memory Retrieval**: Uses Mem0 to store and retrieve contextually relevant memories
+2. **Voice Interaction**: Leverages LiveKit for voice communication
+3. **Intelligent Context Management**: Augments conversations with past interactions
+4. **Travel Planning Specialization**: Focused on creating a helpful travel guide assistant
+
+## Running the Example
+
+To run this example:
+
+1. Install all required dependencies
+2. Set up your `.env` file with the necessary API keys
+3. Ensure your microphone and audio setup are configured
+4. Run the script with Python 3.11 or newer and with the following command:
+```sh
+python mem0-livekit-voice-agent.py start
+```
+5. After the script starts, you can interact with the voice agent using [Livekit's Agent Platform](https://agents-playground.livekit.io/) and Connect to the agent inorder to start conversations. 
+
+## Best Practices for Voice Agents with Memory
+
+1. **Context Preservation**: Store enough context with each memory for effective retrieval
+2. **Privacy Considerations**: Implement secure memory management
+3. **Relevant Memory Filtering**: Use semantic search to retrieve only the most pertinent memories
+4. **Error Handling**: Implement robust error handling for memory operations
+
+## Debugging Function Tools
+
+- To run the script in debug mode simply start the assistant with `dev` mode:
+```sh
+python mem0-livekit-voice-agent.py dev
+```
+
+- When working with memory-enabled voice agents, use Python's `logging` module for effective debugging:
+
+```python
+import logging
+
+# Set up logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("memory_voice_agent")
+```
@@ -2,6 +2,8 @@
 title: LlamaIndex
 ---

+<Snippet file="paper-release.mdx" />
+
 LlamaIndex supports Mem0 as a [memory store](https://llamahub.ai/l/memory/llama-index-memory-mem0). In this guide, we'll show you how to use it.

 <Note type="info">
@@ -2,6 +2,8 @@
 title: MCP Server
 ---

+<Snippet file="paper-release.mdx" />
+
 ## Integrating mem0 as an MCP Server in Cursor
 [mem0](https://github.com/mem0ai/mem0-mcp) is a powerful tool designed to enhance AI-driven workflows, particularly in code generation and contextual memory. In this guide, we'll walk through integrating mem0 as an **MCP (Model Context Protocol) server** within [Cursor](https://cursor.sh/), an AI-powered coding editor.

@@ -2,6 +2,8 @@
 title: MultiOn
 ---

+<Snippet file="paper-release.mdx" />
+
 Build a personal browser agent that remembers user preferences and automates web tasks. It integrates Mem0 for memory management with MultiOn for executing browser actions, enabling personalized and efficient web interactions.

 ## Overview
@@ -0,0 +1,220 @@
+---
+title: 'Pipecat'
+description: 'Integrate Mem0 with Pipecat for conversational memory in AI agents'
+---
+
+<Snippet file="paper-release.mdx" />
+
+# Pipecat Integration
+
+Mem0 seamlessly integrates with [Pipecat](https://pipecat.ai), providing long-term memory capabilities for conversational AI agents. This integration allows your Pipecat-powered applications to remember past conversations and provide personalized responses based on user history.
+
+## Installation
+
+To use Mem0 with Pipecat, install the required dependencies:
+
+```bash
+pip install "pipecat-ai[mem0]"
+```
+
+You'll also need to set up your Mem0 API key as an environment variable:
+
+```bash
+export MEM0_API_KEY=your_mem0_api_key
+```
+
+You can obtain a Mem0 API key by signing up at [mem0.ai](https://mem0.ai).
+
+## Configuration
+
+Mem0 integration is provided through the `Mem0MemoryService` class in Pipecat. Here's how to configure it:
+
+```python
+from pipecat.services.mem0 import Mem0MemoryService
+
+memory = Mem0MemoryService(
+    api_key=os.getenv("MEM0_API_KEY"),  # Your Mem0 API key
+    user_id="unique_user_id",           # Unique identifier for the end user
+    agent_id="my_agent",                # Identifier for the agent using the memory
+    run_id="session_123",               # Optional: specific conversation session ID
+    params={                            # Optional: configuration parameters
+        "search_limit": 10,             # Maximum memories to retrieve per query
+        "search_threshold": 0.1,        # Relevance threshold (0.0 to 1.0)
+        "system_prompt": "Here are your past memories:", # Custom prefix for memories
+        "add_as_system_message": True,  # Add memories as system (True) or user (False) message
+        "position": 1,                  # Position in context to insert memories
+    }
+)
+```
+
+## Pipeline Integration
+
+The `Mem0MemoryService` should be positioned between your context aggregator and LLM service in the Pipecat pipeline:
+
+```python
+pipeline = Pipeline([
+    transport.input(),
+    stt,                # Speech-to-text for audio input
+    user_context,       # User context aggregator
+    memory,             # Mem0 Memory service enhances context here
+    llm,                # LLM for response generation
+    tts,                # Optional: Text-to-speech
+    transport.output(),
+    assistant_context   # Assistant context aggregator
+])
+```
+
+## Example: Voice Agent with Memory
+
+Here's a complete example of a Pipecat voice agent with Mem0 memory integration:
+
+```python
+import asyncio
+import os
+from fastapi import FastAPI, WebSocket
+
+from pipecat.frames.frames import TextFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.task import PipelineTask
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.services.mem0 import Mem0MemoryService
+from pipecat.services.openai import OpenAILLMService, OpenAIUserContextAggregator, OpenAIAssistantContextAggregator
+from pipecat.transports.network.fastapi_websocket import (
+    FastAPIWebsocketTransport,
+    FastAPIWebsocketParams
+)
+from pipecat.serializers.protobuf import ProtobufFrameSerializer
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.services.whisper import WhisperSTTService
+
+app = FastAPI()
+
+@app.websocket("/chat")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    
+    # Basic setup with minimal configuration
+    user_id = "user123"
+    
+    # WebSocket transport
+    transport = FastAPIWebsocketTransport(
+        websocket=websocket,
+        params=FastAPIWebsocketParams(
+            audio_out_enabled=True,
+            vad_enabled=True,
+            vad_analyzer=SileroVADAnalyzer(),
+            vad_audio_passthrough=True,
+            serializer=ProtobufFrameSerializer(),
+        )
+    )
+    
+    # Core services
+    user_context = OpenAIUserContextAggregator()
+    assistant_context = OpenAIAssistantContextAggregator()
+    stt = WhisperSTTService(api_key=os.getenv("OPENAI_API_KEY"))
+    
+    # Memory service - the key component
+    memory = Mem0MemoryService(
+        api_key=os.getenv("MEM0_API_KEY"),
+        user_id=user_id,
+        agent_id="fastapi_memory_bot"
+    )
+    
+    # LLM for response generation
+    llm = OpenAILLMService(
+        api_key=os.getenv("OPENAI_API_KEY"),
+        model="gpt-3.5-turbo",
+        system_prompt="You are a helpful assistant that remembers past conversations."
+    )
+    
+    # Simple pipeline
+    pipeline = Pipeline([
+        transport.input(),
+        stt,                # Speech-to-text for audio input
+        user_context,
+        memory,             # Memory service enhances context here
+        llm,
+        transport.output(),
+        assistant_context
+    ])
+    
+    # Run the pipeline
+    runner = PipelineRunner()
+    task = PipelineTask(pipeline)
+    
+    # Event handlers for WebSocket connections
+    @transport.event_handler("on_client_connected")
+    async def on_client_connected(transport, client):
+        # Send welcome message when client connects
+        await task.queue_frame(TextFrame("Hello! I'm a memory bot. I'll remember our conversation."))
+    
+    @transport.event_handler("on_client_disconnected")
+    async def on_client_disconnected(transport, client):
+        # Clean up when client disconnects
+        await task.cancel()
+    
+    await runner.run(task)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+## How It Works
+
+When integrated with Pipecat, Mem0 provides two key functionalities:
+
+### 1. Message Storage
+
+All conversation messages are automatically stored in Mem0 for future reference:
+- Captures the full message history from context frames
+- Associates messages with the specified user, agent, and run IDs
+- Stores metadata to enable efficient retrieval
+
+### 2. Memory Retrieval
+
+When a new user message is detected:
+1. The message is used as a search query to find relevant past memories
+2. Relevant memories are retrieved from Mem0's database
+3. Memories are formatted and added to the conversation context
+4. The enhanced context is passed to the LLM for response generation
+
+## Additional Configuration Options
+
+### Memory Search Parameters
+
+You can customize how memories are retrieved and used:
+
+```python
+memory = Mem0MemoryService(
+    api_key=os.getenv("MEM0_API_KEY"),
+    user_id="user123",
+    params={
+        "search_limit": 5,            # Retrieve up to 5 memories
+        "search_threshold": 0.2,      # Higher threshold for more relevant matches
+        "api_version": "v2",          # Mem0 API version
+    }
+)
+```
+
+### Memory Presentation Options
+
+Control how memories are presented to the LLM:
+
+```python
+memory = Mem0MemoryService(
+    api_key=os.getenv("MEM0_API_KEY"),
+    user_id="user123",
+    params={
+        "system_prompt": "Previous conversations with this user:",
+        "add_as_system_message": True,  # Add as system message instead of user message
+        "position": 0,                  # Insert at the beginning of the context
+    }
+)
+```
+
+## Resources
+
+- [Mem0 Pipecat Integration](https://docs.pipecat.ai/server/services/memory/mem0)
+- [Pipecat Documentation](https://docs.pipecat.ai)
+
@@ -2,6 +2,8 @@
 title: Vercel AI SDK
 ---

+<Snippet file="paper-release.mdx" />
+
 The [**Mem0 AI SDK Provider**](https://www.npmjs.com/package/@mem0/vercel-ai-provider) is a library developed by **Mem0** to integrate with the Vercel AI SDK. This library brings enhanced AI interaction capabilities to your applications by introducing persistent memory functionality.

 <Note type="info">
@@ -10,7 +12,6 @@ The [**Mem0 AI SDK Provider**](https://www.npmjs.com/package/@mem0/vercel-ai-pro

 ## Overview

-In this guide, we'll create a Travel Agent AI that:
 1. 🧠 Offers persistent memory storage for conversational AI
 2. 🔄 Enables smooth integration with the Vercel AI SDK
 3. 🚀 Ensures compatibility with multiple LLM providers
@@ -191,6 +192,20 @@ npm install @mem0/vercel-ai-provider
    console.log(result);
    ```

+### 5. Get sources from memory
+
+```typescript
+const { text, sources } = await generateText({
+    model: mem0("gpt-4-turbo"),
+    prompt: "Suggest me a good car to buy!",
+});
+
+console.log(sources);
+```
+
+The same can be done for `streamText` as well.
+
+
 ## Key Features

 - `createMem0()`: Initializes a new Mem0 provider instance.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dev Khant	ad98f542f8	Fix mem0-migrations issue (#2597 )	2025-05-01 01:14:57 +05:30
Saket Aryan	0fce700e65	Removed Grok3 Announcement (#2593 )	2025-04-29 08:23:13 -07:00
Prateek Chhikara	393a4fd5a6	Docs Update (#2591 )	2025-04-29 08:15:25 -07:00
Saket Aryan	6d13e83001	Fix Ping Method for using the default org_id and project_id (#2590 )	2025-04-28 12:53:52 +05:30
Dev Khant	1d916c9dd1	update changelog (#2588 )	2025-04-26 16:40:56 +05:30
Dev Khant	07ddd7cb4b	version bump -> 0.1.94 (#2587 )	2025-04-26 16:22:20 +05:30
darkhaniop	f412f8bb0d	Doc: add "memory" in EC "Custom config" section and fix typos in the json config sample (#2574 )	2025-04-25 19:51:33 +05:30
Dev Khant	64c3d34deb	Reset function for VectorDBs (#2584 )	2025-04-25 00:01:53 +05:30
Dev Khant	ff6ae478f1	Doc: fix v2 search (#2583 )	2025-04-23 18:11:36 +05:30
Saket Aryan	cc5686bd0d	Added Timestamp (#2579 )	2025-04-23 12:29:27 +05:30
Dev Khant	c958664185	Doc: Update timestamp and expiration_date (#2581 ) Co-authored-by: Deshraj Yadav <deshrajdry@gmail.com>	2025-04-22 14:09:18 -07:00
Dev Khant	d43ca06992	Doc: add timestamp (#2580 )	2025-04-23 01:05:16 +05:30
Katarina Supe	ba2e479902	Add Memgraph integration (#2537 )	2025-04-22 16:27:24 +05:30
Dev Khant	cd5c3035ab	version bump -> 0.1.93 (#2576 )	2025-04-21 09:25:00 +05:30
Dev Khant	09ac3618a8	Doc: fix agno link (#2573 )	2025-04-19 10:59:50 +05:30
Dev Khant	3ee4768c14	Init embedding_model_dims in all vectordbs (#2572 )	2025-04-19 10:53:01 +05:30
Prateek Chhikara	78912928bc	Changes to client (#2562 )	2025-04-17 11:28:39 -07:00
Dev Khant	8bd0d2dc24	Doc: fix curl for v2 get_all (#2567 )	2025-04-17 23:10:54 +05:30
Saket Aryan	f0bdd2c341	Add Support for Custom Instructions (#2565 )	2025-04-17 14:38:07 +05:30
Antaripa Saha	bf0c4adc0c	Fitness Checker powered by memory (#2561 )	2025-04-16 08:37:23 -07:00
Dev Khant	2cca50db80	Doc: update changelog (#2559 )	2025-04-16 16:43:15 +05:30
Dev Khant	b8e4d0980a	Memory Reset (#2558 )	2025-04-16 16:36:45 +05:30
Dev Khant	3613e2f14a	Fix `user_id` functionality (#2548 )	2025-04-16 13:32:33 +05:30
Dev Khant	541030d69c	Update capture_event (#2527 )	2025-04-16 10:42:36 +05:30
Dev Khant	f77a084d1b	silence faiss info logs (#2557 )	2025-04-16 09:57:32 +05:30
Saket Aryan	33abf772ce	Adds Azure OpenAI Embedding Model (#2545 )	2025-04-15 22:02:30 +05:30
Saket Aryan	c3c9205ffa	TypeScript OSS: Langchain Integration (#2556 )	2025-04-15 20:08:41 +05:30
Gábor Tóth	9f204dc557	Update openai.mdx (#2503 )	2025-04-14 21:08:49 +05:30
Antaripa Saha	0e98773efb	Voice Assistant using Elevenlabs (#2555 )	2025-04-14 20:48:10 +05:30
Dev Khant	4431bd7d51	Doc: update changelog (#2553 )	2025-04-14 15:58:16 +05:30
Dev Khant	0354ab0d6b	Doc: reformat navbar page URLs (#2551 )	2025-04-14 06:09:12 +05:30
Antaripa Saha	6dfc193296	movie recommendation using grok3 (#2547 )	2025-04-12 08:53:18 -07:00
Dev Khant	9be6850b9d	Doc: Add keywords AI (#2546 )	2025-04-12 17:49:59 +05:30
Deshraj Yadav	d33547a77a	User/dyadav/fix telemetry issue (#2541 )	2025-04-11 13:36:26 -07:00
Vir Kothari	d77bed2d5d	Update YT chrome extension example doc (#2540 )	2025-04-11 22:21:24 +05:30
Dev Khant	9c89e0ec95	Doc; Update xAI doc (#2539 )	2025-04-11 21:37:18 +05:30
Saket Aryan	ca1ee2d2d7	Patch to fix Azure OpenAI (#2538 )	2025-04-11 21:28:38 +05:30
Saket Aryan	05f9607282	Adds Azure OpenAI LLM to Mem0 TS SDK (#2536 )	2025-04-11 20:09:20 +05:30
Achraf Dev	d9236de4ed	feat: add mistral AI as LLM provider (#2496 ) Co-authored-by: Saket Aryan <94069182+whysosaket@users.noreply.github.com>	2025-04-11 20:02:44 +05:30
Dev Khant	942727fec6	Fix `EmbedderFactory.create()` in GraphMemory (#2535 )	2025-04-11 13:56:05 +05:30
Manthan Gupta	72396e307d	Fix: memory exclusion example in doc (#2520 )	2025-04-11 13:50:48 +05:30
Dev Khant	881cf5b5a6	update changelog (#2534 )	2025-04-11 13:45:34 +05:30
Dev Khant	5327d6e50d	version bump -> 0.1.89 (#2533 )	2025-04-11 13:40:47 +05:30
Dev Khant	15a3e20371	Store `user_id` in vectordb (#2466 )	2025-04-11 13:37:34 +05:30
Dev Khant	19d7beef43	Add support for Langchain VectorStores (#2518 )	2025-04-11 13:37:18 +05:30
Vir Kothari	8b789adb15	Add YT assistant chrome extension (#2485 )	2025-04-10 22:14:57 +05:30
Antaripa Saha	fd065fe9cc	Personal Study Buddy (#2531 )	2025-04-10 08:12:39 -07:00
Antaripa Saha	b5127f7c62	personal assistant (#2530 )	2025-04-10 20:24:18 +05:30
Dev-Khant	37d9fed690	doc: update agno	2025-04-10 15:49:36 +05:30
Dev Khant	31861e9acb	Doc: Add agno example (#2529 )	2025-04-10 15:46:46 +05:30
Dev Khant	07462adc9a	Formatting (#2526 )	2025-04-10 11:42:25 +05:30
Dev Khant	616313b8b5	Add async support (#2492 ) Co-authored-by: Deshraj Yadav <deshrajdry@gmail.com>	2025-04-10 11:16:44 +05:30
Dev Khant	44f2490667	Doc: modify 2 examples to show OpenAIResponses API (#2525 )	2025-04-10 10:24:10 +05:30
Dev Khant	3cc794fb98	version bump -> 0.1.88 (#2524 )	2025-04-10 01:02:05 +05:30
Dev Khant	ff6b251c66	Handle HF logging (#2523 )	2025-04-10 01:01:00 +05:30
Sergio Toro	55df395fd6	fix: extract entities tool_calls some times is an array (#2481 )	2025-04-10 00:03:52 +05:30
Dev Khant	244e60cea6	update python changelog (#2522 )	2025-04-09 23:38:10 +05:30
Dev Khant	b480c71f0f	version bump -> 0.1.87 (#2521 )	2025-04-09 23:34:15 +05:30
Saket Aryan	309c8c18a6	Add user_id in TS OSS SDK (#2514 )	2025-04-09 10:24:56 -07:00
Dev Khant	f4d8647264	Doc: update memory export (#2519 )	2025-04-09 17:34:16 +05:30
Dev Khant	f95c4cbbe5	Update MAKEFILE (#2517 )	2025-04-09 12:04:39 +05:30
Dev Khant	00c7cc432c	Remove redundant lines (#2516 )	2025-04-09 11:02:37 +05:30
ytkimirti	91abc03880	Add Upstash Vector support (#2493 )	2025-04-09 10:06:07 +05:30
Saket Aryan	9100e95175	Fix Batch API docs (#2512 )	2025-04-07 23:54:16 +05:30
Dev Khant	cdb8dcdb9e	Add embeding_dims param to FAISS (#2513 )	2025-04-07 23:29:55 +05:30
Dev-Khant	2a79add7a5	hotfix: _create_procedural_memory	2025-04-07 16:07:26 +05:30
Dev Khant	9dfa9b4412	Add langchain embedding, update langchain LLM and version bump -> 0.1.84 (#2510 )	2025-04-07 15:27:26 +05:30
Dev Khant	5509066925	Doc: changelog update (#2509 )	2025-04-07 11:51:52 +05:30
Dev Khant	3712522b14	Fix langchain llm and update changelog (#2508 )	2025-04-07 11:49:39 +05:30
Dev Khant	93f34e4116	Formatting and version bump -> 0.1.82 (#2507 )	2025-04-07 11:31:16 +05:30
Dev Khant	39e5cbfacc	Support for langchain LLMs (#2506 )	2025-04-07 11:28:30 +05:30
Dev Khant	d30c78c5eb	Doc: update output_format (#2498 )	2025-04-03 10:46:06 +05:30
Dev Khant	039756abbe	Doc: pipecat integration (#2494 )	2025-04-02 18:44:04 +05:30
Mrinank Bhowmick	cb38c2dae7	Feature/google as new llm and embedder in mem0-ts (#2468 ) Co-authored-by: Saket Aryan <94069182+whysosaket@users.noreply.github.com>	2025-04-02 15:56:18 +05:30
Pranav Puranik	4dc9f6fad6	adding lmstudio and together in docs (#2489 )	2025-04-02 11:21:27 +05:30
Anusha Yella	1b1f02eb57	fix/failing-unit-tests (#2486 )	2025-04-02 10:36:02 +05:30
Dev Khant	1db1105cad	Set output_format='v1.1' and update docs (#2480 )	2025-04-02 10:35:29 +05:30
Saket Aryan	91a28c7f04	Docs: Flowise Integration Documentation for Mem0 Memory Setup (#2482 )	2025-04-01 10:16:53 -07:00
Dev Khant	a78e1894b1	Doc: Add llms.txt (#2484 )	2025-04-01 22:06:20 +05:30
Sergio Toro	83338295d8	feat: add development docker compose (#2411 )	2025-04-01 16:19:30 +05:30
Dev Khant	aff70807c6	update faqs (#2477 )	2025-04-01 00:40:50 +05:30
Dev Khant	648c86b53d	doc: fix lmstudio link (#2476 )	2025-04-01 00:28:02 +05:30
Dev Khant	de0b2de9c2	doc: fix links (#2475 )	2025-03-31 22:20:55 +05:30
Saket Aryan	e3f460fba4	Added Mastra Example (#2473 )	2025-03-30 11:56:00 -07:00
Saket Aryan	fe7b336922	Update Demo Mem0AI (#2471 )	2025-03-30 12:49:54 +05:30
Saket Aryan	1033ab227c	Introduce Ping in Mem0 Client (#2472 )	2025-03-30 12:49:36 +05:30
Saket Aryan	5ed15c3bcd	AI SDK Updates (#2470 )	2025-03-30 11:10:30 +05:30
Deshraj Yadav	c1f5a655ba	Minor fixes in procedural memory (#2469 )	2025-03-29 17:20:58 -07:00
Deshraj Yadav	72bb631bb5	Add support for procedural memory (#2460 )	2025-03-29 15:58:12 -07:00
Dev Khant	2bf9286071	update for faiss doc (#2464 )	2025-03-29 13:51:01 +05:30
Dev Khant	884b597312	bump version -> 0.1.79 (#2463 )	2025-03-29 13:46:00 +05:30
Dev Khant	f1471bcc55	update changelog (#2462 )	2025-03-29 13:39:11 +05:30
Dev Khant	9ae23f9c88	Add Faiss Support (#2461 )	2025-03-29 13:35:36 +05:30
Dev Khant	cbecbb7b64	doc: update email example (#2459 )	2025-03-29 00:11:02 +05:30
Dev Khant	f8ad0c2b2c	Doc: Add example for email processing (#2458 )	2025-03-29 00:09:22 +05:30
Dev Khant	d0da9a1ae0	Doc: Add changelog (#2455 )	2025-03-28 12:18:17 +05:30
Saket Aryan	bc4ab3db77	Add Infer Property (#2452 )	2025-03-27 21:18:42 +05:30
Dev Khant	0eb53b9f27	doc: update API reference for expiration_date (#2450 )	2025-03-27 12:24:26 +05:30
Prateek Chhikara	3cef3ed95e	Added Evaluation folder (#2448 )	2025-03-26 12:37:54 -07:00
Dev Khant	45e5f2af93	Doc: Update API reference section and Add elevenlabs example (#2447 )	2025-03-27 00:13:09 +05:30
Prateek Chhikara	32ba13b3ea	Updated multimodal docs (#2446 )	2025-03-26 09:56:16 -07:00
Parshva Daftari	69a91d5cbb	Mem0 livekit example (#2442 )	2025-03-26 16:06:23 +05:30
Dev Khant	2004427acd	tools fix and formatting (#2441 )	2025-03-26 11:25:03 +05:30
Saket Aryan	2517ccd489	fix(deployments): Add package.json file to fix deployment errors (#2440 )	2025-03-26 10:31:09 +05:30
Saket Aryan	9d0300f774	Update Vercel AI SDK to support tools call (#2383 )	2025-03-26 10:30:44 +05:30
Saket Aryan	366d263e0b	docs(supabase-ts): Update Docs for Supabase TS (#2439 )	2025-03-26 10:11:01 +05:30
Pranav Puranik	4321d24284	Open AI env var fix (#2384 )	2025-03-26 08:43:33 +05:30
Dev Khant	9cb2a13f3b	fix for Azure AI and version bump -> 0.1.76 (#2438 )	2025-03-25 18:10:36 +05:30
Dev Khant	5ec7889d9a	embedchain version bump -> 0.1.128 (#2437 )	2025-03-25 13:18:34 +05:30
Dev Khant	b54845bcc9	Add feeback method to client and doc changes (#2435 )	2025-03-25 11:39:19 +05:30
Saket Aryan	1ae2747ff8	Add Supabase History DB to run Mem0 OSS on Serverless (#2429 )	2025-03-24 16:14:29 -07:00
Parshva Daftari	953a5a4a2d	Azure openai fixes (#2428 )	2025-03-25 00:34:21 +05:30
Saket Aryan	2b49c9eedd	Supabase Vector Store (#2427 )	2025-03-25 00:15:50 +05:30
Anusha Yella	9db5f62262	fix-azure-ai-search-test-cases (#2422 )	2025-03-24 15:20:02 +05:30
Dev Khant	a1bd4285db	version bump -> 0.1.75 (#2426 )	2025-03-24 15:17:00 +05:30
Dev Khant	e77a10a8da	Add LM Studio support (#2425 )	2025-03-24 13:32:26 +05:30
Gaurav Agerwala	e4307ae420	Fix: Export ollama (#2421 ) Co-authored-by: Gaurav Agerwala <ice@Gauravs-MacBook-Pro.local>	2025-03-23 02:06:23 +05:30
Saket Aryan	7c89d00079	Adds Langchain Community Package (#2417 )	2025-03-22 10:44:40 +05:30
Dev Khant	563eaae5ee	Openai Agents SDK voice demo (#2416 )	2025-03-22 01:09:37 +05:30
Dev Khant	6733f78f81	Doc: Support for expiration date in ADD (#2419 )	2025-03-21 23:38:25 +05:30
Saket Aryan	c11637bd2f	Update Node SDK Docs for Update Method (#2418 )	2025-03-21 21:23:57 +05:30
Dev-Khant	ff30cb8ddd	version bump -> 0.1.74	2025-03-21 13:06:40 +05:30
Parshva Daftari	2e853c3d22	Updated VDB Docs (#2409 )	2025-03-20 23:47:57 +05:30
Dev Khant	3cc7013fde	fix pinecone (#2414 )	2025-03-20 23:47:09 +05:30
Dev Khant	8e6a08aa83	Support for hybrid search in Azure AI vector store (#2408 ) Co-authored-by: Deshraj Yadav <deshrajdry@gmail.com>	2025-03-20 22:57:00 +05:30
Wonbin Kim	8b9a8e5825	URGENT Hotfix - update default Elasticsearch search query (#2413 )	2025-03-20 20:50:18 +05:30