feat: bump version to 0.0.58 (#617)

Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>

.env.example

@@ -0,0 +1 @@
+OPENAI_API_KEY=

.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/gventuri/pandas-ai/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,40 @@
+name: Publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+
+on:
+  release:
+    types: [published] # This will trigger the workflow when you create a new release
+
+jobs:
+  build-n-publish:
+    name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+    runs-on: ubuntu-latest
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      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: poetry install
+  
+      - name: Build a binary wheel and a source tarball
+        run: poetry build
+
+      - name: Publish distribution 📦 to Test PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository_url: https://test.pypi.org/legacy/
+
+      - name: Publish distribution 📦 to PyPI
+        if: startsWith(github.ref, 'refs/tags')
+        uses: pypa/gh-action-pypi-publish@release/v1

.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  build:
+    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
+        run: pip install poetry==1.4.2
+      - name: Install dependencies
+        run: poetry install --all-extras
+      - name: Lint with ruff
+        run: make ci_lint
+      - name: Test with pytest
+        run: make ci_test

.gitignore

@@ -166,4 +166,8 @@ cython_debug/
 # Database
 db
 
-.vscode
+.vscode
+/poetry.lock
+.idea/
+
+.DS_Store

.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 23.3.0
+    hooks:
+      - id: black
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: 'v0.0.220'
+    hooks:
+      - id: ruff
+        name: ruff
+        # Respect `exclude` and `extend-exclude` settings.
+        args: ["--force-exclude"]
+  - repo: local
+    hooks:
+      - id: pytest-check
+        name: pytest-check
+        entry: poetry run pytest
+        language: system
+        pass_filenames: false
+        always_run: true

CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing to embedchain
+
+Let us make contributing easy, collaborative and fun.
+
+## Submit your Contribution through PR
+
+To make a contribution, follow the following 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 star 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 Format 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
+```
+
+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.

Makefile

@@ -4,7 +4,7 @@ PIP := $(PYTHON) -m pip
 PROJECT_NAME := embedchain
 
 # Targets
-.PHONY: install format lint clean test
+.PHONY: install format lint clean test ci_lint ci_test
 
 install:
 	$(PIP) install --upgrade pip
@@ -22,3 +22,9 @@ clean:
 
 test:
 	$(PYTHON) -m pytest
+
+ci_lint:
+	poetry run ruff .
+
+ci_test:
+	poetry run pytest

README.md

@@ -1,623 +1,84 @@
 # embedchain
 
 [![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)
+[![Slack](https://img.shields.io/badge/slack-embedchain-brightgreen.svg?logo=slack)](https://join.slack.com/t/embedchain/shared_invite/zt-22uwz3c46-Zg7cIh5rOBteT_xe1jwLDw)
+[![Discord](https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat)](https://discord.gg/CUU9FPhRNt)
 [![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/)
+[![Open in Colab](https://camo.githubusercontent.com/84f0493939e0c4de4e6dbe113251b4bfb5353e57134ffd9fcab6b8714514d4d1/68747470733a2f2f636f6c61622e72657365617263682e676f6f676c652e636f6d2f6173736574732f636f6c61622d62616467652e737667)](https://colab.research.google.com/drive/138lMWhENGeEu7Q1-6lNbNTHGLZXBBz_B?usp=sharing)
 
-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)
+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)
 
-# Table of Contents
+## Community
 
-- [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)
+* Join embedchain community on slack by accepting [this invite](https://join.slack.com/t/embedchain/shared_invite/zt-22uwz3c46-Zg7cIh5rOBteT_xe1jwLDw)
 
-# Latest Updates
+## 🤝 Schedule a 1-on-1 Session
 
-- 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.
+Book a [1-on-1 Session](https://cal.com/taranjeetio/ec) with Taranjeet, the founder, to discuss any issues, provide feedback, or explore how we can improve Embedchain for you.
 
-- 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`
+## 🔧 Quick install
 
 ```bash
-pip install embedchain
+pip install --upgrade embedchain
 ```
 
-## Usage
+## 🔍 Demo
 
-Creating a chatbot involves 3 steps:
+Try out embedchain in your browser:
 
-- Import the App instance (App Types)
-- Add Dataset (Add Dataset)
-- Query or Chat on the dataset and get answers (Interface Types)
+[![Open in Colab](https://camo.githubusercontent.com/84f0493939e0c4de4e6dbe113251b4bfb5353e57134ffd9fcab6b8714514d4d1/68747470733a2f2f636f6c61622e72657365617263682e676f6f676c652e636f6d2f6173736574732f636f6c61622d62616467652e737667)](https://colab.research.google.com/drive/138lMWhENGeEu7Q1-6lNbNTHGLZXBBz_B?usp=sharing)
 
-### App Types
+## 📖 Documentation
 
-We have three types of App.
+The documentation for embedchain can be found at [docs.embedchain.ai](https://docs.embedchain.ai).
 
-#### 1. App (uses OpenAI models, paid)
+## 💻 Usage
 
-```python
-from embedchain import App
+Embedchain empowers you to create chatbot models similar to ChatGPT, using your own evolving dataset.
 
-naval_chat_bot = App()
-```
+### Data Types Supported
 
-- `App` uses OpenAI's model, so these are paid models. You will be charged for embedding model usage and LLM usage.
+* Youtube video
+* PDF file
+* Web page
+* Sitemap
+* Doc file
+* Code documentation website loader
+* Notion
 
-- `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).
+### Queries
 
-- 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"
-```
-
-#### 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.
+For example, you can use Embedchain to create an Elon Musk bot using the following code:
 
 ```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)
+# Create a bot instance
+os.environ["OPENAI_API_KEY"] = "YOUR API KEY"
+elon_bot = App()
 
-# Example: define your own chunker config for `youtube_video`
-youtube_add_config = {
-        "chunker": {
-                "chunk_size": 1000,
-                "chunk_overlap": 100,
-                "length_function": len,
-        }
-}
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44", AddConfig(**youtube_add_config))
+# Embed online resources
+elon_bot.add("https://en.wikipedia.org/wiki/Elon_Musk")
+elon_bot.add("https://tesla.com/elon-musk")
+elon_bot.add("https://www.youtube.com/watch?v=MxZpaJK74Y4")
 
-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))
+# Query the bot
+elon_bot.query("How many companies does Elon Musk run?")
+# Answer: Elon Musk runs four companies: Tesla, SpaceX, Neuralink, and The Boring Company
 ```
 
-Here's the example of using custom prompt template with `.query`
+## 🤝 Contributing
 
-```python
-from embedchain.config import QueryConfig
-from embedchain.embedchain import App
-from string import Template
-import wikipedia
+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).
 
-einstein_chat_bot = App()
+For more reference, please go through [Development Guide](https://docs.embedchain.ai/contribution/dev) and [Documentation Guide](https://docs.embedchain.ai/contribution/docs).
 
-# 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)
+<a href="https://github.com/embedchain/embedchain/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=embedchain/embedchain" />
+</a>
 
 ## Citation
 
@@ -626,7 +87,7 @@ 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},
+  title = {Embedchain: Framework to easily create LLM powered bots over any dataset},
   year = {2023},
   publisher = {GitHub},
   journal = {GitHub repository},

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`

docs/advanced/adding_data.mdx

@@ -0,0 +1,25 @@
+---
+title: '➕ Adding Data'
+---
+
+## Add Dataset
+
+- This step assumes that you have already created an `app` instance by either using `App`, `OpenSourceApp` or `CustomApp`. We are calling our app instance as `naval_chat_bot` 🤖
+
+- Now use `.add` method to add any dataset.
+
+```python
+# naval_chat_bot = App() or
+# naval_chat_bot = OpenSourceApp()
+
+# Embed Online Resources
+naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44")
+naval_chat_bot.add("https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
+naval_chat_bot.add("https://nav.al/feedback")
+naval_chat_bot.add("https://nav.al/agi")
+
+# Embed Local Resources
+naval_chat_bot.add(("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
+```
+
+The possible formats to add data can be found on the [Supported Data Formats](/advanced/data_types) page.

docs/advanced/app_types.mdx

@@ -0,0 +1,140 @@
+---
+title: '📱 App types'
+---
+
+## App Types
+
+We have three types of App.
+
+### App
+
+```python
+from embedchain import App
+app = App()
+```
+
+- `App` uses OpenAI's model, so these are paid models. 💸 You will be charged for embedding model usage and LLM usage.
+- `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 don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
+- `App` is opinionated. It uses the best embedding model and LLM on the market.
+- 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"
+```
+
+### Llama2App
+
+```python
+import os
+
+from embedchain import Llama2App
+
+os.environ['REPLICATE_API_TOKEN'] = "REPLICATE API TOKEN"
+
+zuck_bot = Llama2App()
+
+# Embed your data
+zuck_bot.add("https://www.youtube.com/watch?v=Ff4fRgnuFgQ")
+zuck_bot.add("https://en.wikipedia.org/wiki/Mark_Zuckerberg")
+
+# Nice, your bot is ready now. Start asking questions to your bot.
+zuck_bot.query("Who is Mark Zuckerberg?")
+# Answer: Mark Zuckerberg is an American internet entrepreneur and business magnate. He is the co-founder and CEO of Facebook. Born in 1984, he dropped out of Harvard University to focus on his social media platform, which has since grown to become one of the largest and most influential technology companies in the world.
+
+# Enable web search for your bot
+zuck_bot.online = True # enable internet access for the bot
+zuck_bot.query("Who owns the new threads app and when it was founded?")
+# Answer: Based on the context provided, the new Threads app is owned by Meta, the parent company of Facebook, Instagram, and WhatsApp.
+```
+
+- `Llama2App` uses Replicate's LLM model, so these are paid models. You can get the `REPLICATE_API_TOKEN` by registering on [their website](https://replicate.com/account).
+- `Llama2App` uses OpenAI's embedding model to create embeddings for chunks. Make sure that you have an OpenAI account and an API key. If you don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
+
+
+### OpenSourceApp
+
+```python
+from embedchain import OpenSourceApp
+app = 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. 📚
+- `OpenSourceApp` is opinionated. It uses the best open source embedding model and LLM on the market.
+- extra dependencies are required for this app type. Install them with `pip install --upgrade embedchain[opensource]`.
+
+### CustomApp
+
+```python
+from embedchain import CustomApp
+from embedchain.config import (CustomAppConfig, ElasticsearchDBConfig,
+                               EmbedderConfig, LlmConfig)
+from embedchain.embedder.vertexai import VertexAiEmbedder
+from embedchain.llm.vertex_ai import VertexAiLlm
+from embedchain.models import EmbeddingFunctions, Providers
+from embedchain.vectordb.elasticsearch import Elasticsearch
+
+# short
+app = CustomApp(llm=VertexAiLlm(), db=Elasticsearch(), embedder=VertexAiEmbedder())
+# with configs
+app = CustomApp(
+    config=CustomAppConfig(log_level="INFO"),
+    llm=VertexAiLlm(config=LlmConfig(number_documents=5)),
+    db=Elasticsearch(config=ElasticsearchDBConfig(es_url="...")),
+    embedder=VertexAiEmbedder(config=EmbedderConfig()),
+)
+```
+
+- `CustomApp` is not opinionated.
+- Configuration required. It's for advanced users who want to mix and match different embedding models and LLMs.
+- while it's doing that, it's still providing abstractions by allowing you to import Classes from `embedchain.llm`, `embedchain.vectordb`, and `embedchain.embedder`.
+- paid and free/open source providers included.
+- Once you have imported and instantiated the app, every functionality from here onwards is the same for either type of app. 📚
+- Following providers are available for an LLM
+    - OPENAI
+    - ANTHPROPIC
+    - VERTEX_AI
+    - GPT4ALL
+    - AZURE_OPENAI
+    - LLAMA2
+- Following embedding functions are available for an embedding function
+    - OPENAI
+    - HUGGING_FACE
+    - VERTEX_AI
+    - GPT4ALL
+    - AZURE_OPENAI
+
+
+### PersonApp
+
+```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 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"
+```
+
+#### Compatibility with other apps
+
+- 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
+```

docs/advanced/configuration.mdx

@@ -0,0 +1,104 @@
+---
+title: '⚙️ Custom configurations'
+---
+
+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.
+
+## Concept
+The main `App` class is available in the following varieties: `CustomApp`, `OpenSourceApp` and `Llama2App` and `App`. The first is fully configurable, the others are opinionated in some aspects.
+
+The `App` class has three subclasses: `llm`, `db` and `embedder`. These are the core ingredients that make up an EmbedChain app.
+App plus each one of the subclasses have a `config` attribute.
+You can pass a `Config` instance as an argument during initialization to persistently configure a class.
+These configs can be imported from `embedchain.config`
+
+There are `set` methods for some things that should not (only) be set at start-up, like `app.db.set_collection_name`.
+
+## Examples
+
+### General
+
+Here's the readme example with configuration options.
+
+```python
+from embedchain import App
+from embedchain.config import AppConfig, AddConfig, LlmConfig, ChunkerConfig
+
+# Example: set the log level for debugging
+config = AppConfig(log_level="DEBUG")
+naval_chat_bot = App(config)
+
+# Example: specify a custom collection name
+naval_chat_bot.db.set_collection_name("naval_chat_bot")
+
+# Example: define your own chunker config for `youtube_video`
+chunker_config = ChunkerConfig(chunk_size=1000, chunk_overlap=100, length_function=len)
+# Example: Add your chunker config to an AddConfig to actually use it
+add_config = AddConfig(chunker=chunker_config)
+naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44", config=add_config)
+
+# Example: Reset to default
+add_config = AddConfig()
+naval_chat_bot.add("https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf", config=add_config)
+naval_chat_bot.add("https://nav.al/feedback", config=add_config)
+naval_chat_bot.add("https://nav.al/agi", config=add_config)
+naval_chat_bot.add(("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."), config=add_config)
+
+# Change the number of documents.
+query_config = LlmConfig(number_documents=5)
+print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", config=query_config))
+```
+
+### Custom prompt template
+
+Here's the example of using custom prompt template with `.query`
+
+```python
+from string import Template
+
+import wikipedia
+
+from embedchain import App
+from embedchain.config import LlmConfig
+
+einstein_chat_bot = App()
+
+# Embed Wikipedia page
+page = wikipedia.page("Albert Einstein")
+einstein_chat_bot.add(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:"""
+)
+# Example: Use the template, also add a system prompt.
+llm_config = LlmConfig(template=einstein_chat_template, system_prompt="You are Albert Einstein.")
+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, config=llm_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.
+```

docs/advanced/data_types.mdx

@@ -0,0 +1,158 @@
+---
+title: '📋 Supported data formats'
+---
+
+## Automatic data type detection
+The add method automatically tries to detect the data_type, based on your input for the source argument. So `app.add('https://www.youtube.com/watch?v=dQw4w9WgXcQ')` is enough to embed a YouTube video.
+
+This detection is implemented for all formats. It is based on factors such as whether it's a URL, a local file, the source data type, etc.
+
+### Debugging automatic detection
+
+
+Set `log_level=DEBUG` (in [AppConfig](http://localhost:3000/advanced/query_configuration#appconfig)) and make sure it's working as intended.
+
+Otherwise, you will not know when, for instance, an invalid filepath is interpreted as raw text instead.
+
+### Forcing a data type
+
+To omit any issues with the data type detection, you can **force** a data_type by adding it as a `add` method argument.
+The examples below show you the keyword to force the respective `data_type`.
+
+Forcing can also be used for edge cases, such as interpreting a sitemap as a web_page, for reading its raw text instead of following links.
+
+## Remote Data Types
+
+<Tip>
+**Use local files in remote data types**
+
+Some data_types are meant for remote content and only work with URLs.
+You can pass local files by formatting the path using the `file:` [URI scheme](https://en.wikipedia.org/wiki/File_URI_scheme), e.g. `file:///info.pdf`.
+</Tip>
+
+### Youtube video
+
+To add any youtube video to your app, use the data_type (first argument to `.add()` method) as `youtube_video`. Eg:
+
+```python
+app.add('a_valid_youtube_url_here', data_type='youtube_video')
+```
+
+### PDF file
+
+To add any pdf file, use the data_type as `pdf_file`. Eg:
+
+```python
+app.add('a_valid_url_where_pdf_file_can_be_accessed', data_type='pdf_file')
+```
+
+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('a_valid_web_page_url', data_type='web_page')
+```
+
+### Sitemap
+
+Add all web pages from an xml-sitemap. Filters non-text files. Use the data_type as `sitemap`. Eg:
+
+```python
+app.add('https://example.com/sitemap.xml', data_type='sitemap')
+```
+
+### Doc file
+
+To add any doc/docx file, use the data_type as `docx`. `docx` allows remote urls and conventional file paths. Eg:
+
+```python
+app.add('https://example.com/content/intro.docx', data_type="docx")
+app.add('content/intro.docx', data_type="docx")
+```
+
+### CSV file
+
+To add any csv file, use the data_type as `csv`. `csv` allows remote urls and conventional file paths. Headers are included for each line, so if you have an `age` column, `18` will be added as `age: 18`. Eg:
+
+```python
+app.add('https://example.com/content/sheet.csv', data_type="csv")
+app.add('content/sheet.csv', data_type="csv")
+```
+
+### Code documentation website loader
+
+To add any code documentation website as a loader, use the data_type as `docs_site`. Eg:
+
+```python
+app.add("https://docs.embedchain.ai/", data_type="docs_site")
+```
+
+### Notion
+To use notion you must install the extra dependencies with `pip install --upgrade embedchain[notion]`.
+
+To load a notion page, use the data_type as `notion`. Since it is hard to automatically detect, forcing this is advised.
+The next argument must **end** with the `notion page id`. The id is a 32-character string. Eg:
+
+```python
+app.add("cfbc134ca6464fc980d0391613959196", "notion")
+app.add("my-page-cfbc134ca6464fc980d0391613959196", "notion")
+app.add("https://www.notion.so/my-page-cfbc134ca6464fc980d0391613959196", "notion")
+```
+
+### Mdx file
+
+To add any mdx file to your app, use the data_type (first argument to `.add()` method) as `mdx`. Note that this supports support mdx file present on machine, so this should be a file path. Eg:
+
+```python
+app.add('path/to/file.mdx', data_type='mdx')
+```
+
+## Local Data Types
+
+### 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('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.', data_type='text')
+```
+
+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(("Question", "Answer"), data_type="qna_pair")
+```
+
+## Reusing a vector database
+
+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("https://www.youtube.com/watch?v=3qHkcs3kG44")
+naval_chat_bot.add("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.

docs/advanced/interface_types.mdx

@@ -0,0 +1,75 @@
+---
+title: '🤝 Interface types'
+---
+
+## Interface Types
+
+The embedchain app exposes the following methods.
+
+### 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 a chat interface that remembers previous conversations. Right now it remembers 5 conversations 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.
+```
+
+#### Dry Run
+
+Dry Run is an option in the `add`, `query` and `chat` methods that allows the user to displays the data chunks and their constructed prompt which is not send to the LLM, to save money. It's used for [testing](/advanced/testing#dry-run).
+
+
+### 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.
+```
+
+### 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
+```

docs/advanced/query_configuration.mdx

@@ -0,0 +1,77 @@
+---
+title: '🔍 Query configurations'
+---
+
+## AppConfig
+
+| option    | description           | type                            | default                |
+|-----------|-----------------------|---------------------------------|------------------------|
+| log_level | log level             | string                          | WARNING                |
+| embedding_fn| embedding function    | chromadb.utils.embedding_functions | \{text-embedding-ada-002\} |
+| db        | vector database (experimental) | BaseVectorDB               | ChromaDB               |
+| collection_name | initial collection name for the database | string             | embedchain_store |
+| collect_metrics | collect anonymous telemetry data to improve embedchain | boolean | true |
+
+
+## AddConfig
+
+|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|
+
+Yes, you are passing `ChunkerConfig` to `AddConfig`, like so:
+
+```python
+chunker_config = ChunkerConfig(chunk_size=100)
+add_config = AddConfig(chunker=chunker_config)
+app.add("lorem ipsum", config=add_config)
+```
+
+### ChunkerConfig
+
+|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|
+|docs_site|500|50|len|
+|notion|300|0|len|
+
+### LoaderConfig
+
+_coming soon_
+
+## LlmConfig
+
+|option|description|type|default|
+|---|---|---|---|
+|number_documents|Absolute number of documents to pull from the database as context.|int|1
+|template|custom template for prompt. If history is used with query, $history has to be included as well.|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:")|
+|model|name of the model used.|string|depends on app type|
+|temperature|Controls the randomness of the model's output. Higher values (closer to 1) make output more random, lower values make it more deterministic.|float|0|
+|max_tokens|Controls how many tokens are used. Exact implementation (whether it counts prompt and/or response) depends on the model.|int|1000|
+|top_p|Controls the diversity of words. Higher values (closer to 1) make word selection more diverse, lower values make words less diverse.|float|1|
+|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|
+|deployment_name|t.b.a.|str|None|
+|system_prompt|System prompt string. Unused if none.|str|None|
+
+## ChatConfig
+
+All options for query and...
+
+_coming soon_
+
+`history` is not supported, as that is handled is handled automatically, the config option is not supported.

docs/advanced/showcase.mdx

@@ -0,0 +1,115 @@
+---
+title: '🎪 Community showcase'
+---
+
+Embedchain community has been super active in creating demos on top of Embedchain. On this page, we showcase all the apps, blogs, videos, and tutorials created by the community. ❤️
+
+## Apps
+
+### Open Source
+
+- [My GSoC23 bot- Streamlit chat](https://github.com/lucifertrj/EmbedChain_GSoC23_BOT) by Tarun Jain
+- [Discord Bot for LLM chat](https://github.com/Reidond/discord_bots_playground/tree/c8b0c36541e4b393782ee506804c4b6962426dd6/python/chat-channel-bot) by Reidond
+- [EmbedChain-Streamlit-Docker App](https://github.com/amjadraza/embedchain-streamlit-app) by amjadraza
+- [Harry Potter Philosphers Stone Bot](https://github.com/vinayak-kempawad/Harry_Potter_Philosphers_Stone_Bot/) by Vinayak Kempawad, ([LinkedIn post](https://www.linkedin.com/feed/update/urn:li:activity:7080907532155686912/))
+- [LLM bot trained on own messages](https://github.com/Harin329/harinBot) by Hao Wu
+
+### Closed Source
+
+- [Taobot.io](https://taobot.io) - chatbot & knowledgebase hybrid by [cachho](https://github.com/cachho)
+- [Create Instant ChatBot 🤖 using embedchain](https://databutton.com/v/h3e680h9) by Avra, ([Tweet](https://twitter.com/Avra_b/status/1674704745154641920/))
+- [JOBO 🤖 — The AI-driven sidekick to craft your resume](https://try-jobo.com/) by Enrico Willemse, ([LinkedIn Post](https://www.linkedin.com/posts/enrico-willemse_jobai-gptfun-embedchain-activity-7090340080879374336-ueLB/))
+- [Explore Your Knowledge Base: Interactive chats over various forms of documents](https://chatdocs.dkedar.com/) by Kedar Dabhadkar, ([LinkedIn Post](https://www.linkedin.com/posts/dkedar7_machinelearning-llmops-activity-7092524836639424513-2O3L/))
+- [Chatbot trained on 1000+ videos of Ester hicks the co-author behind the famous book Secret](https://ask-abraham.thoughtseed.repl.co) by Mohan Kumar
+
+
+## Templates
+
+### Replit
+- [Embedchain Chat Bot](https://replit.com/@taranjeet1/Embedchain-Chat-Bot) by taranjeetio
+- [Embedchain Memory Chat Bot Template](https://replit.com/@taranjeetio/Embedchain-Memory-Chat-Bot-Template) by taranjeetio
+- [Chatbot app to demonstrate question-answering using retrieved information](https://replit.com/@AllisonMorrell/EmbedChainlitPublic) by Allison Morrell, ([LinkedIn Post](https://www.linkedin.com/posts/allison-morrell-2889275a_retrievalbot-screenshots-activity-7080339991754649600-wihZ/))
+
+## Posts
+
+### Blogs
+
+- [Customer Service LINE Bot](https://www.evanlin.com/langchain-embedchain/) by Evan Lin
+- [Chatbot in Under 5 mins using Embedchain](https://medium.com/@ayush.wattal/chatbot-in-under-5-mins-using-embedchain-a4f161fcf9c5) by Ayush Wattal
+- [Understanding what the LLM framework embedchain does](https://zenn.dev/hijikix/articles/4bc8d60156a436) by Daisuke Hashimoto
+- [In bed with GPT and Node.js](https://dev.to/worldlinetech/in-bed-with-gpt-and-nodejs-4kh2) by Raphaël Semeteys, ([LinkedIn Post](https://www.linkedin.com/posts/raphaelsemeteys_in-bed-with-gpt-and-nodejs-activity-7088113552326029313-nn87/))
+- [Using Embedchain — A powerful LangChain Python wrapper to build Chat Bots even faster!⚡](https://medium.com/@avra42/using-embedchain-a-powerful-langchain-python-wrapper-to-build-chat-bots-even-faster-35c12994a360) by Avra, ([Tweet](https://twitter.com/Avra_b/status/1686767751560310784/))
+- [What is the Embedchain library?](https://jahaniwww.com/%da%a9%d8%aa%d8%a7%d8%a8%d8%ae%d8%a7%d9%86%d9%87-embedchain/) by Ali Jahani, ([LinkedIn Post](https://www.linkedin.com/posts/ajahani_aepaetaeqaexaggahyaeu-aetaexaesabraeaaeqaepaeu-activity-7097605202135904256-ppU-/))
+- [LangChain is Nice, But Have You Tried EmbedChain ?](https://medium.com/thoughts-on-machine-learning/langchain-is-nice-but-have-you-tried-embedchain-215a34421cde) by FS Ndzomga, ([Tweet](https://twitter.com/ndzfs/status/1695583640372035951/))
+- [Simplest Method to Build a Custom Chatbot with GPT-3.5 (via Embedchain)](https://www.ainewsletter.today/p/simplest-method-to-build-a-custom) by Arjun, ([Tweet](https://twitter.com/aiguy_arjun/status/1696393808467091758/))
+
+### LinkedIn
+
+- [What is embedchain](https://www.linkedin.com/posts/activity-7079393104423698432-wRyi/) by Rithesh Sreenivasan
+- [Building a chatbot with EmbedChain](https://www.linkedin.com/posts/activity-7078434598984060928-Zdso/) by Lior Sinclair
+- [Making chatbot without vs with embedchain](https://www.linkedin.com/posts/kalyanksnlp_llms-chatbots-langchain-activity-7077453416221863936-7N1L/) by Kalyan KS
+- [EmbedChain - very intuitive, first you index your data and then query!](https://www.linkedin.com/posts/shubhamsaboo_embedchain-a-framework-to-easily-create-activity-7079535460699557888-ad1X/) by Shubham Saboo
+- [EmbedChain - Harnessing power of LLM](https://www.linkedin.com/posts/uditsaini_chatbotrevolution-llmpoweredbots-embedchainframework-activity-7077520356827181056-FjTK/) by Udit S.
+- [AI assistant for ABBYY Vantage](https://www.linkedin.com/posts/maximevermeir_llm-github-abbyy-activity-7081658972071424000-fXfZ/) by Maxime V.
+- [About embedchain](https://www.linkedin.com/feed/update/urn:li:activity:7080984218914189312/) by Morris Lee
+- [How to use Embedchain](https://www.linkedin.com/posts/nehaabansal_github-embedchainembedchain-framework-activity-7085830340136595456-kbW5/) by Neha Bansal
+- [Youtube/Webpage summary for Energy Study](https://www.linkedin.com/posts/bar%C4%B1%C5%9F-sanl%C4%B1-34b82715_enerji-python-activity-7082735341563977730-Js0U/) by Barış Sanlı, ([Tweet](https://twitter.com/barissanli/status/1676968784979193857/)) 
+- [Demo: How to use Embedchain? (Contains Collab Notebook link)](https://www.linkedin.com/posts/liorsinclair_embedchain-is-getting-a-lot-of-traction-because-activity-7103044695995424768-RckT/) by Lior Sinclair
+
+### Twitter
+
+- [What is embedchain](https://twitter.com/AlphaSignalAI/status/1672668574450847745) by Lior
+- [Building a chatbot with Embedchain](https://twitter.com/Saboo_Shubham_/status/1673537044419686401) by Shubham Saboo
+- [Chatbot docker image behind an API with yaml configs with Embedchain](https://twitter.com/tricalt/status/1678411430192730113/) by Vasilije
+- [Build AI powered PDF chatbot with just five lines of Python code with Embedchain!](https://twitter.com/Saboo_Shubham_/status/1676627104866156544/) by Shubham Saboo
+- [Chatbot against a youtube video using embedchain](https://twitter.com/smaameri/status/1675201443043704834/) by Sami Maameri
+- [Highlights of EmbedChain](https://twitter.com/carl_AIwarts/status/1673542204328120321/) by carl_AIwarts
+- [Build Llama-2 chatbot in less than 5 minutes](https://twitter.com/Saboo_Shubham_/status/1682168956918833152/) by Shubham Saboo
+- [All cool features of embedchain](https://twitter.com/DhravyaShah/status/1683497882438217728/) by Dhravya Shah, ([LinkedIn Post](https://www.linkedin.com/posts/dhravyashah_what-if-i-tell-you-that-you-can-make-an-ai-activity-7089459599287726080-ZIYm/))
+- [Read paid Medium articles for Free using embedchain](https://twitter.com/kumarkaushal_/status/1688952961622585344) by Kaushal Kumar
+
+## Videos
+
+- [Embedchain in one shot](https://www.youtube.com/watch?v=vIhDh7H73Ww&t=82s) by AI with Tarun
+- [embedChain Create LLM powered bots over any dataset Python Demo Tesla Neurallink Chatbot Example](https://www.youtube.com/watch?v=bJqAn22a6Gc) by Rithesh Sreenivasan
+- [Embedchain - NEW 🔥 Langchain BABY to build LLM Bots](https://www.youtube.com/watch?v=qj_GNQ06I8o) by 1littlecoder
+- [EmbedChain -- NEW!: Build LLM-Powered Bots with Any Dataset](https://www.youtube.com/watch?v=XmaBezzGHu4) by DataInsightEdge
+- [Chat With Your PDFs in less than 10 lines of code! EMBEDCHAIN tutorial](https://www.youtube.com/watch?v=1ugkcsAcw44) by Phani Reddy
+- [How To Create A Custom Knowledge AI Powered Bot | Install + How To Use](https://www.youtube.com/watch?v=VfCrIiAst-c) by The Ai Solopreneur
+- [Build Custom Chatbot in 6 min with this Framework [Beginner Friendly]](https://www.youtube.com/watch?v=-8HxOpaFySM) by Maya Akim
+- [embedchain-streamlit-app](https://www.youtube.com/watch?v=3-9GVd-3v74) by Amjad Raza
+- [🤖CHAT with ANY ONLINE RESOURCES using EMBEDCHAIN - a LangChain wrapper, in few lines of code !](https://www.youtube.com/watch?v=Mp7zJe4TIdM) by Avra
+- [Building resource-driven LLM-powered bots with Embedchain](https://www.youtube.com/watch?v=IVfcAgxTO4I) by BugBytes
+- [embedchain-streamlit-demo](https://www.youtube.com/watch?v=yJAWB13FhYQ) by Amjad Raza
+- [Embedchain - create your own AI chatbots using open source models](https://www.youtube.com/shorts/O3rJWKwSrWE) by Dhravya Shah
+- [AI ChatBot in 5 lines Python Code](https://www.youtube.com/watch?v=zjWvLJLksv8) by Data Engineering
+- [Interview with Karl Marx](https://www.youtube.com/watch?v=5Y4Tscwj1xk) by Alexander Ray Williams
+- [Vlog where we try to build a bot based on our content on the internet](https://www.youtube.com/watch?v=I2w8CWM3bx4) by DV, ([Tweet](https://twitter.com/dvcoolster/status/1688387017544261632))
+- [CHAT with ANY ONLINE RESOURCES using EMBEDCHAIN|STREAMLIT with MEMORY |All OPENSOURCE](https://www.youtube.com/watch?v=TqQIHWoWTDQ&pp=ygUKZW1iZWRjaGFpbg%3D%3D) by DataInsightEdge
+- [Build POWERFUL LLM Bots EASILY with Your Own Data - Embedchain - Langchain 2.0? (Tutorial)](https://www.youtube.com/watch?v=jE24Y_GasE8) by WorldofAI, ([Tweet](https://twitter.com/intheworldofai/status/1696229166922780737))
+- [Embedchain: An AI knowledge base assistant for customizing enterprise private data, which can be connected to discord, whatsapp, slack, tele and other terminals (with gradio to build a request interface) in Chinese](https://www.youtube.com/watch?v=5RZzCJRk-d0) by AIGC LINK
+- [Embedchain Introduction](https://www.youtube.com/watch?v=Jet9zAqyggI) by Fahd Mirza 
+
+## Mentions
+
+### Github repos
+
+- [Awesome-LLM](https://github.com/Hannibal046/Awesome-LLM)
+- [awesome-chatgpt-api](https://github.com/reorx/awesome-chatgpt-api)
+- [awesome-langchain](https://github.com/kyrolabs/awesome-langchain)
+- [Awesome-Prompt-Engineering](https://github.com/promptslab/Awesome-Prompt-Engineering)
+- [awesome-chatgpt](https://github.com/eon01/awesome-chatgpt)
+- [Awesome-LLMOps](https://github.com/tensorchord/Awesome-LLMOps)
+- [awesome-generative-ai](https://github.com/filipecalegario/awesome-generative-ai)
+- [awesome-gpt](https://github.com/formulahendry/awesome-gpt)
+- [awesome-ChatGPT-repositories](https://github.com/taishi-i/awesome-ChatGPT-repositories)
+- [awesome-gpt-prompt-engineering](https://github.com/snwfdhmp/awesome-gpt-prompt-engineering)
+- [awesome-chatgpt](https://github.com/awesome-chatgpt/awesome-chatgpt)
+- [awesome-llm-and-aigc](https://github.com/sjinzh/awesome-llm-and-aigc)
+- [awesome-compbio-chatgpt](https://github.com/csbl-br/awesome-compbio-chatgpt)
+- [Awesome-LLM4Tool](https://github.com/OpenGVLab/Awesome-LLM4Tool)
+
+## Meetups
+
+- [Dash and ChatGPT: Future of AI-enabled apps 30/08/23](https://go.plotly.com/dash-chatgpt)
+- [Pie & AI: Bangalore - Build end-to-end LLM app using Embedchain 01/09/23](https://www.eventbrite.com/e/pie-ai-bangalore-build-end-to-end-llm-app-using-embedchain-tickets-698045722547)

docs/advanced/testing.mdx

@@ -0,0 +1,40 @@
+---
+title: '🧪 Testing'
+---
+
+## Methods for testing
+
+### Dry Run
+
+Before you consume valueable tokens, you should make sure that data chunks are properly created and the embedding you have done works and that it's receiving the correct document from the database.
+
+- For `query` or `chat` method, you can add this to your script:
+
+```python
+print(naval_chat_bot.query('Can you tell me who Naval Ravikant is?', dry_run=True))
+
+'''
+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.**
+
+
+- For `add` method, you can add this to your script:
+
+```python
+print(naval_chat_bot.add('https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', dry_run=True))
+
+'''
+{'chunks': ['THE ALMANACK OF NAVAL RAVIKANT', 'GETTING RICH IS NOT JUST ABOUT LUCK;', 'HAPPINESS IS NOT JUST A TRAIT WE ARE'], 'metadata': [{'source': 'C:\\Users\\Dev\\AppData\\Local\\Temp\\tmp3g5mjoiz\\tmp.pdf', 'page': 0, 'url': 'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', 'data_type': 'pdf_file'}, {'source': 'C:\\Users\\Dev\\AppData\\Local\\Temp\\tmp3g5mjoiz\\tmp.pdf', 'page': 2, 'url': 'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', 'data_type': 'pdf_file'}, {'source': 'C:\\Users\\Dev\\AppData\\Local\\Temp\\tmp3g5mjoiz\\tmp.pdf', 'page': 2, 'url': 'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', 'data_type': 'pdf_file'}], 'count': 7358, 'type': <DataType.PDF_FILE: 'pdf_file'>}
+
+# less items to show for readability
+'''
+```

docs/advanced/vector_database.mdx

@@ -0,0 +1,70 @@
+---
+title: '💾 Vector Database'
+---
+
+We support `Chroma` and `Elasticsearch` as two vector database. 
+`Chroma` is used as a default database.
+
+## Elasticsearch
+
+### Minimal Example
+
+In order to use `Elasticsearch` as vector database we need to use App type `CustomApp`.
+
+1. Set the environment variables in a `.env` file.
+```
+OPENAI_API_KEY=sk-SECRETKEY
+ELASTICSEARCH_API_KEY=SECRETKEY==
+ELASTICSEARCH_URL=https://secret-domain.europe-west3.gcp.cloud.es.io:443
+```
+Please note that the key needs certain privileges. For testing you can just toggle off `restrict privileges` under `/app/management/security/api_keys/` in your web interface.
+
+2. Load the app
+```python
+from embedchain import CustomApp
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.elasticsearch import ElasticsearchDB
+
+es_app = CustomApp(
+    llm=OpenAILlm(),
+    embedder=OpenAiEmbedder(),
+    db=ElasticsearchDB(),
+)
+```
+
+### More custom settings
+
+You can get a URL for elasticsearch in the cloud, or run it locally. 
+The following example shows you how to configure embedchain to work with a locally running elasticsearch.
+
+Instead of using an API key, we use http login credentials. The localhost url can be defined in .env or in the config.
+
+```python
+import os
+
+from embedchain import CustomApp
+from embedchain.config import CustomAppConfig, ElasticsearchDBConfig
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.elasticsearch import ElasticsearchDB
+
+es_config = ElasticsearchDBConfig(
+    # elasticsearch url or list of nodes url with different hosts and ports.
+    es_url='https://localhost:9200',
+    # pass named parameters supported by Python Elasticsearch client
+    http_auth=("elastic", "secret"),
+    ca_certs="~/binaries/elasticsearch-8.7.0/config/certs/http_ca.crt" # your cert path
+    # verify_certs=False # Alternative, if you aren't using certs
+) # pass named parameters supported by elasticsearch-py
+
+es_app = CustomApp(
+    config=CustomAppConfig(log_level="INFO"),
+    llm=OpenAILlm(),
+    embedder=OpenAiEmbedder(),
+    db=ElasticsearchDB(config=es_config),
+)
+```
+3. This should log your connection details to the console.
+4. Alternatively to a URL, you `ElasticsearchDBConfig` accepts `es_url` as a list of nodes url with different hosts and ports.
+5. Additionally we can pass named parameters supported by Python Elasticsearch client.

docs/contribution/dev.mdx

@@ -0,0 +1,60 @@
+---
+title: '👨‍💻 Development'
+description: 'Contribute to Embedchain framework development'
+---
+
+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
+
+- Deshraj Yadav ([@deshrajdry](https://twitter.com/taranjeetio))
+- [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}},
+}
+```

docs/contribution/docs.mdx

@@ -0,0 +1,61 @@
+---
+title: '📝 Documentation'
+description: 'Contribute to Embedchain docs'
+---
+
+<Info>
+  **Prerequisite** You should have installed Node.js (version 18.10.0 or
+  higher).
+</Info>
+
+Step 1. Install Mintlify on your OS:
+
+<CodeGroup>
+
+```bash npm
+npm i -g mintlify
+```
+
+```bash yarn
+yarn global add mintlify
+```
+
+</CodeGroup>
+
+Step 2. Go to the `docs/` directory (where you can find `mint.json`) and run the following command:
+
+```bash
+mintlify dev
+```
+
+The documentation website is now available at `http://localhost:3000`.
+
+### Custom Ports
+
+Mintlify uses port 3000 by default. You can use the `--port` flag to customize the port Mintlify runs on. For example, use this command to run in port 3333:
+
+```bash
+mintlify dev --port 3333
+```
+
+You will see an error like this if you try to run Mintlify in a port that's already taken:
+
+```md
+Error: listen EADDRINUSE: address already in use :::3000
+```
+
+## Mintlify Versions
+
+Each CLI is linked to a specific version of Mintlify. Please update the CLI if your local website looks different than production.
+
+<CodeGroup>
+
+```bash npm
+npm i -g mintlify@latest
+```
+
+```bash yarn
+yarn global upgrade mintlify
+```
+
+</CodeGroup>

docs/development.mdx

@@ -0,0 +1,98 @@
+---
+title: 'Development'
+description: 'Learn how to preview changes locally'
+---
+
+<Info>
+  **Prerequisite** You should have installed Node.js (version 18.10.0 or
+  higher).
+</Info>
+
+Step 1. Install Mintlify on your OS:
+
+<CodeGroup>
+
+```bash npm
+npm i -g mintlify
+```
+
+```bash yarn
+yarn global add mintlify
+```
+
+</CodeGroup>
+
+Step 2. Go to the docs are located (where you can find `mint.json`) and run the following command:
+
+```bash
+mintlify dev
+```
+
+The documentation website is now available at `http://localhost:3000`.
+
+### Custom Ports
+
+Mintlify uses port 3000 by default. You can use the `--port` flag to customize the port Mintlify runs on. For example, use this command to run in port 3333:
+
+```bash
+mintlify dev --port 3333
+```
+
+You will see an error like this if you try to run Mintlify in a port that's already taken:
+
+```md
+Error: listen EADDRINUSE: address already in use :::3000
+```
+
+## Mintlify Versions
+
+Each CLI is linked to a specific version of Mintlify. Please update the CLI if your local website looks different than production.
+
+<CodeGroup>
+
+```bash npm
+npm i -g mintlify@latest
+```
+
+```bash yarn
+yarn global upgrade mintlify
+```
+
+</CodeGroup>
+
+## Deployment
+
+<Tip>
+  Unlimited editors available under the [Startup
+  Plan](https://mintlify.com/pricing)
+</Tip>
+
+You should see the following if the deploy successfully went through:
+
+<Frame>
+  <img src="/images/checks-passed.png" style={{ borderRadius: '0.5rem' }} />
+</Frame>
+
+## Troubleshooting
+
+Here's how to solve some common problems when working with the CLI.
+
+<AccordionGroup>
+  <Accordion title="Mintlify is not loading">
+    Update to Node v18. Run `mintlify install` and try again.
+  </Accordion>
+  <Accordion title="No such file or directory on Windows">
+Go to the `C:/Users/Username/.mintlify/` directory and remove the `mint`
+folder. Then Open the Git Bash in this location and run `git clone
+https://github.com/mintlify/mint.git`.
+
+Repeat step 3.
+
+  </Accordion>
+  <Accordion title="Getting an unknown error">
+    Try navigating to the root of your device and delete the ~/.mintlify folder.
+    Then run `mintlify dev` again.
+  </Accordion>
+</AccordionGroup>
+
+Curious about what changed in a CLI version? [Check out the CLI changelog.](/changelog/command-line)

docs/examples/api_server.mdx

@@ -0,0 +1,91 @@
+---
+title: '🌍 API Server'
+---
+
+The API Server based on Flask integrates the `embedchain` package, offering endpoints to add, query, and chat to engage in conversations with a chatbot using JSON requests.
+
+### 🐳 Docker Setup
+
+- Open variables.env, and edit it to add your 🔑 `OPENAI_API_KEY`.
+- To setup your api server using docker, run the following command inside this folder using your terminal.
+
+```bash
+docker-compose up --build
+```
+
+📝 Note: The build command might take a while to install all the packages depending on your system resources.
+
+### 🚀 Usage Instructions
+
+- Your api server is running on [http://localhost:5000/](http://localhost:5000/)
+- To use the api server, make an api call to the endpoints `/add`, `/query` and `/chat` using the json formats discussed below.
+- To add data sources to the bot (/add):
+```json
+// Request
+{
+  "data_type": "your_data_type_here",
+  "url_or_text": "your_url_or_text_here"
+}
+
+// Response
+{
+  "data": "Added data_type: url_or_text"
+}
+```
+- To ask queries from the bot (/query):
+```json
+// Request
+{
+  "question": "your_question_here"
+}
+
+// Response
+{
+  "data": "your_answer_here"
+}
+```
+- To chat with the bot (/chat):
+```json
+// Request
+{
+  "question": "your_question_here"
+}
+
+// Response
+{
+  "data": "your_answer_here"
+}
+```
+
+### 📡 Curl Call Formats
+
+- To add data sources to the bot (/add):
+```bash
+curl -X POST \
+     -H "Content-Type: application/json" \
+     -d '{
+         "data_type": "your_data_type_here",
+         "url_or_text": "your_url_or_text_here"
+     }' \
+     http://localhost:5000/add
+```
+- To ask queries from the bot (/query):
+```bash
+curl -X POST \
+     -H "Content-Type: application/json" \
+     -d '{
+         "question": "your_question_here"
+     }' \
+     http://localhost:5000/query
+```
+- To chat with the bot (/chat):
+```bash
+curl -X POST \
+     -H "Content-Type: application/json" \
+     -d '{
+         "question": "your_question_here"
+     }' \
+     http://localhost:5000/chat
+```
+
+🎉 Happy Chatting! 🎉

docs/examples/discord_bot.mdx

@@ -0,0 +1,58 @@
+---
+title: '🤖 Discord Bot'
+---
+
+### 🔑 Keys Setup
+
+- Set your `OPENAI_API_KEY` in your variables.env file.
+- Go to [https://discord.com/developers/applications/](https://discord.com/developers/applications/) and click on `New Application`.
+- Enter the name for your bot, accept the terms and click on `Create`. On the resulting page, enter the details of your bot as you like.
+- On the left sidebar, click on `Bot`. Under the heading `Privileged Gateway Intents`, toggle all 3 options to ON position. Save your changes.
+- Now click on `Reset Token` and copy the token value. Set it as `DISCORD_BOT_TOKEN` in .env file.
+- On the left sidebar, click on `OAuth2` and go to `General`.
+- Set `Authorization Method` to `In-app Authorization`. Under `Scopes` select `bot`.
+- Under `Bot Permissions` allow the following and then click on `Save Changes`.
+```text
+Send Messages (under Text Permissions)
+```
+- Now under `OAuth2` and go to `URL Generator`. Under `Scopes` select `bot`.
+- Under `Bot Permissions` set the same permissions as above.
+- Now scroll down and copy the `Generated URL`. Paste it in a browser window and select the Server where you want to add the bot.
+- Click on `Continue` and authorize the bot.
+- 🎉 The bot has been successfully added to your server. But it's still offline.
+
+### Take the bot online
+
+1. Install embedchain python package:
+
+```bash
+pip install --upgrade "embedchain[discord]"
+```
+
+2. Launch your Discord bot:
+
+
+```bash
+python -m embedchain.bots.discord
+```
+
+If you prefer to see the question and not only the answer, run it with
+
+```bash
+python -m embedchain.bots.discord --include-question
+```
+
+### 🚀 Usage Instructions
+
+- Go to the server where you have added your bot.
+- You can add data sources to the bot using the slash command:
+```text
+/add <data_type> <url_or_text>
+```
+- You can ask your queries from the bot using the slash command:
+```text
+/query <question>
+```
+📝 Note: To use the bot privately, you can message the bot directly by right clicking the bot and selecting `Message`.
+
+🎉 Happy Chatting! 🎉

docs/examples/full_stack.mdx

@@ -0,0 +1,22 @@
+---
+title: '🌐 Full Stack'
+---
+
+### 🐳 Docker Setup
+
+- To setup full stack app using docker, run the following command inside this folder using your terminal.
+
+```bash
+docker-compose up --build
+```
+
+📝 Note: The build command might take a while to install all the packages depending on your system resources.
+
+### 🚀 Usage Instructions
+
+- Go to [http://localhost:3000/](http://localhost:3000/) in your browser to view the dashboard.
+- Add your `OpenAI API key` 🔑 in the Settings.
+- Create a new bot and you'll be navigated to its page.
+- Here you can add your data sources and then chat with the bot.
+
+🎉 Happy Chatting! 🎉

docs/examples/poe_bot.mdx

@@ -0,0 +1,59 @@
+---
+title: '🔮 Poe Bot'
+---
+
+### 🚀 Getting started
+
+1. Install embedchain python package:
+
+```bash
+pip install --upgrade "embedchain[poe]"
+```
+
+2. Create a free account on [Poe](https://www.poe.com?utm_source=embedchain).
+3. Click "Create Bot" button on top left.
+4. Give it a handle and an optional description.
+5. Select `Use API`.
+6. Under `API URL` enter your server or ngrok address. You can use your machine's public IP or DNS. Otherwise, employ a proxy server like [ngrok](https://ngrok.com/) to make your local bot accessible.
+7. Copy your api key and paste it in `.env` as `POE_API_KEY`.
+8. You will need to set `OPENAI_API_KEY` for generating embeddings and using LLM. Copy your OpenAI API key from [here](https://platform.openai.com/account/api-keys) and paste it in `.env` as `OPENAI_API_KEY`.
+9. Now create your bot using the following code snippet.
+
+```bash
+# make sure that you have set OPENAI_API_KEY and POE_API_KEY in .env file
+from embedchain.bots import PoeBot
+
+poe_bot = PoeBot()
+
+# add as many data sources as you want
+poe_bot.add("https://en.wikipedia.org/wiki/Adam_D%27Angelo")
+poe_bot.add("https://www.youtube.com/watch?v=pJQVAqmKua8")
+
+# start the bot
+# this start the poe bot server on port 8080 by default
+poe_bot.start()
+```
+
+10. You can paste the above in a file called `your_script.py` and then simply do
+
+```bash
+python your_script.py
+```
+
+Now your bot will start running at port `8080` by default.
+
+11. You can refer the [Supported Data formats](https://docs.embedchain.ai/advanced/data_types) section to refer the supported data types in embedchain.
+
+12. Click `Run check` to make sure your machine can be reached.
+13. Make sure your bot is private if that's what you want.
+14. Click `Create bot` at the bottom to finally create the bot
+15. Now your bot is created.
+
+### 💬 How to use
+
+- To ask the bot questions, just type your query in the Poe interface:
+```text
+<your-question-here>
+```
+
+- If you wish to add more data source to the bot, simply update your script and add as many `.add` as you like. You need to restart the server.

docs/examples/slack_bot.mdx

@@ -0,0 +1,37 @@
+---
+title: '💼 Slack Bot'
+---
+
+### 🖼️ Setup
+
+1. Create a workspace on Slack if you don't have one already by clicking [here](https://slack.com/intl/en-in/).
+2. Create a new App on your Slack account by going [here](https://api.slack.com/apps).
+3. Select `From Scratch`, then enter the Bot Name and select your workspace.
+4. On the left Sidebar, go to `OAuth and Permissions` and add the following scopes under `Bot Token Scopes`:
+```text
+app_mentions:read
+channels:history
+channels:read
+chat:write
+```
+5. Now select the option `Install to Workspace` and after it's done, copy the `Bot User OAuth Token` and set it in your secrets as `SLACK_BOT_TOKEN`.
+6. Run your bot now with `python3 -m embedchain.bots.slack`
+7. Expose your bot to the internet. Default port is `5000`, which can be changed by adding `port --8080` to the startup command. You can use your machine's public IP or DNS. Otherwise, employ a proxy server like [ngrok](https://ngrok.com/) to make your local bot accessible.
+8. On the Slack API website go to `Event Subscriptions` on the left Sidebar and turn on `Enable Events`.
+9. In `Request URL`, enter your server or ngrok address.
+10. After it gets verified, click on `Subscribe to bot events`, add `message.channels` Bot User Event and click on `Save Changes`.
+11. Now go to your workspace, right click on the bot name in the sidebar, click `view app details`, then `add this app to a channel`.
+
+### 🚀 Usage Instructions
+
+- Go to the channel where you have added your bot.
+- To add data sources to the bot, use the command:
+```text
+add <data_type> <url_or_text>
+```
+- To ask queries from the bot, use the command:
+```text
+query <question>
+```
+
+🎉 Happy Chatting! 🎉

docs/examples/telegram_bot.mdx

@@ -0,0 +1,26 @@
+---
+title: '📱 Telegram Bot'
+---
+
+### 🖼️ Template Setup
+
+- Fork [this](https://replit.com/@taranjeetio/EC-Telegram-Bot-Template?v=1#README.md) replit template.
+- Set your `OPENAI_API_KEY` in Secrets.
+- Open the Telegram app and search for the `BotFather` user.
+- Start a chat with BotFather and use the `/newbot` command to create a new bot.
+- Follow the instructions to choose a name and username for your bot.
+- Once the bot is created, BotFather will provide you with a unique token for your bot.
+- Set this token as `TELEGRAM_BOT_TOKEN` in Secrets.
+- Click on `Run` in the replit container and a URL will get generated for your bot.
+- Now set your webhook by running the following link in your browser:
+```url
+https://api.telegram.org/bot<Your_Telegram_Bot_Token>/setWebhook?url=<Replit_Generated_URL>
+```
+- When you get a successful response in your browser, your bot is ready to be used.
+
+### 🚀 Usage Instructions
+
+- Open your bot by searching for it using the bot name or bot username.
+- Click on `Start` or type `/start` and follow the on screen instructions.
+
+🎉 Happy Chatting! 🎉

docs/examples/whatsapp_bot.mdx

@@ -0,0 +1,46 @@
+---
+title: '💬 WhatsApp Bot'
+---
+
+### 🚀 Getting started
+
+1. Install embedchain python package:
+
+```bash
+pip install --upgrade embedchain
+```
+
+2. Launch your WhatsApp bot:
+
+
+```bash
+python -m embedchain.bots.whatsapp --port 5000
+```
+
+If your bot needs to be accessible online, use your machine's public IP or DNS. Otherwise, employ a proxy server like [ngrok](https://ngrok.com/) to make your local bot accessible.
+
+3. Create a free account on [Twilio](https://www.twilio.com/try-twilio)
+    - Set up a WhatsApp Sandbox in your Twilio dashboard. Access it via the left sidebar: `Messaging > Try it out > Send a WhatsApp Message`.
+    - Follow on-screen instructions to link a phone number for chatting with your bot
+    - Copy your bot's public URL, add /chat at the end, and paste it in Twilio's WhatsApp Sandbox settings under "When a message comes in". Save the settings.
+
+- Copy your bot's public url, append `/chat` at the end and paste it under `When a message comes in` under the `Sandbox settings` for Whatsapp in Twilio. Save your settings.
+
+### 💬 How to use
+
+- To connect a new number or reconnect an old one in the Sandbox, follow Twilio's instructions.
+- To include data sources, use this command:
+```text
+add <url_or_text>
+```
+
+- To ask the bot questions, just type your query:
+```text
+<your-question-here>
+```
+
+### Example
+
+Here is an example of Elon Musk WhatsApp Bot that we created:
+
+<img src="/images/whatsapp.jpg"/>

docs/introduction.mdx

@@ -0,0 +1,56 @@
+---
+title: 📚 Introduction
+description: '📝 Embedchain is a framework to easily create LLM powered bots over any dataset.'
+---
+
+## 🤔 What is Embedchain?
+
+Embedchain abstracts the entire process of loading a dataset, chunking it, creating embeddings, and storing it in a vector database.
+
+You can add a single or multiple datasets using the `.add` method. Then, simply use the `.query` method to find answers from the added datasets.
+
+If you want to create a Naval Ravikant bot with a YouTube video, a book in PDF format, two blog posts, and a question and answer pair, all you need to do is add the respective links. Embedchain will take care of the rest, creating a bot for you.
+
+```python
+from embedchain import App
+
+naval_chat_bot = App()
+# Embed Online Resources
+naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44")
+naval_chat_bot.add("https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf")
+naval_chat_bot.add("https://nav.al/feedback")
+naval_chat_bot.add("https://nav.al/agi")
+
+# Embed Local Resources
+naval_chat_bot.add(("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.
+```
+
+## 🚀 How it works?
+
+Creating a chat bot over any dataset involves the following steps:
+
+1. Detect the data type and load the data
+2. Create meaningful chunks
+3. Create embeddings for each chunk
+4. Store the chunks in a vector database
+
+When a user asks a query, the following process happens to find the answer:
+
+1. Create an embedding for the query
+2. Find similar documents for the query from the vector database
+3. Pass the similar documents as context to LLM to get the final answer.
+
+The process of loading the dataset and querying involves multiple steps, each with its own nuances:
+
+- 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 a vector database? Which vector database should I use?
+- Should I store metadata along with the embeddings?
+- How should I find similar documents for a query? Which ranking model should I use?
+
+Embedchain takes care of all these nuances and provides a simple interface to create bots over any dataset.
+
+In the first release, we make it easier for anyone to get a chatbot over any dataset up and running in less than a minute. Just create an app instance, add the datasets using the `.add` method, and use the `.query` method to get the relevant answers.

docs/mint.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://mintlify.com/schema.json",
+  "name": "Embedchain",
+  "logo": {
+    "dark": "/logo/dark.svg",
+    "light": "/logo/light.svg"
+  },
+  "favicon": "/favicon.png",
+  "colors": {
+    "primary": "#12A7D3",
+    "light": "#81D7F7",
+    "dark": "#004E7A"
+  },
+  "topbarLinks": [
+    {
+      "name": "Twitter",
+      "url": "https://twitter.com/embedchain"
+    },
+    {
+      "name": "Discord",
+      "url": "https://discord.gg/6PzXDgEjG5"
+    }
+  ],
+  "topbarCtaButton": {
+    "name": "GitHub",
+    "url": "https://embedchain.ai"
+  },
+  "navigation": [
+    {
+      "group": "Getting started",
+      "pages": ["quickstart", "introduction"]
+    },
+    {
+      "group": "Advanced",
+      "pages": ["advanced/app_types", "advanced/interface_types", "advanced/adding_data", "advanced/data_types", "advanced/query_configuration", "advanced/configuration", "advanced/testing", "advanced/vector_database", "advanced/showcase"]
+    },
+    {
+      "group": "Examples",
+      "pages": ["examples/full_stack", "examples/api_server", "examples/discord_bot", "examples/slack_bot", "examples/telegram_bot", "examples/whatsapp_bot", "examples/poe_bot"]
+    },
+    {
+      "group": "Contribution Guidelines",
+      "pages": ["contribution/dev", "contribution/docs"]
+    }
+
+  ],
+  "footerSocials": {
+    "twitter": "https://twitter.com/embedchain",
+    "github": "https://github.com/embedchain/embedchain",
+    "linkedin": "https://www.linkedin.com/company/embedchain",
+    "website": "https://embedchain.ai"
+  },
+  "backgroundImage": "/background.png",
+  "isWhiteLabeled": true
+}

docs/quickstart.mdx

@@ -0,0 +1,35 @@
+---
+title: '🚀 Quickstart'
+description: '💡 Start building LLM powered bots under 30 seconds'
+---
+
+Install embedchain python package:
+
+```bash
+pip install --upgrade embedchain
+```
+
+Creating a chatbot involves 3 steps:
+
+- ⚙️ Import the App instance
+- 🗃️ Add Dataset
+- 💬 Query or Chat on the dataset and get answers (Interface Types)
+
+Run your first bot in python using the following code. Make sure to set the `OPENAI_API_KEY` 🔑 environment variable in the code.
+
+```python
+import os
+
+from embedchain import App
+
+os.environ["OPENAI_API_KEY"] = "xxx"
+elon_musk_bot = App()
+
+# Embed Online Resources
+elon_musk_bot.add("https://en.wikipedia.org/wiki/Elon_Musk")
+elon_musk_bot.add("https://www.tesla.com/elon-musk")
+
+response = elon_musk_bot.query("How many companies does Elon Musk run?")
+print(response)
+# Answer: 'Elon Musk runs four companies: Tesla, SpaceX, Neuralink, and The Boring Company.'
+```

embedchain-js/.eslintignore

@@ -0,0 +1,2 @@
+node_modules
+dist

embedchain-js/.eslintrc

@@ -0,0 +1,56 @@
+{
+    // Configuration for JavaScript files
+    "extends": [
+      "airbnb-base",
+      "plugin:prettier/recommended"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "error",
+        {
+          "singleQuote": true,
+          "endOfLine": "auto"
+        }
+      ]
+    },
+    "overrides": [
+      // Configuration for TypeScript files
+      {
+        "files": ["**/*.ts", "**/__tests__/*.test.ts"],
+        "plugins": [
+          "@typescript-eslint",
+          "unused-imports",
+          "simple-import-sort"
+        ],
+        "extends": [
+          "airbnb-typescript",
+          "plugin:prettier/recommended"
+        ],
+        "parserOptions": {
+          "project": "./tsconfig.json"
+        },
+        "rules": {
+          "prettier/prettier": [
+            "error",
+            {
+              "singleQuote": true,
+              "endOfLine": "auto"
+            }
+          ],
+          "@typescript-eslint/comma-dangle": "off", // Avoid conflict rule between Eslint and Prettier
+          "@typescript-eslint/consistent-type-imports": "error", // Ensure `import type` is used when it's necessary
+          "import/prefer-default-export": "off", // Named export is easier to refactor automatically
+          "simple-import-sort/imports": "error", // Import configuration for `eslint-plugin-simple-import-sort`
+          "simple-import-sort/exports": "error", // Export configuration for `eslint-plugin-simple-import-sort`
+          "@typescript-eslint/no-unused-vars": "off",
+          "react/jsx-filename-extension": "off", // Gives error
+          "unused-imports/no-unused-imports": "error",
+          "unused-imports/no-unused-vars": [
+            "error",
+            { "argsIgnorePattern": "^_" }
+          ]
+        }
+      }
+    ]
+  }
+  

embedchain-js/.github/workflows/npm-publish.yml

@@ -0,0 +1,47 @@
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+      - run: npm run build
+      - uses: actions/upload-artifact@v3
+        with:
+          name: dist
+          path: dist
+      - uses: actions/upload-artifact@v3
+        with:
+          name: types
+          path: types
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - uses: actions/download-artifact@v3
+        with:
+          name: dist
+          path: dist
+      - uses: actions/download-artifact@v3
+        with:
+          name: types
+          path: types
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

embedchain-js/.gitignore

@@ -0,0 +1,138 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+.ideas.md
+.todos.md
+
+# Custom
+dist
+types
+build

embedchain-js/.husky/commit-msg

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit $1

embedchain-js/.husky/pre-commit

@@ -0,0 +1,5 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+# Disable concurent to run `check-types` after ESLint in lint-staged
+npx lint-staged --concurrent false

embedchain-js/CITATION.cff

@@ -0,0 +1,8 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- family-names: "Singh"
+  given-names: "Taranjeet"
+title: "Embedchain"
+date-released: 2023-06-25
+url: "https://github.com/embedchain/embedchainjs"

embedchain-js/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

embedchain-js/README.md

@@ -0,0 +1,263 @@
+# embedchainjs
+
+[![Discord](https://dcbadge.vercel.app/api/server/CUU9FPhRNt?style=flat)](https://discord.gg/CUU9FPhRNt)
+[![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/)
+
+embedchain is a framework to easily create LLM powered bots over any dataset. embedchainjs is Javascript version of embedchain. If you want a python version, check out [embedchain-python](https://github.com/embedchain/embedchain)
+
+# 🤝 Let's Talk Embedchain!
+
+Schedule a [Feedback Session](https://cal.com/taranjeetio/ec) with Taranjeet, the founder, to discuss any issues, provide feedback, or explore improvements.
+
+# How it works
+
+It abstracts the entire process of loading dataset, chunking it, creating embeddings and then storing in vector database.
+
+You can add a single or multiple dataset using `.add` and `.addLocal` 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 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 blog posts and the QnA pair and embedchain will create a bot for you.
+
+```javascript
+const dotenv = require("dotenv");
+dotenv.config();
+const { App } = require("embedchain");
+
+//Run the app commands inside an async function only
+async function testApp() {
+  const navalChatBot = await App();
+
+  // Embed Online Resources
+  await navalChatBot.add("web_page", "https://nav.al/feedback");
+  await navalChatBot.add("web_page", "https://nav.al/agi");
+  await navalChatBot.add(
+    "pdf_file",
+    "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf"
+  );
+
+  // Embed Local Resources
+  await navalChatBot.addLocal("qna_pair", [
+    "Who is Naval Ravikant?",
+    "Naval Ravikant is an Indian-American entrepreneur and investor.",
+  ]);
+
+  const result = await navalChatBot.query(
+    "What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"
+  );
+  console.log(result);
+  // answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
+}
+
+testApp();
+```
+
+# Getting Started
+
+## Installation
+
+- First make sure that you have the package installed. If not, then install it using `npm`
+
+```bash
+npm install embedchain && npm install -S openai@^3.3.0
+```
+
+- Currently, it is only compatible with openai 3.X, not the latest version 4.X. Please make sure to use the right version, otherwise you will see the `ChromaDB` error `TypeError: OpenAIApi.Configuration is not a constructor`
+
+- Make sure that dotenv package is installed and your `OPENAI_API_KEY` in a file called `.env` in the root folder. You can install dotenv by
+
+```js
+npm install dotenv
+```
+
+- Download and install Docker on your device by visiting [this link](https://www.docker.com/). You will need this to run Chroma vector database on your machine.
+
+- Run the following commands to setup Chroma container in Docker
+
+```bash
+git clone https://github.com/chroma-core/chroma.git
+cd chroma
+docker-compose up -d --build
+```
+
+- Once Chroma container has been set up, run it inside Docker
+
+## Usage
+
+- We use 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 dont 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`
+
+```js
+// Set this inside your .env file
+OPENAI_API_KEY = "sk-xxxx";
+```
+
+- Load the environment variables inside your .js file using the following commands
+
+```js
+const dotenv = require("dotenv");
+dotenv.config();
+```
+
+- Next import the `App` class from embedchain and use `.add` function to add any dataset.
+- Now your app is created. You can use `.query` function to get the answer for any query.
+
+```js
+const dotenv = require("dotenv");
+dotenv.config();
+const { App } = require("embedchain");
+
+async function testApp() {
+  const navalChatBot = await App();
+
+  // Embed Online Resources
+  await navalChatBot.add("web_page", "https://nav.al/feedback");
+  await navalChatBot.add("web_page", "https://nav.al/agi");
+  await navalChatBot.add(
+    "pdf_file",
+    "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf"
+  );
+
+  // Embed Local Resources
+  await navalChatBot.addLocal("qna_pair", [
+    "Who is Naval Ravikant?",
+    "Naval Ravikant is an Indian-American entrepreneur and investor.",
+  ]);
+
+  const result = await navalChatBot.query(
+    "What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"
+  );
+  console.log(result);
+  // answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
+}
+
+testApp();
+```
+
+- If there is any other app instance in your script or app, you can change the import as
+
+```javascript
+const { App: EmbedChainApp } = require("embedchain");
+
+// or
+
+const { App: ECApp } = require("embedchain");
+```
+
+## Format supported
+
+We support the following formats:
+
+### PDF File
+
+To add any pdf file, use the data_type as `pdf_file`. Eg:
+
+```javascript
+await app.add("pdf_file", "a_valid_url_where_pdf_file_can_be_accessed");
+```
+
+### Web Page
+
+To add any web page, use the data_type as `web_page`. Eg:
+
+```javascript
+await app.add("web_page", "a_valid_web_page_url");
+```
+
+### QnA Pair
+
+To supply your own QnA pair, use the data_type as `qna_pair` and enter a tuple. Eg:
+
+```javascript
+await app.addLocal("qna_pair", ["Question", "Answer"]);
+```
+
+### More Formats coming soon
+
+- If you want to add any other format, please create an [issue](https://github.com/embedchain/embedchainjs/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 `dryRun` method.
+
+Following the example above, add this to your script:
+
+```js
+let result = await naval_chat_bot.dryRun("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?");console.log(result);
+
+'''
+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.
+terms of the unseen. And I think that’s critical. That is what humans do uniquely that no other creature, no other computer, no other intelligence—biological or artificial—that we have ever encountered does. And not only do we do it uniquely, but if we were to meet an alien species that also had the power to generate these good explanations, there is no explanation that they could generate that we could not understand. We are maximally capable of understanding. There is no concept out there that is possible in this physical reality that a human being, given sufficient time and resources and
+Query: What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?
+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.**
+
+# 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.
+
+# 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
+
+# Team
+
+## Author
+
+- Taranjeet Singh ([@taranjeetio](https://twitter.com/taranjeetio))
+
+## Maintainer
+
+- [cachho](https://github.com/cachho)
+- [sahilyadav902](https://github.com/sahilyadav902)
+
+## 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/embedchainjs}},
+}
+```

embedchain-js/commitlint.config.js

@@ -0,0 +1 @@
+module.exports = { extends: ['@commitlint/config-conventional'] };

embedchain-js/embedchain/__tests__/readme.test.ts

@@ -0,0 +1,66 @@
+import { EmbedChainApp } from '../embedchain';
+
+const mockAdd = jest.fn();
+const mockAddLocal = jest.fn();
+const mockQuery = jest.fn();
+
+jest.mock('../embedchain', () => {
+  return {
+    EmbedChainApp: jest.fn().mockImplementation(() => {
+      return {
+        add: mockAdd,
+        addLocal: mockAddLocal,
+        query: mockQuery,
+      };
+    }),
+  };
+});
+
+describe('Test App', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('tests the App', async () => {
+    mockQuery.mockResolvedValue(
+      'Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.'
+    );
+
+    const navalChatBot = await new EmbedChainApp(undefined, false);
+
+    // Embed Online Resources
+    await navalChatBot.add('web_page', 'https://nav.al/feedback');
+    await navalChatBot.add('web_page', 'https://nav.al/agi');
+    await navalChatBot.add(
+      'pdf_file',
+      'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf'
+    );
+
+    // Embed Local Resources
+    await navalChatBot.addLocal('qna_pair', [
+      'Who is Naval Ravikant?',
+      'Naval Ravikant is an Indian-American entrepreneur and investor.',
+    ]);
+
+    const result = await navalChatBot.query(
+      'What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?'
+    );
+
+    expect(mockAdd).toHaveBeenCalledWith('web_page', 'https://nav.al/feedback');
+    expect(mockAdd).toHaveBeenCalledWith('web_page', 'https://nav.al/agi');
+    expect(mockAdd).toHaveBeenCalledWith(
+      'pdf_file',
+      'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf'
+    );
+    expect(mockAddLocal).toHaveBeenCalledWith('qna_pair', [
+      'Who is Naval Ravikant?',
+      'Naval Ravikant is an Indian-American entrepreneur and investor.',
+    ]);
+    expect(mockQuery).toHaveBeenCalledWith(
+      'What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?'
+    );
+    expect(result).toBe(
+      'Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.'
+    );
+  });
+});

embedchain-js/embedchain/chunkers/BaseChunker.ts

@@ -0,0 +1,44 @@
+import { createHash } from 'crypto';
+import type { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import type { BaseLoader } from '../loaders';
+import type { Input, LoaderResult } from '../models';
+import type { ChunkResult } from '../models/ChunkResult';
+
+class BaseChunker {
+  textSplitter: RecursiveCharacterTextSplitter;
+
+  constructor(textSplitter: RecursiveCharacterTextSplitter) {
+    this.textSplitter = textSplitter;
+  }
+
+  async createChunks(loader: BaseLoader, url: Input): Promise<ChunkResult> {
+    const documents: ChunkResult['documents'] = [];
+    const ids: ChunkResult['ids'] = [];
+    const datas: LoaderResult = await loader.loadData(url);
+    const metadatas: ChunkResult['metadatas'] = [];
+
+    const dataPromises = datas.map(async (data) => {
+      const { content, metaData } = data;
+      const chunks: string[] = await this.textSplitter.splitText(content);
+      chunks.forEach((chunk) => {
+        const chunkId = createHash('sha256')
+          .update(chunk + metaData.url)
+          .digest('hex');
+        ids.push(chunkId);
+        documents.push(chunk);
+        metadatas.push(metaData);
+      });
+    });
+
+    await Promise.all(dataPromises);
+
+    return {
+      documents,
+      ids,
+      metadatas,
+    };
+  }
+}
+
+export { BaseChunker };

embedchain-js/embedchain/chunkers/PdfFile.ts

@@ -0,0 +1,26 @@
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import { BaseChunker } from './BaseChunker';
+
+interface TextSplitterChunkParams {
+  chunkSize: number;
+  chunkOverlap: number;
+  keepSeparator: boolean;
+}
+
+const TEXT_SPLITTER_CHUNK_PARAMS: TextSplitterChunkParams = {
+  chunkSize: 1000,
+  chunkOverlap: 0,
+  keepSeparator: false,
+};
+
+class PdfFileChunker extends BaseChunker {
+  constructor() {
+    const textSplitter = new RecursiveCharacterTextSplitter(
+      TEXT_SPLITTER_CHUNK_PARAMS
+    );
+    super(textSplitter);
+  }
+}
+
+export { PdfFileChunker };

embedchain-js/embedchain/chunkers/QnaPair.ts

@@ -0,0 +1,26 @@
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import { BaseChunker } from './BaseChunker';
+
+interface TextSplitterChunkParams {
+  chunkSize: number;
+  chunkOverlap: number;
+  keepSeparator: boolean;
+}
+
+const TEXT_SPLITTER_CHUNK_PARAMS: TextSplitterChunkParams = {
+  chunkSize: 300,
+  chunkOverlap: 0,
+  keepSeparator: false,
+};
+
+class QnaPairChunker extends BaseChunker {
+  constructor() {
+    const textSplitter = new RecursiveCharacterTextSplitter(
+      TEXT_SPLITTER_CHUNK_PARAMS
+    );
+    super(textSplitter);
+  }
+}
+
+export { QnaPairChunker };

embedchain-js/embedchain/chunkers/WebPage.ts

@@ -0,0 +1,26 @@
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import { BaseChunker } from './BaseChunker';
+
+interface TextSplitterChunkParams {
+  chunkSize: number;
+  chunkOverlap: number;
+  keepSeparator: boolean;
+}
+
+const TEXT_SPLITTER_CHUNK_PARAMS: TextSplitterChunkParams = {
+  chunkSize: 500,
+  chunkOverlap: 0,
+  keepSeparator: false,
+};
+
+class WebPageChunker extends BaseChunker {
+  constructor() {
+    const textSplitter = new RecursiveCharacterTextSplitter(
+      TEXT_SPLITTER_CHUNK_PARAMS
+    );
+    super(textSplitter);
+  }
+}
+
+export { WebPageChunker };

embedchain-js/embedchain/chunkers/index.ts

@@ -0,0 +1,6 @@
+import { BaseChunker } from './BaseChunker';
+import { PdfFileChunker } from './PdfFile';
+import { QnaPairChunker } from './QnaPair';
+import { WebPageChunker } from './WebPage';
+
+export { BaseChunker, PdfFileChunker, QnaPairChunker, WebPageChunker };

embedchain-js/embedchain/embedchain.ts

@@ -0,0 +1,317 @@
+/* eslint-disable max-classes-per-file */
+import type { Collection } from 'chromadb';
+import type { QueryResponse } from 'chromadb/dist/main/types';
+import * as fs from 'fs';
+import { Document } from 'langchain/document';
+import OpenAI from 'openai';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+
+import type { BaseChunker } from './chunkers';
+import { PdfFileChunker, QnaPairChunker, WebPageChunker } from './chunkers';
+import type { BaseLoader } from './loaders';
+import { LocalQnaPairLoader, PdfFileLoader, WebPageLoader } from './loaders';
+import type {
+  DataDict,
+  DataType,
+  FormattedResult,
+  Input,
+  LocalInput,
+  Metadata,
+  Method,
+  RemoteInput,
+} from './models';
+import { ChromaDB } from './vectordb';
+import type { BaseVectorDB } from './vectordb/BaseVectorDb';
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+class EmbedChain {
+  dbClient: any;
+
+  // TODO: Definitely assign
+  collection!: Collection;
+
+  userAsks: [DataType, Input][] = [];
+
+  initApp: Promise<void>;
+
+  collectMetrics: boolean;
+
+  sId: string; // sessionId
+
+  constructor(db?: BaseVectorDB, collectMetrics: boolean = true) {
+    if (!db) {
+      this.initApp = this.setupChroma();
+    } else {
+      this.initApp = this.setupOther(db);
+    }
+
+    this.collectMetrics = collectMetrics;
+
+    // Send anonymous telemetry
+    this.sId = uuidv4();
+    this.sendTelemetryEvent('init');
+  }
+
+  async setupChroma(): Promise<void> {
+    const db = new ChromaDB();
+    await db.initDb;
+    this.dbClient = db.client;
+    if (db.collection) {
+      this.collection = db.collection;
+    } else {
+      // TODO: Add proper error handling
+      console.error('No collection');
+    }
+  }
+
+  async setupOther(db: BaseVectorDB): Promise<void> {
+    await db.initDb;
+    // TODO: Figure out how we can initialize an unknown database.
+    // this.dbClient = db.client;
+    // this.collection = db.collection;
+    this.userAsks = [];
+  }
+
+  static getLoader(dataType: DataType) {
+    const loaders: { [t in DataType]: BaseLoader } = {
+      pdf_file: new PdfFileLoader(),
+      web_page: new WebPageLoader(),
+      qna_pair: new LocalQnaPairLoader(),
+    };
+    return loaders[dataType];
+  }
+
+  static getChunker(dataType: DataType) {
+    const chunkers: { [t in DataType]: BaseChunker } = {
+      pdf_file: new PdfFileChunker(),
+      web_page: new WebPageChunker(),
+      qna_pair: new QnaPairChunker(),
+    };
+    return chunkers[dataType];
+  }
+
+  public async add(dataType: DataType, url: RemoteInput) {
+    const loader = EmbedChain.getLoader(dataType);
+    const chunker = EmbedChain.getChunker(dataType);
+    this.userAsks.push([dataType, url]);
+    const { documents, countNewChunks } = await this.loadAndEmbed(
+      loader,
+      chunker,
+      url
+    );
+
+    if (this.collectMetrics) {
+      const wordCount = documents.reduce(
+        (sum, document) => sum + document.split(' ').length,
+        0
+      );
+
+      this.sendTelemetryEvent('add', {
+        data_type: dataType,
+        word_count: wordCount,
+        chunks_count: countNewChunks,
+      });
+    }
+  }
+
+  public async addLocal(dataType: DataType, content: LocalInput) {
+    const loader = EmbedChain.getLoader(dataType);
+    const chunker = EmbedChain.getChunker(dataType);
+    this.userAsks.push([dataType, content]);
+    const { documents, countNewChunks } = await this.loadAndEmbed(
+      loader,
+      chunker,
+      content
+    );
+
+    if (this.collectMetrics) {
+      const wordCount = documents.reduce(
+        (sum, document) => sum + document.split(' ').length,
+        0
+      );
+
+      this.sendTelemetryEvent('add_local', {
+        data_type: dataType,
+        word_count: wordCount,
+        chunks_count: countNewChunks,
+      });
+    }
+  }
+
+  protected async loadAndEmbed(
+    loader: any,
+    chunker: BaseChunker,
+    src: Input
+  ): Promise<{
+    documents: string[];
+    metadatas: Metadata[];
+    ids: string[];
+    countNewChunks: number;
+  }> {
+    const embeddingsData = await chunker.createChunks(loader, src);
+    let { documents, ids, metadatas } = embeddingsData;
+
+    const existingDocs = await this.collection.get({ ids });
+    const existingIds = new Set(existingDocs.ids);
+
+    if (existingIds.size > 0) {
+      const dataDict: DataDict = {};
+      for (let i = 0; i < ids.length; i += 1) {
+        const id = ids[i];
+        if (!existingIds.has(id)) {
+          dataDict[id] = { doc: documents[i], meta: metadatas[i] };
+        }
+      }
+
+      if (Object.keys(dataDict).length === 0) {
+        console.log(`All data from ${src} already exists in the database.`);
+        return { documents: [], metadatas: [], ids: [], countNewChunks: 0 };
+      }
+      ids = Object.keys(dataDict);
+      const dataValues = Object.values(dataDict);
+      documents = dataValues.map(({ doc }) => doc);
+      metadatas = dataValues.map(({ meta }) => meta);
+    }
+
+    const countBeforeAddition = await this.count();
+    await this.collection.add({ documents, metadatas, ids });
+    const countNewChunks = (await this.count()) - countBeforeAddition;
+    console.log(
+      `Successfully saved ${src}. New chunks count: ${countNewChunks}`
+    );
+    return { documents, metadatas, ids, countNewChunks };
+  }
+
+  static async formatResult(
+    results: QueryResponse
+  ): Promise<FormattedResult[]> {
+    return results.documents[0].map((document: any, index: number) => {
+      const metadata = results.metadatas[0][index] || {};
+      // TODO: Add proper error handling
+      const distance = results.distances ? results.distances[0][index] : null;
+      return [new Document({ pageContent: document, metadata }), distance];
+    });
+  }
+
+  static async getOpenAiAnswer(prompt: string) {
+    const messages: OpenAI.Chat.CreateChatCompletionRequestMessage[] = [
+      { role: 'user', content: prompt },
+    ];
+    const response = await openai.chat.completions.create({
+      model: 'gpt-3.5-turbo',
+      messages,
+      temperature: 0,
+      max_tokens: 1000,
+      top_p: 1,
+    });
+    return (
+      response.choices[0].message?.content ?? 'Response could not be processed.'
+    );
+  }
+
+  protected async retrieveFromDatabase(inputQuery: string) {
+    const result = await this.collection.query({
+      nResults: 1,
+      queryTexts: [inputQuery],
+    });
+    const resultFormatted = await EmbedChain.formatResult(result);
+    const content = resultFormatted[0][0].pageContent;
+    return content;
+  }
+
+  static generatePrompt(inputQuery: string, context: any) {
+    const 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.\n${context}\nQuery: ${inputQuery}\nHelpful Answer:`;
+    return prompt;
+  }
+
+  static async getAnswerFromLlm(prompt: string) {
+    const answer = await EmbedChain.getOpenAiAnswer(prompt);
+    return answer;
+  }
+
+  public async query(inputQuery: string) {
+    const context = await this.retrieveFromDatabase(inputQuery);
+    const prompt = EmbedChain.generatePrompt(inputQuery, context);
+    const answer = await EmbedChain.getAnswerFromLlm(prompt);
+    this.sendTelemetryEvent('query');
+    return answer;
+  }
+
+  public async dryRun(input_query: string) {
+    const context = await this.retrieveFromDatabase(input_query);
+    const prompt = EmbedChain.generatePrompt(input_query, context);
+    return prompt;
+  }
+
+  /**
+   * Count the number of embeddings.
+   * @returns {Promise<number>}: The number of embeddings.
+   */
+  public count(): Promise<number> {
+    return this.collection.count();
+  }
+
+  protected async sendTelemetryEvent(method: Method, extraMetadata?: object) {
+    if (!this.collectMetrics) {
+      return;
+    }
+    const url = 'https://api.embedchain.ai/api/v1/telemetry/';
+
+    // Read package version from filesystem (because it's not in the ts root dir)
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+    const metadata = {
+      s_id: this.sId,
+      version: packageJson.version,
+      method,
+      language: 'js',
+      ...extraMetadata,
+    };
+
+    const maxRetries = 3;
+
+    // Retry the fetch
+    for (let i = 0; i < maxRetries; i += 1) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const response = await fetch(url, {
+          method: 'POST',
+          body: JSON.stringify({ metadata }),
+        });
+
+        if (response.ok) {
+          // Break out of the loop if the request was successful
+          break;
+        } else {
+          // Log the unsuccessful response (optional)
+          console.error(
+            `Telemetry: Attempt ${i + 1} failed with status:`,
+            response.status
+          );
+        }
+      } catch (error) {
+        // Log the error (optional)
+        console.error(`Telemetry: Attempt ${i + 1} failed with error:`, error);
+      }
+
+      // If this was the last attempt, throw an error or handle the failure
+      if (i === maxRetries - 1) {
+        console.error('Telemetry: Max retries reached');
+      }
+    }
+  }
+}
+
+class EmbedChainApp extends EmbedChain {
+  // The EmbedChain app.
+  // Has two functions: add and query.
+  // adds(dataType, url): adds the data from the given URL to the vector db.
+  // query(query): finds answer to the given query using vector database and LLM.
+}
+
+export { EmbedChainApp };

embedchain-js/embedchain/index.ts

@@ -0,0 +1,7 @@
+import { EmbedChainApp } from './embedchain';
+
+export const App = async () => {
+  const app = new EmbedChainApp();
+  await app.initApp;
+  return app;
+};

embedchain-js/embedchain/loaders/BaseLoader.ts

@@ -0,0 +1,5 @@
+import type { Input, LoaderResult } from '../models';
+
+export abstract class BaseLoader {
+  abstract loadData(src: Input): Promise<LoaderResult>;
+}

embedchain-js/embedchain/loaders/LocalQnaPair.ts

@@ -0,0 +1,21 @@
+import type { LoaderResult, QnaPair } from '../models';
+import { BaseLoader } from './BaseLoader';
+
+class LocalQnaPairLoader extends BaseLoader {
+  // eslint-disable-next-line class-methods-use-this
+  async loadData(content: QnaPair): Promise<LoaderResult> {
+    const [question, answer] = content;
+    const contentText = `Q: ${question}\nA: ${answer}`;
+    const metaData = {
+      url: 'local',
+    };
+    return [
+      {
+        content: contentText,
+        metaData,
+      },
+    ];
+  }
+}
+
+export { LocalQnaPairLoader };

embedchain-js/embedchain/loaders/PdfFile.ts

@@ -0,0 +1,58 @@
+import type { TextContent } from 'pdfjs-dist/types/src/display/api';
+
+import type { LoaderResult, Metadata } from '../models';
+import { cleanString } from '../utils';
+import { BaseLoader } from './BaseLoader';
+
+const pdfjsLib = require('pdfjs-dist');
+
+interface Page {
+  page_content: string;
+}
+
+class PdfFileLoader extends BaseLoader {
+  static async getPagesFromPdf(url: string): Promise<Page[]> {
+    const loadingTask = pdfjsLib.getDocument(url);
+    const pdf = await loadingTask.promise;
+    const { numPages } = pdf;
+
+    const promises = Array.from({ length: numPages }, async (_, i) => {
+      const page = await pdf.getPage(i + 1);
+      const pageText: TextContent = await page.getTextContent();
+      const pageContent: string = pageText.items
+        .map((item) => ('str' in item ? item.str : ''))
+        .join(' ');
+
+      return {
+        page_content: pageContent,
+      };
+    });
+
+    return Promise.all(promises);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async loadData(url: string): Promise<LoaderResult> {
+    const pages: Page[] = await PdfFileLoader.getPagesFromPdf(url);
+    const output: LoaderResult = [];
+
+    if (!pages.length) {
+      throw new Error('No data found');
+    }
+
+    pages.forEach((page) => {
+      let content: string = page.page_content;
+      content = cleanString(content);
+      const metaData: Metadata = {
+        url,
+      };
+      output.push({
+        content,
+        metaData,
+      });
+    });
+    return output;
+  }
+}
+
+export { PdfFileLoader };

embedchain-js/embedchain/loaders/WebPage.ts

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import { JSDOM } from 'jsdom';
+
+import { cleanString } from '../utils';
+import { BaseLoader } from './BaseLoader';
+
+class WebPageLoader extends BaseLoader {
+  // eslint-disable-next-line class-methods-use-this
+  async loadData(url: string) {
+    const response = await axios.get(url);
+    const html = response.data;
+    const dom = new JSDOM(html);
+    const { document } = dom.window;
+    const unwantedTags = [
+      'nav',
+      'aside',
+      'form',
+      'header',
+      'noscript',
+      'svg',
+      'canvas',
+      'footer',
+      'script',
+      'style',
+    ];
+    unwantedTags.forEach((tagName) => {
+      const elements = document.getElementsByTagName(tagName);
+      Array.from(elements).forEach((element) => {
+        // eslint-disable-next-line no-param-reassign
+        (element as HTMLElement).textContent = ' ';
+      });
+    });
+
+    const output = [];
+    let content = document.body.textContent;
+    if (!content) {
+      throw new Error('Web page content is empty.');
+    }
+    content = cleanString(content);
+    const metaData = {
+      url,
+    };
+    output.push({
+      content,
+      metaData,
+    });
+    return output;
+  }
+}
+
+export { WebPageLoader };

embedchain-js/embedchain/loaders/index.ts

@@ -0,0 +1,6 @@
+import { BaseLoader } from './BaseLoader';
+import { LocalQnaPairLoader } from './LocalQnaPair';
+import { PdfFileLoader } from './PdfFile';
+import { WebPageLoader } from './WebPage';
+
+export { BaseLoader, LocalQnaPairLoader, PdfFileLoader, WebPageLoader };

embedchain-js/embedchain/models/ChunkResult.ts

@@ -0,0 +1,7 @@
+import type { Metadata } from './Metadata';
+
+export type ChunkResult = {
+  documents: string[];
+  ids: string[];
+  metadatas: Metadata[];
+};

embedchain-js/embedchain/models/DataDict.ts

@@ -0,0 +1,10 @@
+import type { ChunkResult } from './ChunkResult';
+
+type Data = {
+  doc: ChunkResult['documents'][0];
+  meta: ChunkResult['metadatas'][0];
+};
+
+export type DataDict = {
+  [id: string]: Data;
+};

embedchain-js/embedchain/models/DataType.ts

@@ -0,0 +1 @@
+export type DataType = 'pdf_file' | 'web_page' | 'qna_pair';

embedchain-js/embedchain/models/FormattedResult.ts

@@ -0,0 +1,3 @@
+import type { Document } from 'langchain/document';
+
+export type FormattedResult = [Document, number | null];

embedchain-js/embedchain/models/Input.ts

@@ -0,0 +1,7 @@
+import type { QnaPair } from './QnAPair';
+
+export type RemoteInput = string;
+
+export type LocalInput = QnaPair;
+
+export type Input = RemoteInput | LocalInput;

embedchain-js/embedchain/models/LoaderResult.ts

@@ -0,0 +1,3 @@
+import type { Metadata } from './Metadata';
+
+export type LoaderResult = { content: any; metaData: Metadata }[];

embedchain-js/embedchain/models/Metadata.ts

@@ -0,0 +1,3 @@
+export type Metadata = {
+  url: string;
+};

embedchain-js/embedchain/models/Method.ts

@@ -0,0 +1 @@
+export type Method = 'init' | 'query' | 'add' | 'add_local';

embedchain-js/embedchain/models/QnAPair.ts

@@ -0,0 +1,4 @@
+type Question = string;
+type Answer = string;
+
+export type QnaPair = [Question, Answer];

embedchain-js/embedchain/models/index.ts

@@ -0,0 +1,21 @@
+import { DataDict } from './DataDict';
+import { DataType } from './DataType';
+import { FormattedResult } from './FormattedResult';
+import { Input, LocalInput, RemoteInput } from './Input';
+import { LoaderResult } from './LoaderResult';
+import { Metadata } from './Metadata';
+import { Method } from './Method';
+import { QnaPair } from './QnAPair';
+
+export {
+  DataDict,
+  DataType,
+  FormattedResult,
+  Input,
+  LoaderResult,
+  LocalInput,
+  Metadata,
+  Method,
+  QnaPair,
+  RemoteInput,
+};

embedchain-js/embedchain/utils.ts

@@ -0,0 +1,26 @@
+/**
+ * This function takes in a string and performs a series of text cleaning operations.
+ * @param {str} text: The text to be cleaned. This is expected to be a string.
+ * @returns {str}: The cleaned text after all the cleaning operations have been performed.
+ */
+export function cleanString(text: string): string {
+  // Replacement of newline characters:
+  let cleanedText = text.replace(/\n/g, ' ');
+
+  // Stripping and reducing multiple spaces to single:
+  cleanedText = cleanedText.trim().replace(/\s+/g, ' ');
+
+  // Removing backslashes:
+  cleanedText = cleanedText.replace(/\\/g, '');
+
+  // Replacing hash characters:
+  cleanedText = cleanedText.replace(/#/g, ' ');
+
+  // Eliminating consecutive non-alphanumeric characters:
+  // This regex identifies consecutive non-alphanumeric characters (i.e., not a word character [a-zA-Z0-9_] and not a whitespace) in the string
+  // and replaces each group of such characters with a single occurrence of that character.
+  // For example, "!!! hello !!!" would become "! hello !".
+  cleanedText = cleanedText.replace(/([^\w\s])\1*/g, '$1');
+
+  return cleanedText;
+}

embedchain-js/embedchain/vectordb/BaseVectorDb.ts

@@ -0,0 +1,14 @@
+class BaseVectorDB {
+  initDb: Promise<void>;
+
+  constructor() {
+    this.initDb = this.getClientAndCollection();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected async getClientAndCollection(): Promise<void> {
+    throw new Error('getClientAndCollection() method is not implemented');
+  }
+}
+
+export { BaseVectorDB };

embedchain-js/embedchain/vectordb/ChromaDb.ts

@@ -0,0 +1,38 @@
+import type { Collection } from 'chromadb';
+import { ChromaClient, OpenAIEmbeddingFunction } from 'chromadb';
+
+import { BaseVectorDB } from './BaseVectorDb';
+
+const embedder = new OpenAIEmbeddingFunction({
+  openai_api_key: process.env.OPENAI_API_KEY ?? '',
+});
+
+class ChromaDB extends BaseVectorDB {
+  client: ChromaClient | undefined;
+
+  collection: Collection | null = null;
+
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor() {
+    super();
+  }
+
+  protected async getClientAndCollection(): Promise<void> {
+    this.client = new ChromaClient({ path: 'http://localhost:8000' });
+    try {
+      this.collection = await this.client.getCollection({
+        name: 'embedchain_store',
+        embeddingFunction: embedder,
+      });
+    } catch (err) {
+      if (!this.collection) {
+        this.collection = await this.client.createCollection({
+          name: 'embedchain_store',
+          embeddingFunction: embedder,
+        });
+      }
+    }
+  }
+}
+
+export { ChromaDB };

embedchain-js/embedchain/vectordb/index.ts

@@ -0,0 +1,3 @@
+import { ChromaDB } from './ChromaDb';
+
+export { ChromaDB };

embedchain-js/index.js

@@ -0,0 +1,9 @@
+const { EmbedChainApp } = require("./embedchain/embedchain");
+
+async function App() {
+  const app = new EmbedChainApp();
+  await app.init_app;
+  return app;
+}
+
+module.exports = { App };

embedchain-js/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testPathIgnorePatterns: ['.d.ts'],
+};

embedchain-js/lint-staged.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  '*.{js,ts}': ['eslint --fix', 'eslint'],
+  '**/*.ts?(x)': () => 'npm run check-types',
+  '*.json': ['prettier --write'],
+};

embedchain-js/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "embedchain",
+  "version": "0.0.8",
+  "description": "embedchain is a framework to easily create LLM powered bots over any dataset",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json --listFiles",
+    "prepare": "husky install",
+    "test": "jest",
+    "check-types": "tsc --noEmit --pretty"
+  },
+  "author": "Taranjeet Singh",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "axios": "^1.4.0",
+    "chromadb": "^1.5.6",
+    "jsdom": "^22.1.0",
+    "langchain": "^0.0.136",
+    "openai": "^4.3.1",
+    "pdfjs-dist": "^3.8.162",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.1.2",
+    "@commitlint/config-conventional": "^17.1.0",
+    "@commitlint/cz-commitlint": "^17.1.2",
+    "@types/jest": "^29.5.1",
+    "@types/jsdom": "^21.1.1",
+    "@typescript-eslint/eslint-plugin": "^5.41.0",
+    "@typescript-eslint/parser": "^5.41.0",
+    "eslint": "^8.34.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-simple-import-sort": "^8.0.0",
+    "eslint-plugin-testing-library": "^5.9.1",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "husky": "^8.0.1",
+    "jest": "^29.5.0",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.1.0",
+    "ts-loader": "^9.4.2",
+    "typescript": "^5.2.2"
+  }
+}

embedchain-js/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["embedchain/__tests__"]
+}

embedchain-js/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "CommonJS",
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "embedchain",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationDir": "types",
+    "esModuleInterop": true
+  },
+  "include": ["embedchain/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

embedchain/__init__.py

@@ -1 +1,11 @@
-from .embedchain import App, OpenSourceApp, PersonApp, PersonOpenSourceApp
+import importlib.metadata
+
+__version__ = importlib.metadata.version(__package__ or __name__)
+
+from embedchain.apps.App import App  # noqa: F401
+from embedchain.apps.CustomApp import CustomApp  # noqa: F401
+from embedchain.apps.Llama2App import Llama2App  # noqa: F401
+from embedchain.apps.OpenSourceApp import OpenSourceApp  # noqa: F401
+from embedchain.apps.PersonApp import (PersonApp,  # noqa: F401
+                                       PersonOpenSourceApp)
+from embedchain.vectordb.chroma import ChromaDB  # noqa: F401

embedchain/apps/App.py

@@ -0,0 +1,54 @@
+from typing import Optional
+
+from embedchain.config import (AppConfig, BaseEmbedderConfig, BaseLlmConfig,
+                               ChromaDbConfig)
+from embedchain.embedchain import EmbedChain
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.chroma import ChromaDB
+
+
+@register_deserializable
+class App(EmbedChain):
+    """
+    The EmbedChain app in it's simplest and most straightforward form.
+    An opinionated choice of LLM, vector database and embedding model.
+
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
+    query(query): finds answer to the given query using vector database and LLM.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
+    """
+
+    def __init__(
+        self,
+        config: AppConfig = None,
+        llm_config: BaseLlmConfig = None,
+        chromadb_config: Optional[ChromaDbConfig] = None,
+        system_prompt: Optional[str] = None,
+    ):
+        """
+        Initialize a new `CustomApp` instance. You only have a few choices to make.
+
+        :param config: Config for the app instance.
+        This is the most basic configuration, that does not fall into the LLM, database or embedder category,
+        defaults to None
+        :type config: AppConfig, optional
+        :param llm_config: Allows you to configure the LLM, e.g. how many documents to return,
+        example: `from embedchain.config import LlmConfig`, defaults to None
+        :type llm_config: BaseLlmConfig, optional
+        :param chromadb_config: Allows you to configure the vector database,
+        example: `from embedchain.config import ChromaDbConfig`, defaults to None
+        :type chromadb_config: Optional[ChromaDbConfig], optional
+        :param system_prompt: System prompt that will be provided to the LLM as such, defaults to None
+        :type system_prompt: Optional[str], optional
+        """
+        if config is None:
+            config = AppConfig()
+
+        llm = OpenAILlm(config=llm_config)
+        embedder = OpenAiEmbedder(config=BaseEmbedderConfig(model="text-embedding-ada-002"))
+        database = ChromaDB(config=chromadb_config)
+
+        super().__init__(config, llm, db=database, embedder=embedder, system_prompt=system_prompt)

embedchain/apps/CustomApp.py

@@ -0,0 +1,83 @@
+from typing import Optional
+
+from embedchain.config import CustomAppConfig
+from embedchain.embedchain import EmbedChain
+from embedchain.embedder.base import BaseEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.base import BaseLlm
+from embedchain.vectordb.base import BaseVectorDB
+
+
+@register_deserializable
+class CustomApp(EmbedChain):
+    """
+    Embedchain's custom app allows for most flexibility.
+
+    You can craft your own mix of various LLMs, vector databases and embedding model/functions.
+
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
+    query(query): finds answer to the given query using vector database and LLM.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
+    """
+
+    def __init__(
+        self,
+        config: Optional[CustomAppConfig] = None,
+        llm: BaseLlm = None,
+        db: BaseVectorDB = None,
+        embedder: BaseEmbedder = None,
+        system_prompt: Optional[str] = None,
+    ):
+        """
+        Initialize a new `CustomApp` instance. You have to choose a LLM, database and embedder.
+
+        :param config: Config for the app instance. This is the most basic configuration,
+        that does not fall into the LLM, database or embedder category, defaults to None
+        :type config: Optional[CustomAppConfig], optional
+        :param llm: LLM Class instance. example: `from embedchain.llm.openai import OpenAILlm`, defaults to None
+        :type llm: BaseLlm
+        :param db: The database to use for storing and retrieving embeddings,
+        example: `from embedchain.vectordb.chroma_db import ChromaDb`, defaults to None
+        :type db: BaseVectorDB
+        :param embedder: The embedder (embedding model and function) use to calculate embeddings.
+        example: `from embedchain.embedder.gpt4all_embedder import GPT4AllEmbedder`, defaults to None
+        :type embedder: BaseEmbedder
+        :param system_prompt: System prompt that will be provided to the LLM as such, defaults to None
+        :type system_prompt: Optional[str], optional
+        :raises ValueError: LLM, database or embedder has not been defined.
+        :raises TypeError: LLM, database or embedder is not a valid class instance.
+        """
+        # Config is not required, it has a default
+        if config is None:
+            config = CustomAppConfig()
+
+        if llm is None:
+            raise ValueError("LLM must be provided for custom app. Please import from `embedchain.llm`.")
+        if db is None:
+            raise ValueError("Database must be provided for custom app. Please import from `embedchain.vectordb`.")
+        if embedder is None:
+            raise ValueError("Embedder must be provided for custom app. Please import from `embedchain.embedder`.")
+
+        if not isinstance(config, CustomAppConfig):
+            raise TypeError(
+                "Config is not a `CustomAppConfig` instance. "
+                "Please make sure the type is right and that you are passing an instance."
+            )
+        if not isinstance(llm, BaseLlm):
+            raise TypeError(
+                "LLM is not a `BaseLlm` instance. "
+                "Please make sure the type is right and that you are passing an instance."
+            )
+        if not isinstance(db, BaseVectorDB):
+            raise TypeError(
+                "Database is not a `BaseVectorDB` instance. "
+                "Please make sure the type is right and that you are passing an instance."
+            )
+        if not isinstance(embedder, BaseEmbedder):
+            raise TypeError(
+                "Embedder is not a `BaseEmbedder` instance. "
+                "Please make sure the type is right and that you are passing an instance."
+            )
+
+        super().__init__(config=config, llm=llm, db=db, embedder=embedder, system_prompt=system_prompt)

embedchain/apps/Llama2App.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from embedchain.apps.CustomApp import CustomApp
+from embedchain.config import CustomAppConfig
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.llama2 import Llama2Llm
+from embedchain.vectordb.chroma import ChromaDB
+
+
+@register_deserializable
+class Llama2App(CustomApp):
+    """
+    The EmbedChain Llama2App class.
+
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
+    query(query): finds answer to the given query using vector database and LLM.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
+    """
+
+    def __init__(self, config: CustomAppConfig = None, system_prompt: Optional[str] = None):
+        """
+        :param config: CustomAppConfig instance to load as configuration. Optional.
+        :param system_prompt: System prompt string. Optional.
+        """
+
+        if config is None:
+            config = CustomAppConfig()
+
+        super().__init__(
+            config=config, llm=Llama2Llm(), db=ChromaDB(), embedder=OpenAiEmbedder(), system_prompt=system_prompt
+        )

embedchain/apps/OpenSourceApp.py

@@ -0,0 +1,78 @@
+import logging
+from typing import Optional
+
+from embedchain.config import (BaseEmbedderConfig, BaseLlmConfig,
+                               ChromaDbConfig, OpenSourceAppConfig)
+from embedchain.embedchain import EmbedChain
+from embedchain.embedder.gpt4all import GPT4AllEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.gpt4all import GPT4ALLLlm
+from embedchain.vectordb.chroma import ChromaDB
+
+gpt4all_model = None
+
+
+@register_deserializable
+class OpenSourceApp(EmbedChain):
+    """
+    The embedchain Open Source App.
+    Comes preconfigured with the best open source LLM, embedding model, database.
+
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
+    query(query): finds answer to the given query using vector database and LLM.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
+    """
+
+    def __init__(
+        self,
+        config: OpenSourceAppConfig = None,
+        llm_config: BaseLlmConfig = None,
+        chromadb_config: Optional[ChromaDbConfig] = None,
+        system_prompt: Optional[str] = None,
+    ):
+        """
+        Initialize a new `CustomApp` instance.
+        Since it's opinionated you don't have to choose a LLM, database and embedder.
+        However, you can configure those.
+
+        :param config: Config for the app instance. This is the most basic configuration,
+        that does not fall into the LLM, database or embedder category, defaults to None
+        :type config: OpenSourceAppConfig, optional
+        :param llm_config: Allows you to configure the LLM, e.g. how many documents to return.
+        example: `from embedchain.config import LlmConfig`, defaults to None
+        :type llm_config: BaseLlmConfig, optional
+        :param chromadb_config: Allows you to configure the open source database,
+        example: `from embedchain.config import ChromaDbConfig`, defaults to None
+        :type chromadb_config: Optional[ChromaDbConfig], optional
+        :param system_prompt: System prompt that will be provided to the LLM as such.
+        Please don't use for the time being, as it's not supported., defaults to None
+        :type system_prompt: Optional[str], optional
+        :raises TypeError: `OpenSourceAppConfig` or `LlmConfig` invalid.
+        """
+        logging.info("Loading open source embedding model. This may take some time...")  # noqa:E501
+        if not config:
+            config = OpenSourceAppConfig()
+
+        if not isinstance(config, OpenSourceAppConfig):
+            raise TypeError(
+                "OpenSourceApp needs a OpenSourceAppConfig passed to it. "
+                "You can import it with `from embedchain.config import OpenSourceAppConfig`"
+            )
+
+        if not llm_config:
+            llm_config = BaseLlmConfig(model="orca-mini-3b.ggmlv3.q4_0.bin")
+        elif not isinstance(llm_config, BaseLlmConfig):
+            raise TypeError(
+                "The LlmConfig passed to OpenSourceApp is invalid. "
+                "You can import it with `from embedchain.config import LlmConfig`"
+            )
+        elif not llm_config.model:
+            llm_config.model = "orca-mini-3b.ggmlv3.q4_0.bin"
+
+        llm = GPT4ALLLlm(config=llm_config)
+        embedder = GPT4AllEmbedder(config=BaseEmbedderConfig(model="all-MiniLM-L6-v2"))
+        logging.error("Successfully loaded open source embedding model.")
+        database = ChromaDB(config=chromadb_config)
+
+        super().__init__(config, llm=llm, db=database, embedder=embedder, system_prompt=system_prompt)

embedchain/apps/PersonApp.py

@@ -0,0 +1,94 @@
+from string import Template
+
+from embedchain.apps.App import App
+from embedchain.apps.OpenSourceApp import OpenSourceApp
+from embedchain.config import BaseLlmConfig
+from embedchain.config.apps.BaseAppConfig import BaseAppConfig
+from embedchain.config.llm.base_llm_config import (DEFAULT_PROMPT,
+                                                   DEFAULT_PROMPT_WITH_HISTORY)
+from embedchain.helper.json_serializable import register_deserializable
+
+
+@register_deserializable
+class EmbedChainPersonApp:
+    """
+    Base class to create a person bot.
+    This bot behaves and speaks like a person.
+
+    :param person: name of the person, better if its a well known person.
+    :param config: BaseAppConfig instance to load as configuration.
+    """
+
+    def __init__(self, person: str, config: BaseAppConfig = None):
+        """Initialize a new person app
+
+        :param person: Name of the person that's imitated.
+        :type person: str
+        :param config: Configuration class instance, defaults to None
+        :type config: BaseAppConfig, optional
+        """
+        self.person = person
+        self.person_prompt = f"You are {person}. Whatever you say, you will always say in {person} style."  # noqa:E501
+        super().__init__(config)
+
+    def add_person_template_to_config(self, default_prompt: str, config: BaseLlmConfig = None):
+        """
+        This method checks if the config object contains a prompt template
+        if yes it adds the person prompt to it and return the updated config
+        else it creates a config object with the default prompt added to the person prompt
+
+        :param default_prompt:  it is the default prompt for query or chat methods
+        :type default_prompt: str
+        :param config: _description_, defaults to None
+        :type config: BaseLlmConfig, optional
+        :return: The `ChatConfig` instance to use as configuration options.
+        :rtype: _type_
+        """
+        template = Template(self.person_prompt + " " + default_prompt)
+
+        if config:
+            if config.template:
+                # Add person prompt to custom user template
+                config.template = Template(self.person_prompt + " " + config.template.template)
+            else:
+                # If no user template is present, use person prompt with the default template
+                config.template = template
+        else:
+            # if no config is present at all, initialize the config with person prompt and default template
+            config = BaseLlmConfig(
+                template=template,
+            )
+
+        return config
+
+
+@register_deserializable
+class PersonApp(EmbedChainPersonApp, App):
+    """
+    The Person app.
+    Extends functionality from EmbedChainPersonApp and App
+    """
+
+    def query(self, input_query, config: BaseLlmConfig = None, dry_run=False):
+        config = self.add_person_template_to_config(DEFAULT_PROMPT, config, where=None)
+        return super().query(input_query, config, dry_run, where=None)
+
+    def chat(self, input_query, config: BaseLlmConfig = None, dry_run=False, where=None):
+        config = self.add_person_template_to_config(DEFAULT_PROMPT_WITH_HISTORY, config)
+        return super().chat(input_query, config, dry_run, where)
+
+
+@register_deserializable
+class PersonOpenSourceApp(EmbedChainPersonApp, OpenSourceApp):
+    """
+    The Person app.
+    Extends functionality from EmbedChainPersonApp and OpenSourceApp
+    """
+
+    def query(self, input_query, config: BaseLlmConfig = None, dry_run=False):
+        config = self.add_person_template_to_config(DEFAULT_PROMPT, config)
+        return super().query(input_query, config, dry_run)
+
+    def chat(self, input_query, config: BaseLlmConfig = None, dry_run=False):
+        config = self.add_person_template_to_config(DEFAULT_PROMPT_WITH_HISTORY, config)
+        return super().chat(input_query, config, dry_run)

embedchain/bots/__init__.py

@@ -0,0 +1,5 @@
+from embedchain.bots.poe import PoeBot  # noqa: F401
+from embedchain.bots.whatsapp import WhatsAppBot  # noqa: F401
+
+# TODO: fix discord import
+# from embedchain.bots.discord import DiscordBot

embedchain/bots/base.py

@@ -0,0 +1,46 @@
+from typing import Any
+
+from embedchain import CustomApp
+from embedchain.config import AddConfig, CustomAppConfig, LlmConfig
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.helper.json_serializable import (JSONSerializable,
+                                                 register_deserializable)
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.chroma import ChromaDB
+
+
+@register_deserializable
+class BaseBot(JSONSerializable):
+    def __init__(self):
+        self.app = CustomApp(config=CustomAppConfig(), llm=OpenAILlm(), db=ChromaDB(), embedder=OpenAiEmbedder())
+
+    def add(self, data: Any, config: AddConfig = None):
+        """
+        Add data to the bot (to the vector database).
+        Auto-dectects type only, so some data types might not be usable.
+
+        :param data: data to embed
+        :type data: Any
+        :param config: configuration class instance, defaults to None
+        :type config: AddConfig, optional
+        """
+        config = config if config else AddConfig()
+        self.app.add(data, config=config)
+
+    def query(self, query: str, config: LlmConfig = None) -> str:
+        """
+        Query the bot
+
+        :param query: the user query
+        :type query: str
+        :param config: configuration class instance, defaults to None
+        :type config: LlmConfig, optional
+        :return: Answer
+        :rtype: str
+        """
+        config = config
+        return self.app.query(query, config=config)
+
+    def start(self):
+        """Start the bot's functionality."""
+        raise NotImplementedError("Subclasses must implement the start method.")

embedchain/bots/discord.py

@@ -0,0 +1,127 @@
+import argparse
+import logging
+import os
+
+from embedchain.helper.json_serializable import register_deserializable
+
+from .base import BaseBot
+
+try:
+    import discord
+    from discord import app_commands
+    from discord.ext import commands
+except ModuleNotFoundError:
+    raise ModuleNotFoundError(
+        "The required dependencies for Discord are not installed."
+        'Please install with `pip install "embedchain[discord]"`'
+    ) from None
+
+
+intents = discord.Intents.default()
+intents.message_content = True
+client = discord.Client(intents=intents)
+tree = app_commands.CommandTree(client)
+
+# Invite link example
+# https://discord.com/api/oauth2/authorize?client_id={DISCORD_CLIENT_ID}&permissions=2048&scope=bot
+
+
+@register_deserializable
+class DiscordBot(BaseBot):
+    def __init__(self, *args, **kwargs):
+        BaseBot.__init__(self, *args, **kwargs)
+
+    def add_data(self, message):
+        data = message.split(" ")[-1]
+        try:
+            self.add(data)
+            response = f"Added data from: {data}"
+        except Exception:
+            logging.exception(f"Failed to add data {data}.")
+            response = "Some error occurred while adding data."
+        return response
+
+    def ask_bot(self, message):
+        try:
+            response = self.query(message)
+        except Exception:
+            logging.exception(f"Failed to query {message}.")
+            response = "An error occurred. Please try again!"
+        return response
+
+    def start(self):
+        client.run(os.environ["DISCORD_BOT_TOKEN"])
+
+
+# @tree decorator cannot be used in a class. A global discord_bot is used as a workaround.
+
+
+@tree.command(name="question", description="ask embedchain")
+async def query_command(interaction: discord.Interaction, question: str):
+    await interaction.response.defer()
+    member = client.guilds[0].get_member(client.user.id)
+    logging.info(f"User: {member}, Query: {question}")
+    try:
+        answer = discord_bot.ask_bot(question)
+        if args.include_question:
+            response = f"> {question}\n\n{answer}"
+        else:
+            response = answer
+        await interaction.followup.send(response)
+    except Exception as e:
+        await interaction.followup.send("An error occurred. Please try again!")
+        logging.error("Error occurred during 'query' command:", e)
+
+
+@tree.command(name="add", description="add new content to the embedchain database")
+async def add_command(interaction: discord.Interaction, url_or_text: str):
+    await interaction.response.defer()
+    member = client.guilds[0].get_member(client.user.id)
+    logging.info(f"User: {member}, Add: {url_or_text}")
+    try:
+        response = discord_bot.add_data(url_or_text)
+        await interaction.followup.send(response)
+    except Exception as e:
+        await interaction.followup.send("An error occurred. Please try again!")
+        logging.error("Error occurred during 'add' command:", e)
+
+
+@tree.command(name="ping", description="Simple ping pong command")
+async def ping(interaction: discord.Interaction):
+    await interaction.response.send_message("Pong", ephemeral=True)
+
+
+@tree.error
+async def on_app_command_error(interaction: discord.Interaction, error: discord.app_commands.AppCommandError) -> None:
+    if isinstance(error, commands.CommandNotFound):
+        await interaction.followup.send("Invalid command. Please refer to the documentation for correct syntax.")
+    else:
+        logging.error("Error occurred during command execution:", error)
+
+
+@client.event
+async def on_ready():
+    # TODO: Sync in admin command, to not hit rate limits.
+    # This might be overkill for most users, and it would require to set a guild or user id, where sync is allowed.
+    await tree.sync()
+    logging.debug("Command tree synced")
+    logging.info(f"Logged in as {client.user.name}")
+
+
+def start_command():
+    parser = argparse.ArgumentParser(description="EmbedChain DiscordBot command line interface")
+    parser.add_argument(
+        "--include-question",
+        help="include question in query reply, otherwise it is hidden behind the slash command.",
+        action="store_true",
+    )
+    global args
+    args = parser.parse_args()
+
+    global discord_bot
+    discord_bot = DiscordBot()
+    discord_bot.start()
+
+
+if __name__ == "__main__":
+    start_command()

embedchain/bots/poe.py

@@ -0,0 +1,87 @@
+import argparse
+import logging
+import os
+from typing import List, Optional
+
+from embedchain.helper.json_serializable import register_deserializable
+
+from .base import BaseBot
+
+try:
+    from fastapi_poe import PoeBot, run
+except ModuleNotFoundError:
+    raise ModuleNotFoundError(
+        "The required dependencies for Poe are not installed." 'Please install with `pip install "embedchain[poe]"`'
+    ) from None
+
+
+def start_command():
+    parser = argparse.ArgumentParser(description="EmbedChain PoeBot command line interface")
+    # parser.add_argument("--host", default="0.0.0.0", help="Host IP to bind")
+    parser.add_argument("--port", default=8080, type=int, help="Port to bind")
+    parser.add_argument("--api-key", type=str, help="Poe API key")
+    # parser.add_argument(
+    #     "--history-length",
+    #     default=5,
+    #     type=int,
+    #     help="Set the max size of the chat history. Multiplies cost, but improves conversation awareness.",
+    # )
+    args = parser.parse_args()
+
+    # FIXME: Arguments are automatically loaded by Poebot's ArgumentParser which causes it to fail.
+    # the port argument here is also just for show, it actually works because poe has the same argument.
+
+    run(PoeBot(), api_key=args.api_key or os.environ.get("POE_API_KEY"))
+
+
+@register_deserializable
+class PoeBot(BaseBot, PoeBot):
+    def __init__(self):
+        self.history_length = 5
+        super().__init__()
+
+    async def get_response(self, query):
+        last_message = query.query[-1].content
+        try:
+            history = (
+                [f"{m.role}: {m.content}" for m in query.query[-(self.history_length + 1) : -1]]
+                if len(query.query) > 0
+                else None
+            )
+        except Exception as e:
+            logging.error(f"Error when processing the chat history. Message is being sent without history. Error: {e}")
+        answer = self.handle_message(last_message, history)
+        yield self.text_event(answer)
+
+    def handle_message(self, message, history: Optional[List[str]] = None):
+        if message.startswith("/add "):
+            response = self.add_data(message)
+        else:
+            response = self.ask_bot(message, history)
+        return response
+
+    # def add_data(self, message):
+    #     data = message.split(" ")[-1]
+    #     try:
+    #         self.add(data)
+    #         response = f"Added data from: {data}"
+    #     except Exception:
+    #         logging.exception(f"Failed to add data {data}.")
+    #         response = "Some error occurred while adding data."
+    #     return response
+
+    def ask_bot(self, message, history: List[str]):
+        try:
+            self.app.llm.set_history(history=history)
+            response = self.query(message)
+        except Exception:
+            logging.exception(f"Failed to query {message}.")
+            response = "An error occurred. Please try again!"
+        return response
+
+    def start(self):
+        start_command()
+
+
+if __name__ == "__main__":
+    start_command()

embedchain/bots/slack.py

@@ -0,0 +1,99 @@
+import argparse
+import logging
+import os
+import signal
+import sys
+
+from embedchain import App
+from embedchain.helper.json_serializable import register_deserializable
+
+from .base import BaseBot
+
+try:
+    from flask import Flask, request
+    from slack_sdk import WebClient
+except ModuleNotFoundError:
+    raise ModuleNotFoundError(
+        "The required dependencies for Slack are not installed."
+        'Please install with `pip install --upgrade "embedchain[slack]"`'
+    ) from None
+
+
+SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
+
+
+@register_deserializable
+class SlackBot(BaseBot):
+    def __init__(self):
+        self.client = WebClient(token=SLACK_BOT_TOKEN)
+        self.chat_bot = App()
+        self.recent_message = {"ts": 0, "channel": ""}
+        super().__init__()
+
+    def handle_message(self, event_data):
+        message = event_data.get("event")
+        if message and "text" in message and message.get("subtype") != "bot_message":
+            text: str = message["text"]
+            if float(message.get("ts")) > float(self.recent_message["ts"]):
+                self.recent_message["ts"] = message["ts"]
+                self.recent_message["channel"] = message["channel"]
+                if text.startswith("query"):
+                    _, question = text.split(" ", 1)
+                    try:
+                        response = self.chat_bot.chat(question)
+                        self.send_slack_message(message["channel"], response)
+                        logging.info("Query answered successfully!")
+                    except Exception as e:
+                        self.send_slack_message(message["channel"], "An error occurred. Please try again!")
+                        logging.error("Error occurred during 'query' command:", e)
+                elif text.startswith("add"):
+                    _, data_type, url_or_text = text.split(" ", 2)
+                    if url_or_text.startswith("<") and url_or_text.endswith(">"):
+                        url_or_text = url_or_text[1:-1]
+                    try:
+                        self.chat_bot.add(url_or_text, data_type)
+                        self.send_slack_message(message["channel"], f"Added {data_type} : {url_or_text}")
+                    except ValueError as e:
+                        self.send_slack_message(message["channel"], f"Error: {str(e)}")
+                        logging.error("Error occurred during 'add' command:", e)
+                    except Exception as e:
+                        self.send_slack_message(message["channel"], f"Failed to add {data_type} : {url_or_text}")
+                        logging.error("Error occurred during 'add' command:", e)
+
+    def send_slack_message(self, channel, message):
+        response = self.client.chat_postMessage(channel=channel, text=message)
+        return response
+
+    def start(self, host="0.0.0.0", port=5000, debug=True):
+        app = Flask(__name__)
+
+        def signal_handler(sig, frame):
+            logging.info("\nGracefully shutting down the SlackBot...")
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, signal_handler)
+
+        @app.route("/", methods=["POST"])
+        def chat():
+            # Check if the request is a verification request
+            if request.json.get("challenge"):
+                return str(request.json.get("challenge"))
+
+            response = self.handle_message(request.json)
+            return str(response)
+
+        app.run(host=host, port=port, debug=debug)
+
+
+def start_command():
+    parser = argparse.ArgumentParser(description="EmbedChain SlackBot command line interface")
+    parser.add_argument("--host", default="0.0.0.0", help="Host IP to bind")
+    parser.add_argument("--port", default=5000, type=int, help="Port to bind")
+    args = parser.parse_args()
+
+    slack_bot = SlackBot()
+    slack_bot.start(host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    start_command()

embedchain/bots/whatsapp.py

@@ -0,0 +1,81 @@
+import argparse
+import importlib
+import logging
+import signal
+import sys
+
+from embedchain.helper.json_serializable import register_deserializable
+
+from .base import BaseBot
+
+
+@register_deserializable
+class WhatsAppBot(BaseBot):
+    def __init__(self):
+        try:
+            self.flask = importlib.import_module("flask")
+            self.twilio = importlib.import_module("twilio")
+        except ModuleNotFoundError:
+            raise ModuleNotFoundError(
+                "The required dependencies for WhatsApp are not installed. "
+                'Please install with `pip install --upgrade "embedchain[whatsapp]"`'
+            ) from None
+        super().__init__()
+
+    def handle_message(self, message):
+        if message.startswith("add "):
+            response = self.add_data(message)
+        else:
+            response = self.ask_bot(message)
+        return response
+
+    def add_data(self, message):
+        data = message.split(" ")[-1]
+        try:
+            self.add(data)
+            response = f"Added data from: {data}"
+        except Exception:
+            logging.exception(f"Failed to add data {data}.")
+            response = "Some error occurred while adding data."
+        return response
+
+    def ask_bot(self, message):
+        try:
+            response = self.query(message)
+        except Exception:
+            logging.exception(f"Failed to query {message}.")
+            response = "An error occurred. Please try again!"
+        return response
+
+    def start(self, host="0.0.0.0", port=5000, debug=True):
+        app = self.flask.Flask(__name__)
+
+        def signal_handler(sig, frame):
+            logging.info("\nGracefully shutting down the WhatsAppBot...")
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, signal_handler)
+
+        @app.route("/chat", methods=["POST"])
+        def chat():
+            incoming_message = self.flask.request.values.get("Body", "").lower()
+            response = self.handle_message(incoming_message)
+            twilio_response = self.twilio.twiml.messaging_response.MessagingResponse()
+            twilio_response.message(response)
+            return str(twilio_response)
+
+        app.run(host=host, port=port, debug=debug)
+
+
+def start_command():
+    parser = argparse.ArgumentParser(description="EmbedChain WhatsAppBot command line interface")
+    parser.add_argument("--host", default="0.0.0.0", help="Host IP to bind")
+    parser.add_argument("--port", default=5000, type=int, help="Port to bind")
+    args = parser.parse_args()
+
+    whatsapp_bot = WhatsAppBot()
+    whatsapp_bot.start(host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    start_command()

embedchain/chunkers/base_chunker.py

@@ -1,10 +1,14 @@
 import hashlib
 
+from embedchain.helper.json_serializable import JSONSerializable
+from embedchain.models.data_type import DataType
 
-class BaseChunker:
+
+class BaseChunker(JSONSerializable):
     def __init__(self, text_splitter):
         """Initialize the chunker."""
         self.text_splitter = text_splitter
+        self.data_type = None
 
     def create_chunks(self, loader, src):
         """
@@ -18,14 +22,20 @@ class BaseChunker:
         documents = []
         ids = []
         idMap = {}
-        datas = loader.load_data(src)
+        data_result = loader.load_data(src)
+        data_records = data_result["data"]
+        doc_id = data_result["doc_id"]
         metadatas = []
-        for data in datas:
+        for data in data_records:
             content = data["content"]
+
             meta_data = data["meta_data"]
+            # add data type to meta data to allow query using data type
+            meta_data["data_type"] = self.data_type.value
+            meta_data["doc_id"] = doc_id
             url = meta_data["url"]
 
-            chunks = self.text_splitter.split_text(content)
+            chunks = self.get_chunks(content)
 
             for chunk in chunks:
                 chunk_id = hashlib.sha256((chunk + url).encode()).hexdigest()
@@ -38,4 +48,21 @@ class BaseChunker:
             "documents": documents,
             "ids": ids,
             "metadatas": metadatas,
+            "doc_id": doc_id,
         }
+
+    def get_chunks(self, content):
+        """
+        Returns chunks using text splitter instance.
+
+        Override in child class if custom logic.
+        """
+        return self.text_splitter.split_text(content)
+
+    def set_data_type(self, data_type: DataType):
+        """
+        set the data type of chunker
+        """
+        self.data_type = data_type
+
+        # TODO: This should be done during initialization. This means it has to be done in the child classes.