Mem0 fix in embedchain (#1506)

Co-authored-by: Deshraj Yadav <deshrajdry@gmail.com>

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,41 @@
+name: 🐛 Bug Report
+description: Create a report to help us reproduce and fix the bug
+
+body:
+- type: markdown
+  attributes:
+    value: >
+      #### Before submitting a bug, please make sure the issue hasn't been already addressed by searching through [the existing and past issues](https://github.com/embedchain/embedchain/issues?q=is%3Aissue+sort%3Acreated-desc+).
+- type: textarea
+  attributes:
+    label: 🐛 Describe the bug
+    description: |
+      Please provide a clear and concise description of what the bug is.
+
+      If relevant, add a minimal example so that we can reproduce the error by running the code. It is very important for the snippet to be as succinct (minimal) as possible, so please take time to trim down any irrelevant code to help us debug efficiently. We are going to copy-paste your code and we expect to get the same result as you did: avoid any external data, and include the relevant imports, etc. For example:
+
+      ```python
+      # All necessary imports at the beginning
+      import embedchain as ec
+      # Your code goes here
+
+
+      ```
+
+      Please also paste or describe the results you observe instead of the expected results. If you observe an error, please paste the error message including the **full** traceback of the exception. It may be relevant to wrap error messages in ```` ```triple quotes blocks``` ````.
+    placeholder: |
+      A clear and concise description of what the bug is.
+
+      ```python
+      Sample code to reproduce the problem
+      ```
+
+      ```
+      The error message you got, with the full traceback.
+      ````
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: true
+contact_links:
+  - name: 1-on-1 Session
+    url: https://cal.com/taranjeetio/ec
+    about: Speak directly with Taranjeet, the founder, to discuss issues, share feedback, or explore improvements for Embedchain
+  - name: Discord
+    url: https://discord.gg/6PzXDgEjG5
+    about: General community discussions

.github/ISSUE_TEMPLATE/documentation_issue.yml

@@ -0,0 +1,11 @@
+name: Documentation
+description: Report an issue related to the Embedchain docs.
+title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
+
+body:
+- type: textarea
+  attributes:
+    label: "Issue with current documentation:"
+    description: >
+      Please make sure to leave a reference to the document/code you're
+      referring to.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,23 @@
+name: 🚀 Feature request
+description: Submit a proposal/request for a new Embedchain feature
+
+body:
+- type: textarea
+  id: feature-request
+  attributes:
+    label: 🚀 The feature
+    description: >
+      A clear and concise description of the feature proposal
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Motivation, pitch
+    description: >
+      Please outline the motivation for the proposal. Is your feature request related to a specific problem? e.g., *"I'm working on X and would like Y to be possible"*. If this is related to another GitHub issue, please link here too.
+  validations:
+    required: true
+- type: markdown
+  attributes:
+    value: >
+      Thanks for contributing 🎉!

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,41 @@
+## Description
+
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Refactor (does not change functionality, e.g. code style improvements, linting)
+- [ ] Documentation update
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration
+
+Please delete options that are not relevant.
+
+- [ ] Unit Test
+- [ ] Test Script (please provide)
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules
+- [ ] I have checked my code and corrected any misspellings
+
+## Maintainer Checklist
+
+- [ ] closes #xxxx (Replace xxxx with the GitHub issue number)
+- [ ] Made sure Checks passed

.github/workflows/cd.yml

@@ -0,0 +1,46 @@
+name: Publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-n-publish:
+    name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: '3.11'
+
+      - name: Install Poetry
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        run: |
+          cd embedchain
+          poetry install
+
+      - name: Build a binary wheel and a source tarball
+        run: |
+          cd embedchain
+          poetry build
+
+      - name: Publish distribution 📦 to Test PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository_url: https://test.pypi.org/legacy/
+          packages_dir: embedchain/dist/
+
+      - name: Publish distribution 📦 to PyPI
+        if: startsWith(github.ref, 'refs/tags')
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages_dir: embedchain/dist/

.github/workflows/ci.yml

@@ -0,0 +1,110 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'mem0/**'
+      - 'tests/**'
+      - 'embedchain/**'
+      - 'embedchain/tests/**'
+      - 'embedchain/examples/**'
+  pull_request:
+    paths:
+      - 'mem0/**'
+      - 'tests/**'
+      - 'embedchain/**'
+      - 'embedchain/tests/**'
+      - 'embedchain/examples/**'
+
+jobs:
+  check_changes:
+    runs-on: ubuntu-latest
+    outputs:
+      mem0_changed: ${{ steps.filter.outputs.mem0 }}
+      embedchain_changed: ${{ steps.filter.outputs.embedchain }}
+    steps:
+    - uses: actions/checkout@v3
+    - uses: dorny/paths-filter@v2
+      id: filter
+      with:
+        filters: |
+          mem0:
+            - 'mem0/**'
+            - 'tests/**'
+          embedchain:
+            - 'embedchain/**'
+            - 'embedchain/tests/**'
+            - 'embedchain/examples/**'
+
+  build_mem0:
+    needs: check_changes
+    if: ${{ needs.check_changes.outputs.mem0_changed == 'true' || (needs.check_changes.outputs.mem0_changed == 'false' && needs.check_changes.outputs.embedchain_changed == 'false') }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11"]
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: 1.4.2
+          virtualenvs-create: true
+          virtualenvs-in-project: true
+      - name: Load cached venv
+        id: cached-poetry-dependencies
+        uses: actions/cache@v2
+        with:
+          path: .venv
+          key: venv-mem0-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Install dependencies
+        run: make install_all
+        if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+      - name: Run tests and generate coverage report
+        run: make test
+
+  build_embedchain:
+    needs: check_changes
+    if: ${{ needs.check_changes.outputs.embedchain_changed == 'true' || (needs.check_changes.outputs.mem0_changed == 'false' && needs.check_changes.outputs.embedchain_changed == 'false') }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11"]
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: 1.4.2
+          virtualenvs-create: true
+          virtualenvs-in-project: true
+      - name: Load cached venv
+        id: cached-poetry-dependencies
+        uses: actions/cache@v2
+        with:
+          path: .venv
+          key: venv-embedchain-${{ runner.os }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Install dependencies
+        run: cd embedchain && make install_all
+        if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+      - name: Lint with ruff
+        run: cd embedchain && make lint
+      - name: Run tests and generate coverage report
+        run: cd embedchain && make coverage
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+        with:
+          file: coverage.xml
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -76,7 +76,6 @@ docs/_build/
 target/
 
 # Jupyter Notebook
-.ipynb_checkpoints
 
 # IPython
 profile_default/
@@ -165,5 +164,23 @@ cython_debug/
 
 # Database
 db
+test-db
+!embedchain/embedchain/core/db/
 
-.vscode
+.vscode
+.idea/
+
+.DS_Store
+
+notebooks/*.yaml
+.ipynb_checkpoints/
+
+!configs/*.yaml
+
+# cache db
+*.db
+
+# local directories for testing
+eval/
+qdrant_storage/
+.crossnote

Makefile

@@ -1,24 +1,41 @@
-# Variables
-PYTHON := python3
-PIP := $(PYTHON) -m pip
-PROJECT_NAME := embedchain
+.PHONY: format sort lint
 
-# Targets
-.PHONY: install format lint clean test
+# Variables
+ISORT_OPTIONS = --profile black
+PROJECT_NAME := mem0ai
+
+# Default target
+all: format sort lint
 
 install:
-	$(PIP) install --upgrade pip
-	$(PIP) install -e .[dev]
+	poetry install
 
+install_all:
+	poetry install
+
+# Format code with ruff
 format:
-	$(PYTHON) -m black .
-	$(PYTHON) -m isort .
+	poetry run ruff check . --fix $(RUFF_OPTIONS)
 
+# Sort imports with isort
+sort:
+	poetry run isort . $(ISORT_OPTIONS)
+
+# Lint code with ruff
 lint:
-	$(PYTHON) -m ruff .
+	poetry run ruff .
+
+docs:
+	cd docs && mintlify dev
+
+build:
+	poetry build
+
+publish:
+	poetry publish
 
 clean:
-	rm -rf dist build *.egg-info
+	poetry run rm -rf dist
 
 test:
-	$(PYTHON) -m pytest
+	poetry run pytest

README.md

@@ -1,635 +1,107 @@
-# embedchain
+<p align="center">
+  <img src="docs/images/mem0-bg.png" width="500px" alt="Mem0 Logo">
+</p>
 
-[![PyPI](https://img.shields.io/pypi/v/embedchain)](https://pypi.org/project/embedchain/)
-[![Discord](https://dcbadge.vercel.app/api/server/nhvCbCtKV?style=flat)](https://discord.gg/6PzXDgEjG5)
-[![Twitter](https://img.shields.io/twitter/follow/embedchain)](https://twitter.com/embedchain)
-[![Substack](https://img.shields.io/badge/Substack-%23006f5c.svg?logo=substack)](https://embedchain.substack.com/)
+<p align="center">
+  <a href="https://embedchain.ai/slack">
+    <img src="https://img.shields.io/badge/slack-embedchain-brightgreen.svg?logo=slack" alt="Slack">
+  </a>
+  <a href="https://embedchain.ai/discord">
+    <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Discord">
+  </a>
+  <a href="https://twitter.com/mem0ai">
+    <img src="https://img.shields.io/twitter/follow/mem0ai" alt="Twitter">
+  </a>
+</p>
 
-embedchain is a framework to easily create LLM powered bots over any dataset. If you want a javascript version, check out [embedchain-js](https://github.com/embedchain/embedchainjs)
+# Mem0: The Memory Layer for Personalized AI
 
-# Table of Contents
+Mem0 provides a smart, self-improving memory layer for Large Language Models, enabling personalized AI experiences across applications.
 
-- [Latest Updates](#latest-updates)
-- [What is embedchain?](#what-is-embedchain)
-- [Getting Started](#getting-started)
-  - [Installation](#installation)
-  - [Usage](#usage)
-    - [App Types](#app-types)
-      - [1. App (uses OpenAI models, paid)](#1-app-uses-openai-models-paid)
-      - [2. OpenSourceApp (uses opensource models, free)](#2-opensourceapp-uses-opensource-models-free)
-      - [3. PersonApp (uses OpenAI models, paid)](#3-personapp-uses-openai-models-paid)
-    - [Add Dataset](#add-dataset)
-  - [Interface Types](#interface-types)
-    - [Query Interface](#query-interface)
-    - [Chat Interface](#chat-interface)
-  - [Format supported](#format-supported)
-    - [Youtube Video](#youtube-video)
-    - [PDF File](#pdf-file)
-    - [Web Page](#web-page)
-    - [Doc File](#doc-file)
-    - [Text](#text)
-    - [QnA Pair](#qna-pair)
-    - [Reusing a Vector DB](#reusing-a-vector-db)
-    - [More Formats coming soon](#more-formats-coming-soon)
-  - [Testing](#testing)
-- [Advanced](#advanced)
-  - [Configuration](#configuration)
-    - [Example](#example)
-    - [Configs](#configs)
-      - [InitConfig](#initconfig)
-      - [Add Config](#add-config)
-      - [Query Config](#query-config)
-      - [Chat Config](#chat-config)
-  - [Other methods](#other-methods)
-    - [Reset](#reset)
-    - [Count](#count)
-- [How does it work?](#how-does-it-work)
-- [Contribution Guidelines](#contribution-guidelines)
-- [Tech Stack](#tech-stack)
-- [Team](#team)
-  - [Author](#author)
-  - [Maintainer](#maintainer)
-  - [Citation](#citation)
+> Note: The Mem0 repository now also includes the Embedchain project. We continue to maintain and support Embedchain ❤️. You can find the Embedchain codebase in the [embedchain](https://github.com/mem0ai/mem0/tree/main/embedchain) directory.
+## 🚀 Quick Start
 
-# Latest Updates
-
-- Introduce a new interface called `chat`. It remembers the history (last 5 messages) and can be used to powerful stateful bots. You can use it by calling `.chat` on any app instance. Works for both OpenAI and OpenSourceApp.
-
-- Introduce a new app type called `OpenSourceApp`. It uses `gpt4all` as the LLM and `sentence transformers` all-MiniLM-L6-v2 as the embedding model. If you use this app, you dont have to pay for anything.
-
-# What is embedchain?
-
-Embedchain abstracts the entire process of loading a dataset, chunking it, creating embeddings and then storing in a vector database.
-
-You can add a single or multiple dataset using `.add` and `.add_local` function and then use `.query` function to find an answer from the added datasets.
-
-If you want to create a Naval Ravikant bot which has 1 youtube video, 1 book as pdf and 2 of his blog posts, as well as a question and answer pair you supply, all you need to do is add the links to the videos, pdf and blog posts and the QnA pair and embedchain will create a bot for you.
-
-```python
-
-from embedchain import App
-
-naval_chat_bot = App()
-
-# Embed Online Resources
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
-naval_chat_bot.add("web_page", "https://nav.al/feedback")
-naval_chat_bot.add("web_page", "https://nav.al/agi")
-
-# Embed Local Resources
-naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
-
-naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?")
-# answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
-```
-
-# Getting Started
-
-## Installation
-
-First make sure that you have the package installed. If not, then install it using `pip`
+### Installation
 
 ```bash
-pip install embedchain
+pip install mem0ai
 ```
 
-## Usage
-
-Creating a chatbot involves 3 steps:
-
-- Import the App instance (App Types)
-- Add Dataset (Add Dataset)
-- Query or Chat on the dataset and get answers (Interface Types)
-
-### App Types
-
-We have three types of App.
-
-#### 1. App (uses OpenAI models, paid)
+### Basic Usage
 
 ```python
-from embedchain import App
+from mem0 import Memory
 
-naval_chat_bot = App()
+# Initialize Mem0
+m = Memory()
+
+# Store a memory from any unstructured text
+result = m.add("I am working on improving my tennis skills. Suggest some online courses.", user_id="alice", metadata={"category": "hobbies"})
+print(result)
+# Created memory: Improving her tennis skills. Looking for online suggestions.
+
+# Retrieve memories
+all_memories = m.get_all()
+print(all_memories)
+
+# Search memories
+related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
+print(related_memories)
+
+# Update a memory
+result = m.update(memory_id="m1", data="Likes to play tennis on weekends")
+print(result)
+
+# Get memory history
+history = m.history(memory_id="m1")
+print(history)
 ```
 
-- `App` uses OpenAI's model, so these are paid models. You will be charged for embedding model usage and LLM usage.
+## 🔑 Core Features
 
-- `App` uses OpenAI's embedding model to create embeddings for chunks and ChatGPT API as LLM to get answer given the relevant docs. Make sure that you have an OpenAI account and an API key. If you have don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
+- **Multi-Level Memory**: User, Session, and AI Agent memory retention
+- **Adaptive Personalization**: Continuous improvement based on interactions
+- **Developer-Friendly API**: Simple integration into various applications
+- **Cross-Platform Consistency**: Uniform behavior across devices
+- **Managed Service**: Hassle-free hosted solution
 
-- Once you have the API key, set it in an environment variable called `OPENAI_API_KEY`
+## 📖 Documentation
+
+For detailed usage instructions and API reference, visit our documentation at [docs.mem0.ai](https://docs.mem0.ai).
+
+## 🔧 Advanced Usage
+
+For production environments, you can use Qdrant as a vector store:
 
 ```python
-import os
-os.environ["OPENAI_API_KEY"] = "sk-xxxx"
-```
-
-#### 2. OpenSourceApp (uses opensource models, free)
-
-```python
-from embedchain import OpenSourceApp
-
-naval_chat_bot = OpenSourceApp()
-```
-
-- `OpenSourceApp` uses open source embedding and LLM model. It uses `all-MiniLM-L6-v2` from Sentence Transformers library as the embedding model and `gpt4all` as the LLM.
-
-- Here there is no need to setup any api keys. You just need to install embedchain package and these will get automatically installed.
-
-- Once you have imported and instantiated the app, every functionality from here onwards is the same for either type of app.
-
-#### 3. PersonApp (uses OpenAI models, paid)
-
-```python
-from embedchain import PersonApp
-
-naval_chat_bot = PersonApp("name_of_person_or_character") #Like "Yoda"
-```
-
-- `PersonApp` uses OpenAI's model, so these are paid models. You will be charged for embedding model usage and LLM usage.
-
-- `PersonApp` uses OpenAI's embedding model to create embeddings for chunks and ChatGPT API as LLM to get answer given the relevant docs. Make sure that you have an OpenAI account and an API key. If you have don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
-
-- Once you have the API key, set it in an environment variable called `OPENAI_API_KEY`
-
-```python
-import os
-os.environ["OPENAI_API_KEY"] = "sk-xxxx"
-```
-
-### Add Dataset
-
-- This step assumes that you have already created an `app` instance by either using `App` or `OpenSourceApp`. We are calling our app instance as `naval_chat_bot`
-
-- Now use `.add` function to add any dataset.
-
-```python
-
-# naval_chat_bot = App() or
-# naval_chat_bot = OpenSourceApp()
-
-# Embed Online Resources
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
-naval_chat_bot.add("web_page", "https://nav.al/feedback")
-naval_chat_bot.add("web_page", "https://nav.al/agi")
-
-# Embed Local Resources
-naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
-```
-
-- If there is any other app instance in your script or app, you can change the import as
-
-```python
-from embedchain import App as EmbedChainApp
-from embedchain import OpenSourceApp as EmbedChainOSApp
-from embedchain import PersonApp as EmbedChainPersonApp
-
-# or
-
-from embedchain import App as ECApp
-from embedchain import OpenSourceApp as ECOSApp
-from embedchain import PersonApp as ECPApp
-```
-
-## Interface Types
-
-### Query Interface
-
-- This interface is like a question answering bot. It takes a question and gets the answer. It does not maintain context about the previous chats.
-
-- To use this, call `.query` function to get the answer for any query.
-
-```python
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"))
-# answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
-```
-
-### Chat Interface
-
-- This interface is chat interface where it remembers previous conversation. Right now it remembers 5 conversation by default.
-
-- To use this, call `.chat` function to get the answer for any query.
-
-```python
-print(naval_chat_bot.chat("How to be happy in life?"))
-# answer: The most important trick to being happy is to realize happiness is a skill you develop and a choice you make. You choose to be happy, and then you work at it. It's just like building muscles or succeeding at your job. It's about recognizing the abundance and gifts around you at all times.
-
-print(naval_chat_bot.chat("who is naval ravikant?"))
-# answer: Naval Ravikant is an Indian-American entrepreneur and investor.
-
-print(naval_chat_bot.chat("what did the author say about happiness?"))
-# answer: The author, Naval Ravikant, believes that happiness is a choice you make and a skill you develop. He compares the mind to the body, stating that just as the body can be molded and changed, so can the mind. He emphasizes the importance of being present in the moment and not getting caught up in regrets of the past or worries about the future. By being present and grateful for where you are, you can experience true happiness.
-```
-
-### Stream Response
-
-- You can add config to your query method to stream responses like ChatGPT does. You would require a downstream handler to render the chunk in your desirable format. Supports both OpenAI model and OpenSourceApp.
-
-- To use this, instantiate a `QueryConfig` or `ChatConfig` object with `stream=True`. Then pass it to the `.chat()` or `.query()` method. The following example iterates through the chunks and prints them as they appear.
-
-```python
-app = App()
-query_config = QueryConfig(stream = True)
-resp = app.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", query_config)
-
-for chunk in resp:
-    print(chunk, end="", flush=True)
-# answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
-```
-
-## Format supported
-
-We support the following formats:
-
-### Youtube Video
-
-To add any youtube video to your app, use the data_type (first argument to `.add`) as `youtube_video`. Eg:
-
-```python
-app.add('youtube_video', 'a_valid_youtube_url_here')
-```
-
-### PDF File
-
-To add any pdf file, use the data_type as `pdf_file`. Eg:
-
-```python
-app.add('pdf_file', 'a_valid_url_where_pdf_file_can_be_accessed')
-```
-
-Note that we do not support password protected pdfs.
-
-### Web Page
-
-To add any web page, use the data_type as `web_page`. Eg:
-
-```python
-app.add('web_page', 'a_valid_web_page_url')
-```
-
-### Doc File
-
-To add any doc/docx file, use the data_type as `docx`. Eg:
-
-```python
-app.add('docx', 'a_local_docx_file_path')
-```
-
-### Text
-
-To supply your own text, use the data_type as `text` and enter a string. The text is not processed, this can be very versatile. Eg:
-
-```python
-app.add_local('text', 'Seek wealth, not money or status. Wealth is having assets that earn while you sleep. Money is how we transfer time and wealth. Status is your place in the social hierarchy.')
-```
-
-Note: This is not used in the examples because in most cases you will supply a whole paragraph or file, which did not fit.
-
-### QnA Pair
-
-To supply your own QnA pair, use the data_type as `qna_pair` and enter a tuple. Eg:
-
-```python
-app.add_local('qna_pair', ("Question", "Answer"))
-```
-### Sitemap
-
-To add a XML site map containing list of all urls, use the data_type as `sitemap` and enter the sitemap url. Eg:
-
-```python
-app.add('sitemap', 'a_valid_sitemap_url/sitemap.xml')
-```
-
-### Reusing a Vector DB
-
-Default behavior is to create a persistent vector DB in the directory **./db**. You can split your application into two Python scripts: one to create a local vector DB and the other to reuse this local persistent vector DB. This is useful when you want to index hundreds of documents and separately implement a chat interface.
-
-Create a local index:
-
-```python
-
-from embedchain import App
-
-naval_chat_bot = App()
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44")
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
-```
-
-You can reuse the local index with the same code, but without adding new documents:
-
-```python
-
-from embedchain import App
-
-naval_chat_bot = App()
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"))
-```
-
-### More Formats coming soon
-
-- If you want to add any other format, please create an [issue](https://github.com/embedchain/embedchain/issues) and we will add it to the list of supported formats.
-
-## Testing
-
-Before you consume valueable tokens, you should make sure that the embedding you have done works and that it's receiving the correct document from the database.
-
-For this you can use the `dry_run` method.
-
-Following the example above, add this to your script:
-
-```python
-print(naval_chat_bot.dry_run('Can you tell me who Naval Ravikant is?'))
-
-'''
-Use the following pieces of context to answer the query at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
-        Q: Who is Naval Ravikant?
-A: Naval Ravikant is an Indian-American entrepreneur and investor.
-        Query: Can you tell me who Naval Ravikant is?
-        Helpful Answer:
-'''
-```
-
-_The embedding is confirmed to work as expected. It returns the right document, even if the question is asked slightly different. No prompt tokens have been consumed._
-
-**The dry run will still consume tokens to embed your query, but it is only ~1/15 of the prompt.**
-
-## Colab Notebook and Video Tutorials
-
-Chinese Colab Tutorial:https://colab.research.google.com/drive/10_7Y0x4YXWVjuhhYwVraGQLpKAatTQTm?usp=sharing
-
-Chinese Video Tutorial:https://www.bilibili.com/video/BV1YX4y1H7oN
-
-# Advanced
-
-## Configuration
-
-Embedchain is made to work out of the box. However, for advanced users we're also offering configuration options. All of these configuration options are optional and have sane defaults.
-
-### Example
-
-Here's the readme example with configuration options.
-
-```python
-import os
-from embedchain import App
-from embedchain.config import InitConfig, AddConfig, QueryConfig
-from chromadb.utils import embedding_functions
-
-# Example: use your own embedding function
-config = InitConfig(ef=embedding_functions.OpenAIEmbeddingFunction(
-                api_key=os.getenv("OPENAI_API_KEY"),
-                organization_id=os.getenv("OPENAI_ORGANIZATION"),
-                model_name="text-embedding-ada-002"
-            ))
-naval_chat_bot = App(config)
-
-# Example: define your own chunker config for `youtube_video`
-youtube_add_config = {
-        "chunker": {
-                "chunk_size": 1000,
-                "chunk_overlap": 100,
-                "length_function": len,
+from mem0 import Memory
+
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "host": "localhost",
+            "port": 6333,
         }
+    },
 }
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44", AddConfig(**youtube_add_config))
 
-add_config = AddConfig()
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf", add_config)
-naval_chat_bot.add("web_page", "https://nav.al/feedback", add_config)
-naval_chat_bot.add("web_page", "https://nav.al/agi", add_config)
-
-naval_chat_bot.add_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."), add_config)
-
-query_config = QueryConfig() # Currently no options
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", query_config))
+m = Memory.from_config(config)
 ```
 
-Here's the example of using custom prompt template with `.query`
-
-```python
-from embedchain.config import QueryConfig
-from embedchain.embedchain import App
-from string import Template
-import wikipedia
-
-einstein_chat_bot = App()
-
-# Embed Wikipedia page
-page = wikipedia.page("Albert Einstein")
-einstein_chat_bot.add("text", page.content)
-
-# Example: use your own custom template with `$context` and `$query`
-einstein_chat_template = Template("""
-        You are Albert Einstein, a German-born theoretical physicist,
-        widely ranked among the greatest and most influential scientists of all time.
-
-        Use the following information about Albert Einstein to respond to 
-        the human's query acting as Albert Einstein.
-        Context: $context                                
-
-        Keep the response brief. If you don't know the answer, just say that you don't know, don't try to make up an answer.
-
-        Human: $query
-        Albert Einstein:""")
-query_config = QueryConfig(einstein_chat_template)
-queries = [
-        "Where did you complete your studies?",
-        "Why did you win nobel prize?",
-        "Why did you divorce your first wife?",
-]
-for query in queries:
-        response = einstein_chat_bot.query(query, query_config)
-        print("Query: ", query)
-        print("Response: ", response)
-
-# Output
-# Query:  Where did you complete your studies?
-# Response:  I completed my secondary education at the Argovian cantonal school in Aarau, Switzerland.
-# Query:  Why did you win nobel prize?
-# Response:  I won the Nobel Prize in Physics in 1921 for my services to Theoretical Physics, particularly for my discovery of the law of the photoelectric effect.
-# Query:  Why did you divorce your first wife?
-# Response:  We divorced due to living apart for five years.
-```
-
-**Client Mode**. By defining a (ChromaDB) server, you can run EmbedChain as a client only.
-
-```python
-from embedchain import App
-config = InitConfig(host="localhost", port="8080")
-app = App(config)
-```
-This is useful for scalability. Say you have EmbedChain behind an API with multiple workers. If you separate clients and server, all clients can connect to the server, which only has to keep one instance of the database in memory. You also don't have to worry about replication.
-
-To run a chroma db server, run `git clone https://github.com/chroma-core/chroma.git`, navigate to the directory (`cd chroma`) and then start the server with `docker-compose up -d --build`.
-
-### Configs
-
-This section describes all possible config options.
-
-#### **InitConfig**
-
-|option|description|type|default|
-|---|---|---|---|
-|log_level|log level|string|WARNING|
-|ef|embedding function|chromadb.utils.embedding_functions|{text-embedding-ada-002}|
-|db|vector database (experimental)|BaseVectorDB|ChromaDB|
-|host|hostname for (Chroma) DB server|string|None|
-|port|port number for (Chroma) DB server|string, int|None|
-
-#### **Add Config**
-
-|option|description|type|default|
-|---|---|---|---|
-|chunker|chunker config|ChunkerConfig|Default values for chunker depends on the `data_type`. Please refer [ChunkerConfig](#chunker-config)|
-|loader|loader config|LoaderConfig|None|
-
-##### **Chunker Config**
-
-|option|description|type|default|
-|---|---|---|---|
-|chunk_size|Maximum size of chunks to return|int|Default value for various `data_type` mentioned below|
-|chunk_overlap|Overlap in characters between chunks|int|Default value for various `data_type` mentioned below|
-|length_function|Function that measures the length of given chunks|typing.Callable|Default value for various `data_type` mentioned below|
-
-Default values of chunker config parameters for different `data_type`:
-
-|data_type|chunk_size|chunk_overlap|length_function|
-|---|---|---|---|
-|docx|1000|0|len|
-|text|300|0|len|
-|qna_pair|300|0|len|
-|web_page|500|0|len|
-|pdf_file|1000|0|len|
-|youtube_video|2000|0|len|
-
-##### **Loader Config**
-
-_coming soon_
-
-#### **Query Config**
-
-|option|description|type|default|
-|---|---|---|---|
-|number_documents|number of documents to be retrieved as context|int|1|
-|template|custom template for prompt|Template|Template("Use the following pieces of context to answer the query at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer. \$context Query: $query Helpful Answer:")|
-|history|include conversation history from your client or database|any (recommendation: list[str])|None
-|stream|control if response is streamed back to the user|bool|False|
-|model|OpenAI model|string|gpt-3.5-turbo-0613|
-|temperature|creativity of the model (0-1)|float|0|
-|max_tokens|limit maximum tokens used|int|1000|
-|top_p|diversity of words used by the model (0-1)|float|1|
-
-#### **Chat Config**
-
-All options for query and...
-
-_coming soon_
-
-history is handled automatically, the config option is not supported.
-
-## Other methods
-
-### Reset
-
-Resets the database and deletes all embeddings. Irreversible. Requires reinitialization afterwards.
-
-```python
-app.reset()
-```
-
-### Count
-
-Counts the number of embeddings (chunks) in the database.
-
-```python
-print(app.count())
-# returns: 481
-```
-
-# How does it work?
-
-Creating a chat bot over any dataset needs the following steps to happen
-
-- load the data
-- create meaningful chunks
-- create embeddings for each chunk
-- store the chunks in vector database
-
-Whenever a user asks any query, following process happens to find the answer for the query
-
-- create the embedding for query
-- find similar documents for this query from vector database
-- pass similar documents as context to LLM to get the final answer.
-
-The process of loading the dataset and then querying involves multiple steps and each steps has nuances of it is own.
-
-- How should I chunk the data? What is a meaningful chunk size?
-- How should I create embeddings for each chunk? Which embedding model should I use?
-- How should I store the chunks in vector database? Which vector database should I use?
-- Should I store meta data along with the embeddings?
-- How should I find similar documents for a query? Which ranking model should I use?
-
-These questions may be trivial for some but for a lot of us, it needs research, experimentation and time to find out the accurate answers.
-
-embedchain is a framework which takes care of all these nuances and provides a simple interface to create bots over any dataset.
-
-In the first release, we are making it easier for anyone to get a chatbot over any dataset up and running in less than a minute. All you need to do is create an app instance, add the data sets using `.add` function and then use `.query` function to get the relevant answer.
-
-# Contribution Guidelines
-
-Thank you for your interest in contributing to the EmbedChain project! We welcome your ideas and contributions to help improve the project. Please follow the instructions below to get started:
-
-1. **Fork the repository**: Click on the "Fork" button at the top right corner of this repository page. This will create a copy of the repository in your own GitHub account.
-
-2. **Install the required dependencies**: Ensure that you have the necessary dependencies installed in your Python environment. You can do this by running the following command:
-
-```bash
-make install
-```
-
-3. **Make changes in the code**: Create a new branch in your forked repository and make your desired changes in the codebase.
-4. **Format code**: Before creating a pull request, it's important to ensure that your code follows our formatting guidelines. Run the following commands to format the code:
-
-```bash
-make lint format
-```
-
-5. **Create a pull request**: When you are ready to contribute your changes, submit a pull request to the EmbedChain repository. Provide a clear and descriptive title for your pull request, along with a detailed description of the changes you have made.
-
-# Tech Stack
-
-embedchain is built on the following stack:
-
-- [Langchain](https://github.com/hwchase17/langchain) as an LLM framework to load, chunk and index data
-- [OpenAI's Ada embedding model](https://platform.openai.com/docs/guides/embeddings) to create embeddings
-- [OpenAI's ChatGPT API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) as LLM to get answers given the context
-- [Chroma](https://github.com/chroma-core/chroma) as the vector database to store embeddings
-- [gpt4all](https://github.com/nomic-ai/gpt4all) as an open source LLM
-- [sentence-transformers](https://huggingface.co/sentence-transformers) as open source embedding model
-
-# Team
-
-## Author
-
-- Taranjeet Singh ([@taranjeetio](https://twitter.com/taranjeetio))
-
-## Maintainer
-
-- [cachho](https://github.com/cachho)
-
-## Citation
-
-If you utilize this repository, please consider citing it with:
-
-```
-@misc{embedchain,
-  author = {Taranjeet Singh},
-  title = {Embechain: Framework to easily create LLM powered bots over any dataset},
-  year = {2023},
-  publisher = {GitHub},
-  journal = {GitHub repository},
-  howpublished = {\url{https://github.com/embedchain/embedchain}},
-}
-```
+## 🗺️ Roadmap
+
+- Integration with various LLM providers
+- Support for LLM frameworks
+- Integration with AI Agents frameworks
+- Customizable memory creation/update rules
+- Hosted platform support
+
+## 🙋‍♂️ Support
+Join our Slack or Discord 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://embedchain.ai/discord)
+- [Join our Slack](https://embedchain.ai/slack)
+- [Follow us on Twitter](https://twitter.com/mem0ai)
+- [Email us](mailto:founders@mem0.ai)

docs/README.md

@@ -0,0 +1,32 @@
+# Mintlify Starter Kit
+
+Click on `Use this template` to copy the Mintlify starter kit. The starter kit contains examples including
+
+- Guide pages
+- Navigation
+- Customizations
+- API Reference pages
+- Use of popular components
+
+### Development
+
+Install the [Mintlify CLI](https://www.npmjs.com/package/mintlify) to preview the documentation changes locally. To install, use the following command
+
+```
+npm i -g mintlify
+```
+
+Run the following command at the root of your documentation (where mint.json is)
+
+```
+mintlify dev
+```
+
+### Publishing Changes
+
+Install our Github App to auto propagate changes from your repo to your deployment. Changes will be deployed to production automatically after pushing to the default branch. Find the link to install on your dashboard. 
+
+#### Troubleshooting
+
+- Mintlify dev isn't running - Run `mintlify install` it'll re-install dependencies.
+- Page loads as a 404 - Make sure you are running in a folder with `mint.json`

docs/_snippets/get-help.mdx

@@ -0,0 +1,11 @@
+<CardGroup cols={3}>
+  <Card title="Talk to founders" icon="calendar" href="https://cal.com/taranjeetio/meet">
+  Talk to founders
+  </Card>
+  <Card title="Slack" icon="slack" href="https://embedchain.ai/slack" color="#4A154B">
+    Join our slack community
+  </Card>
+  <Card title="Discord" icon="discord" href="https://discord.gg/6PzXDgEjG5" color="#7289DA">
+    Join our discord community
+  </Card>
+</CardGroup>

docs/examples/customer-support-agent.mdx

@@ -0,0 +1,109 @@
+---
+title: Customer Support AI Agent
+---
+
+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
+
+The Customer Support AI Agent leverages Mem0 to retain information across interactions, enabling a personalized and efficient support experience.
+
+## Setup
+
+Install the necessary packages using pip:
+
+```bash
+pip install openai mem0ai
+```
+
+## Full Code Example
+
+Below is the simplified code to create and interact with a Customer Support AI Agent using Mem0:
+
+```python
+from openai import OpenAI
+from mem0 import Memory
+
+# Set the OpenAI API key
+os.environ['OPENAI_API_KEY'] = 'sk-xxx'
+
+class CustomerSupportAIAgent:
+    def __init__(self):
+        """
+        Initialize the CustomerSupportAIAgent with memory configuration and OpenAI client.
+        """
+        config = {
+            "vector_store": {
+                "provider": "qdrant",
+                "config": {
+                    "host": "localhost",
+                    "port": 6333,
+                }
+            },
+        }
+        self.memory = Memory.from_config(config)
+        self.client = OpenAI()
+        self.app_id = "customer-support"
+
+    def handle_query(self, query, user_id=None):
+        """
+        Handle a customer query and store the relevant information in memory.
+
+        :param query: The customer query to handle.
+        :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 customer support AI agent."},
+                {"role": "user", "content": query}
+            ]
+        )
+        # Store the query in memory
+        self.memory.add(query, 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="")
+
+    def get_memories(self, user_id=None):
+        """
+        Retrieve all memories associated with the given customer ID.
+
+        :param user_id: Optional user ID to filter memories.
+        :return: List of memories.
+        """
+        return self.memory.get_all(user_id=user_id)
+
+# Instantiate the CustomerSupportAIAgent
+support_agent = CustomerSupportAIAgent()
+
+# Define a customer ID
+customer_id = "jane_doe"
+
+# Handle a customer query
+support_agent.handle_query("I need help with my recent order. It hasn't arrived yet.", user_id=customer_id)
+```
+
+### Fetching Memories
+
+You can fetch all the memories at any point in time using the following code:
+
+```python
+memories = support_agent.get_memories(user_id=customer_id)
+for m in memories:
+    print(m['text'])
+```
+
+### Key Points
+
+- **Initialization**: The CustomerSupportAIAgent class is initialized with the necessary memory configuration and OpenAI client setup.
+- **Handling Queries**: The handle_query method sends a query to the AI and stores the relevant information in memory.
+- **Retrieving Memories**: The get_memories method fetches all stored memories associated with a customer.
+
+### Conclusion
+
+As the conversation progresses, Mem0's memory automatically updates based on the interactions, providing a continuously improving personalized support experience.

docs/examples/overview.mdx

@@ -0,0 +1,32 @@
+---
+title: Overview
+description: How to use mem0 in your existing applications?
+---
+
+
+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:
+
+- More personalized
+- More reliable
+- Cost-effective by reducing the number of LLM interactions
+- More engaging
+- Enables long-term memory
+
+Here are some examples of how Mem0 can be integrated into various applications:
+
+## Example Use Cases
+
+<CardGroup cols={1}>
+  <Card title="Personal AI Tutor" icon="square-1" href="/examples/personal-ai-tutor">
+    <img width="100%" src="/images/ai-tutor.png" />
+    Create a Personalized AI Tutor that adapts to student progress and learning preferences.
+  </Card>
+  <Card title="Personal Travel Assistant" icon="square-2" href="/examples/personal-travel-assistant">
+    <img src="/images/personal-travel-agent.png" />
+    Build a Personalized AI Travel Assistant that understands your travel preferences and past itineraries.
+  </Card>
+  <Card title="Customer Support Agent" icon="square-3" href="/examples/customer-support-agent">
+    <img width="100%" src="/images/customer-support-agent.png" />
+    Develop a Personal AI Assistant that remembers user preferences, past interactions, and context to provide personalized and efficient assistance.
+  </Card>
+</CardGroup>

docs/examples/personal-ai-tutor.mdx

@@ -0,0 +1,111 @@
+---
+title: Personalized AI Tutor
+---
+
+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
+
+The Personalized AI Tutor leverages Mem0 to retain information across interactions, enabling a tailored learning experience. By integrating with OpenAI's GPT-4 model, the tutor can provide detailed and context-aware responses to user queries.
+
+## Setup
+Before you begin, ensure you have the required dependencies installed. You can install the necessary packages using pip:
+
+```bash
+pip install openai mem0ai
+```
+
+## Full Code Example
+
+Below is the complete code to create and interact with a Personalized AI Tutor using Mem0:
+
+```python
+from openai import OpenAI
+from mem0 import Memory
+
+# Set the OpenAI API key
+os.environ['OPENAI_API_KEY'] = 'sk-xxx'
+
+# Initialize the OpenAI client
+client = OpenAI()
+
+class PersonalAITutor:
+    def __init__(self):
+        """
+        Initialize the PersonalAITutor with memory configuration and OpenAI client.
+        """
+        config = {
+            "vector_store": {
+                "provider": "qdrant",
+                "config": {
+                    "host": "localhost",
+                    "port": 6333,
+                }
+            },
+        }
+        self.memory = Memory.from_config(config)
+        self.client = client
+        self.app_id = "app-1"
+
+    def ask(self, question, user_id=None):
+        """
+        Ask a question to the AI and store the relevant facts in memory
+
+        :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}
+            ]
+        )
+        # 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="")
+
+    def get_memories(self, user_id=None):
+        """
+        Retrieve all memories associated with the given user ID.
+
+        :param user_id: Optional user ID to filter memories.
+        :return: List of memories.
+        """
+        return self.memory.get_all(user_id=user_id)
+
+# Instantiate the PersonalAITutor
+ai_tutor = PersonalAITutor()
+
+# Define a user ID
+user_id = "john_doe"
+
+# Ask a question
+ai_tutor.ask("I am learning introduction to CS. What is queue? Briefly explain.", user_id=user_id)
+```
+
+### Fetching Memories
+
+You can fetch all the memories at any point in time using the following code:
+
+```python
+memories = ai_tutor.get_memories(user_id=user_id)
+for m in memories:
+    print(m['text'])
+```
+
+### Key Points
+
+- **Initialization**: The PersonalAITutor class is initialized with the necessary memory configuration and OpenAI client setup.
+- **Asking Questions**: The ask method sends a question to the AI and stores the relevant information in memory.
+- **Retrieving Memories**: The get_memories method fetches all stored memories associated with a user.
+
+### Conclusion
+
+As the conversation progresses, Mem0's memory automatically updates based on the interactions, providing a continuously improving personalized learning experience. This setup ensures that the AI Tutor can offer contextually relevant and accurate responses, enhancing the overall educational process.

docs/examples/personal-travel-assistant.mdx

@@ -0,0 +1,101 @@
+---
+title: Personal AI Travel Assistant
+---
+Create a personalized AI Travel Assistant using Mem0. This guide provides step-by-step instructions and the complete code to get you started.
+
+## Overview
+
+The Personalized AI Travel Assistant uses Mem0 to store and retrieve information across interactions, enabling a tailored travel planning experience. It integrates with OpenAI's GPT-4 model to provide detailed and context-aware responses to user queries.
+
+## Setup
+
+Install the required dependencies using pip:
+
+```bash
+pip install openai mem0ai
+```
+
+## Full Code Example
+
+Here's the complete code to create and interact with a Personalized AI Travel Assistant using Mem0:
+
+```python
+import os
+from openai import OpenAI
+from mem0 import Memory
+
+# Set the OpenAI API key
+os.environ['OPENAI_API_KEY'] = 'sk-xxx'
+
+class PersonalTravelAssistant:
+    def __init__(self):
+        self.client = OpenAI()
+        self.memory = Memory()
+        self.messages = [{"role": "system", "content": "You are a personal AI Assistant."}]
+
+    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(
+            model="gpt-4o",
+            messages=self.messages
+        )
+        answer = response.choices[0].message.content
+        self.messages.append({"role": "assistant", "content": answer})
+
+        # Store the question in memory
+        self.memory.add(question, user_id=user_id)
+        return answer
+
+    def get_memories(self, user_id):
+        memories = self.memory.get_all(user_id=user_id)
+        return [m['text'] for m in memories]
+
+    def search_memories(self, query, user_id):
+        memories = self.memory.search(query, user_id=user_id)
+        return [m['text'] for m in memories]
+
+# Usage example
+user_id = "traveler_123"
+ai_assistant = PersonalTravelAssistant()
+
+def main():
+    while True:
+        question = input("Question: ")
+        if question.lower() in ['q', 'exit']:
+            print("Exiting...")
+            break
+
+        answer = ai_assistant.ask_question(question, user_id=user_id)
+        print(f"Answer: {answer}")
+        memories = ai_assistant.get_memories(user_id=user_id)
+        print("Memories:")
+        for memory in memories:
+            print(f"- {memory}")
+        print("-----")
+
+if __name__ == "__main__":
+    main()
+```
+
+## Key Components
+
+- **Initialization**: The `PersonalTravelAssistant` class is initialized with the OpenAI client and Mem0 memory setup.
+- **Asking Questions**: The `ask_question` method sends a question to the AI, incorporates previous memories, and stores new information.
+- **Memory Management**: The `get_memories` and search_memories methods handle retrieval and searching of stored memories.
+
+## Usage
+
+1. Set your OpenAI API key in the environment variable.
+2. Instantiate the `PersonalTravelAssistant`.
+3. Use the `main()` function to interact with the assistant in a loop.
+
+## Conclusion
+
+This Personalized AI Travel Assistant leverages Mem0's memory capabilities to provide context-aware responses. As you interact with it, the assistant learns and improves, offering increasingly personalized travel advice and information.

docs/favicon.svg

@@ -0,0 +1,49 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61505C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5914 7.95343 21.1394Z" fill="white"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61505C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5914 7.95343 21.1394Z" fill="url(#paint0_radial_101_2703)"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61505C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5914 7.95343 21.1394Z" fill="black" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M7.95343 21.1394C4.89586 21.1304 2.25471 19.458 0.987296 16.2895C-0.280118 13.121 0.108924 9.16314 1.74363 5.61505C4.8012 5.62409 7.44235 7.29648 8.70976 10.465C9.97718 13.6335 9.58814 17.5914 7.95343 21.1394Z" fill="url(#paint1_linear_101_2703)" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M8.68359 10.4755C9.94543 13.63 9.56145 17.5723 7.9354 21.1112C4.89702 21.0957 2.27411 19.4306 1.01347 16.279C-0.248375 13.1245 0.135612 9.18218 1.76165 5.64328C4.80004 5.65883 7.42295 7.32386 8.68359 10.4755Z" stroke="url(#paint2_linear_101_2703)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M7.31038 21.2574C11.3543 20.2215 14.8836 17.3754 16.6285 13.2361C18.3735 9.09671 17.9448 4.58749 15.8598 0.976291C11.8159 2.01214 8.2866 4.85826 6.54167 8.99762C4.79674 13.137 5.2254 17.6462 7.31038 21.2574Z" fill="white"/>
+<path d="M7.31038 21.2574C11.3543 20.2215 14.8836 17.3754 16.6285 13.2361C18.3735 9.09671 17.9448 4.58749 15.8598 0.976291C11.8159 2.01214 8.2866 4.85826 6.54167 8.99762C4.79674 13.137 5.2254 17.6462 7.31038 21.2574Z" fill="url(#paint3_radial_101_2703)"/>
+<path d="M16.6026 13.2251C14.8642 17.349 11.3512 20.1866 7.32411 21.2248C5.25257 17.624 4.82926 13.1324 6.56764 9.00855C8.30603 4.88472 11.819 2.04706 15.8461 1.00889C17.9176 4.60967 18.3409 9.10131 16.6026 13.2251Z" stroke="url(#paint4_linear_101_2703)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="white"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="url(#paint5_radial_101_2703)"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="black" fill-opacity="0.2" style="mix-blend-mode:hard-light"/>
+<path d="M7.23368 21.2069C9.78906 23.2373 13.2102 23.9506 16.5772 22.8141C19.9441 21.6775 22.5058 18.9445 23.7304 15.6382C21.175 13.6078 17.7538 12.8944 14.3869 14.031C11.0199 15.1676 8.45822 17.9006 7.23368 21.2069Z" fill="url(#paint6_linear_101_2703)" fill-opacity="0.5" style="mix-blend-mode:hard-light"/>
+<path d="M16.5682 22.7874C13.2176 23.9184 9.81361 23.2124 7.2672 21.1975C8.49194 17.9068 11.0444 15.189 14.3959 14.0577C17.7465 12.9266 21.1504 13.6326 23.6968 15.6476C22.4721 18.9383 19.9196 21.656 16.5682 22.7874Z" stroke="url(#paint7_linear_101_2703)" stroke-opacity="0.05" stroke-width="0.056338"/>
+<defs>
+<radialGradient id="paint0_radial_101_2703" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(-3.00503 15.023) rotate(-10.029) scale(17.9572 17.784)">
+<stop stop-color="#00B0BB"/>
+<stop offset="1" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint1_linear_101_2703" x1="7.39036" y1="4.81308" x2="1.62975" y2="18.6894" gradientUnits="userSpaceOnUse">
+<stop stop-color="#18E299"/>
+<stop offset="1"/>
+</linearGradient>
+<linearGradient id="paint2_linear_101_2703" x1="7.94816" y1="8.01563" x2="1.7612" y2="18.746" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+<radialGradient id="paint3_radial_101_2703" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(8.11404 20.8822) rotate(-75.7542) scale(21.6246 23.7772)">
+<stop stop-color="#00BBBB"/>
+<stop offset="0.712616" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint4_linear_101_2703" x1="7.60205" y1="5.8709" x2="15.5561" y2="16.3719" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+<radialGradient id="paint5_radial_101_2703" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(7.84537 21.5181) rotate(-20.3525) scale(18.5603 17.32)">
+<stop stop-color="#00B0BB"/>
+<stop offset="1" stop-color="#00DB65"/>
+</radialGradient>
+<linearGradient id="paint6_linear_101_2703" x1="16.8078" y1="13.0071" x2="10.0409" y2="22.9937" gradientUnits="userSpaceOnUse">
+<stop stop-color="#00B1BC"/>
+<stop offset="1"/>
+</linearGradient>
+<linearGradient id="paint7_linear_101_2703" x1="16.8078" y1="13.0071" x2="14.1687" y2="23.841" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+</defs>
+</svg>

docs/integrations/multion.mdx

@@ -0,0 +1,85 @@
+---
+title: MultiOn
+---
+
+Build personal browser agent 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
+
+In this example, we will create a Browser based AI Agent that searches [arxiv.org](https://arxiv.org) for research papers relevant to user's research interests.
+
+## Setup and Configuration
+
+Install necessary libraries:
+
+```bash
+pip install mem0ai multion
+```
+
+First, we'll import the necessary libraries and set up our configurations.
+
+```python
+import os
+from mem0 import Memory
+from multion.client import MultiOn
+
+# Configuration
+OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
+MULTION_API_KEY = 'your-multion-key'  # Replace with your actual MultiOn API key
+USER_ID = "deshraj"
+
+# Set up OpenAI API key
+os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY
+
+# Initialize Mem0 and MultiOn
+memory = Memory()
+multion = MultiOn(api_key=MULTION_API_KEY)
+```
+
+## Add memories to Mem0
+
+Next, we'll define our user data and add it to Mem0.
+
+```python
+# Define user data
+USER_DATA = """
+About me
+- I'm Deshraj Yadav, Co-founder and CTO at Mem0, interested in AI and ML Infrastructure.
+- Previously, I was a Senior Autopilot Engineer at Tesla, leading the AI Platform for Autopilot.
+- I built EvalAI at Georgia Tech, an open-source platform for evaluating ML algorithms.
+- Outside of work, I enjoy playing cricket in two leagues in the San Francisco.
+"""
+
+# Add user data to memory
+memory.add(USER_DATA, user_id=USER_ID)
+print("User data added to memory.")
+```
+
+## Retrieving Relevant Memories
+
+Now, we'll define our search command and retrieve relevant memories from Mem0.
+
+```python
+# Define search command and retrieve relevant memories
+command = "Find papers on arxiv that I should read based on my interests."
+
+relevant_memories = memory.search(command, user_id=USER_ID, limit=3)
+relevant_memories_text = '\n'.join(mem['text'] for mem in relevant_memories)
+print(f"Relevant memories:")
+print(relevant_memories_text)
+```
+
+## Browsing arXiv
+
+Finally, we'll use MultiOn to browse arXiv based on our command and relevant memories.
+
+```python
+# Create prompt and browse arXiv
+prompt = f"{command}\n My past memories: {relevant_memories_text}"
+browse_result = multion.browse(cmd=prompt, url="https://arxiv.org/")
+print(browse_result)
+```
+
+## Conclusion
+
+By integrating Mem0 with MultiOn, you've created a personalized browser agent that remembers user preferences and automates web tasks. For more details and advanced usage, refer to the full [cookbook here](https://github.com/mem0ai/mem0/blob/main/cookbooks/mem0-multion.ipynb).

docs/llms.mdx

@@ -0,0 +1,206 @@
+---
+title: 🤖 Overview
+---
+
+## Overview
+
+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.
+
+<CardGroup cols={4}>
+  <Card title="OpenAI" href="#openai"></Card>
+  <Card title="Groq" href="#groq"></Card>
+  <Card title="Together" href="#together"></Card>
+  <Card title="AWS Bedrock" href="#aws_bedrock"></Card>
+  <Card title="Litellm" href="#litellm"></Card>
+  <Card title="Google AI" href="#google-ai"></Card>
+  <Card title="Anthropic" href="#anthropic"></Card>
+</CardGroup>
+
+## OpenAI
+
+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).
+
+Once you have obtained the key, you can use it like this:
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "openai",
+        "config": {
+            "model": "gpt-4o",
+            "temperature": 0.2,
+            "max_tokens": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## Groq
+
+[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.
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["GROQ_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "groq",
+        "config": {
+            "model": "mixtral-8x7b-32768",
+            "temperature": 0.1,
+            "max_tokens": 1000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## TogetherAI
+
+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).
+
+Once you have obtained the key, you can use it like this:
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["TOGETHER_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "togetherai",
+        "config": {
+            "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "temperature": 0.2,
+            "max_tokens": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## AWS Bedrock
+
+### 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)
+- You will have to export `AWS_REGION`, `AWS_ACCESS_KEY`, and `AWS_SECRET_ACCESS_KEY` to set environment variables.
+
+```python
+import os
+from mem0 import Memory
+
+os.environ['AWS_REGION'] = 'us-east-1'
+os.environ["AWS_ACCESS_KEY"] = "xx"
+os.environ["AWS_SECRET_ACCESS_KEY"] = "xx"
+
+config = {
+    "llm": {
+        "provider": "aws_bedrock",
+        "config": {
+            "model": "arn:aws:bedrock:us-east-1:123456789012:model/your-model-name",
+            "temperature": 0.2,
+            "max_tokens": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## Litellm
+
+[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.
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["OPENAI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "gpt-3.5-turbo",
+            "temperature": 0.2,
+            "max_tokens": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## Google AI
+
+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)
+
+Once you have obtained the key, you can use it like this:
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["GEMINI_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "gemini/gemini-pro",
+            "temperature": 0.2,
+            "max_tokens": 1500,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+
+## Anthropic
+
+To use anthropic's model, please set the `ANTHROPIC_API_KEY` which you find on their [Account Settings Page](https://console.anthropic.com/account/keys).
+
+```python
+import os
+from mem0 import Memory
+
+os.environ["ANTHROPIC_API_KEY"] = "your-api-key"
+
+config = {
+    "llm": {
+        "provider": "litellm",
+        "config": {
+            "model": "claude-3-opus-20240229",
+            "temperature": 0.1,
+            "max_tokens": 2000,
+        }
+    }
+}
+
+m = Memory.from_config(config)
+m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+```
+

docs/mint.json

@@ -0,0 +1,94 @@
+{
+  "$schema": "https://mintlify.com/schema.json",
+  "name": "Mem0.ai",
+  "favicon": "/logo/favicon.png",
+  "colors": {
+    "primary": "#3B2FC9",
+    "light": "#6673FF",
+    "dark": "#3B2FC9",
+    "background": {
+      "dark": "#0f1117",
+      "light": "#fff"
+    }
+  },
+  "logo": {
+    "dark": "/logo/dark.svg",
+    "light": "/logo/light.svg",
+    "href": "https://github.com/embedchain/embedchain"
+  },
+  "tabs": [
+    {
+      "name": "💡 Examples",
+      "url": "examples"
+    },
+    {
+      "name": "🖥️  Platform",
+      "url": "platform"
+    }
+  ],
+  "topbarLinks": [
+    {
+      "name": "Support",
+      "url": "mailto:founders@mem0.ai"
+    }
+  ],
+  "anchors": [
+    {
+      "name": "Slack",
+      "icon": "slack",
+      "url": "https://mem0.ai/slack/"
+    },
+    {
+      "name": "Discord",
+      "icon": "discord",
+      "url": "https://mem0.ai/discord/"
+    },
+    {
+      "name": "Talk to founders",
+      "icon": "calendar",
+      "url": "https://cal.com/taranjeetio/meet"
+    }
+  ],
+  "navigation": [
+    {
+      "group": "Get Started",
+      "pages": [
+        "overview",
+        "quickstart"
+      ]
+    },
+    {
+      "group": "LLMs",
+      "pages": [
+        "llms"
+      ]
+    },
+    {
+      "group": "Integrations",
+      "pages": [
+        "integrations/multion"
+      ]
+    },
+    {
+      "group": "💡 Examples",
+      "pages": [
+        "examples/overview",
+        "examples/personal-ai-tutor",
+        "examples/customer-support-agent",
+        "examples/personal-travel-assistant"
+      ]
+    },
+    {
+      "group": "🖥️  Platform",
+      "pages": [
+        "platform/overview",
+        "platform/quickstart"
+      ]
+    }
+  ],
+  "footerSocials": {
+    "x": "https://x.com/mem0ai",
+    "github": "https://github.com/embedchain/embedchain/mem0",
+    "linkedin": "https://www.linkedin.com/company/mem0/"
+  }
+}

docs/overview.mdx

@@ -0,0 +1,59 @@
+---
+title: 📚 Overview
+description: 'Welcome to the Mem0 docs!'
+---
+
+> Mem0 provides a smart, self-improving memory layer for Large Language Models, enabling personalized AI experiences across applications.
+
+## Core features
+
+- **User, Session, and AI Agent Memory**: Retains information across user sessions, interactions, and AI agents, ensuring continuity and context.
+- **Adaptive Personalization**: Continuously improves personalization based on user interactions and feedback.
+- **Developer-Friendly API**: Offers a straightforward API for seamless integration into various applications.
+- **Platform Consistency**: Ensures consistent behavior and data across different platforms and devices.
+- **Managed Service**: Provides a hosted solution for easy deployment and maintenance.
+
+If you are looking to quick start, jump to one of the following links:
+
+<CardGroup cols={2}>
+  <Card title="Quickstart" icon="square-1" href="/quickstart/">
+    Jump to quickstart section to get started
+  </Card>
+  <Card title="Examples" icon="square-2" href="/examples/overview/">
+    Checkout curated examples
+  </Card>
+</CardGroup>
+
+## Common Use Cases
+
+- **Personalized Learning Assistants**: Long-term memory allows learning assistants to remember user preferences, past interactions, and progress, providing a more tailored and effective learning experience.
+
+- **Customer Support AI Agents**: By retaining information from previous interactions, customer support bots can offer more accurate and context-aware assistance, improving customer satisfaction and reducing resolution times.
+
+- **Healthcare Assistants**: Long-term memory enables healthcare assistants to keep track of patient history, medication schedules, and treatment plans, ensuring personalized and consistent care.
+
+- **Virtual Companions**: Virtual companions can use long-term memory to build deeper relationships with users by remembering personal details, preferences, and past conversations, making interactions more meaningful.
+
+- **Productivity Tools**: Long-term memory helps productivity tools remember user habits, frequently used documents, and task history, streamlining workflows and enhancing efficiency.
+
+- **Gaming AI**: In gaming, AI with long-term memory can create more immersive experiences by remembering player choices, strategies, and progress, adapting the game environment accordingly.
+
+## How is Mem0 different from RAG?
+
+Mem0's memory implementation for Large Language Models (LLMs) offers several advantages over Retrieval-Augmented Generation (RAG):
+
+- **Entity Relationships**: Mem0 can understand and relate entities across different interactions, unlike RAG which retrieves information from static documents. This leads to a deeper understanding of context and relationships.
+
+- **Recency, Relevancy, and Decay**: Mem0 prioritizes recent interactions and gradually forgets outdated information, ensuring the memory remains relevant and up-to-date for more accurate responses.
+
+- **Contextual Continuity**: Mem0 retains information across sessions, maintaining continuity in conversations and interactions, which is essential for long-term engagement applications like virtual companions or personalized learning assistants.
+
+- **Adaptive Learning**: Mem0 improves its personalization based on user interactions and feedback, making the memory more accurate and tailored to individual users over time.
+
+- **Dynamic Updates**: Mem0 can dynamically update its memory with new information and interactions, unlike RAG which relies on static data. This allows for real-time adjustments and improvements, enhancing the user experience.
+
+These advanced memory capabilities make Mem0 a powerful tool for developers aiming to create personalized and context-aware AI applications.
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/platform/overview.mdx

@@ -0,0 +1,45 @@
+---
+title: Introduction
+description: 'Empower your AI applications with long-term memory and personalization'
+---
+
+## Welcome to Mem0 Platform
+
+Mem0 Platform is a managed service that revolutionizes the way AI applications handle memory. By providing a smart, self-improving memory layer for Large Language Models (LLMs), we enable developers to create personalized AI experiences that evolve with each user interaction.
+
+## Why Choose Mem0 Platform?
+
+1. **Enhanced User Experience**: Deliver tailored interactions that make your AI applications truly stand out.
+2. **Simplified Development**: Our API-first approach streamlines integration, allowing you to focus on building great features.
+3. **Scalable Solution**: Designed to grow with your application, from prototypes to production-ready systems.
+
+## Key Features
+
+- **Comprehensive Memory Management**: Easily manage long-term, short-term, semantic, and episodic memories for individual users, agents, and sessions through our robust APIs.
+- **Self-Improving Memory**: Our adaptive system continuously learns from user interactions, refining its understanding over time.
+- **Cross-Platform Consistency**: Ensure a unified user experience across various AI platforms and applications.
+- **Centralized Memory Control**: Store, update, and delete memories effortlessly, taking away the hassle of memory management.
+
+## Common Use Cases
+
+- Personalized Learning Assistants
+- Customer Support AI Agents
+- Healthcare Assistants
+- Virtual Companions
+- Productivity Tools
+- Gaming AI
+
+## Getting Started
+Ready to supercharge your AI application with Mem0? Follow these steps:
+
+1. **Sign Up**: Create your Mem0 account at our platform.
+2. **API Key**: Generate your API key in the dashboard.
+3. **Installation**: Install our Python SDK using pip: `pip install mem0ai`
+4. **Quick Implementation**: Check out our [Quickstart Guide](/platform/quickstart) to start using Mem0 quickly.
+
+## Next Steps
+
+- Explore our API Reference for detailed endpoint documentation.
+- Join our [slack](https://mem0.ai/slack) or [discord](https://mem0.ai/discord) with other developers and get support.
+
+We're excited to see what you'll build with Mem0 Platform. Let's create smarter, more personalized AI experiences together!

docs/platform/quickstart.mdx

@@ -0,0 +1,358 @@
+---
+title: Quickstart
+description: 'Get started with Mem0 Platform in minutes'
+---
+
+## 1. Installation
+
+Install the Mem0 Python package:
+
+```bash
+pip install mem0ai
+```
+
+## 2. API Key Setup
+
+1. Sign in to [Mem0 Platform](https://app.mem0.ai/dashboard/api-keys)
+2. Copy your API Key from the dashboard
+
+![Get API Key from Mem0 Platform](/images/platform/api-key.png)
+
+## 3. Instantiate Client
+
+```python
+from mem0 import MemoryClient
+client = MemoryClient(api_key="your-api-key")
+```
+
+## 4. Memory Operations
+
+We provide a simple yet customizable interface for performing CRUD operations on memory. Here is how you can create and get memories:
+
+
+### 4.1 Create Memories
+
+For users (long-term memory):
+
+```python
+# create long-term memory for users
+client.add("Remember my name is Deshraj Yadav.", user_id="deshraj")
+client.add("I like to eat pizza and go out on weekends.", user_id="deshraj")
+client.add("Oh I am actually allergic to cheese to cannot eat pizza anymore.", user_id="deshraj")
+```
+
+Output:
+```python
+{'message': 'Memory added successfully!'}
+```
+
+You can see all the memory operations happening on the platform itself.
+
+![Mem0 Platform Activity](/images/platform/activity.png)
+
+
+You can also add memories for a particular session or for an AI agent that you are building:
+
+- For user sessions (short-term memory):
+
+```python
+client.add("Deshraj is building Gmail AI agent", user_id="deshraj", session_id="session-1")
+```
+
+- For agents (long-term memory):
+
+```python
+client.add("Return short responses when responding to emails", agent_id="gmail-agent")
+```
+
+### 4.2 Retrieve Memories
+
+
+<CodeGroup>
+
+```python Code
+client.get_all(user_id="deshraj")
+```
+
+```python Output
+[
+  {
+    'id': 'dbce6e06-6adf-40b8-9187-3d30bd13b741',
+    'agent': None,
+    'consumer': {
+      'id': 8,
+      'user_id': 'deshraj',
+      'metadata': None,
+      'created_at': '2024-07-17T16:47:23.899900-07:00',
+      'updated_at': '2024-07-17T16:47:23.899918-07:00'
+    },
+    'app': None,
+    'run': None,
+    'hash': '57288ac8a87c4ac8d3ac7f2075d264ca',
+    'input': 'Remember my name is Deshraj Yadav.',
+    'text': 'My name is Deshraj Yadav.',
+    'metadata': None,
+    'created_at': '2024-07-17T16:47:25.670180-07:00',
+    'updated_at': '2024-07-17T16:47:25.670197-07:00'
+  },
+  {
+    'id': 'f6dec5d1-b5db-45f5-a2fb-3979a0f27d30',
+    'agent': None,
+    'consumer': {
+      'id': 8,
+      'user_id': 'deshraj',
+      # ... other consumer fields ...
+    },
+    # ... other fields ...
+    'text': 'I am allergic to cheese so I cannot eat pizza anymore.',
+    # ... remaining fields ...
+  },
+  # ... additional memory entries ...
+]
+```
+</CodeGroup>
+
+Similarly, you can get all memories for an agent:
+
+```python
+agent_memories = client.get_all(agent_id="gmail-agent")
+```
+
+Get specific memory:
+
+<CodeGroup>
+
+```python Code
+memory = client.get(memory_id="dbce6e06-6adf-40b8-9187-3d30bd13b741")
+```
+
+```python Output
+{
+    'id': 'dbce6e06-6adf-40b8-9187-3d30bd13b741',
+    'agent': None,
+    'consumer': {
+      'id': 8,
+      'user_id': 'deshraj',
+      'metadata': None,
+      'created_at': '2024-07-17T16:47:23.899900-07:00',
+      'updated_at': '2024-07-17T16:47:23.899918-07:00'
+    },
+    'app': None,
+    'run': None,
+    'hash': '57288ac8a87c4ac8d3ac7f2075d264ca',
+    'input': 'Remember my name is Deshraj Yadav.',
+    'text': 'My name is Deshraj Yadav.',
+    'metadata': None,
+    'created_at': '2024-07-17T16:47:25.670180-07:00',
+    'updated_at': '2024-07-17T16:47:25.670197-07:00'
+}
+```
+</CodeGroup>
+
+### 4.3 Update Memory
+
+You can also update specific memory by using the following method:
+
+<CodeGroup>
+
+```python Code
+client.update(memory_id, data="Updated name is Deshraj Kumar")
+```
+
+```python Output
+{
+    'id': 'dbce6e06-6adf-40b8-9187-3d30bd13b741',
+    'agent': None,
+    'consumer': {
+      'id': 8,
+      'user_id': 'deshraj',
+      'metadata': None,
+      'created_at': '2024-07-17T16:47:23.899900-07:00',
+      'updated_at': '2024-07-17T16:47:23.899918-07:00'
+    },
+    'app': None,
+    'run': None,
+    'hash': '57288ac8a87c4ac8d3ac7f2075d264ca',
+    'input': 'Updated name is Deshraj Kumar.',
+    'text': 'Name is Deshraj Kumar.',
+    'metadata': None,
+    'created_at': '2024-07-17T16:47:25.670180-07:00',
+    'updated_at': '2024-07-17T16:47:25.670197-07:00'
+}
+```
+</CodeGroup>
+
+
+### 4.4 Memory History
+
+Get history of how a memory has changed over time
+
+<CodeGroup>
+
+```python Code
+history = client.history(memory_id)
+```
+
+```python Output
+[
+    {
+        'id': '51193804-2ee6-4f81-b4e7-497e98b70858',
+        'memory': {
+            'id': 'dbce6e06-6adf-40b8-9187-3d30bd13b741',
+            'agent': None,
+            'consumer': {
+                'id': 8,
+                'user_id': 'deshraj',
+                'metadata': None,
+                'created_at': '2024-07-17T16:47:23.899900-07:00',
+                'updated_at': '2024-07-17T16:47:23.899918-07:00'
+            },
+            'app': None,
+            'run': None,
+            'hash': '57288ac8a87c4ac8d3ac7f2075d264ca',
+            'input': 'Remember my name is Deshraj Yadav.',
+            'text': 'My name is Deshraj Yadav.',
+            'metadata': None,
+            'created_at': '2024-07-17T16:47:25.670180-07:00',
+            'updated_at': '2024-07-17T16:47:25.670197-07:00'
+        },
+        'hash': '57288ac8a87c4ac8d3ac7f2075d264ca',
+        'event': 'ADD',
+        'input': 'Remember my name is Deshraj Yadav.',
+        'previous_text': None,
+        'text': 'My name is Deshraj Yadav.',
+        'metadata': None,
+        'created_at': '2024-07-17T16:47:25.686899-07:00',
+        'updated_at': '2024-07-17T16:47:25.670197-07:00',
+        'change_description': 'Memory ADD event'
+    }
+]
+```
+</CodeGroup>
+
+### 4.5 Search for relevant memories
+
+<CodeGroup>
+
+```python Code
+client.search("What does Deshraj like to eat?", user_id="deshraj", limit=3)
+```
+
+```python Output
+[
+  {
+    "id": "dbce6e06-6adf-40b8-9187-3d30bd13b741",
+    "agent": null,
+    "consumer": {
+      "id": 8,
+      "user_id": "deshraj",
+      "metadata": null,
+      "created_at": "...",
+      "updated_at": "..."
+    },
+    "app": null,
+    "run": null,
+    "hash": "57288ac8a87c4ac8d3ac7f2075d264ca",
+    "input": "Remember my name is Deshraj Yadav.",
+    "text": "My name is Deshraj Yadav.",
+    "metadata": null,
+    "created_at": "2024-07-17T16:47:25.670180-07:00",
+    "updated_at": "..."
+  },
+  {
+    "id": "091dbed6-74b4-4e15-b765-81be2abe0d6b",
+    "agent": null,
+    "consumer": {
+      "id": 8,
+      "user_id": "deshraj",
+      "metadata": null,
+      "created_at": "...",
+      "updated_at": "..."
+    },
+    "app": null,
+    "run": null,
+    "hash": "622a5a24d5ac54136414a22ec12f9520",
+    "input": "Oh I am actually allergic to cheese to cannot eat pizza anymore.",
+    "text": "I like to eat pizza and go out on weekends.",
+    "metadata": null,
+    "created_at": "2024-07-17T16:49:24.276695-07:00",
+    "updated_at": "..."
+  },
+  {
+    "id": "5fb8f85d-3383-4bad-9d46-f171272478a4",
+    "agent": null,
+    "consumer": {
+      "id": 8,
+      "user_id": "deshraj",
+      "metadata": null,
+      "created_at": "...",
+      "updated_at": "..."
+    },
+    "app": null,
+    "run": {
+      "id": 1,
+      "run_id": "session-1",
+      "name": "",
+      "metadata": null,
+      "created_at": "...",
+      "updated_at": "..."
+    },
+    "hash": "179ced9649ac2b85350ece4946b1ee9b",
+    "input": "Deshraj is building Gmail AI agent",
+    "text": "Deshraj is building Gmail AI agent",
+    "metadata": null,
+    "created_at": "2024-07-17T16:52:41.278920-07:00",
+    "updated_at": "..."
+  },
+  {
+    "id": "f6dec5d1-b5db-45f5-a2fb-3979a0f27d30",
+    "agent": null,
+    "consumer": {
+      "id": 8,
+      "user_id": "deshraj",
+      "metadata": null,
+      "created_at": "...",
+      "updated_at": "..."
+    },
+    "app": null,
+    "run": null,
+    "hash": "19248f0766044b5973fc0ef1bf3955ef",
+    "input": "Oh I am actually allergic to cheese to cannot eat pizza anymore.",
+    "text": "I am allergic to cheese so I cannot eat pizza anymore.",
+    "metadata": null,
+    "created_at": "2024-07-17T16:49:38.622084-07:00",
+    "updated_at": "..."
+  }
+]
+```
+</CodeGroup>
+
+
+### 4.6 Delete Memory
+
+Delete specific memory:
+
+<CodeGroup>
+
+```python Code
+client.delete(memory_id)
+```
+
+```python Output
+{'message': 'Memory deleted successfully!'}
+```
+</CodeGroup>
+
+
+Delete all memories of a user:
+
+<CodeGroup>
+
+```python Code
+client.delete_all(user_id="alex")
+```
+
+```python Output
+{'message': 'Memories deleted successfully!'}
+```
+</CodeGroup>

docs/quickstart.mdx

@@ -0,0 +1,210 @@
+---
+title: 🚀 Quickstart
+description: 'Get started with Mem0 quickly!'
+---
+
+> Welcome to the Mem0 quickstart guide. This guide will help you get up and running with Mem0 in no time.
+
+## Installation
+
+To install Mem0, you can use pip. Run the following command in your terminal:
+
+```bash
+pip install mem0ai
+```
+
+## Basic Usage
+
+### Initialize Mem0
+
+<Tabs>
+  <Tab title="Basic">
+```python
+from mem0 import Memory
+m = Memory()
+```
+  </Tab>
+  <Tab title="Advanced">
+If you want to run Mem0 in production, initialize using the following method:
+
+Run Qdrant first:
+
+```bash
+docker pull qdrant/qdrant
+
+docker run -p 6333:6333 -p 6334:6334 \
+    -v $(pwd)/qdrant_storage:/qdrant/storage:z \
+    qdrant/qdrant
+```
+
+Then, instantiate memory with qdrant server:
+
+```python
+from mem0 import Memory
+
+config = {
+    "vector_store": {
+        "provider": "qdrant",
+        "config": {
+            "host": "localhost",
+            "port": 6333,
+        }
+    },
+}
+
+m = Memory.from_config(config)
+```
+  </Tab>
+</Tabs>
+
+
+### Store a Memory
+
+```python
+# For a user
+result = m.add("Likes to play cricket on weekends", user_id="alice", metadata={"category": "hobbies"})
+print(result)
+```
+
+Output:
+```python
+[
+  {
+    'id': 'm1',
+    'event': 'add',
+    'data': 'Likes to play cricket on weekends'
+  }
+]
+```
+
+### Retrieve Memories
+
+```python
+# Get all memories
+all_memories = m.get_all()
+print(all_memories)
+```
+
+Output:
+
+```python
+[
+  {
+    'id': 'm1',
+    'text': 'Likes to play cricket on weekends',
+    'metadata': {
+      'data': 'Likes to play cricket on weekends',
+      'category': 'hobbies'
+    }
+  },
+  # ... other memories ...
+]
+```
+
+```python
+# Get a single memory by ID
+specific_memory = m.get("m1")
+print(specific_memory)
+```
+
+Output:
+```python
+{
+  'id': 'm1',
+  'text': 'Likes to play cricket on weekends',
+  'metadata': {
+    'data': 'Likes to play cricket on weekends',
+    'category': 'hobbies'
+  }
+}
+```
+
+### Search Memories
+
+```python
+related_memories = m.search(query="What are Alice's hobbies?", user_id="alice")
+print(related_memories)
+```
+
+Output:
+
+```python
+[
+  {
+    'id': 'm1',
+    'text': 'Likes to play cricket on weekends',
+    'metadata': {
+      'data': 'Likes to play cricket on weekends',
+      'category': 'hobbies'
+    },
+    'score': 0.85  # Similarity score
+  },
+  # ... other related memories ...
+]
+```
+
+### Update a Memory
+
+```python
+result = m.update(memory_id="m1", data="Likes to play tennis on weekends")
+print(result)
+```
+
+Output:
+
+```python
+{
+  'id': 'm1',
+  'event': 'update',
+  'data': 'Likes to play tennis on weekends'
+}
+```
+
+### Memory History
+
+```python
+history = m.history(memory_id="m1")
+print(history)
+```
+Output:
+```python
+[
+  {
+    'id': 'h1',
+    'memory_id': 'm1',
+    'prev_value': None,
+    'new_value': 'Likes to play cricket on weekends',
+    'event': 'add',
+    'timestamp': '2024-07-14 10:00:54.466687',
+    'is_deleted': 0
+  },
+  {
+    'id': 'h2',
+    'memory_id': 'm1',
+    'prev_value': 'Likes to play cricket on weekends',
+    'new_value': 'Likes to play tennis on weekends',
+    'event': 'update',
+    'timestamp': '2024-07-14 10:15:17.230943',
+    'is_deleted': 0
+  }
+]
+```
+
+### Delete Memory
+
+```python
+m.delete(memory_id="m1") # Delete a memory
+
+m.delete_all(user_id="alice") # Delete all memories
+```
+
+### Reset Memory
+
+```python
+m.reset() # Reset all memories
+```
+
+
+If you have any questions, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

docs/snippets/snippet-intro.mdx

@@ -0,0 +1,4 @@
+One of the core principles of software development is DRY (Don't Repeat
+Yourself). This is a principle that apply to documentation as
+well. If you find yourself repeating the same content in multiple places, you
+should consider creating a custom snippet to keep your content in sync.

embedchain/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing to embedchain
+
+Let us make contribution easy, collaborative and fun.
+
+## Submit your Contribution through PR
+
+To make a contribution, follow these steps:
+
+1. Fork and clone this repository
+2. Do the changes on your fork with dedicated feature branch `feature/f1`
+3. If you modified the code (new feature or bug-fix), please add tests for it
+4. Include proper documentation / docstring and examples to run the feature
+5. Check the linting
+6. Ensure that all tests pass
+7. Submit a pull request
+
+For more details about pull requests, please read [GitHub's guides](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
+
+
+### 📦 Package manager
+
+We use `poetry` as our package manager. You can install poetry by following the instructions [here](https://python-poetry.org/docs/#installation).
+
+Please DO NOT use pip or conda to install the dependencies. Instead, use poetry:
+
+```bash
+poetry install --all-extras
+or
+poetry install --with dev
+
+#activate
+
+poetry shell
+```
+
+### 📌 Pre-commit
+
+To ensure our standards, make sure to install pre-commit before starting to contribute.
+
+```bash
+pre-commit install
+```
+
+### 🧹 Linting
+
+We use `ruff` to lint our code. You can run the linter by running the following command:
+
+```bash
+make lint
+```
+
+Make sure that the linter does not report any errors or warnings before submitting a pull request.
+
+### Code Formatting with `black`
+
+We use `black` to reformat the code by running the following command:
+
+```bash
+make format
+```
+
+### 🧪 Testing
+
+We use `pytest` to test our code. You can run the tests by running the following command:
+
+```bash
+poetry run pytest
+```
+
+
+Several packages have been removed from Poetry to make the package lighter. Therefore, it is recommended to run `make install_all` to install the remaining packages and ensure all tests pass.
+
+
+Make sure that all tests pass before submitting a pull request.
+
+## 🚀 Release Process
+
+At the moment, the release process is manual. We try to make frequent releases. Usually, we release a new version when we have a new feature or bugfix. A developer with admin rights to the repository will create a new release on GitHub, and then publish the new version to PyPI.

embedchain/Makefile

@@ -0,0 +1,56 @@
+# Variables
+PYTHON := python3
+PIP := $(PYTHON) -m pip
+PROJECT_NAME := embedchain
+
+# Targets
+.PHONY: install format lint clean test ci_lint ci_test coverage
+
+install:
+	poetry install
+
+# TODO: use a more efficient way to install these packages
+install_all:
+	poetry install --all-extras
+	poetry run pip install pinecone-text pinecone-client langchain-anthropic "unstructured[local-inference, all-docs]" ollama langchain_together==0.1.3 \
+		langchain_cohere==0.1.5 deepgram-sdk==3.2.7 langchain-huggingface psutil clarifai==10.0.1 flask==2.3.3 twilio==8.5.0 fastapi-poe==0.0.16 discord==2.3.2 \
+	 	slack-sdk==3.21.3 huggingface_hub==0.23.0 gitpython==3.1.38 yt_dlp==2023.11.14 PyGithub==1.59.1 feedparser==6.0.10 newspaper3k==0.2.8 listparser==0.19 \
+	 	modal==0.56.4329 dropbox==11.36.2 boto3==1.34.20 youtube-transcript-api==0.6.1 pytube==15.0.0 beautifulsoup4==4.12.3
+
+install_es:
+	poetry install --extras elasticsearch
+
+install_opensearch:
+	poetry install --extras opensearch
+
+install_milvus:
+	poetry install --extras milvus
+
+shell:
+	poetry shell
+
+py_shell:
+	poetry run python
+
+format:
+	$(PYTHON) -m black .
+	$(PYTHON) -m isort .
+
+clean:
+	rm -rf dist build *.egg-info
+
+lint:
+	poetry run ruff .
+
+build:
+	poetry build
+
+publish:
+	poetry publish
+
+# for example: make test file=tests/test_factory.py
+test:
+	poetry run pytest $(file)
+
+coverage:
+	poetry run pytest --cov=$(PROJECT_NAME) --cov-report=xml

embedchain/README.md

@@ -0,0 +1,125 @@
+<p align="center">
+  <img src="docs/logo/dark.svg" width="400px" alt="Embedchain Logo">
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/embedchain/">
+    <img src="https://img.shields.io/pypi/v/embedchain" alt="PyPI">
+  </a>
+  <a href="https://pepy.tech/project/embedchain">
+    <img src="https://static.pepy.tech/badge/embedchain" alt="Downloads">
+  </a>
+  <a href="https://embedchain.ai/slack">
+    <img src="https://img.shields.io/badge/slack-embedchain-brightgreen.svg?logo=slack" alt="Slack">
+  </a>
+  <a href="https://embedchain.ai/discord">
+    <img src="https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat" alt="Discord">
+  </a>
+  <a href="https://twitter.com/embedchain">
+    <img src="https://img.shields.io/twitter/follow/embedchain" alt="Twitter">
+  </a>
+  <a href="https://colab.research.google.com/drive/138lMWhENGeEu7Q1-6lNbNTHGLZXBBz_B?usp=sharing">
+    <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open in Colab">
+  </a>
+  <a href="https://codecov.io/gh/embedchain/embedchain">
+    <img src="https://codecov.io/gh/embedchain/embedchain/graph/badge.svg?token=EMRRHZXW1Q" alt="codecov">
+  </a>
+</p>
+
+<hr />
+
+## What is Embedchain?
+
+Embedchain is an Open Source Framework for personalizing LLM responses. It makes it easy to create and deploy personalized AI apps. At its core, Embedchain follows the design principle of being *"Conventional but Configurable"* to serve both software engineers and machine learning engineers.
+
+Embedchain streamlines the creation of personalized LLM applications, offering a seamless process for managing various types of unstructured data. It efficiently segments data into manageable chunks, generates relevant embeddings, and stores them in a vector database for optimized retrieval. With a suite of diverse APIs, it enables users to extract contextual information, find precise answers, or engage in interactive chat conversations, all tailored to their own data.
+
+## 🔧 Quick install
+
+### Python API
+
+```bash
+pip install embedchain
+```
+
+## ✨ Live demo
+
+Checkout the [Chat with PDF](https://embedchain.ai/demo/chat-pdf) live demo we created using Embedchain. You can find the source code [here](https://github.com/embedchain/embedchain/tree/main/examples/chat-pdf).
+
+## 🔍 Usage
+
+<!-- Demo GIF or Image -->
+<p align="center">
+  <img src="docs/images/cover.gif" width="900px" alt="Embedchain Demo">
+</p>
+
+For example, you can create an Elon Musk bot using the following code:
+
+```python
+import os
+from embedchain import App
+
+# Create a bot instance
+os.environ["OPENAI_API_KEY"] = "<YOUR_API_KEY>"
+app = App()
+
+# Embed online resources
+app.add("https://en.wikipedia.org/wiki/Elon_Musk")
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# Query the app
+app.query("How many companies does Elon Musk run and name those?")
+# Answer: Elon Musk currently runs several companies. As of my knowledge, he is the CEO and lead designer of SpaceX, the CEO and product architect of Tesla, Inc., the CEO and founder of Neuralink, and the CEO and founder of The Boring Company. However, please note that this information may change over time, so it's always good to verify the latest updates.
+```
+
+You can also try it in your browser with Google Colab:
+
+[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/17ON1LPonnXAtLaZEebnOktstB_1cJJmh?usp=sharing)
+
+## 📖 Documentation
+Comprehensive guides and API documentation are available to help you get the most out of Embedchain:
+
+- [Introduction](https://docs.embedchain.ai/get-started/introduction#what-is-embedchain)
+- [Getting Started](https://docs.embedchain.ai/get-started/quickstart)
+- [Examples](https://docs.embedchain.ai/examples)
+- [Supported data types](https://docs.embedchain.ai/components/data-sources/overview)
+
+## 🔗 Join the Community
+
+* Connect with fellow developers by joining our [Slack Community](https://embedchain.ai/slack) or [Discord Community](https://embedchain.ai/discord).
+
+* Dive into [GitHub Discussions](https://github.com/embedchain/embedchain/discussions), ask questions, or share your experiences.
+
+## 🤝 Schedule a 1-on-1 Session
+
+Book a [1-on-1 Session](https://cal.com/taranjeetio/ec) with the founders, to discuss any issues, provide feedback, or explore how we can improve Embedchain for you.
+
+## 🌐 Contributing
+
+Contributions are welcome! Please check out the issues on the repository, and feel free to open a pull request.
+For more information, please see the [contributing guidelines](CONTRIBUTING.md).
+
+For more reference, please go through [Development Guide](https://docs.embedchain.ai/contribution/dev) and [Documentation Guide](https://docs.embedchain.ai/contribution/docs).
+
+<a href="https://github.com/embedchain/embedchain/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=embedchain/embedchain" />
+</a>
+
+## Anonymous Telemetry
+
+We collect anonymous usage metrics to enhance our package's quality and user experience. This includes data like feature usage frequency and system info, but never personal details. The data helps us prioritize improvements and ensure compatibility. If you wish to opt-out, set the environment variable `EC_TELEMETRY=false`. We prioritize data security and don't share this data externally.
+
+## Citation
+
+If you utilize this repository, please consider citing it with:
+
+```
+@misc{embedchain,
+  author = {Taranjeet Singh, Deshraj Yadav},
+  title = {Embedchain: The Open Source RAG Framework},
+  year = {2023},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/embedchain/embedchain}},
+}
+```

embedchain/__init__.py

@@ -1 +0,0 @@
-from .embedchain import App, OpenSourceApp, PersonApp, PersonOpenSourceApp

embedchain/chunkers/base_chunker.py

@@ -1,41 +0,0 @@
-import hashlib
-
-
-class BaseChunker:
-    def __init__(self, text_splitter):
-        """Initialize the chunker."""
-        self.text_splitter = text_splitter
-
-    def create_chunks(self, loader, src):
-        """
-        Loads data and chunks it.
-
-        :param loader: The loader which's `load_data` method is used to create
-        the raw data.
-        :param src: The data to be handled by the loader. Can be a URL for
-        remote sources or local content for local loaders.
-        """
-        documents = []
-        ids = []
-        idMap = {}
-        datas = loader.load_data(src)
-        metadatas = []
-        for data in datas:
-            content = data["content"]
-            meta_data = data["meta_data"]
-            url = meta_data["url"]
-
-            chunks = self.text_splitter.split_text(content)
-
-            for chunk in chunks:
-                chunk_id = hashlib.sha256((chunk + url).encode()).hexdigest()
-                if idMap.get(chunk_id) is None:
-                    idMap[chunk_id] = True
-                    ids.append(chunk_id)
-                    documents.append(chunk)
-                    metadatas.append(meta_data)
-        return {
-            "documents": documents,
-            "ids": ids,
-            "metadatas": metadatas,
-        }

embedchain/chunkers/docx_file.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-
-TEXT_SPLITTER_CHUNK_PARAMS = {
-    "chunk_size": 1000,
-    "chunk_overlap": 0,
-    "length_function": len,
-}
-
-
-class DocxFileChunker(BaseChunker):
-    """Chunker for .docx file."""
-
-    def __init__(self, config: Optional[ChunkerConfig] = None):
-        if config is None:
-            config = TEXT_SPLITTER_CHUNK_PARAMS
-        text_splitter = RecursiveCharacterTextSplitter(**config)
-        super().__init__(text_splitter)

embedchain/chunkers/pdf_file.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-
-TEXT_SPLITTER_CHUNK_PARAMS = {
-    "chunk_size": 1000,
-    "chunk_overlap": 0,
-    "length_function": len,
-}
-
-
-class PdfFileChunker(BaseChunker):
-    """Chunker for PDF file."""
-
-    def __init__(self, config: Optional[ChunkerConfig] = None):
-        if config is None:
-            config = TEXT_SPLITTER_CHUNK_PARAMS
-        text_splitter = RecursiveCharacterTextSplitter(**config)
-        super().__init__(text_splitter)

embedchain/chunkers/qna_pair.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-
-TEXT_SPLITTER_CHUNK_PARAMS = {
-    "chunk_size": 300,
-    "chunk_overlap": 0,
-    "length_function": len,
-}
-
-
-class QnaPairChunker(BaseChunker):
-    """Chunker for QnA pair."""
-
-    def __init__(self, config: Optional[ChunkerConfig] = None):
-        if config is None:
-            config = TEXT_SPLITTER_CHUNK_PARAMS
-        text_splitter = RecursiveCharacterTextSplitter(**config)
-        super().__init__(text_splitter)

embedchain/chunkers/text.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-
-TEXT_SPLITTER_CHUNK_PARAMS = {
-    "chunk_size": 300,
-    "chunk_overlap": 0,
-    "length_function": len,
-}
-
-
-class TextChunker(BaseChunker):
-    """Chunker for text."""
-
-    def __init__(self, config: Optional[ChunkerConfig] = None):
-        if config is None:
-            config = TEXT_SPLITTER_CHUNK_PARAMS
-        text_splitter = RecursiveCharacterTextSplitter(**config)
-        super().__init__(text_splitter)

embedchain/chunkers/web_page.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-
-TEXT_SPLITTER_CHUNK_PARAMS = {
-    "chunk_size": 500,
-    "chunk_overlap": 0,
-    "length_function": len,
-}
-
-
-class WebPageChunker(BaseChunker):
-    """Chunker for web page."""
-
-    def __init__(self, config: Optional[ChunkerConfig] = None):
-        if config is None:
-            config = TEXT_SPLITTER_CHUNK_PARAMS
-        text_splitter = RecursiveCharacterTextSplitter(**config)
-        super().__init__(text_splitter)

embedchain/chunkers/youtube_video.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-
-from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-
-TEXT_SPLITTER_CHUNK_PARAMS = {
-    "chunk_size": 2000,
-    "chunk_overlap": 0,
-    "length_function": len,
-}
-
-
-class YoutubeVideoChunker(BaseChunker):
-    """Chunker for Youtube video."""
-
-    def __init__(self, config: Optional[ChunkerConfig] = None):
-        if config is None:
-            config = TEXT_SPLITTER_CHUNK_PARAMS
-        text_splitter = RecursiveCharacterTextSplitter(**config)
-        super().__init__(text_splitter)

embedchain/config/AddConfig.py

@@ -1,42 +0,0 @@
-from typing import Callable, Optional
-
-from embedchain.config.BaseConfig import BaseConfig
-
-
-class ChunkerConfig(BaseConfig):
-    """
-    Config for the chunker used in `add` method
-    """
-
-    def __init__(
-        self,
-        chunk_size: Optional[int] = 4000,
-        chunk_overlap: Optional[int] = 200,
-        length_function: Optional[Callable[[str], int]] = len,
-    ):
-        self.chunk_size = chunk_size
-        self.chunk_overlap = chunk_overlap
-        self.length_function = length_function
-
-
-class LoaderConfig(BaseConfig):
-    """
-    Config for the chunker used in `add` method
-    """
-
-    def __init__(self):
-        pass
-
-
-class AddConfig(BaseConfig):
-    """
-    Config for the `add` method.
-    """
-
-    def __init__(
-        self,
-        chunker: Optional[ChunkerConfig] = None,
-        loader: Optional[LoaderConfig] = None,
-    ):
-        self.loader = loader
-        self.chunker = chunker

embedchain/config/BaseConfig.py

@@ -1,10 +0,0 @@
-class BaseConfig:
-    """
-    Base config.
-    """
-
-    def __init__(self):
-        pass
-
-    def as_dict(self):
-        return vars(self)

embedchain/config/ChatConfig.py

@@ -1,80 +0,0 @@
-from string import Template
-
-from embedchain.config.QueryConfig import QueryConfig
-
-DEFAULT_PROMPT = """
-  You are a chatbot having a conversation with a human. You are given chat
-  history and context.
-  You need to answer the query considering context, chat history and your knowledge base. If you don't know the answer or the answer is neither contained in the context nor in history, then simply say "I don't know".
-
-  $context
-
-  History: $history
-
-  Query: $query
-
-  Helpful Answer:
-"""  # noqa:E501
-
-DEFAULT_PROMPT_TEMPLATE = Template(DEFAULT_PROMPT)
-
-
-class ChatConfig(QueryConfig):
-    """
-    Config for the `chat` method, inherits from `QueryConfig`.
-    """
-
-    def __init__(
-        self,
-        number_documents=None,
-        template: Template = None,
-        model=None,
-        temperature=None,
-        max_tokens=None,
-        top_p=None,
-        stream: bool = False,
-    ):
-        """
-        Initializes the ChatConfig instance.
-
-        :param number_documents: Number of documents to pull from the database as
-        context.
-        :param template: Optional. The `Template` instance to use as a template for
-        prompt.
-        :param model: Optional. Controls the OpenAI model used.
-        :param temperature: Optional. Controls the randomness of the model's output.
-        Higher values (closer to 1) make output more random,lower values make it more
-        deterministic.
-        :param max_tokens: Optional. Controls how many tokens are generated.
-        :param top_p: Optional. Controls the diversity of words.Higher values
-        (closer to 1) make word selection more diverse, lower values make words less
-        diverse.
-        :param stream: Optional. Control if response is streamed back to the user
-        :raises ValueError: If the template is not valid as template should contain
-        $context and $query and $history
-        """
-        if template is None:
-            template = DEFAULT_PROMPT_TEMPLATE
-
-        # History is set as 0 to ensure that there is always a history, that way,
-        # there don't have to be two templates. Having two templates would make it
-        # complicated because the history is not user controlled.
-        super().__init__(
-            number_documents=number_documents,
-            template=template,
-            model=model,
-            temperature=temperature,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            history=[0],
-            stream=stream,
-        )
-
-    def set_history(self, history):
-        """
-        Chat history is not user provided and not set at initialization time
-
-        :param history: (string) history to set
-        """
-        self.history = history
-        return

embedchain/config/InitConfig.py

@@ -1,81 +0,0 @@
-import logging
-import os
-
-from chromadb.utils import embedding_functions
-
-from embedchain.config.BaseConfig import BaseConfig
-
-
-class InitConfig(BaseConfig):
-    """
-    Config to initialize an embedchain `App` instance.
-    """
-
-    def __init__(self, log_level=None, ef=None, db=None, host=None, port=None):
-        """
-        :param log_level: Optional. (String) Debug level
-        ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'].
-        :param ef: Optional. Embedding function to use.
-        :param db: Optional. (Vector) database to use for embeddings.
-        :param host: Optional. Hostname for the database server.
-        :param port: Optional. Port for the database server.
-        """
-        self._setup_logging(log_level)
-
-        self.ef = ef
-        self.db = db
-
-        self.host = host
-        self.port = port
-        return
-
-    def _set_embedding_function(self, ef):
-        self.ef = ef
-        return
-
-    def _set_embedding_function_to_default(self):
-        """
-        Sets embedding function to default (`text-embedding-ada-002`).
-
-        :raises ValueError: If the template is not valid as template should contain
-        $context and $query
-        """
-        if (
-            os.getenv("OPENAI_API_KEY") is None
-            and os.getenv("OPENAI_ORGANIZATION") is None
-        ):
-            raise ValueError(
-                "OPENAI_API_KEY or OPENAI_ORGANIZATION environment variables not provided"  # noqa:E501
-            )
-        self.ef = embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"),
-            organization_id=os.getenv("OPENAI_ORGANIZATION"),
-            model_name="text-embedding-ada-002",
-        )
-        return
-
-    def _set_db(self, db):
-        if db:
-            self.db = db
-        return
-
-    def _set_db_to_default(self):
-        """
-        Sets database to default (`ChromaDb`).
-        """
-        from embedchain.vectordb.chroma_db import ChromaDB
-
-        self.db = ChromaDB(ef=self.ef, host=self.host, port=self.port)
-
-    def _setup_logging(self, debug_level):
-        level = logging.WARNING  # Default level
-        if debug_level is not None:
-            level = getattr(logging, debug_level.upper(), None)
-            if not isinstance(level, int):
-                raise ValueError(f"Invalid log level: {debug_level}")
-
-        logging.basicConfig(
-            format="%(asctime)s [%(name)s] [%(levelname)s] %(message)s", level=level
-        )
-        self.logger = logging.getLogger(__name__)
-        return

embedchain/config/QueryConfig.py

@@ -1,128 +0,0 @@
-import re
-from string import Template
-
-from embedchain.config.BaseConfig import BaseConfig
-
-DEFAULT_PROMPT = """
-  Use the following pieces of context to answer the query at the end.
-  If you don't know the answer, just say that you don't know, don't try to make up an answer.
-
-  $context
-
-  Query: $query
-
-  Helpful Answer:
-"""  # noqa:E501
-
-DEFAULT_PROMPT_WITH_HISTORY = """
-  Use the following pieces of context to answer the query at the end.
-  If you don't know the answer, just say that you don't know, don't try to make up an answer.
-  I will provide you with our conversation history. 
-
-  $context
-
-  History: $history
-
-  Query: $query
-
-  Helpful Answer:
-"""  # noqa:E501
-
-DEFAULT_PROMPT_TEMPLATE = Template(DEFAULT_PROMPT)
-DEFAULT_PROMPT_WITH_HISTORY_TEMPLATE = Template(DEFAULT_PROMPT_WITH_HISTORY)
-query_re = re.compile(r"\$\{*query\}*")
-context_re = re.compile(r"\$\{*context\}*")
-history_re = re.compile(r"\$\{*history\}*")
-
-
-class QueryConfig(BaseConfig):
-    """
-    Config for the `query` method.
-    """
-
-    def __init__(
-        self,
-        number_documents=None,
-        template: Template = None,
-        model=None,
-        temperature=None,
-        max_tokens=None,
-        top_p=None,
-        history=None,
-        stream: bool = False,
-    ):
-        """
-        Initializes the QueryConfig instance.
-
-        :param number_documents: Number of documents to pull from the database as
-        context.
-        :param template: Optional. The `Template` instance to use as a template for
-        prompt.
-        :param model: Optional. Controls the OpenAI model used.
-        :param temperature: Optional. Controls the randomness of the model's output.
-        Higher values (closer to 1) make output more random, lower values make it more
-        deterministic.
-        :param max_tokens: Optional. Controls how many tokens are generated.
-        :param top_p: Optional. Controls the diversity of words. Higher values
-        (closer to 1) make word selection more diverse, lower values make words less
-        diverse.
-        :param history: Optional. A list of strings to consider as history.
-        :param stream: Optional. Control if response is streamed back to user
-        :raises ValueError: If the template is not valid as template should
-        contain $context and $query (and optionally $history).
-        """
-        if number_documents is None:
-            self.number_documents = 1
-        else:
-            self.number_documents = number_documents
-
-        if not history:
-            self.history = None
-        else:
-            if len(history) == 0:
-                self.history = None
-            else:
-                self.history = history
-
-        if template is None:
-            if self.history is None:
-                template = DEFAULT_PROMPT_TEMPLATE
-            else:
-                template = DEFAULT_PROMPT_WITH_HISTORY_TEMPLATE
-
-        self.temperature = temperature if temperature else 0
-        self.max_tokens = max_tokens if max_tokens else 1000
-        self.model = model if model else "gpt-3.5-turbo-0613"
-        self.top_p = top_p if top_p else 1
-
-        if self.validate_template(template):
-            self.template = template
-        else:
-            if self.history is None:
-                raise ValueError("`template` should have `query` and `context` keys")
-            else:
-                raise ValueError(
-                    "`template` should have `query`, `context` and `history` keys"
-                )
-
-        if not isinstance(stream, bool):
-            raise ValueError("`stream` should be bool")
-        self.stream = stream
-
-    def validate_template(self, template: Template):
-        """
-        validate the template
-
-        :param template: the template to validate
-        :return: Boolean, valid (true) or invalid (false)
-        """
-        if self.history is None:
-            return re.search(query_re, template.template) and re.search(
-                context_re, template.template
-            )
-        else:
-            return (
-                re.search(query_re, template.template)
-                and re.search(context_re, template.template)
-                and re.search(history_re, template.template)
-            )

embedchain/config/__init__.py

@@ -1,5 +0,0 @@
-from .AddConfig import AddConfig
-from .BaseConfig import BaseConfig
-from .ChatConfig import ChatConfig
-from .InitConfig import InitConfig
-from .QueryConfig import QueryConfig

embedchain/configs/anthropic.yaml

@@ -0,0 +1,8 @@
+llm:
+  provider: anthropic
+  config:
+    model: 'claude-instant-1'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false

embedchain/configs/azure_openai.yaml

@@ -0,0 +1,19 @@
+app:
+  config:
+    id: azure-openai-app
+
+llm:
+  provider: azure_openai
+  config:
+    model: gpt-35-turbo
+    deployment_name: your_llm_deployment_name
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+
+embedder:
+  provider: azure_openai
+  config:
+    model: text-embedding-ada-002
+    deployment_name: you_embedding_model_deployment_name

embedchain/configs/chroma.yaml

@@ -0,0 +1,24 @@
+app:
+  config:
+    id: 'my-app'
+
+llm:
+  provider: openai
+  config:
+    model: 'gpt-3.5-turbo'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+
+vectordb:
+  provider: chroma
+  config:
+    collection_name: 'my-app'
+    dir: db
+    allow_reset: true
+
+embedder:
+  provider: openai
+  config:
+    model: 'text-embedding-ada-002'

embedchain/configs/chunker.yaml

@@ -0,0 +1,4 @@
+chunker:
+  chunk_size: 100
+  chunk_overlap: 20
+  length_function: 'len'

embedchain/configs/clarifai.yaml

@@ -0,0 +1,12 @@
+llm:
+  provider: clarifai
+  config: 
+    model: "https://clarifai.com/mistralai/completion/models/mistral-7B-Instruct"
+    model_kwargs: 
+      temperature: 0.5
+      max_tokens: 1000
+
+embedder:
+  provider: clarifai
+  config: 
+    model: "https://clarifai.com/clarifai/main/models/BAAI-bge-base-en-v15"

embedchain/configs/cohere.yaml

@@ -0,0 +1,7 @@
+llm:
+  provider: cohere
+  config:
+    model: large
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1

embedchain/configs/full-stack.yaml

@@ -0,0 +1,40 @@
+app:
+  config:
+    id: 'full-stack-app'
+
+chunker:
+  chunk_size: 100
+  chunk_overlap: 20
+  length_function: 'len'
+
+llm:
+  provider: openai
+  config:
+    model: 'gpt-3.5-turbo'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+    prompt: |
+      Use the following pieces of context to answer the query at the end.
+      If you don't know the answer, just say that you don't know, don't try to make up an answer.
+
+      $context
+
+      Query: $query
+
+      Helpful Answer:
+    system_prompt: |
+      Act as William Shakespeare. Answer the following questions in the style of William Shakespeare.
+
+vectordb:
+  provider: chroma
+  config:
+    collection_name: 'my-collection-name'
+    dir: db
+    allow_reset: true
+
+embedder:
+  provider: openai
+  config:
+    model: 'text-embedding-ada-002'

embedchain/configs/google.yaml

@@ -0,0 +1,13 @@
+llm:
+  provider: google
+  config:
+    model: gemini-pro
+    max_tokens: 1000
+    temperature: 0.9
+    top_p: 1.0
+    stream: false
+
+embedder:
+  provider: google
+  config:
+    model: models/embedding-001

embedchain/configs/gpt4.yaml

@@ -0,0 +1,8 @@
+llm:
+  provider: openai
+  config:
+    model: 'gpt-4'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false

embedchain/configs/gpt4all.yaml

@@ -0,0 +1,11 @@
+llm:
+  provider: gpt4all
+  config:
+    model: 'orca-mini-3b-gguf2-q4_0.gguf'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+
+embedder:
+  provider: gpt4all

embedchain/configs/huggingface.yaml

@@ -0,0 +1,8 @@
+llm:
+  provider: huggingface
+  config:
+    model: 'google/flan-t5-xxl'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 0.5
+    stream: false

embedchain/configs/jina.yaml

@@ -0,0 +1,7 @@
+llm:
+  provider: jina
+  config:
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false

embedchain/configs/llama2.yaml

@@ -0,0 +1,8 @@
+llm:
+  provider: llama2
+  config:
+    model: 'a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 0.5
+    stream: false

embedchain/configs/ollama.yaml

@@ -0,0 +1,14 @@
+llm:
+  provider: ollama
+  config:
+    model: 'llama2'
+    temperature: 0.5
+    top_p: 1
+    stream: true
+    base_url: http://localhost:11434
+
+embedder:
+  provider: ollama
+  config:
+    model: 'mxbai-embed-large:latest'
+    base_url: http://localhost:11434

embedchain/configs/opensearch.yaml

@@ -0,0 +1,33 @@
+app:
+  config:
+    id: 'my-app'
+    log_level: 'WARNING'
+    collect_metrics: true
+    collection_name: 'my-app'
+
+llm:
+  provider: openai
+  config:
+    model: 'gpt-3.5-turbo'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+
+vectordb:
+  provider: opensearch
+  config:
+    opensearch_url: 'https://localhost:9200'
+    http_auth:
+      - admin
+      - admin
+    vector_dimension: 1536
+    collection_name: 'my-app'
+    use_ssl: false
+    verify_certs: false
+
+embedder:
+  provider: openai
+  config:
+    model: 'text-embedding-ada-002'
+    deployment_name: 'my-app'

embedchain/configs/opensource.yaml

@@ -0,0 +1,25 @@
+app:
+  config:
+    id: 'open-source-app'
+    collect_metrics: false
+
+llm:
+  provider: gpt4all
+  config:
+    model: 'orca-mini-3b-gguf2-q4_0.gguf'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+
+vectordb:
+  provider: chroma
+  config:
+    collection_name: 'open-source-app'
+    dir: db
+    allow_reset: true
+
+embedder:
+  provider: gpt4all
+  config:
+    deployment_name: 'test-deployment'

embedchain/configs/pinecone.yaml

@@ -0,0 +1,6 @@
+vectordb:
+  provider: pinecone
+  config:
+    metric: cosine
+    vector_dimension: 1536
+    collection_name: my-pinecone-index

embedchain/configs/pipeline.yaml

@@ -0,0 +1,26 @@
+pipeline:
+  config:
+    name: Example pipeline
+    id: pipeline-1  # Make sure that id is different every time you create a new pipeline
+
+vectordb:
+  provider: chroma
+  config:
+    collection_name: pipeline-1
+    dir: db
+    allow_reset: true
+
+llm:
+  provider: gpt4all
+  config:
+    model: 'orca-mini-3b-gguf2-q4_0.gguf'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+
+embedding_model:
+  provider: gpt4all
+  config:
+    model: 'all-MiniLM-L6-v2'
+    deployment_name: null

embedchain/configs/together.yaml

@@ -0,0 +1,6 @@
+llm:
+  provider: together
+  config:
+    model: mistralai/Mixtral-8x7B-Instruct-v0.1
+    temperature: 0.5
+    max_tokens: 1000

embedchain/configs/vertexai.yaml

@@ -0,0 +1,6 @@
+llm:
+  provider: vertexai
+  config:
+    model: 'chat-bison'
+    temperature: 0.5
+    top_p: 0.5

embedchain/configs/vllm.yaml

@@ -0,0 +1,14 @@
+llm:
+  provider: vllm
+  config:
+    model: 'meta-llama/Llama-2-70b-hf'
+    temperature: 0.5
+    top_p: 1
+    top_k: 10
+    stream: true
+    trust_remote_code: true
+
+embedder:
+  provider: huggingface
+  config:
+    model: 'BAAI/bge-small-en-v1.5'

embedchain/configs/weaviate.yaml

@@ -0,0 +1,4 @@
+vectordb:
+  provider: weaviate
+  config:
+    collection_name: my_weaviate_index

embedchain/data_formatter/__init__.py

@@ -1 +0,0 @@
-from .data_formatter import DataFormatter

embedchain/data_formatter/data_formatter.py

@@ -1,70 +0,0 @@
-from embedchain.chunkers.docx_file import DocxFileChunker
-from embedchain.chunkers.pdf_file import PdfFileChunker
-from embedchain.chunkers.qna_pair import QnaPairChunker
-from embedchain.chunkers.text import TextChunker
-from embedchain.chunkers.web_page import WebPageChunker
-from embedchain.chunkers.youtube_video import YoutubeVideoChunker
-from embedchain.config import AddConfig
-from embedchain.loaders.docx_file import DocxFileLoader
-from embedchain.loaders.local_qna_pair import LocalQnaPairLoader
-from embedchain.loaders.local_text import LocalTextLoader
-from embedchain.loaders.pdf_file import PdfFileLoader
-from embedchain.loaders.sitemap import SitemapLoader
-from embedchain.loaders.web_page import WebPageLoader
-from embedchain.loaders.youtube_video import YoutubeVideoLoader
-
-
-class DataFormatter:
-    """
-    DataFormatter is an internal utility class which abstracts the mapping for
-    loaders and chunkers to the data_type entered by the user in their
-    .add or .add_local method call
-    """
-
-    def __init__(self, data_type: str, config: AddConfig):
-        self.loader = self._get_loader(data_type, config.loader)
-        self.chunker = self._get_chunker(data_type, config.chunker)
-
-    def _get_loader(self, data_type, config):
-        """
-        Returns the appropriate data loader for the given data type.
-
-        :param data_type: The type of the data to load.
-        :return: The loader for the given data type.
-        :raises ValueError: If an unsupported data type is provided.
-        """
-        loaders = {
-            "youtube_video": YoutubeVideoLoader(),
-            "pdf_file": PdfFileLoader(),
-            "web_page": WebPageLoader(),
-            "qna_pair": LocalQnaPairLoader(),
-            "text": LocalTextLoader(),
-            "docx": DocxFileLoader(),
-            "sitemap": SitemapLoader(),
-        }
-        if data_type in loaders:
-            return loaders[data_type]
-        else:
-            raise ValueError(f"Unsupported data type: {data_type}")
-
-    def _get_chunker(self, data_type, config):
-        """
-        Returns the appropriate chunker for the given data type.
-
-        :param data_type: The type of the data to chunk.
-        :return: The chunker for the given data type.
-        :raises ValueError: If an unsupported data type is provided.
-        """
-        chunkers = {
-            "youtube_video": YoutubeVideoChunker(config),
-            "pdf_file": PdfFileChunker(config),
-            "web_page": WebPageChunker(config),
-            "qna_pair": QnaPairChunker(config),
-            "text": TextChunker(config),
-            "docx": DocxFileChunker(config),
-            "sitemap": WebPageChunker(config),
-        }
-        if data_type in chunkers:
-            return chunkers[data_type]
-        else:
-            raise ValueError(f"Unsupported data type: {data_type}")

embedchain/docs/Makefile

@@ -0,0 +1,10 @@
+install:
+	npm i -g mintlify
+
+run_local:
+	mintlify dev
+
+troubleshoot:
+	mintlify install
+
+.PHONY: install run_local troubleshoot

embedchain/docs/README.md

@@ -0,0 +1,25 @@
+# Contributing to embedchain docs
+
+
+### 👩‍💻 Development
+
+Install the [Mintlify CLI](https://www.npmjs.com/package/mintlify) to preview the documentation changes locally. To install, use the following command
+
+```
+npm i -g mintlify
+```
+
+Run the following command at the root of your documentation (where mint.json is)
+
+```
+mintlify dev
+```
+
+### 😎 Publishing Changes
+
+Changes will be deployed to production automatically after your PR is merged to the main branch.
+
+#### Troubleshooting
+
+- Mintlify dev isn't running - Run `mintlify install` it'll re-install dependencies.
+- Page loads as a 404 - Make sure you are running in a folder with `mint.json`

embedchain/docs/_snippets/get-help.mdx

@@ -0,0 +1,11 @@
+<CardGroup cols={3}>
+  <Card title="Talk to founders" icon="calendar" href="https://cal.com/taranjeetio/ec">
+  Schedule a call
+  </Card>
+  <Card title="Slack" icon="slack" href="https://embedchain.ai/slack" color="#4A154B">
+    Join our slack community
+  </Card>
+  <Card title="Discord" icon="discord" href="https://discord.gg/6PzXDgEjG5" color="#7289DA">
+    Join our discord community
+  </Card>
+</CardGroup>

embedchain/docs/_snippets/missing-data-source-tip.mdx

@@ -0,0 +1,19 @@
+<p>If you can't find the specific data source, please feel free to request through one of the following channels and help us prioritize.</p>
+
+<CardGroup cols={2}>
+  <Card title="Google Form" icon="file" href="https://forms.gle/NDRCKsRpUHsz2Wcm8" color="#7387d0">
+    Fill out this form
+  </Card>
+  <Card title="Slack" icon="slack" href="https://embedchain.ai/slack" color="#4A154B">
+    Let us know on our slack community
+  </Card>
+  <Card title="Discord" icon="discord" href="https://discord.gg/6PzXDgEjG5" color="#7289DA">
+    Let us know on discord community
+  </Card>
+  <Card title="GitHub" icon="github" href="https://github.com/embedchain/embedchain/issues/new?assignees=&labels=&projects=&template=feature_request.yml" color="#181717">
+  Open an issue on our GitHub
+  </Card>
+  <Card title="Schedule a call" icon="calendar" href="https://cal.com/taranjeetio/ec">
+  Schedule a call with Embedchain founder
+  </Card>
+</CardGroup>

embedchain/docs/_snippets/missing-llm-tip.mdx

@@ -0,0 +1,16 @@
+<p>If you can't find the specific LLM you need, no need to fret. We're continuously expanding our support for additional LLMs, and you can help us prioritize by opening an issue on our GitHub or simply reaching out to us on our Slack or Discord community.</p>
+
+<CardGroup cols={2}>
+  <Card title="Slack" icon="slack" href="https://embedchain.ai/slack" color="#4A154B">
+    Let us know on our slack community
+  </Card>
+  <Card title="Discord" icon="discord" href="https://discord.gg/6PzXDgEjG5" color="#7289DA">
+    Let us know on discord community
+  </Card>
+  <Card title="GitHub" icon="github" href="https://github.com/embedchain/embedchain/issues/new?assignees=&labels=&projects=&template=feature_request.yml" color="#181717">
+  Open an issue on our GitHub
+  </Card>
+  <Card title="Schedule a call" icon="calendar" href="https://cal.com/taranjeetio/ec">
+  Schedule a call with Embedchain founder
+  </Card>
+</CardGroup>

embedchain/docs/_snippets/missing-vector-db-tip.mdx

@@ -0,0 +1,18 @@
+
+
+<p>If you can't find specific feature or run into issues, please feel free to reach out through one of the following channels.</p>
+
+<CardGroup cols={2}>
+  <Card title="Slack" icon="slack" href="https://embedchain.ai/slack" color="#4A154B">
+    Let us know on our slack community
+  </Card>
+  <Card title="Discord" icon="discord" href="https://discord.gg/6PzXDgEjG5" color="#7289DA">
+    Let us know on discord community
+  </Card>
+  <Card title="GitHub" icon="github" href="https://github.com/embedchain/embedchain/issues/new?assignees=&labels=&projects=&template=feature_request.yml" color="#181717">
+  Open an issue on our GitHub
+  </Card>
+  <Card title="Schedule a call" icon="calendar" href="https://cal.com/taranjeetio/ec">
+  Schedule a call with Embedchain founder
+  </Card>
+</CardGroup>

embedchain/docs/api-reference/advanced/configuration.mdx

@@ -0,0 +1,259 @@
+---
+title: 'Custom configurations'
+---
+
+Embedchain offers several configuration options for your LLM, vector database, and embedding model. All of these configuration options are optional and have sane defaults.
+
+You can configure different components of your app (`llm`, `embedding model`, or `vector database`) through a simple yaml configuration that Embedchain offers. Here is a generic full-stack example of the yaml config:
+
+
+<Tip>
+Embedchain applications are configurable using YAML file, JSON file or by directly passing the config dictionary. Checkout the [docs here](/api-reference/app/overview#usage) on how to use other formats.
+</Tip>
+
+<CodeGroup>
+```yaml config.yaml
+app:
+  config:
+    name: 'full-stack-app'
+
+llm:
+  provider: openai
+  config:
+    model: 'gpt-3.5-turbo'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+    api_key: sk-xxx
+    model_kwargs:
+      response_format: 
+        type: json_object
+    api_version: 2024-02-01
+    http_client_proxies: http://testproxy.mem0.net:8000
+    prompt: |
+      Use the following pieces of context to answer the query at the end.
+      If you don't know the answer, just say that you don't know, don't try to make up an answer.
+
+      $context
+
+      Query: $query
+
+      Helpful Answer:
+    system_prompt: |
+      Act as William Shakespeare. Answer the following questions in the style of William Shakespeare.
+
+vectordb:
+  provider: chroma
+  config:
+    collection_name: 'full-stack-app'
+    dir: db
+    allow_reset: true
+
+embedder:
+  provider: openai
+  config:
+    model: 'text-embedding-ada-002'
+    api_key: sk-xxx
+
+chunker:
+  chunk_size: 2000
+  chunk_overlap: 100
+  length_function: 'len'
+  min_chunk_size: 0
+
+cache:
+  similarity_evaluation:
+    strategy: distance
+    max_distance: 1.0
+  config:
+    similarity_threshold: 0.8
+    auto_flush: 50
+```
+
+```json config.json
+{
+  "app": {
+    "config": {
+      "name": "full-stack-app"
+    }
+  },
+  "llm": {
+    "provider": "openai",
+    "config": {
+      "model": "gpt-3.5-turbo",
+      "temperature": 0.5,
+      "max_tokens": 1000,
+      "top_p": 1,
+      "stream": false,
+      "prompt": "Use the following pieces of context to answer the query at the end.\nIf you don't know the answer, just say that you don't know, don't try to make up an answer.\n$context\n\nQuery: $query\n\nHelpful Answer:",
+      "system_prompt": "Act as William Shakespeare. Answer the following questions in the style of William Shakespeare.",
+      "api_key": "sk-xxx",
+      "model_kwargs": {"response_format": {"type": "json_object"}},
+      "api_version": "2024-02-01",
+      "http_client_proxies": "http://testproxy.mem0.net:8000",
+    }
+  },
+  "vectordb": {
+    "provider": "chroma",
+    "config": {
+      "collection_name": "full-stack-app",
+      "dir": "db",
+      "allow_reset": true
+    }
+  },
+  "embedder": {
+    "provider": "openai",
+    "config": {
+      "model": "text-embedding-ada-002",
+      "api_key": "sk-xxx"
+    }
+  },
+  "chunker": {
+    "chunk_size": 2000,
+    "chunk_overlap": 100,
+    "length_function": "len",
+    "min_chunk_size": 0
+  },
+  "cache": {
+    "similarity_evaluation": {
+        "strategy": "distance",
+        "max_distance": 1.0,
+    },
+    "config": {
+        "similarity_threshold": 0.8,
+        "auto_flush": 50,
+    },
+  },
+}
+```
+
+```python config.py
+config = {
+    'app': {
+        'config': {
+            'name': 'full-stack-app'
+        }
+    },
+    'llm': {
+        'provider': 'openai',
+        'config': {
+            'model': 'gpt-3.5-turbo',
+            'temperature': 0.5,
+            'max_tokens': 1000,
+            'top_p': 1,
+            'stream': False,
+            'prompt': (
+                "Use the following pieces of context to answer the query at the end.\n"
+                "If you don't know the answer, just say that you don't know, don't try to make up an answer.\n"
+                "$context\n\nQuery: $query\n\nHelpful Answer:"
+            ),
+            'system_prompt': (
+                "Act as William Shakespeare. Answer the following questions in the style of William Shakespeare."
+            ),
+            'api_key': 'sk-xxx',
+            "model_kwargs": {"response_format": {"type": "json_object"}},
+            "http_client_proxies": "http://testproxy.mem0.net:8000",
+        }
+    },
+    'vectordb': {
+        'provider': 'chroma',
+        'config': {
+            'collection_name': 'full-stack-app',
+            'dir': 'db',
+            'allow_reset': True
+        }
+    },
+    'embedder': {
+        'provider': 'openai',
+        'config': {
+            'model': 'text-embedding-ada-002',
+            'api_key': 'sk-xxx'
+        }
+    },
+    'chunker': {
+        'chunk_size': 2000,
+        'chunk_overlap': 100,
+        'length_function': 'len',
+        'min_chunk_size': 0
+    },
+    'cache': {
+      'similarity_evaluation': {
+          'strategy': 'distance',
+          'max_distance': 1.0,
+      },
+      'config': {
+          'similarity_threshold': 0.8,
+          'auto_flush': 50,
+      },
+    },
+}
+```
+</CodeGroup>
+
+Alright, let's dive into what each key means in the yaml config above:
+
+1. `app` Section:
+    - `config`:
+        - `name` (String): The name of your full-stack application.
+        - `id` (String): The id of your full-stack application.
+        <Note>Only use this to reload already created apps. We recommend users to not create their own ids.</Note>
+        - `collect_metrics` (Boolean): Indicates whether metrics should be collected for the app, defaults to `True`
+        - `log_level` (String): The log level for the app, defaults to `WARNING`
+2. `llm` Section:
+    - `provider` (String): The provider for the language model, which is set to 'openai'. You can find the full list of llm providers in [our docs](/components/llms).
+    - `config`:
+        - `model` (String): The specific model being used, 'gpt-3.5-turbo'.
+        - `temperature` (Float): Controls the randomness of the model's output. A higher value (closer to 1) makes the output more random.
+        - `max_tokens` (Integer): Controls how many tokens are used in the response.
+        - `top_p` (Float): Controls the diversity of word selection. A higher value (closer to 1) makes word selection more diverse.
+        - `stream` (Boolean): Controls if the response is streamed back to the user (set to false).
+        - `online` (Boolean): Controls whether to use internet to get more context for answering query (set to false).
+        - `token_usage` (Boolean): Controls whether to use token usage for the querying models (set to false).
+        - `prompt` (String): A prompt for the model to follow when generating responses, requires `$context` and `$query` variables.
+        - `system_prompt` (String): A system prompt for the model to follow when generating responses, in this case, it's set to the style of William Shakespeare.
+        - `number_documents` (Integer): Number of documents to pull from the vectordb as context, defaults to 1
+        - `api_key` (String): The API key for the language model.
+        - `model_kwargs` (Dict): Keyword arguments to pass to the language model. Used for `aws_bedrock` provider, since it requires different arguments for each model.
+        - `http_client_proxies` (Dict | String): The proxy server settings used to create `self.http_client` using `httpx.Client(proxies=http_client_proxies)`
+        - `http_async_client_proxies` (Dict | String): The proxy server settings for async calls used to create `self.http_async_client` using `httpx.AsyncClient(proxies=http_async_client_proxies)`
+3. `vectordb` Section:
+    - `provider` (String): The provider for the vector database, set to 'chroma'. You can find the full list of vector database providers in [our docs](/components/vector-databases).
+    - `config`:
+        - `collection_name` (String): The initial collection name for the vectordb, set to 'full-stack-app'.
+        - `dir` (String): The directory for the local database, set to 'db'.
+        - `allow_reset` (Boolean): Indicates whether resetting the vectordb is allowed, set to true.
+        - `batch_size` (Integer): The batch size for docs insertion in vectordb, defaults to `100`
+    <Note>We recommend you to checkout vectordb specific config [here](https://docs.embedchain.ai/components/vector-databases)</Note>
+4. `embedder` Section:
+    - `provider` (String): The provider for the embedder, set to 'openai'. You can find the full list of embedding model providers in [our docs](/components/embedding-models).
+    - `config`:
+        - `model` (String): The specific model used for text embedding, 'text-embedding-ada-002'.
+        - `vector_dimension` (Integer): The vector dimension of the embedding model. [Defaults](https://github.com/embedchain/embedchain/blob/main/embedchain/models/vector_dimensions.py)
+        - `api_key` (String): The API key for the embedding model.
+        - `endpoint` (String): The endpoint for the HuggingFace embedding model.
+        - `deployment_name` (String): The deployment name for the embedding model.
+        - `title` (String): The title for the embedding model for Google Embedder.
+        - `task_type` (String): The task type for the embedding model for Google Embedder.
+        - `model_kwargs` (Dict): Used to pass extra arguments to embedders.
+5. `chunker` Section:
+    - `chunk_size` (Integer): The size of each chunk of text that is sent to the language model.
+    - `chunk_overlap` (Integer): The amount of overlap between each chunk of text.
+    - `length_function` (String): The function used to calculate the length of each chunk of text. In this case, it's set to 'len'. You can also use any function import directly as a string here.
+    - `min_chunk_size` (Integer): The minimum size of each chunk of text that is sent to the language model. Must be less than `chunk_size`, and greater than `chunk_overlap`.
+6. `cache` Section: (Optional)
+    - `similarity_evaluation` (Optional): The config for similarity evaluation strategy. If not provided, the default `distance` based similarity evaluation strategy is used.
+      - `strategy` (String): The strategy to use for similarity evaluation. Currently, only `distance` and `exact` based similarity evaluation is supported. Defaults to `distance`.
+      - `max_distance` (Float): The bound of maximum distance. Defaults to `1.0`.
+      - `positive` (Boolean): If the larger distance indicates more similar of two entities, set it `True`, otherwise `False`. Defaults to `False`.
+    - `config` (Optional): The config for initializing the cache. If not provided, sensible default values are used as mentioned below.
+      - `similarity_threshold` (Float): The threshold for similarity evaluation. Defaults to `0.8`.
+      - `auto_flush` (Integer): The number of queries after which the cache is flushed. Defaults to `20`.
+7. `memory` Section: (Optional)
+    - `top_k` (Integer): The number of top-k results to return. Defaults to `10`.
+    <Note>
+    If you provide a cache section, the app will automatically configure and use a cache to store the results of the language model. This is useful if you want to speed up the response time and save inference cost of your app.
+    </Note>
+If you have questions about the configuration above, please feel free to reach out to us using one of the following methods:
+
+<Snippet file="get-help.mdx" />

embedchain/docs/api-reference/app/add.mdx

@@ -0,0 +1,44 @@
+---
+title: '📊 add'
+---
+
+`add()` method is used to load the data sources from different data sources to a RAG pipeline. You can find the signature below:
+
+### Parameters
+
+<ParamField path="source" type="str">
+    The data to embed, can be a URL, local file or raw content, depending on the data type.. You can find the full list of supported data sources [here](/components/data-sources/overview).
+</ParamField>
+<ParamField path="data_type" type="str" optional>
+    Type of data source. It can be automatically detected but user can force what data type to load as.
+</ParamField>
+<ParamField path="metadata" type="dict" optional>
+    Any metadata that you want to store with the data source. Metadata is generally really useful for doing metadata filtering on top of semantic search to yield faster search and better results.
+</ParamField>
+
+## Usage
+
+### Load data from webpage
+
+```python Code example
+from embedchain import App
+
+app = App()
+app.add("https://www.forbes.com/profile/elon-musk")
+# Inserting batches in chromadb: 100%|███████████████| 1/1 [00:00<00:00,  1.19it/s]
+# Successfully saved https://www.forbes.com/profile/elon-musk (DataType.WEB_PAGE). New chunks count: 4
+```
+
+### Load data from sitemap
+
+```python Code example
+from embedchain import App
+
+app = App()
+app.add("https://python.langchain.com/sitemap.xml", data_type="sitemap")
+# Loading pages: 100%|█████████████| 1108/1108 [00:47<00:00, 23.17it/s]
+# Inserting batches in chromadb: 100%|█████████| 111/111 [04:41<00:00,  2.54s/it]
+# Successfully saved https://python.langchain.com/sitemap.xml (DataType.SITEMAP). New chunks count: 11024
+```
+
+You can find complete list of supported data sources [here](/components/data-sources/overview).

embedchain/docs/api-reference/app/chat.mdx

@@ -0,0 +1,175 @@
+---
+title: '💬 chat'
+---
+
+`chat()` method allows you to chat over your data sources using a user-friendly chat API. You can find the signature below:
+
+### Parameters
+
+<ParamField path="input_query" type="str">
+    Question to ask
+</ParamField>
+<ParamField path="config" type="BaseLlmConfig" optional>
+    Configure different llm settings such as prompt, temprature, number_documents etc.
+</ParamField>
+<ParamField path="dry_run" type="bool" optional>
+    The purpose is to test the prompt structure without actually running LLM inference. Defaults to `False`
+</ParamField>
+<ParamField path="where" type="dict" optional>
+    A dictionary of key-value pairs to filter the chunks from the vector database. Defaults to `None`
+</ParamField>
+<ParamField path="session_id" type="str" optional>
+    Session ID of the chat. This can be used to maintain chat history of different user sessions. Default value: `default`
+</ParamField>
+<ParamField path="citations" type="bool" optional>
+    Return citations along with the LLM answer. Defaults to `False`
+</ParamField>
+
+### Returns
+
+<ResponseField name="answer" type="str | tuple">
+  If `citations=False`, return a stringified answer to the question asked. <br />
+  If `citations=True`, returns a tuple with answer and citations respectively.
+</ResponseField>
+
+## Usage
+
+### With citations
+
+If you want to get the answer to question and return both answer and citations, use the following code snippet:
+
+```python With Citations
+from embedchain import App
+
+# Initialize app
+app = App()
+
+# Add data source
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# Get relevant answer for your query
+answer, sources = app.chat("What is the net worth of Elon?", citations=True)
+print(answer)
+# Answer: The net worth of Elon Musk is $221.9 billion.
+
+print(sources)
+# [
+#    (
+#        'Elon Musk PROFILEElon MuskCEO, Tesla$247.1B$2.3B (0.96%)Real Time Net Worthas of 12/7/23 ...',
+#        {
+#           'url': 'https://www.forbes.com/profile/elon-musk', 
+#           'score': 0.89,
+#           ...
+#        }
+#    ),
+#    (
+#        '74% of the company, which is now called X.Wealth HistoryHOVER TO REVEAL NET WORTH BY YEARForbes ...',
+#        {
+#           'url': 'https://www.forbes.com/profile/elon-musk', 
+#           'score': 0.81,
+#           ...
+#        }
+#    ),
+#    (
+#        'founded in 2002, is worth nearly $150 billion after a $750 million tender offer in June 2023 ...',
+#        {
+#           'url': 'https://www.forbes.com/profile/elon-musk', 
+#           'score': 0.73,
+#           ...
+#        }
+#    )
+# ]
+```
+
+<Note>
+When `citations=True`, note that the returned `sources` are a list of tuples where each tuple has two elements (in the following order):
+1. source chunk
+2. dictionary with metadata about the source chunk
+    - `url`: url of the source
+    - `doc_id`: document id (used for book keeping purposes)
+    - `score`: score of the source chunk with respect to the question
+    - other metadata you might have added at the time of adding the source
+</Note>
+
+
+### Without citations
+
+If you just want to return answers and don't want to return citations, you can use the following example:
+
+```python Without Citations
+from embedchain import App
+
+# Initialize app
+app = App()
+
+# Add data source
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# Chat on your data using `.chat()`
+answer = app.chat("What is the net worth of Elon?")
+print(answer)
+# Answer: The net worth of Elon Musk is $221.9 billion.
+```
+
+### With session id
+
+If you want to maintain chat sessions for different users, you can simply pass the `session_id` keyword argument. See the example below:
+
+```python With session id
+from embedchain import App
+
+app = App()
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# Chat on your data using `.chat()`
+app.chat("What is the net worth of Elon Musk?", session_id="user1")
+# 'The net worth of Elon Musk is $250.8 billion.'
+app.chat("What is the net worth of Bill Gates?", session_id="user2")
+# "I don't know the current net worth of Bill Gates."
+app.chat("What was my last question", session_id="user1")
+# 'Your last question was "What is the net worth of Elon Musk?"'
+```
+
+### With custom context window
+
+If you want to customize the context window that you want to use during chat (default context window is 3 document chunks), you can do using the following code snippet:
+
+```python with custom chunks size
+from embedchain import App
+from embedchain.config import BaseLlmConfig
+
+app = App()
+app.add("https://www.forbes.com/profile/elon-musk")
+
+query_config = BaseLlmConfig(number_documents=5)
+app.chat("What is the net worth of Elon Musk?", config=query_config)
+```
+
+### With Mem0 to store chat history
+
+Mem0 is a cutting-edge long-term memory for LLMs to enable personalization for the GenAI stack. It enables LLMs to remember past interactions and provide more personalized responses. 
+
+In order to use Mem0 to enable memory for personalization in your apps:
+- Install the [`mem0`](https://docs.mem0.ai/) package using `pip install mem0ai`. 
+- Prepare config for `memory`, refer [Configurations](docs/api-reference/advanced/configuration.mdx).
+
+```python with mem0
+from embedchain import App
+
+config = {
+  "memory": {
+    "top_k": 5
+  }
+}
+
+app = App.from_config(config=config)
+app.add("https://www.forbes.com/profile/elon-musk")
+
+app.chat("What is the net worth of Elon Musk?")
+```
+
+## How Mem0 works:
+- Mem0 saves context derived from each user question into its memory.
+- When a user poses a new question, Mem0 retrieves relevant previous memories.
+- The `top_k` parameter in the memory configuration specifies the number of top memories to consider during retrieval.
+- Mem0 generates the final response by integrating the user's question, context from the data source, and the relevant memories.

embedchain/docs/api-reference/app/delete.mdx

@@ -0,0 +1,48 @@
+---
+title: 🗑 delete
+---
+
+## Delete Document
+
+`delete()` method allows you to delete a document previously added to the app.
+
+### Usage
+
+```python
+from embedchain import App
+
+app = App()
+
+forbes_doc_id = app.add("https://www.forbes.com/profile/elon-musk")
+wiki_doc_id = app.add("https://en.wikipedia.org/wiki/Elon_Musk")
+
+app.delete(forbes_doc_id)   # deletes the forbes document
+```
+
+<Note>
+    If you do not have the document id, you can use `app.db.get()` method to get the document and extract the `hash` key from `metadatas` dictionary object, which serves as the document id.
+</Note>
+
+
+## Delete Chat Session History
+
+`delete_session_chat_history()` method allows you to delete all previous messages in a chat history.
+
+### Usage
+
+```python
+from embedchain import App
+
+app = App()
+
+app.add("https://www.forbes.com/profile/elon-musk")
+
+app.chat("What is the net worth of Elon Musk?")
+
+app.delete_session_chat_history()
+```
+
+<Note>
+    `delete_session_chat_history(session_id="session_1")` method also accepts `session_id` optional param for deleting chat history of a specific session.
+    It assumes the default session if no `session_id` is provided.
+</Note>

embedchain/docs/api-reference/app/deploy.mdx

@@ -0,0 +1,5 @@
+---
+title: 🚀 deploy
+---
+
+The `deploy()` method is currently available on an invitation-only basis. To request access, please submit your information via the provided [Google Form](https://forms.gle/vigN11h7b4Ywat668). We will review your request and respond promptly.

embedchain/docs/api-reference/app/evaluate.mdx

@@ -0,0 +1,41 @@
+---
+title: '📝 evaluate'
+---
+
+`evaluate()` method is used to evaluate the performance of a RAG app. You can find the signature below:
+
+### Parameters
+
+<ParamField path="question" type="Union[str, list[str]]">
+    A question or a list of questions to evaluate your app on.
+</ParamField>
+<ParamField path="metrics" type="Optional[list[Union[BaseMetric, str]]]" optional>
+    The metrics to evaluate your app on. Defaults to all metrics: `["context_relevancy", "answer_relevancy", "groundedness"]`
+</ParamField>
+<ParamField path="num_workers" type="int" optional>
+    Specify the number of threads to use for parallel processing.
+</ParamField>
+
+### Returns
+
+<ResponseField name="metrics" type="dict">
+    Returns the metrics you have chosen to evaluate your app on as a dictionary.
+</ResponseField>
+
+## Usage
+
+```python
+from embedchain import App
+
+app = App()
+
+# add data source
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# run evaluation
+app.evaluate("what is the net worth of Elon Musk?")
+# {'answer_relevancy': 0.958019958036268, 'context_relevancy': 0.12903225806451613}
+
+# or
+# app.evaluate(["what is the net worth of Elon Musk?", "which companies does Elon Musk own?"])
+```

embedchain/docs/api-reference/app/get.mdx

@@ -0,0 +1,33 @@
+---
+title: 📄 get
+---
+
+## Get data sources
+
+`get_data_sources()` returns a list of all the data sources added in the app.
+
+
+### Usage
+
+```python
+from embedchain import App
+
+app = App()
+
+app.add("https://www.forbes.com/profile/elon-musk")
+app.add("https://en.wikipedia.org/wiki/Elon_Musk")
+
+data_sources = app.get_data_sources()
+# [
+#   {
+#       'data_type': 'web_page',
+#       'data_value': 'https://en.wikipedia.org/wiki/Elon_Musk',
+#       'metadata': 'null'
+#   },
+#   {
+#       'data_type': 'web_page',
+#       'data_value': 'https://www.forbes.com/profile/elon-musk',
+#       'metadata': 'null'
+#   }
+# ]
+```

embedchain/docs/api-reference/app/overview.mdx

@@ -0,0 +1,130 @@
+---
+title: "App"
+---
+
+Create a RAG app object on Embedchain. This is the main entrypoint for a developer to interact with Embedchain APIs. An app configures the llm, vector database, embedding model, and retrieval strategy of your choice.
+
+### Attributes
+
+<ParamField path="local_id" type="str">
+    App ID
+</ParamField>
+<ParamField path="name" type="str" optional>
+    Name of the app
+</ParamField>
+<ParamField path="config" type="BaseConfig">
+    Configuration of the app
+</ParamField>
+<ParamField path="llm" type="BaseLlm">
+    Configured LLM for the RAG app
+</ParamField>
+<ParamField path="db" type="BaseVectorDB">
+    Configured vector database for the RAG app
+</ParamField>
+<ParamField path="embedding_model" type="BaseEmbedder">
+    Configured embedding model for the RAG app
+</ParamField>
+<ParamField path="chunker" type="ChunkerConfig">
+    Chunker configuration
+</ParamField>
+<ParamField path="client" type="Client" optional>
+    Client object (used to deploy an app to Embedchain platform)
+</ParamField>
+<ParamField path="logger" type="logging.Logger">
+    Logger object
+</ParamField>
+
+## Usage
+
+You can create an app instance using the following methods:
+
+### Default setting
+
+```python Code Example
+from embedchain import App
+app = App()
+```
+
+
+### Python Dict
+
+```python Code Example
+from embedchain import App
+
+config_dict = {
+  'llm': {
+    'provider': 'gpt4all',
+    'config': {
+      'model': 'orca-mini-3b-gguf2-q4_0.gguf',
+      'temperature': 0.5,
+      'max_tokens': 1000,
+      'top_p': 1,
+      'stream': False
+    }
+  },
+  'embedder': {
+    'provider': 'gpt4all'
+  }
+}
+
+# load llm configuration from config dict
+app = App.from_config(config=config_dict)
+```
+
+### YAML Config
+
+<CodeGroup>
+
+```python main.py
+from embedchain import App
+
+# load llm configuration from config.yaml file
+app = App.from_config(config_path="config.yaml")
+```
+
+```yaml config.yaml
+llm:
+  provider: gpt4all
+  config:
+    model: 'orca-mini-3b-gguf2-q4_0.gguf'
+    temperature: 0.5
+    max_tokens: 1000
+    top_p: 1
+    stream: false
+
+embedder:
+  provider: gpt4all
+```
+
+</CodeGroup>
+
+### JSON Config
+
+<CodeGroup>
+
+```python main.py
+from embedchain import App
+
+# load llm configuration from config.json file
+app = App.from_config(config_path="config.json")
+```
+
+```json config.json
+{
+  "llm": {
+    "provider": "gpt4all",
+    "config": {
+      "model": "orca-mini-3b-gguf2-q4_0.gguf",
+      "temperature": 0.5,
+      "max_tokens": 1000,
+      "top_p": 1,
+      "stream": false
+    }
+  },
+  "embedder": {
+    "provider": "gpt4all"
+  }
+}
+```
+
+</CodeGroup>

embedchain/docs/api-reference/app/query.mdx

@@ -0,0 +1,109 @@
+---
+title: '❓ query'
+---
+
+`.query()` method empowers developers to ask questions and receive relevant answers through a user-friendly query API. Function signature is given below:
+
+### Parameters
+
+<ParamField path="input_query" type="str">
+    Question to ask
+</ParamField>
+<ParamField path="config" type="BaseLlmConfig" optional>
+    Configure different llm settings such as prompt, temprature, number_documents etc.
+</ParamField>
+<ParamField path="dry_run" type="bool" optional>
+    The purpose is to test the prompt structure without actually running LLM inference. Defaults to `False`
+</ParamField>
+<ParamField path="where" type="dict" optional>
+    A dictionary of key-value pairs to filter the chunks from the vector database. Defaults to `None`
+</ParamField>
+<ParamField path="citations" type="bool" optional>
+    Return citations along with the LLM answer. Defaults to `False`
+</ParamField>
+
+### Returns
+
+<ResponseField name="answer" type="str | tuple">
+  If `citations=False`, return a stringified answer to the question asked. <br />
+  If `citations=True`, returns a tuple with answer and citations respectively.
+</ResponseField>
+
+## Usage
+
+### With citations
+
+If you want to get the answer to question and return both answer and citations, use the following code snippet:
+
+```python With Citations
+from embedchain import App
+
+# Initialize app
+app = App()
+
+# Add data source
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# Get relevant answer for your query
+answer, sources = app.query("What is the net worth of Elon?", citations=True)
+print(answer)
+# Answer: The net worth of Elon Musk is $221.9 billion.
+
+print(sources)
+# [
+#    (
+#        'Elon Musk PROFILEElon MuskCEO, Tesla$247.1B$2.3B (0.96%)Real Time Net Worthas of 12/7/23 ...',
+#        {
+#           'url': 'https://www.forbes.com/profile/elon-musk', 
+#           'score': 0.89,
+#           ...
+#        }
+#    ),
+#    (
+#        '74% of the company, which is now called X.Wealth HistoryHOVER TO REVEAL NET WORTH BY YEARForbes ...',
+#        {
+#           'url': 'https://www.forbes.com/profile/elon-musk', 
+#           'score': 0.81,
+#           ...
+#        }
+#    ),
+#    (
+#        'founded in 2002, is worth nearly $150 billion after a $750 million tender offer in June 2023 ...',
+#        {
+#           'url': 'https://www.forbes.com/profile/elon-musk', 
+#           'score': 0.73,
+#           ...
+#        }
+#    )
+# ]
+```
+
+<Note>
+When `citations=True`, note that the returned `sources` are a list of tuples where each tuple has two elements (in the following order):
+1. source chunk
+2. dictionary with metadata about the source chunk
+    - `url`: url of the source
+    - `doc_id`: document id (used for book keeping purposes)
+    - `score`: score of the source chunk with respect to the question
+    - other metadata you might have added at the time of adding the source
+</Note>
+
+### Without citations
+
+If you just want to return answers and don't want to return citations, you can use the following example:
+
+```python Without Citations
+from embedchain import App
+
+# Initialize app
+app = App()
+
+# Add data source
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# Get relevant answer for your query
+answer = app.query("What is the net worth of Elon?")
+print(answer)
+# Answer: The net worth of Elon Musk is $221.9 billion.
+```
+

embedchain/docs/api-reference/app/reset.mdx

@@ -0,0 +1,17 @@
+---
+title: 🔄 reset
+---
+
+`reset()` method allows you to wipe the data from your RAG application and start from scratch.
+
+## Usage
+
+```python
+from embedchain import App
+
+app = App()
+app.add("https://www.forbes.com/profile/elon-musk")
+
+# Reset the app
+app.reset()
+```

embedchain/docs/api-reference/app/search.mdx

@@ -0,0 +1,111 @@
+---
+title: '🔍 search'
+---
+
+`.search()` enables you to uncover the most pertinent context by performing a semantic search across your data sources based on a given query. Refer to the function signature below:
+
+### Parameters
+
+<ParamField path="query" type="str">
+    Question
+</ParamField>
+<ParamField path="num_documents" type="int" optional>
+    Number of relevant documents to fetch. Defaults to `3`
+</ParamField>
+<ParamField path="where" type="dict" optional>
+    Key value pair for metadata filtering.
+</ParamField>
+<ParamField path="raw_filter" type="dict" optional>
+    Pass raw filter query based on your vector database.
+    Currently, `raw_filter` param is only supported for Pinecone vector database.
+</ParamField>
+
+### Returns
+
+<ResponseField name="answer" type="dict">
+    Return list of dictionaries that contain the relevant chunk and their source information.
+</ResponseField>
+
+## Usage
+
+### Basic
+
+Refer to the following example on how to use the search api:
+
+```python Code example
+from embedchain import App
+
+app = App()
+app.add("https://www.forbes.com/profile/elon-musk")
+
+context = app.search("What is the net worth of Elon?", num_documents=2)
+print(context)
+```
+
+### Advanced
+
+#### Metadata filtering using `where` params
+
+Here is an advanced example of `search()` API with metadata filtering on pinecone database:
+
+```python
+import os
+
+from embedchain import App
+
+os.environ["PINECONE_API_KEY"] = "xxx"
+
+config = {
+    "vectordb": {
+        "provider": "pinecone",
+        "config": {
+            "metric": "dotproduct",
+            "vector_dimension": 1536,
+            "index_name": "ec-test",
+            "serverless_config": {"cloud": "aws", "region": "us-west-2"},
+        },
+    }
+}
+
+app = App.from_config(config=config)
+
+app.add("https://www.forbes.com/profile/bill-gates", metadata={"type": "forbes", "person": "gates"})
+app.add("https://en.wikipedia.org/wiki/Bill_Gates", metadata={"type": "wiki", "person": "gates"})
+
+results = app.search("What is the net worth of Bill Gates?", where={"person": "gates"})
+print("Num of search results: ", len(results))
+```
+
+#### Metadata filtering using `raw_filter` params
+
+Following is an example of metadata filtering by passing the raw filter query that pinecone vector database follows:
+
+```python
+import os
+
+from embedchain import App
+
+os.environ["PINECONE_API_KEY"] = "xxx"
+
+config = {
+    "vectordb": {
+        "provider": "pinecone",
+        "config": {
+            "metric": "dotproduct",
+            "vector_dimension": 1536,
+            "index_name": "ec-test",
+            "serverless_config": {"cloud": "aws", "region": "us-west-2"},
+        },
+    }
+}
+
+app = App.from_config(config=config)
+
+app.add("https://www.forbes.com/profile/bill-gates", metadata={"year": 2022, "person": "gates"})
+app.add("https://en.wikipedia.org/wiki/Bill_Gates", metadata={"year": 2024, "person": "gates"})
+
+print("Filter with person: gates and year > 2023")
+raw_filter = {"$and": [{"person": "gates"}, {"year": {"$gt": 2023}}]}
+results = app.search("What is the net worth of Bill Gates?", raw_filter=raw_filter)
+print("Num of search results: ", len(results))
+```

embedchain/docs/api-reference/store/ai-assistants.mdx

@@ -0,0 +1,54 @@
+---
+title: 'AI Assistant'
+---
+
+The `AIAssistant` class, an alternative to the OpenAI Assistant API, is designed for those who prefer using large language models (LLMs) other than those provided by OpenAI. It facilitates the creation of AI Assistants with several key benefits:
+
+- **Visibility into Citations**: It offers transparent access to the sources and citations used by the AI, enhancing the understanding and trustworthiness of its responses.
+
+- **Debugging Capabilities**: Users have the ability to delve into and debug the AI's processes, allowing for a deeper understanding and fine-tuning of its performance.
+
+- **Customizable Prompts**: The class provides the flexibility to modify and tailor prompts according to specific needs, enabling more precise and relevant interactions.
+
+- **Chain of Thought Integration**: It supports the incorporation of a 'chain of thought' approach, which helps in breaking down complex queries into simpler, sequential steps, thereby improving the clarity and accuracy of responses.
+
+It is ideal for those who value customization, transparency, and detailed control over their AI Assistant's functionalities.
+
+### Arguments
+
+<ParamField path="name" type="string" optional>
+  Name for your AI assistant
+</ParamField>
+
+<ParamField path="instructions" type="string" optional>
+  How the Assistant and model should behave or respond
+</ParamField>
+
+<ParamField path="assistant_id" type="string" optional>
+  Load existing AI Assistant. If you pass this, you don't have to pass other arguments.
+</ParamField>
+
+<ParamField path="thread_id" type="string" optional>
+  Existing thread id if exists
+</ParamField>
+
+<ParamField path="yaml_path" type="str" Optional>
+    Embedchain pipeline config yaml path to use. This will define the configuration of the AI Assistant (such as configuring the LLM, vector database, and embedding model)
+</ParamField>
+
+<ParamField path="data_sources" type="list" default="[]">
+  Add data sources to your assistant. You can add in the following format: `[{"source": "https://example.com", "data_type": "web_page"}]`
+</ParamField>
+
+<ParamField path="collect_metrics" type="boolean" default="True">
+  Anonymous telemetry (doesn't collect any user information or user's files). Used to improve the Embedchain package utilization. Default is `True`.
+</ParamField>
+
+
+## Usage
+
+For detailed guidance on creating your own AI Assistant, click the link below. It provides step-by-step instructions to help you through the process:
+
+<Card title="Guide to Creating Your AI Assistant" icon="link" href="/examples/opensource-assistant">
+  Learn how to build a customized AI Assistant using the `AIAssistant` class.
+</Card>