feat: Bump version to 0.0.53 (#552 )

fix: Add upgrade for pip install (#551 )
feat: Make poe bot run as an app instead of server. (#550 )
2023-09-05 09:04:37 +05:30 · 2023-09-05 09:02:48 +05:30 · 2023-09-05 08:59:41 +05:30 · 2023-09-05 03:45:53 +05:30 · 2023-09-05 02:19:59 +05:30 · 2023-09-05 00:20:20 +05:30
178 changed files with 16775 additions and 392 deletions
@@ -1 +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
@@ -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.
@@ -1,8 +1,9 @@
 name: 🚀 Feature request
-description: Submit a proposal/request for a new embedchain feature
+description: Submit a proposal/request for a new Embedchain feature

 body:
 - type: textarea
+  id: feature-request
  attributes:
    label: 🚀 The feature
    description: >
@@ -16,16 +17,6 @@ body:
      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: textarea
-  attributes:
-    label: Alternatives
-    description: >
-      A description of any alternative solutions or features you've considered, if any.
- type: textarea
-  attributes:
-    label: Additional context
-    description: >
-      Add any other context or screenshots about the feature request.
 - type: markdown
  attributes:
    value: >
@@ -1,24 +1,40 @@
-name: cd
+name: Publish Python 🐍 distributions 📦 to PyPI and TestPyPI

 on:
  release:
-    types:
-      - published
-
-permissions:
-  id-token: write
-  contents: read
+    types: [published] # This will trigger the workflow when you create a new release

 jobs:
-  publish_to_pypi:
-    name: publish to pypi on new release
+  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@v3
-      - uses: JRubics/poetry-publish@v1.16
-        name: Build and publish to PyPI
+      - uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
        with:
-          pypi_token: ${{ secrets.PYPI_TOKEN }}
-          ignore_dev_requirements: "yes"
-          repository_url: https://upload.pypi.org/legacy/
-          repository_name: embedchain
+          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
@@ -1,42 +1,23 @@
 # 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)
+[![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)

+## 🤝 Schedule a 1-on-1 Session
+
+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.
+
 ## 🔧 Quick install

 ```bash
-pip install embedchain
+pip install --upgrade embedchain
 ```

-## 🔥 Latest
-
- **[2023/07/19]** Released support for 🦙 `llama2` model. Start creating your `llama2` based bots like this:
-
-  ```python
-  import os
-
-  from embedchain import Llama2App
-
-  os.environ['REPLICATE_API_TOKEN'] = "REPLICATE API TOKEN"
-
-  zuck_bot = Llama2App()
-
-  # Embed your data
-  zuck_bot.add("youtube_video", "https://www.youtube.com/watch?v=Ff4fRgnuFgQ")
-  zuck_bot.add("web_page", "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.
-  ```
-
-
 ## 🔍 Demo

 Try out embedchain in your browser:
@@ -51,6 +32,16 @@ The documentation for embedchain can be found at [docs.embedchain.ai](https://do

 Embedchain empowers you to create chatbot models similar to ChatGPT, using your own evolving dataset.

+### Data Types Supported
+
+* Youtube video
+* PDF file
+* Web page
+* Sitemap
+* Doc file
+* Code documentation website loader
+* Notion
+
 ### Queries

 For example, you can use Embedchain to create an Elon Musk bot using the following code:
@@ -64,9 +55,9 @@ os.environ["OPENAI_API_KEY"] = "YOUR API KEY"
 elon_bot = App()

 # Embed online resources
-elon_bot.add("web_page", "https://en.wikipedia.org/wiki/Elon_Musk")
-elon_bot.add("web_page", "https://tesla.com/elon-musk")
-elon_bot.add("youtube_video", "https://www.youtube.com/watch?v=MxZpaJK74Y4")
+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")

 # Query the bot
 elon_bot.query("How many companies does Elon Musk run?")
@@ -78,6 +69,12 @@ elon_bot.query("How many companies does Elon Musk run?")
 Contributions are welcome! Please check out the issues on the repository, and feel free to open a pull request.
 For more information, please see the [contributing guidelines](CONTRIBUTING.md).

+For more reference, please go through [Development Guide](https://docs.embedchain.ai/contribution/dev) and [Documentation Guide](https://docs.embedchain.ai/contribution/docs).
+
+<a href="https://github.com/embedchain/embedchain/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=embedchain/embedchain" />
+</a>
+
 ## Citation

 If you utilize this repository, please consider citing it with:
@@ -85,7 +82,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},
@@ -6,20 +6,20 @@ title: '➕ Adding Data'

 - 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()` function to add any dataset.
+- 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("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")
+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_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
+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.
@@ -14,7 +14,7 @@ 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 have don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
+- `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`

@@ -35,8 +35,8 @@ os.environ['REPLICATE_API_TOKEN'] = "REPLICATE API TOKEN"
 zuck_bot = Llama2App()

 # Embed your data
-zuck_bot.add("youtube_video", "https://www.youtube.com/watch?v=Ff4fRgnuFgQ")
-zuck_bot.add("web_page", "https://en.wikipedia.org/wiki/Mark_Zuckerberg")
+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?")
@@ -49,7 +49,7 @@ zuck_bot.query("Who owns the new threads app and when it was founded?")
 ```

 - `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 have don't have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
+- `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
@@ -63,6 +63,7 @@ app = OpenSourceApp()
 - 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 embedchain[opensource]`.

 ### CustomApp

@@ -85,11 +86,13 @@ app = CustomApp(config)
    - ANTHPROPIC
    - VERTEX_AI
    - GPT4ALL
+    - AZURE_OPENAI
 - Following embedding functions are available for an embedding function
    - OPENAI
    - HUGGING_FACE
    - VERTEX_AI
    - GPT4ALL
+    - AZURE_OPENAI


 ### PersonApp
@@ -100,7 +103,7 @@ 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).
+- `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
@@ -20,19 +20,23 @@ from chromadb.utils import embedding_functions
 config = AppConfig(log_level="DEBUG")
 naval_chat_bot = App(config)

+# Example: specify a custom collection name
+config = AppConfig(collection_name="naval_chat_bot")
+naval_chat_bot = App(config)
+
 # Example: define your own chunker config for `youtube_video`
 chunker_config = ChunkerConfig(chunk_size=1000, chunk_overlap=100, length_function=len)
-naval_chat_bot.add("youtube_video", "https://www.youtube.com/watch?v=3qHkcs3kG44", AddConfig(chunker=chunker_config))
+naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44", AddConfig(chunker=chunker_config))

 add_config = AddConfig()
-naval_chat_bot.add("pdf_file", "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf", add_config)
-naval_chat_bot.add("web_page", "https://nav.al/feedback", add_config)
-naval_chat_bot.add("web_page", "https://nav.al/agi", add_config)
+naval_chat_bot.add("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_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."), add_config)
+naval_chat_bot.add(("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."), config=add_config)

 query_config = QueryConfig()
-print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", query_config))
+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
@@ -49,7 +53,7 @@ einstein_chat_bot = App()

 # Embed Wikipedia page
 page = wikipedia.page("Albert Einstein")
-einstein_chat_bot.add("text", page.content)
+einstein_chat_bot.add(page.content)

 # Example: use your own custom template with `$context` and `$query`
 einstein_chat_template = Template("""
@@ -64,14 +68,14 @@ einstein_chat_template = Template("""

        Human: $query
        Albert Einstein:""")
-query_config = QueryConfig(einstein_chat_template)
+query_config = QueryConfig(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, query_config)
+        response = einstein_chat_bot.query(query, config=query_config)
        print("Query: ", query)
        print("Response: ", response)

@@ -2,14 +2,40 @@
 title: '📋 Supported data formats'
 ---

-Embedchain supports following 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('youtube_video', 'a_valid_youtube_url_here')
+app.add('a_valid_youtube_url_here', data_type='youtube_video')
 ```

 ### PDF file
@@ -17,7 +43,7 @@ app.add('youtube_video', 'a_valid_youtube_url_here')
 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')
+app.add('a_valid_url_where_pdf_file_can_be_accessed', data_type='pdf_file')
 ```

 Note that we do not support password protected pdfs.
@@ -27,7 +53,7 @@ Note that we do not support password protected pdfs.
 To add any web page, use the data_type as `web_page`. Eg:

 ```python
-app.add('web_page', 'a_valid_web_page_url')
+app.add('a_valid_web_page_url', data_type='web_page')
 ```

 ### Sitemap
@@ -35,15 +61,16 @@ app.add('web_page', 'a_valid_web_page_url')
 Add all web pages from an xml-sitemap. Filters non-text files. Use the data_type as `sitemap`. Eg:

 ```python
-app.add('sitemap', 'https://example.com/sitemap.xml')
+app.add('https://example.com/sitemap.xml', data_type='sitemap')
 ```

 ### Doc file

-To add any doc/docx file, use the data_type as `docx`. Eg:
+To add any doc/docx file, use the data_type as `docx`. `docx` allows remote urls and conventional file paths. Eg:

 ```python
-app.add('docx', 'a_local_docx_file_path')
+app.add('https://example.com/content/intro.docx', data_type="docx")
+app.add('content/intro.docx', data_type="docx")
 ```

 ### Code documentation website loader
@@ -51,15 +78,29 @@ app.add('docx', 'a_local_docx_file_path')
 To add any code documentation website as a loader, use the data_type as `docs_site`. Eg:

 ```python
-app.add("docs_site", "https://docs.embedchain.ai/")
+app.add("https://docs.embedchain.ai/", data_type="docs_site")
 ```

+### Notion
+To use notion you must install the extra dependencies with `pip install 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")
+```
+
+## 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_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.')
+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.
@@ -69,7 +110,7 @@ Note: This is not used in the examples because in most cases you will supply a w
 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"))
+app.add(("Question", "Answer"), data_type="qna_pair")
 ```

 ## Reusing a vector database
@@ -82,8 +123,8 @@ Create a local index:
 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")
+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:
@@ -95,6 +136,6 @@ 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!)
+## 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.
@@ -19,7 +19,7 @@ print(naval_chat_bot.query("What unique capacity does Naval argue humans possess

 ### Chat Interface

- This interface is chat interface where it remembers previous conversation. Right now it remembers 5 conversation by default. 💬
+- 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.

@@ -72,4 +72,4 @@ Counts the number of embeddings (chunks) in the database.
 ```python
 print(app.count())
 # returns: 481
-```
+```
@@ -4,11 +4,13 @@ title: '🔍 Query configurations'

 ## AppConfig

-| option      | description           | type                            | default                |
-|-------------|-----------------------|---------------------------------|------------------------|
-| log_level   | log level             | string                          | WARNING                |
+| 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               |
+| 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
@@ -23,7 +25,7 @@ Yes, you are passing `ChunkerConfig` to `AddConfig`, like so:
 ```python
 chunker_config = ChunkerConfig(chunk_size=100)
 add_config = AddConfig(chunker=chunker_config)
-app.add_local("text", "lorem ipsum", config=add_config)
+app.add("lorem ipsum", config=add_config)
 ```

 ### ChunkerConfig
@@ -45,6 +47,7 @@ Default values of chunker config parameters for different `data_type`:
 |pdf_file|1000|0|len|
 |youtube_video|2000|0|len|
 |docs_site|500|50|len|
+|notion|300|0|len|

 ### LoaderConfig

@@ -54,9 +57,16 @@ _coming soon_

 |option|description|type|default|
 |---|---|---|---|
-|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|
+|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

@@ -64,4 +74,4 @@ All options for query and...

 _coming soon_

-History is handled automatically, the config option is not supported.
+`history` is not supported, as that is handled is handled automatically, the config option is not supported.
@@ -8,40 +8,69 @@ Embedchain community has been super active in creating demos on top of Embedchai

 ### 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/))
+- [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/)
+- [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
@@ -49,9 +78,38 @@ Embedchain community has been super active in creating demos on top of Embedchai
 - [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)
@@ -0,0 +1,34 @@
+---
+title: '💾 Vector Database'
+---
+
+We support `Chroma` and `Elasticsearch` as two vector database. 
+`Chroma` is used as a default database.
+
+### Elasticsearch
+In order to use `Elasticsearch` as vector database we need to use App type `CustomApp`. 
+```python
+import os
+from embedchain import CustomApp
+from embedchain.config import CustomAppConfig, ElasticsearchDBConfig
+from embedchain.models import Providers, EmbeddingFunctions, VectorDatabases
+
+os.environ["OPENAI_API_KEY"] = 'OPENAI_API_KEY'
+
+es_config = ElasticsearchDBConfig(
+	# elasticsearch url or list of nodes url with different hosts and ports.
+	es_url='http://localhost:9200',
+	# pass named parameters supported by Python Elasticsearch client
+	ca_certs="/path/to/http_ca.crt",
+	basic_auth=("username", "password")
+)
+config = CustomAppConfig(
+	embedding_fn=EmbeddingFunctions.OPENAI, 
+	provider=Providers.OPENAI, 
+	db_type=VectorDatabases.ELASTICSEARCH, 
+	es_config=es_config,
+)
+es_app = CustomApp(config)
+```
+- Set `db_type=VectorDatabases.ELASTICSEARCH` and `es_config=ElasticsearchDBConfig(es_url='')` in `CustomAppConfig`.
+- `ElasticsearchDBConfig` accepts `es_url` as elasticsearch url or as list of nodes url with different hosts and ports. Additionally we can pass named parameters supported by Python Elasticsearch client.
@@ -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! 🎉
@@ -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 "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! 🎉
@@ -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! 🎉
@@ -0,0 +1,49 @@
+---
+title: '🔮 Poe Bot'
+---
+
+### 🚀 Getting started
+
+1. Install embedchain python package:
+
+```bash
+pip install "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. Now create your bot using the following code snippet
+
+```bash
+from embedchain 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()
+```
+
+9. You can refer the [Supported Data formats](https://docs.embedchain.ai/advanced/data_types) section to refer the supported data types in embedchain.
+
+10. Click `Run check` to make sure your machine can be reached.
+11. Make sure your bot is private if that's what you want.
+12. Click `Create bot` at the bottom to finally create the bot
+13. Now you 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.
@@ -0,0 +1,39 @@
+---
+title: '💼 Slack Bot'
+---
+
+### 🖼️ Template Setup
+
+- Fork [this](https://replit.com/@taranjeetio/EC-Slack-Bot-Template?v=1#README.md) replit template.
+- Set your `OPENAI_API_KEY` in Secrets.
+- Create a workspace on Slack if you don't have one already by clicking [here](https://slack.com/intl/en-in/).
+- Create a new App on your Slack account by going [here](https://api.slack.com/apps).
+- Select `From Scratch`, then enter the Bot Name and select your workspace.
+- On the `Basic Information` page copy the `Signing Secret` and set it in your secrets as `SLACK_SIGNING_SECRET`.
+- 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
+```
+- 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`.
+- Start your replit container now by clicking on `Run`.
+- On the Slack API website go to `Event Subscriptions` on the left Sidebar and turn on `Enable Events`.
+- Copy the generated server URL in replit, append `/chat` at its end and paste it in `Request URL` box.
+- After it gets verified, click on `Subscribe to bot events`, add `message.channels` Bot User Event and click on `Save Changes`.
+- Now go to your workspace, click on the bot name in the Sidebar and then add the bot to any channel you want.
+
+### 🚀 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! 🎉
@@ -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! 🎉
@@ -0,0 +1,46 @@
+---
+title: '💬 WhatsApp Bot'
+---
+
+### 🚀 Getting started
+
+1. Install embedchain python package:
+
+```bash
+pip install 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"/>
@@ -7,7 +7,7 @@ description: '📝 Embedchain is a framework to easily create LLM powered bots o

 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 and .add_local functions. Then, simply use the .query function to find answers from the added datasets.
+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.

@@ -16,13 +16,13 @@ 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")
+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_local("qna_pair", ("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))
+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.
@@ -32,7 +32,7 @@ naval_chat_bot.query("What unique capacity does Naval argue humans possess when

 Creating a chat bot over any dataset involves the following steps:

-1. Load the data
+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
@@ -53,4 +53,4 @@ The process of loading the dataset and querying involves multiple steps, each wi

 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()` function, and use the `.query()` function to get the relevant answers.
+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.
@@ -32,7 +32,11 @@
    },
    {
      "group": "Advanced",
-      "pages": ["advanced/app_types", "advanced/interface_types", "advanced/adding_data","advanced/data_types", "advanced/query_configuration", "advanced/configuration", "advanced/testing", "advanced/showcase"]
+      "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",
@@ -43,7 +47,8 @@
  "footerSocials": {
    "twitter": "https://twitter.com/embedchain",
    "github": "https://github.com/embedchain/embedchain",
-    "linkedin": "https://www.linkedin.com/company/embedchain"
+    "linkedin": "https://www.linkedin.com/company/embedchain",
+    "website": "https://embedchain.ai"
  },
  "backgroundImage": "/background.png",
  "isWhiteLabeled": true
@@ -20,16 +20,16 @@ Run your first bot in python using the following code. Make sure to set the `OPE
 ```python
 import os

-from embedchain Import App
+from embedchain import App

 os.environ["OPENAI_API_KEY"] = "xxx"
 elon_musk_bot = App()

 # Embed Online Resources
-elon_musk_bot.add("web_page", "https://en.wikipedia.org/wiki/Elon_Musk")
-elon_musk_bot.add("web_page", "https://www.tesla.com/elon-musk")
+elon_musk_bot.add("https://en.wikipedia.org/wiki/Elon_Musk")
+elon_musk_bot.add("https://www.tesla.com/elon-musk")

-response = elon_bot.query("How many companies does Elon Musk run?")
+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.'
 ```
@@ -1,9 +1,13 @@
+from typing import Optional
+
 import openai

 from embedchain.config import AppConfig, ChatConfig
 from embedchain.embedchain import EmbedChain
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class App(EmbedChain):
    """
    The EmbedChain app.
@@ -14,17 +18,27 @@ class App(EmbedChain):
    dry_run(query): test your prompt without consuming tokens.
    """

-    def __init__(self, config: AppConfig = None):
+    def __init__(self, config: AppConfig = None, system_prompt: Optional[str] = None):
        """
        :param config: AppConfig instance to load as configuration. Optional.
+        :param system_prompt: System prompt string. Optional.
        """
        if config is None:
            config = AppConfig()

-        super().__init__(config)
+        super().__init__(config, system_prompt)

    def get_llm_model_answer(self, prompt, config: ChatConfig):
        messages = []
+        system_prompt = (
+            self.system_prompt
+            if self.system_prompt is not None
+            else config.system_prompt
+            if config.system_prompt is not None
+            else None
+        )
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
        messages.append({"role": "user", "content": prompt})
        response = openai.ChatCompletion.create(
            model=config.model or "gpt-3.5-turbo-0613",
@@ -1,13 +1,15 @@
 import logging
-from typing import List
+from typing import List, Optional

 from langchain.schema import BaseMessage

 from embedchain.config import ChatConfig, CustomAppConfig
 from embedchain.embedchain import EmbedChain
+from embedchain.helper_classes.json_serializable import register_deserializable
 from embedchain.models import Providers


+@register_deserializable
 class CustomApp(EmbedChain):
    """
    The custom EmbedChain app.
@@ -18,10 +20,11 @@ class CustomApp(EmbedChain):
    dry_run(query): test your prompt without consuming tokens.
    """

-    def __init__(self, config: CustomAppConfig = None):
+    def __init__(self, config: CustomAppConfig = None, system_prompt: Optional[str] = None):
        """
        :param config: Optional. `CustomAppConfig` instance to load as configuration.
        :raises ValueError: Config must be provided for custom app
+        :param system_prompt: Optional. System prompt string.
        """
        if config is None:
            raise ValueError("Config must be provided for custom app")
@@ -34,7 +37,7 @@ class CustomApp(EmbedChain):
            # Because these models run locally, they should have an instance running when the custom app is created
            self.open_source_app = OpenSourceApp(config=config.open_source_app_config)

-        super().__init__(config)
+        super().__init__(config, system_prompt)

    def set_llm_model(self, provider: Providers):
        self.provider = provider
@@ -51,6 +54,9 @@ class CustomApp(EmbedChain):
                "Streaming responses have not been implemented for this model yet. Please disable."
            )

+        if config.system_prompt is None and self.system_prompt is not None:
+            config.system_prompt = self.system_prompt
+
        try:
            if self.provider == Providers.OPENAI:
                return CustomApp._get_openai_answer(prompt, config)
@@ -64,15 +70,16 @@ class CustomApp(EmbedChain):
            if self.provider == Providers.GPT4ALL:
                return self.open_source_app._get_gpt4all_answer(prompt, config)

+            if self.provider == Providers.AZURE_OPENAI:
+                return CustomApp._get_azure_openai_answer(prompt, config)
+
        except ImportError as e:
-            raise ImportError(e.msg) from None
+            raise ModuleNotFoundError(e.msg) from None

    @staticmethod
    def _get_openai_answer(prompt: str, config: ChatConfig) -> str:
        from langchain.chat_models import ChatOpenAI

-        logging.info(vars(config))
-
        chat = ChatOpenAI(
            temperature=config.temperature,
            model=config.model or "gpt-3.5-turbo",
@@ -83,7 +90,7 @@ class CustomApp(EmbedChain):
        if config.top_p and config.top_p != 1:
            logging.warning("Config option `top_p` is not supported by this model.")

-        messages = CustomApp._get_messages(prompt)
+        messages = CustomApp._get_messages(prompt, system_prompt=config.system_prompt)

        return chat(messages).content

@@ -96,7 +103,7 @@ class CustomApp(EmbedChain):
        if config.max_tokens and config.max_tokens != 1000:
            logging.warning("Config option `max_tokens` is not supported by this model.")

-        messages = CustomApp._get_messages(prompt)
+        messages = CustomApp._get_messages(prompt, system_prompt=config.system_prompt)

        return chat(messages).content

@@ -109,15 +116,42 @@ class CustomApp(EmbedChain):
        if config.top_p and config.top_p != 1:
            logging.warning("Config option `top_p` is not supported by this model.")

-        messages = CustomApp._get_messages(prompt)
+        messages = CustomApp._get_messages(prompt, system_prompt=config.system_prompt)

        return chat(messages).content

    @staticmethod
-    def _get_messages(prompt: str) -> List[BaseMessage]:
+    def _get_azure_openai_answer(prompt: str, config: ChatConfig) -> str:
+        from langchain.chat_models import AzureChatOpenAI
+
+        if not config.deployment_name:
+            raise ValueError("Deployment name must be provided for Azure OpenAI")
+
+        chat = AzureChatOpenAI(
+            deployment_name=config.deployment_name,
+            openai_api_version="2023-05-15",
+            model_name=config.model or "gpt-3.5-turbo",
+            temperature=config.temperature,
+            max_tokens=config.max_tokens,
+            streaming=config.stream,
+        )
+
+        if config.top_p and config.top_p != 1:
+            logging.warning("Config option `top_p` is not supported by this model.")
+
+        messages = CustomApp._get_messages(prompt, system_prompt=config.system_prompt)
+
+        return chat(messages).content
+
+    @staticmethod
+    def _get_messages(prompt: str, system_prompt: Optional[str] = None) -> List[BaseMessage]:
        from langchain.schema import HumanMessage, SystemMessage

-        return [SystemMessage(content="You are a helpful assistant."), HumanMessage(content=prompt)]
+        messages = []
+        if system_prompt:
+            messages.append(SystemMessage(content=system_prompt))
+        messages.append(HumanMessage(content=prompt))
+        return messages

    def _stream_llm_model_response(self, response):
        """
@@ -1,8 +1,9 @@
 import os
+from typing import Optional

 from langchain.llms import Replicate

-from embedchain.config import AppConfig
+from embedchain.config import AppConfig, ChatConfig
 from embedchain.embedchain import EmbedChain


@@ -15,9 +16,10 @@ class Llama2App(EmbedChain):
    query(query): finds answer to the given query using vector database and LLM.
    """

-    def __init__(self, config: AppConfig = None):
+    def __init__(self, config: AppConfig = None, system_prompt: Optional[str] = None):
        """
        :param config: AppConfig instance to load as configuration. Optional.
+        :param system_prompt: System prompt string. Optional.
        """
        if "REPLICATE_API_TOKEN" not in os.environ:
            raise ValueError("Please set the REPLICATE_API_TOKEN environment variable.")
@@ -25,10 +27,12 @@ class Llama2App(EmbedChain):
        if config is None:
            config = AppConfig()

-        super().__init__(config)
+        super().__init__(config, system_prompt)

-    def get_llm_model_answer(self, prompt, config: AppConfig = None):
+    def get_llm_model_answer(self, prompt, config: ChatConfig = None):
        # TODO: Move the model and other inputs into config
+        if self.system_prompt or config.system_prompt:
+            raise ValueError("Llama2App does not support `system_prompt`")
        llm = Replicate(
            model="a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5",
            input={"temperature": 0.75, "max_length": 500, "top_p": 1},
@@ -1,12 +1,14 @@
 import logging
-from typing import Iterable, Union
+from typing import Iterable, Optional, Union

 from embedchain.config import ChatConfig, OpenSourceAppConfig
 from embedchain.embedchain import EmbedChain
+from embedchain.helper_classes.json_serializable import register_deserializable

 gpt4all_model = None


+@register_deserializable
 class OpenSourceApp(EmbedChain):
    """
    The OpenSource app.
@@ -18,10 +20,11 @@ class OpenSourceApp(EmbedChain):
    query(query): finds answer to the given query using vector database and LLM.
    """

-    def __init__(self, config: OpenSourceAppConfig = None):
+    def __init__(self, config: OpenSourceAppConfig = None, system_prompt: Optional[str] = None):
        """
        :param config: OpenSourceAppConfig instance to load as configuration. Optional.
        `ef` defaults to open source.
+        :param system_prompt: System prompt string. Optional.
        """
        logging.info("Loading open source embedding model. This may take some time...")  # noqa:E501
        if not config:
@@ -33,7 +36,7 @@ class OpenSourceApp(EmbedChain):
        self.instance = OpenSourceApp._get_instance(config.model)

        logging.info("Successfully loaded open source embedding model.")
-        super().__init__(config)
+        super().__init__(config, system_prompt)

    def get_llm_model_answer(self, prompt, config: ChatConfig):
        return self._get_gpt4all_answer(prompt=prompt, config=config)
@@ -43,8 +46,8 @@ class OpenSourceApp(EmbedChain):
        try:
            from gpt4all import GPT4All
        except ModuleNotFoundError:
-            raise ValueError(
-                "The GPT4All python package is not installed. Please install it with `pip install GPT4All`"
+            raise ModuleNotFoundError(
+                "The GPT4All python package is not installed. Please install it with `pip install embedchain[opensource]`"  # noqa E501
            ) from None

        return GPT4All(model)
@@ -55,6 +58,9 @@ class OpenSourceApp(EmbedChain):
                "OpenSourceApp does not support switching models at runtime. Please create a new app instance."
            )

+        if self.system_prompt or config.system_prompt:
+            raise ValueError("OpenSourceApp does not support `system_prompt`")
+
        response = self.instance.generate(
            prompt=prompt,
            streaming=config.stream,
@@ -4,10 +4,11 @@ from embedchain.apps.App import App
 from embedchain.apps.OpenSourceApp import OpenSourceApp
 from embedchain.config import ChatConfig, QueryConfig
 from embedchain.config.apps.BaseAppConfig import BaseAppConfig
-from embedchain.config.QueryConfig import (DEFAULT_PROMPT,
-                                           DEFAULT_PROMPT_WITH_HISTORY)
+from embedchain.config.QueryConfig import DEFAULT_PROMPT, DEFAULT_PROMPT_WITH_HISTORY
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class EmbedChainPersonApp:
    """
    Base class to create a person bot.
@@ -22,42 +23,61 @@ class EmbedChainPersonApp:
        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: ChatConfig = 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
+        :param config: Optional. The `ChatConfig` instance to use as
+        configuration options.
+        """
+        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 = QueryConfig(
+                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: QueryConfig = None):
-        self.template = Template(self.person_prompt + " " + DEFAULT_PROMPT)
-        query_config = QueryConfig(
-            template=self.template,
-        )
-        return super().query(input_query, query_config)
+    def query(self, input_query, config: QueryConfig = 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: ChatConfig = None):
-        self.template = Template(self.person_prompt + " " + DEFAULT_PROMPT_WITH_HISTORY)
-        chat_config = ChatConfig(
-            template=self.template,
-        )
-        return super().chat(input_query, chat_config)
+    def chat(self, input_query, config: ChatConfig = 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: QueryConfig = None):
-        query_config = QueryConfig(
-            template=self.template,
-        )
-        return super().query(input_query, query_config)
+    def query(self, input_query, config: QueryConfig = 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: ChatConfig = None):
-        chat_config = ChatConfig(
-            template=self.template,
-        )
-        return super().chat(input_query, chat_config)
+    def chat(self, input_query, config: ChatConfig = None, dry_run=False):
+        config = self.add_person_template_to_config(DEFAULT_PROMPT_WITH_HISTORY, config)
+        return super().chat(input_query, config, dry_run)
@@ -0,0 +1,4 @@
+from embedchain.bots.poe import PoeBot
+from embedchain.bots.whatsapp import WhatsAppBot
+# TODO: fix discord import
+# from embedchain.bots.discord import DiscordBot
@@ -0,0 +1,28 @@
+from embedchain import CustomApp
+from embedchain.config import AddConfig, CustomAppConfig, QueryConfig
+from embedchain.helper_classes.json_serializable import (
+    JSONSerializable, register_deserializable)
+from embedchain.models import EmbeddingFunctions, Providers
+
+
+@register_deserializable
+class BaseBot(JSONSerializable):
+    def __init__(self, app_config=None):
+        if app_config is None:
+            app_config = CustomAppConfig(embedding_fn=EmbeddingFunctions.OPENAI, provider=Providers.OPENAI)
+        self.app_config = app_config
+        self.app = CustomApp(config=self.app_config)
+
+    def add(self, data, config: AddConfig = None):
+        """Add data to the bot"""
+        config = config if config else AddConfig()
+        self.app.add(data, config=config)
+
+    def query(self, query, config: QueryConfig = None):
+        """Query bot"""
+        config = config if config else QueryConfig()
+        return self.app.query(query, config=config)
+
+    def start(self):
+        """Start the bot's functionality."""
+        raise NotImplementedError("Subclasses must implement the start method.")
@@ -0,0 +1,117 @@
+import argparse
+import logging
+import os
+
+import discord
+from discord import app_commands
+from discord.ext import commands
+
+from .base import BaseBot
+
+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
+
+
+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()
@@ -0,0 +1,84 @@
+import argparse
+import logging
+import os
+from typing import List, Optional
+
+from fastapi_poe import PoeBot, run
+
+from embedchain.config import QueryConfig
+from embedchain.helper_classes.json_serializable import register_deserializable
+
+from .base import BaseBot
+
+
+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}")
+        logging.warning(history)
+        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:
+            config = QueryConfig(history=history)
+            response = self.query(message, config)
+        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()
@@ -0,0 +1,74 @@
+import argparse
+import logging
+import signal
+import sys
+
+from embedchain.helper_classes.json_serializable import register_deserializable
+
+from .base import BaseBot
+
+
+@register_deserializable
+class WhatsAppBot(BaseBot):
+    def __init__(self):
+        from flask import Flask, request
+        from twilio.twiml.messaging_response import MessagingResponse
+        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 = 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 = request.values.get("Body", "").lower()
+            response = self.handle_message(incoming_message)
+            twilio_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()
@@ -1,7 +1,10 @@
 import hashlib

+from embedchain.helper_classes.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
@@ -26,7 +29,7 @@ class BaseChunker:

            meta_data = data["meta_data"]
            # add data type to meta data to allow query using data type
-            meta_data["data_type"] = self.data_type
+            meta_data["data_type"] = self.data_type.value
            url = meta_data["url"]

            chunks = self.get_chunks(content)
@@ -52,8 +55,10 @@ class BaseChunker:
        """
        return self.text_splitter.split_text(content)

-    def set_data_type(self, data_type):
+    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.
@@ -4,8 +4,10 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter

 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class DocsSiteChunker(BaseChunker):
    """Chunker for code docs site."""

@@ -4,8 +4,10 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter

 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class DocxFileChunker(BaseChunker):
    """Chunker for .docx file."""

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+from embedchain.chunkers.base_chunker import BaseChunker
+from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable
+
+
+@register_deserializable
+class NotionChunker(BaseChunker):
+    """Chunker for notion."""
+
+    def __init__(self, config: Optional[ChunkerConfig] = None):
+        if config is None:
+            config = ChunkerConfig(chunk_size=300, chunk_overlap=0, length_function=len)
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=config.chunk_size,
+            chunk_overlap=config.chunk_overlap,
+            length_function=config.length_function,
+        )
+        super().__init__(text_splitter)
@@ -4,8 +4,10 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter

 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class PdfFileChunker(BaseChunker):
    """Chunker for PDF file."""

@@ -4,8 +4,10 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter

 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class QnaPairChunker(BaseChunker):
    """Chunker for QnA pair."""

@@ -4,8 +4,10 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter

 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class TextChunker(BaseChunker):
    """Chunker for text."""

@@ -4,8 +4,10 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter

 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class WebPageChunker(BaseChunker):
    """Chunker for web page."""

@@ -4,8 +4,10 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter

 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config.AddConfig import ChunkerConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class YoutubeVideoChunker(BaseChunker):
    """Chunker for Youtube video."""

@@ -1,8 +1,10 @@
 from typing import Callable, Optional

 from embedchain.config.BaseConfig import BaseConfig
+from embedchain.helper_classes.json_serializable import register_deserializable


+@register_deserializable
 class ChunkerConfig(BaseConfig):
    """
    Config for the chunker used in `add` method
@@ -19,6 +21,7 @@ class ChunkerConfig(BaseConfig):
        self.length_function = length_function if length_function else len


+@register_deserializable
 class LoaderConfig(BaseConfig):
    """
    Config for the chunker used in `add` method
@@ -28,6 +31,7 @@ class LoaderConfig(BaseConfig):
        pass


+@register_deserializable
 class AddConfig(BaseConfig):
    """
    Config for the `add` method.
@@ -1,4 +1,7 @@
-class BaseConfig:
+from embedchain.helper_classes.json_serializable import JSONSerializable
+
+
+class BaseConfig(JSONSerializable):
    """
    Base config.
    """
@@ -1,6 +1,8 @@
 from string import Template
+from typing import Optional

 from embedchain.config.QueryConfig import QueryConfig
+from embedchain.helper_classes.json_serializable import register_deserializable

 DEFAULT_PROMPT = """
  You are a chatbot having a conversation with a human. You are given chat
@@ -19,6 +21,7 @@ DEFAULT_PROMPT = """
 DEFAULT_PROMPT_TEMPLATE = Template(DEFAULT_PROMPT)


+@register_deserializable
 class ChatConfig(QueryConfig):
    """
    Config for the `chat` method, inherits from `QueryConfig`.
@@ -33,6 +36,9 @@ class ChatConfig(QueryConfig):
        max_tokens=None,
        top_p=None,
        stream: bool = False,
+        deployment_name=None,
+        system_prompt: Optional[str] = None,
+        where=None,
    ):
        """
        Initializes the ChatConfig instance.
@@ -50,6 +56,9 @@ class ChatConfig(QueryConfig):
        (closer to 1) make word selection more diverse, lower values make words less
        diverse.
        :param stream: Optional. Control if response is streamed back to the user
+        :param deployment_name: t.b.a.
+        :param system_prompt: Optional. System prompt string.
+        :param where: Optional. A dictionary of key-value pairs to filter the database results.
        :raises ValueError: If the template is not valid as template should contain
        $context and $query and $history
        """
@@ -68,6 +77,9 @@ class ChatConfig(QueryConfig):
            top_p=top_p,
            history=[0],
            stream=stream,
+            deployment_name=deployment_name,
+            system_prompt=system_prompt,
+            where=where,
        )

    def set_history(self, history):
@@ -1,7 +1,9 @@
 import re
 from string import Template
+from typing import Optional

 from embedchain.config.BaseConfig import BaseConfig
+from embedchain.helper_classes.json_serializable import register_deserializable

 DEFAULT_PROMPT = """
  Use the following pieces of context to answer the query at the end.
@@ -47,6 +49,7 @@ context_re = re.compile(r"\$\{*context\}*")
 history_re = re.compile(r"\$\{*history\}*")


+@register_deserializable
 class QueryConfig(BaseConfig):
    """
    Config for the `query` method.
@@ -62,6 +65,9 @@ class QueryConfig(BaseConfig):
        top_p=None,
        history=None,
        stream: bool = False,
+        deployment_name=None,
+        system_prompt: Optional[str] = None,
+        where=None,
    ):
        """
        Initializes the QueryConfig instance.
@@ -80,6 +86,9 @@ class QueryConfig(BaseConfig):
        diverse.
        :param history: Optional. A list of strings to consider as history.
        :param stream: Optional. Control if response is streamed back to user
+        :param deployment_name: t.b.a.
+        :param system_prompt: Optional. System prompt string.
+        :param where: Optional. A dictionary of key-value pairs to filter the database results.
        :raises ValueError: If the template is not valid as template should
        contain $context and $query (and optionally $history).
        """
@@ -106,6 +115,8 @@ class QueryConfig(BaseConfig):
        self.max_tokens = max_tokens if max_tokens else 1000
        self.model = model
        self.top_p = top_p if top_p else 1
+        self.deployment_name = deployment_name
+        self.system_prompt = system_prompt

        if self.validate_template(template):
            self.template = template
@@ -118,6 +129,7 @@ class QueryConfig(BaseConfig):
        if not isinstance(stream, bool):
            raise ValueError("`stream` should be bool")
        self.stream = stream
+        self.where = where

    def validate_template(self, template: Template):
        """
@@ -5,3 +5,5 @@ from .apps.OpenSourceAppConfig import OpenSourceAppConfig  # noqa: F401
 from .BaseConfig import BaseConfig  # noqa: F401
 from .ChatConfig import ChatConfig  # noqa: F401
 from .QueryConfig import QueryConfig  # noqa: F401
+from .vectordbs.ElasticsearchDBConfig import \
+    ElasticsearchDBConfig  # noqa: F401
@@ -1,25 +1,51 @@
 import os
+from typing import Optional

-from chromadb.utils import embedding_functions
+try:
+    from chromadb.utils import embedding_functions
+except RuntimeError:
+    from embedchain.utils import use_pysqlite3
+
+    use_pysqlite3()
+    from chromadb.utils import embedding_functions
+
+from embedchain.helper_classes.json_serializable import register_deserializable

 from .BaseAppConfig import BaseAppConfig


+@register_deserializable
 class AppConfig(BaseAppConfig):
    """
    Config to initialize an embedchain custom `App` instance, with extra config options.
    """

-    def __init__(self, log_level=None, host=None, port=None, id=None):
+    def __init__(
+        self,
+        log_level=None,
+        host=None,
+        port=None,
+        id=None,
+        collection_name=None,
+        collect_metrics: Optional[bool] = None,
+    ):
        """
        :param log_level: Optional. (String) Debug level
        ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'].
-        :param id: Optional. ID of the app. Document metadata will have this id.
        :param host: Optional. Hostname for the database server.
        :param port: Optional. Port for the database server.
+        :param id: Optional. ID of the app. Document metadata will have this id.
+        :param collection_name: Optional. Collection name for the database.
+        :param collect_metrics: Defaults to True. Send anonymous telemetry to improve embedchain.
        """
        super().__init__(
-            log_level=log_level, embedding_fn=AppConfig.default_embedding_function(), host=host, port=port, id=id
+            log_level=log_level,
+            embedding_fn=AppConfig.default_embedding_function(),
+            host=host,
+            port=port,
+            id=id,
+            collection_name=collection_name,
+            collect_metrics=collect_metrics,
        )

    @staticmethod
@@ -1,45 +1,94 @@
 import logging

 from embedchain.config.BaseConfig import BaseConfig
+from embedchain.config.vectordbs import ElasticsearchDBConfig
+from embedchain.helper_classes.json_serializable import JSONSerializable
+from embedchain.models import VectorDatabases, VectorDimensions


-class BaseAppConfig(BaseConfig):
+class BaseAppConfig(BaseConfig, JSONSerializable):
    """
    Parent config to initialize an instance of `App`, `OpenSourceApp` or `CustomApp`.
    """

-    def __init__(self, log_level=None, embedding_fn=None, db=None, host=None, port=None, id=None):
+    def __init__(
+        self,
+        log_level=None,
+        embedding_fn=None,
+        db=None,
+        host=None,
+        port=None,
+        id=None,
+        collection_name=None,
+        collect_metrics: bool = True,
+        db_type: VectorDatabases = None,
+        vector_dim: VectorDimensions = None,
+        es_config: ElasticsearchDBConfig = None,
+        chroma_settings: dict = {},
+    ):
        """
        :param log_level: Optional. (String) Debug level
        ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'].
        :param embedding_fn: Embedding function to use.
        :param db: Optional. (Vector) database instance to use for embeddings.
-        :param id: Optional. ID of the app. Document metadata will have this id.
        :param host: Optional. Hostname for the database server.
        :param port: Optional. Port for the database server.
+        :param id: Optional. ID of the app. Document metadata will have this id.
+        :param collection_name: Optional. Collection name for the database.
+        :param collect_metrics: Defaults to True. Send anonymous telemetry to improve embedchain.
+        :param db_type: Optional. type of Vector database to use
+        :param vector_dim: Vector dimension generated by embedding fn
+        :param es_config: Optional. elasticsearch database config to be used for connection
+        :param chroma_settings: Optional. Chroma settings for connection.
        """
        self._setup_logging(log_level)
-
-        self.db = db if db else BaseAppConfig.default_db(embedding_fn=embedding_fn, host=host, port=port)
+        self.collection_name = collection_name if collection_name else "embedchain_store"
+        self.db = BaseAppConfig.get_db(
+            db=db,
+            embedding_fn=embedding_fn,
+            host=host,
+            port=port,
+            db_type=db_type,
+            vector_dim=vector_dim,
+            collection_name=self.collection_name,
+            es_config=es_config,
+            chroma_settings=chroma_settings,
+        )
        self.id = id
+        self.collect_metrics = True if (collect_metrics is True or collect_metrics is None) else False
        return

    @staticmethod
-    def default_db(embedding_fn, host, port):
+    def get_db(db, embedding_fn, host, port, db_type, vector_dim, collection_name, es_config, chroma_settings):
        """
-        Sets database to default (`ChromaDb`).
-
+        Get db based on db_type, db with default database (`ChromaDb`)
+        :param Optional. (Vector) database to use for embeddings.
        :param embedding_fn: Embedding function to use in database.
        :param host: Optional. Hostname for the database server.
        :param port: Optional. Port for the database server.
-        :returns: Default database
+        :param db_type: Optional. db type to use. Supported values (`es`, `chroma`)
+        :param vector_dim: Vector dimension generated by embedding fn
+        :param collection_name: Optional. Collection name for the database.
+        :param es_config: Optional. elasticsearch database config to be used for connection
        :raises ValueError: BaseAppConfig knows no default embedding function.
+        :returns: database instance
        """
+        if db:
+            return db
+
        if embedding_fn is None:
            raise ValueError("ChromaDb cannot be instantiated without an embedding function")
+
+        if db_type == VectorDatabases.ELASTICSEARCH:
+            from embedchain.vectordb.elasticsearch_db import ElasticsearchDB
+
+            return ElasticsearchDB(
+                embedding_fn=embedding_fn, vector_dim=vector_dim, collection_name=collection_name, es_config=es_config
+            )
+
        from embedchain.vectordb.chroma_db import ChromaDB

-        return ChromaDB(embedding_fn=embedding_fn, host=host, port=port)
+        return ChromaDB(embedding_fn=embedding_fn, host=host, port=port, chroma_settings=chroma_settings)

    def _setup_logging(self, debug_level):
        level = logging.WARNING  # Default level
@@ -1,15 +1,19 @@
-from typing import Any
+from typing import Any, Optional

 from chromadb.api.types import Documents, Embeddings
 from dotenv import load_dotenv

-from embedchain.models import EmbeddingFunctions, Providers
+from embedchain.config.vectordbs import ElasticsearchDBConfig
+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.models import (EmbeddingFunctions, Providers, VectorDatabases,
+                               VectorDimensions)

 from .BaseAppConfig import BaseAppConfig

 load_dotenv()


+@register_deserializable
 class CustomAppConfig(BaseAppConfig):
    """
    Config to initialize an embedchain custom `App` instance, with extra config options.
@@ -24,9 +28,14 @@ class CustomAppConfig(BaseAppConfig):
        host=None,
        port=None,
        id=None,
+        collection_name=None,
        provider: Providers = None,
-        model=None,
        open_source_app_config=None,
+        deployment_name=None,
+        collect_metrics: Optional[bool] = None,
+        db_type: VectorDatabases = None,
+        es_config: ElasticsearchDBConfig = None,
+        chroma_settings: dict = {},
    ):
        """
        :param log_level: Optional. (String) Debug level
@@ -34,11 +43,16 @@ class CustomAppConfig(BaseAppConfig):
        :param embedding_fn: Optional. Embedding function to use.
        :param embedding_fn_model: Optional. Model name to use for embedding function.
        :param db: Optional. (Vector) database to use for embeddings.
-        :param id: Optional. ID of the app. Document metadata will have this id.
        :param host: Optional. Hostname for the database server.
        :param port: Optional. Port for the database server.
+        :param id: Optional. ID of the app. Document metadata will have this id.
+        :param collection_name: Optional. Collection name for the database.
        :param provider: Optional. (Providers): LLM Provider to use.
        :param open_source_app_config: Optional. Config instance needed for open source apps.
+        :param collect_metrics: Defaults to True. Send anonymous telemetry to improve embedchain.
+        :param db_type: Optional. type of Vector database to use.
+        :param es_config: Optional. elasticsearch database config to be used for connection
+        :param chroma_settings: Optional. Chroma settings for connection.
        """
        if provider:
            self.provider = provider
@@ -49,11 +63,19 @@ class CustomAppConfig(BaseAppConfig):

        super().__init__(
            log_level=log_level,
-            embedding_fn=CustomAppConfig.embedding_function(embedding_function=embedding_fn, model=embedding_fn_model),
+            embedding_fn=CustomAppConfig.embedding_function(
+                embedding_function=embedding_fn, model=embedding_fn_model, deployment_name=deployment_name
+            ),
            db=db,
            host=host,
            port=port,
            id=id,
+            collection_name=collection_name,
+            collect_metrics=collect_metrics,
+            db_type=db_type,
+            vector_dim=CustomAppConfig.get_vector_dimension(embedding_function=embedding_fn),
+            es_config=es_config,
+            chroma_settings=chroma_settings,
        )

    @staticmethod
@@ -68,7 +90,7 @@ class CustomAppConfig(BaseAppConfig):
        return embed_function

    @staticmethod
-    def embedding_function(embedding_function: EmbeddingFunctions, model: str = None):
+    def embedding_function(embedding_function: EmbeddingFunctions, model: str = None, deployment_name: str = None):
        if not isinstance(embedding_function, EmbeddingFunctions):
            raise ValueError(
                f"Invalid option: '{embedding_function}'. Expecting one of the following options: {list(map(lambda x: x.value, EmbeddingFunctions))}"  # noqa: E501
@@ -80,7 +102,10 @@ class CustomAppConfig(BaseAppConfig):
            if model:
                embeddings = OpenAIEmbeddings(model=model)
            else:
-                embeddings = OpenAIEmbeddings()
+                if deployment_name:
+                    embeddings = OpenAIEmbeddings(deployment=deployment_name)
+                else:
+                    embeddings = OpenAIEmbeddings()
            return CustomAppConfig.langchain_default_concept(embeddings)

        elif embedding_function == EmbeddingFunctions.HUGGING_FACE:
@@ -100,3 +125,20 @@ class CustomAppConfig(BaseAppConfig):
            from chromadb.utils import embedding_functions

            return embedding_functions.SentenceTransformerEmbeddingFunction(model_name=model)
+
+    @staticmethod
+    def get_vector_dimension(embedding_function: EmbeddingFunctions):
+        if not isinstance(embedding_function, EmbeddingFunctions):
+            raise ValueError(f"Invalid option: '{embedding_function}'.")
+
+        if embedding_function == EmbeddingFunctions.OPENAI:
+            return VectorDimensions.OPENAI.value
+
+        elif embedding_function == EmbeddingFunctions.HUGGING_FACE:
+            return VectorDimensions.HUGGING_FACE.value
+
+        elif embedding_function == EmbeddingFunctions.VERTEX_AI:
+            return VectorDimensions.VERTEX_AI.value
+
+        elif embedding_function == EmbeddingFunctions.GPT4ALL:
+            return VectorDimensions.GPT4ALL.value
@@ -1,20 +1,36 @@
+from typing import Optional
+
 from chromadb.utils import embedding_functions

+from embedchain.helper_classes.json_serializable import register_deserializable
+
 from .BaseAppConfig import BaseAppConfig


+@register_deserializable
 class OpenSourceAppConfig(BaseAppConfig):
    """
    Config to initialize an embedchain custom `OpenSourceApp` instance, with extra config options.
    """

-    def __init__(self, log_level=None, host=None, port=None, id=None, model=None):
+    def __init__(
+        self,
+        log_level=None,
+        host=None,
+        port=None,
+        id=None,
+        collection_name=None,
+        collect_metrics: Optional[bool] = None,
+        model=None,
+    ):
        """
        :param log_level: Optional. (String) Debug level
        ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'].
        :param id: Optional. ID of the app. Document metadata will have this id.
+        :param collection_name: Optional. Collection name for the database.
        :param host: Optional. Hostname for the database server.
        :param port: Optional. Port for the database server.
+        :param collect_metrics: Defaults to True. Send anonymous telemetry to improve embedchain.
        :param model: Optional. GPT4ALL uses the model to instantiate the class.
        So unlike `App`, it has to be provided before querying.
        """
@@ -26,6 +42,8 @@ class OpenSourceAppConfig(BaseAppConfig):
            host=host,
            port=port,
            id=id,
+            collection_name=collection_name,
+            collect_metrics=collect_metrics,
        )

    @staticmethod
@@ -35,4 +53,10 @@ class OpenSourceAppConfig(BaseAppConfig):

        :returns: The default embedding function
        """
-        return embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
+        try:
+            return embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
+        except ValueError as e:
+            print(e)
+            raise ModuleNotFoundError(
+                "The open source app requires extra dependencies. Install with `pip install embedchain[opensource]`"
+            ) from None
@@ -0,0 +1,17 @@
+from typing import Dict, List, Union
+
+from embedchain.config.BaseConfig import BaseConfig
+from embedchain.helper_classes.json_serializable import register_deserializable
+
+
+@register_deserializable
+class ElasticsearchDBConfig(BaseConfig):
+    """
+    Config to initialize an elasticsearch client.
+    :param es_url. elasticsearch url or list of nodes url to be used for connection
+    :param ES_EXTRA_PARAMS: extra params dict that can be passed to elasticsearch.
+    """
+
+    def __init__(self, es_url: Union[str, List[str]] = None, **ES_EXTRA_PARAMS: Dict[str, any]):
+        self.ES_URL = es_url
+        self.ES_EXTRA_PARAMS = ES_EXTRA_PARAMS
@@ -1,11 +1,13 @@
 from embedchain.chunkers.docs_site import DocsSiteChunker
 from embedchain.chunkers.docx_file import DocxFileChunker
+from embedchain.chunkers.notion import NotionChunker
 from embedchain.chunkers.pdf_file import PdfFileChunker
 from embedchain.chunkers.qna_pair import QnaPairChunker
 from embedchain.chunkers.text import TextChunker
 from embedchain.chunkers.web_page import WebPageChunker
 from embedchain.chunkers.youtube_video import YoutubeVideoChunker
 from embedchain.config import AddConfig
+from embedchain.helper_classes.json_serializable import JSONSerializable
 from embedchain.loaders.docs_site_loader import DocsSiteLoader
 from embedchain.loaders.docx_file import DocxFileLoader
 from embedchain.loaders.local_qna_pair import LocalQnaPairLoader
@@ -14,20 +16,21 @@ from embedchain.loaders.pdf_file import PdfFileLoader
 from embedchain.loaders.sitemap import SitemapLoader
 from embedchain.loaders.web_page import WebPageLoader
 from embedchain.loaders.youtube_video import YoutubeVideoLoader
+from embedchain.models.data_type import DataType


-class DataFormatter:
+class DataFormatter(JSONSerializable):
    """
    DataFormatter is an internal utility class which abstracts the mapping for
    loaders and chunkers to the data_type entered by the user in their
    .add or .add_local method call
    """

-    def __init__(self, data_type: str, config: AddConfig):
+    def __init__(self, data_type: DataType, config: AddConfig):
        self.loader = self._get_loader(data_type, config.loader)
        self.chunker = self._get_chunker(data_type, config.chunker)

-    def _get_loader(self, data_type, config):
+    def _get_loader(self, data_type: DataType, config):
        """
        Returns the appropriate data loader for the given data type.

@@ -36,21 +39,31 @@ class DataFormatter:
        :raises ValueError: If an unsupported data type is provided.
        """
        loaders = {
-            "youtube_video": YoutubeVideoLoader(),
-            "pdf_file": PdfFileLoader(),
-            "web_page": WebPageLoader(),
-            "qna_pair": LocalQnaPairLoader(),
-            "text": LocalTextLoader(),
-            "docx": DocxFileLoader(),
-            "sitemap": SitemapLoader(),
-            "docs_site": DocsSiteLoader(),
+            DataType.YOUTUBE_VIDEO: YoutubeVideoLoader,
+            DataType.PDF_FILE: PdfFileLoader,
+            DataType.WEB_PAGE: WebPageLoader,
+            DataType.QNA_PAIR: LocalQnaPairLoader,
+            DataType.TEXT: LocalTextLoader,
+            DataType.DOCX: DocxFileLoader,
+            DataType.SITEMAP: SitemapLoader,
+            DataType.DOCS_SITE: DocsSiteLoader,
        }
+        lazy_loaders = {DataType.NOTION}
        if data_type in loaders:
-            return loaders[data_type]
+            loader_class = loaders[data_type]
+            loader = loader_class()
+            return loader
+        elif data_type in lazy_loaders:
+            if data_type == DataType.NOTION:
+                from embedchain.loaders.notion import NotionLoader
+
+                return NotionLoader()
+            else:
+                raise ValueError(f"Unsupported data type: {data_type}")
        else:
            raise ValueError(f"Unsupported data type: {data_type}")

-    def _get_chunker(self, data_type, config):
+    def _get_chunker(self, data_type: DataType, config):
        """
        Returns the appropriate chunker for the given data type.

@@ -59,14 +72,15 @@ class DataFormatter:
        :raises ValueError: If an unsupported data type is provided.
        """
        chunker_classes = {
-            "youtube_video": YoutubeVideoChunker,
-            "pdf_file": PdfFileChunker,
-            "web_page": WebPageChunker,
-            "qna_pair": QnaPairChunker,
-            "text": TextChunker,
-            "docx": DocxFileChunker,
-            "sitemap": WebPageChunker,
-            "docs_site": DocsSiteChunker,
+            DataType.YOUTUBE_VIDEO: YoutubeVideoChunker,
+            DataType.PDF_FILE: PdfFileChunker,
+            DataType.WEB_PAGE: WebPageChunker,
+            DataType.QNA_PAIR: QnaPairChunker,
+            DataType.TEXT: TextChunker,
+            DataType.DOCX: DocxFileChunker,
+            DataType.WEB_PAGE: WebPageChunker,
+            DataType.DOCS_SITE: DocsSiteChunker,
+            DataType.NOTION: NotionChunker,
        }
        if data_type in chunker_classes:
            chunker_class = chunker_classes[data_type]
@@ -1,86 +1,175 @@
+import hashlib
+import importlib.metadata
+import json
 import logging
 import os
+import threading
+import uuid
+from pathlib import Path
+from typing import Dict, Optional

-from chromadb.errors import InvalidDimensionException
+import requests
 from dotenv import load_dotenv
 from langchain.docstore.document import Document
 from langchain.memory import ConversationBufferMemory
+from tenacity import retry, stop_after_attempt, wait_fixed

+from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config import AddConfig, ChatConfig, QueryConfig
 from embedchain.config.apps.BaseAppConfig import BaseAppConfig
 from embedchain.config.QueryConfig import DOCS_SITE_PROMPT_TEMPLATE
 from embedchain.data_formatter import DataFormatter
+from embedchain.helper_classes.json_serializable import JSONSerializable
+from embedchain.loaders.base_loader import BaseLoader
+from embedchain.models.data_type import DataType
+from embedchain.utils import detect_datatype

 load_dotenv()

 ABS_PATH = os.getcwd()
 DB_DIR = os.path.join(ABS_PATH, "db")
-
-memory = ConversationBufferMemory()
+HOME_DIR = str(Path.home())
+CONFIG_DIR = os.path.join(HOME_DIR, ".embedchain")
+CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")


-class EmbedChain:
-    def __init__(self, config: BaseAppConfig):
+class EmbedChain(JSONSerializable):
+    def __init__(self, config: BaseAppConfig, system_prompt: Optional[str] = None):
        """
        Initializes the EmbedChain instance, sets up a vector DB client and
        creates a collection.

        :param config: BaseAppConfig instance to load as configuration.
+        :param system_prompt: Optional. System prompt string.
        """

        self.config = config
-        self.db_client = self.config.db.client
-        self.collection = self.config.db.collection
+        self.system_prompt = system_prompt
+        self.collection = self.config.db._get_or_create_collection(self.config.collection_name)
+        self.db = self.config.db
        self.user_asks = []
        self.is_docs_site_instance = False
        self.online = False
+        self.memory = ConversationBufferMemory()

-    def add(self, data_type, url, metadata=None, config: AddConfig = None):
+        # Send anonymous telemetry
+        self.s_id = self.config.id if self.config.id else str(uuid.uuid4())
+        self.u_id = self._load_or_generate_user_id()
+        thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("init",))
+        thread_telemetry.start()
+
+    def _load_or_generate_user_id(self):
+        """
+        Loads the user id from the config file if it exists, otherwise generates a new
+        one and saves it to the config file.
+        """
+        if not os.path.exists(CONFIG_DIR):
+            os.makedirs(CONFIG_DIR)
+
+        if os.path.exists(CONFIG_FILE):
+            with open(CONFIG_FILE, "r") as f:
+                data = json.load(f)
+                if "user_id" in data:
+                    return data["user_id"]
+
+        u_id = str(uuid.uuid4())
+        with open(CONFIG_FILE, "w") as f:
+            json.dump({"user_id": u_id}, f)
+
+        return u_id
+
+    def add(
+        self,
+        source,
+        data_type: Optional[DataType] = None,
+        metadata: Optional[Dict] = None,
+        config: Optional[AddConfig] = None,
+    ):
        """
        Adds the data from the given URL to the vector db.
        Loads the data, chunks it, create embedding for each chunk
        and then stores the embedding to vector database.

-        :param data_type: The type of the data to add.
-        :param url: The URL where the data is located.
+        :param source: The data to embed, can be a URL, local file or raw content, depending on the data type.
+        :param data_type: Optional. Automatically detected, but can be forced with this argument.
+        The type of the data to add.
        :param metadata: Optional. Metadata associated with the data source.
        :param config: Optional. The `AddConfig` instance to use as configuration
        options.
+        :return: source_id, a md5-hash of the source, in hexadecimal representation.
        """
        if config is None:
            config = AddConfig()

+        try:
+            DataType(source)
+            logging.warning(
+                f"""Starting from version v0.0.40, Embedchain can automatically detect the data type. So, in the `add` method, the argument order has changed. You no longer need to specify '{source}' for the `source` argument. So the code snippet will be `.add("{data_type}", "{source}")`"""  # noqa #E501
+            )
+            logging.warning(
+                "Embedchain is swapping the arguments for you. This functionality might be deprecated in the future, so please adjust your code."  # noqa #E501
+            )
+            source, data_type = data_type, source
+        except ValueError:
+            pass
+
+        if data_type:
+            try:
+                data_type = DataType(data_type)
+            except ValueError:
+                raise ValueError(
+                    f"Invalid data_type: '{data_type}'.",
+                    f"Please use one of the following: {[data_type.value for data_type in DataType]}",
+                ) from None
+        if not data_type:
+            data_type = detect_datatype(source)
+
+        # `source_id` is the hash of the source argument
+        hash_object = hashlib.md5(str(source).encode("utf-8"))
+        source_id = hash_object.hexdigest()
+
        data_formatter = DataFormatter(data_type, config)
-        self.user_asks.append([data_type, url, metadata])
-        self.load_and_embed(data_formatter.loader, data_formatter.chunker, url, metadata)
-        if data_type in ("docs_site",):
+        self.user_asks.append([source, data_type.value, metadata])
+        documents, _metadatas, _ids, new_chunks = self.load_and_embed(
+            data_formatter.loader, data_formatter.chunker, source, metadata, source_id
+        )
+        if data_type in {DataType.DOCS_SITE}:
            self.is_docs_site_instance = True

-    def add_local(self, data_type, content, metadata=None, config: AddConfig = None):
+        # Send anonymous telemetry
+        if self.config.collect_metrics:
+            # it's quicker to check the variable twice than to count words when they won't be submitted.
+            word_count = sum([len(document.split(" ")) for document in documents])
+
+            extra_metadata = {"data_type": data_type.value, "word_count": word_count, "chunks_count": new_chunks}
+            thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("add", extra_metadata))
+            thread_telemetry.start()
+
+        return source_id
+
+    def add_local(self, source, data_type=None, metadata=None, config: AddConfig = None):
        """
-        Adds the data you supply to the vector db.
+        Warning:
+            This method is deprecated and will be removed in future versions. Use `add` instead.
+
+        Adds the data from the given URL to the vector db.
        Loads the data, chunks it, create embedding for each chunk
        and then stores the embedding to vector database.

-        :param data_type: The type of the data to add.
-        :param content: The local data. Refer to the `README` for formatting.
+        :param source: The data to embed, can be a URL, local file or raw content, depending on the data type.
+        :param data_type: Optional. Automatically detected, but can be forced with this argument.
+        The type of the data to add.
        :param metadata: Optional. Metadata associated with the data source.
-        :param config: Optional. The `AddConfig` instance to use as
-        configuration options.
+        :param config: Optional. The `AddConfig` instance to use as configuration
+        options.
+        :return: md5-hash of the source, in hexadecimal representation.
        """
-        if config is None:
-            config = AddConfig()
-
-        data_formatter = DataFormatter(data_type, config)
-        self.user_asks.append([data_type, content])
-        self.load_and_embed(
-            data_formatter.loader,
-            data_formatter.chunker,
-            content,
-            metadata,
+        logging.warning(
+            "The `add_local` method is deprecated and will be removed in future versions. Please use the `add` method for both local and remote files."  # noqa: E501
        )
+        return self.add(source=source, data_type=data_type, metadata=metadata, config=config)

-    def load_and_embed(self, loader, chunker, src, metadata=None):
+    def load_and_embed(self, loader: BaseLoader, chunker: BaseChunker, src, metadata=None, source_id=None):
        """
        Loads the data from the given URL, chunks it, and adds it to database.

@@ -89,19 +178,23 @@ class EmbedChain:
        :param src: The data to be handled by the loader. Can be a URL for
        remote sources or local content for local loaders.
        :param metadata: Optional. Metadata associated with the data source.
+        :param source_id: Hexadecimal hash of the source.
+        :return: (List) documents (embedded text), (List) metadata, (list) ids, (int) number of chunks
        """
        embeddings_data = chunker.create_chunks(loader, src)
+
+        # spread chunking results
        documents = embeddings_data["documents"]
        metadatas = embeddings_data["metadatas"]
        ids = embeddings_data["ids"]
+
        # get existing ids, and discard doc if any common id exist.
        where = {"app_id": self.config.id} if self.config.id is not None else {}
        # where={"url": src}
-        existing_docs = self.collection.get(
+        existing_ids = self.db.get(
            ids=ids,
            where=where,  # optional filter
        )
-        existing_ids = set(existing_docs["ids"])

        if len(existing_ids):
            data_dict = {id: (doc, meta) for id, doc, meta in zip(ids, documents, metadatas)}
@@ -109,22 +202,37 @@ class EmbedChain:

            if not data_dict:
                print(f"All data from {src} already exists in the database.")
-                return
+                # Make sure to return a matching return type
+                return [], [], [], 0

            ids = list(data_dict.keys())
            documents, metadatas = zip(*data_dict.values())

-        # Add app id in metadatas so that they can be queried on later
-        if self.config.id is not None:
-            metadatas = [{**m, "app_id": self.config.id} for m in metadatas]
+        # Loop though all metadatas and add extras.
+        new_metadatas = []
+        for m in metadatas:
+            # Add app id in metadatas so that they can be queried on later
+            if self.config.id:
+                m["app_id"] = self.config.id

+            # Add hashed source
+            m["hash"] = source_id
+
+            # Note: Metadata is the function argument
+            if metadata:
+                # Spread whatever is in metadata into the new object.
+                m.update(metadata)
+
+            new_metadatas.append(m)
+        metadatas = new_metadatas
+
+        # Count before, to calculate a delta in the end.
        chunks_before_addition = self.count()

-        # Add metadata to each document
-        metadatas_with_metadata = [{**meta, **metadata} for meta in metadatas]
-
-        self.collection.add(documents=documents, metadatas=list(metadatas_with_metadata), ids=ids)
-        print((f"Successfully saved {src}. New chunks count: " f"{self.count() - chunks_before_addition}"))
+        self.db.add(documents=documents, metadatas=metadatas, ids=ids)
+        count_new_chunks = self.count() - chunks_before_addition
+        print((f"Successfully saved {src} ({chunker.data_type}). New chunks count: {count_new_chunks}"))
+        return list(documents), metadatas, ids, count_new_chunks

    def _format_result(self, results):
        return [
@@ -142,32 +250,33 @@ class EmbedChain:
        """
        raise NotImplementedError

-    def retrieve_from_database(self, input_query, config: QueryConfig):
+    def retrieve_from_database(self, input_query, config: QueryConfig, where=None):
        """
        Queries the vector database based on the given input query.
        Gets relevant doc based on the query

        :param input_query: The query to use.
        :param config: The query configuration.
+        :param where: Optional. A dictionary of key-value pairs to filter the database results.
        :return: The content of the document that matched your query.
        """
-        try:
-            where = {"app_id": self.config.id} if self.config.id is not None else {}  # optional filter
-            result = self.collection.query(
-                query_texts=[
-                    input_query,
-                ],
-                n_results=config.number_documents,
-                where=where,
-            )
-        except InvalidDimensionException as e:
-            raise InvalidDimensionException(
-                e.message()
-                + ". This is commonly a side-effect when an embedding function, different from the one used to add the embeddings, is used to retrieve an embedding from the database."  # noqa E501
-            ) from None

-        results_formatted = self._format_result(result)
-        contents = [result[0].page_content for result in results_formatted]
+        if where is not None:
+            where = where
+        elif config is not None and config.where is not None:
+            where = config.where
+        else:
+            where = {}
+
+        if self.config.id is not None:
+            where.update({"app_id": self.config.id})
+
+        contents = self.db.query(
+            input_query=input_query,
+            n_results=config.number_documents,
+            where=where,
+        )
+
        return contents

    def _append_search_and_context(self, context, web_search_result):
@@ -213,7 +322,7 @@ class EmbedChain:
        logging.info(f"Access search to get answers for {input_query}")
        return search.run(input_query)

-    def query(self, input_query, config: QueryConfig = None, dry_run=False):
+    def query(self, input_query, config: QueryConfig = None, dry_run=False, where=None):
        """
        Queries the vector database based on the given input query.
        Gets relevant doc based on the query and then passes it to an
@@ -228,6 +337,7 @@ class EmbedChain:
        by the vector database's doc retrieval.
        The only thing the dry run does not consider is the cut-off due to
        the `max_tokens` parameter.
+        :param where: Optional. A dictionary of key-value pairs to filter the database results.
        :return: The answer to the query.
        """
        if config is None:
@@ -238,7 +348,7 @@ class EmbedChain:
        k = {}
        if self.online:
            k["web_search_result"] = self.access_search_and_get_results(input_query)
-        contexts = self.retrieve_from_database(input_query, config)
+        contexts = self.retrieve_from_database(input_query, config, where)
        prompt = self.generate_prompt(input_query, contexts, config, **k)
        logging.info(f"Prompt: {prompt}")

@@ -247,6 +357,10 @@ class EmbedChain:

        answer = self.get_answer_from_llm(prompt, config)

+        # Send anonymous telemetry
+        thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("query",))
+        thread_telemetry.start()
+
        if isinstance(answer, str):
            logging.info(f"Answer: {answer}")
            return answer
@@ -260,7 +374,7 @@ class EmbedChain:
            yield chunk
        logging.info(f"Answer: {streamed_answer}")

-    def chat(self, input_query, config: ChatConfig = None, dry_run=False):
+    def chat(self, input_query, config: ChatConfig = None, dry_run=False, where=None):
        """
        Queries the vector database on the given input query.
        Gets relevant doc based on the query and then passes it to an
@@ -276,6 +390,7 @@ class EmbedChain:
        by the vector database's doc retrieval.
        The only thing the dry run does not consider is the cut-off due to
        the `max_tokens` parameter.
+        :param where: Optional. A dictionary of key-value pairs to filter the database results.
        :return: The answer to the query.
        """
        if config is None:
@@ -286,10 +401,9 @@ class EmbedChain:
        k = {}
        if self.online:
            k["web_search_result"] = self.access_search_and_get_results(input_query)
-        contexts = self.retrieve_from_database(input_query, config, **k)
+        contexts = self.retrieve_from_database(input_query, config, where)

-        global memory
-        chat_history = memory.load_memory_variables({})["history"]
+        chat_history = self.memory.load_memory_variables({})["history"]

        if chat_history:
            config.set_history(chat_history)
@@ -302,10 +416,14 @@ class EmbedChain:

        answer = self.get_answer_from_llm(prompt, config)

-        memory.chat_memory.add_user_message(input_query)
+        self.memory.chat_memory.add_user_message(input_query)
+
+        # Send anonymous telemetry
+        thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("chat",))
+        thread_telemetry.start()

        if isinstance(answer, str):
-            memory.chat_memory.add_ai_message(answer)
+            self.memory.chat_memory.add_ai_message(answer)
            logging.info(f"Answer: {answer}")
            return answer
        else:
@@ -317,20 +435,61 @@ class EmbedChain:
        for chunk in answer:
            streamed_answer = streamed_answer + chunk
            yield chunk
-        memory.chat_memory.add_ai_message(streamed_answer)
+        self.memory.chat_memory.add_ai_message(streamed_answer)
        logging.info(f"Answer: {streamed_answer}")

-    def count(self):
+    def set_collection(self, collection_name):
+        """
+        Set the collection to use.
+
+        :param collection_name: The name of the collection to use.
+        """
+        self.collection = self.config.db._get_or_create_collection(collection_name)
+
+    def count(self) -> int:
        """
        Count the number of embeddings.

        :return: The number of embeddings.
        """
-        return self.collection.count()
+        return self.db.count()

    def reset(self):
        """
        Resets the database. Deletes all embeddings irreversibly.
-        `App` has to be reinitialized after using this method.
+        `App` does not have to be reinitialized after using this method.
        """
-        self.db_client.reset()
+        # Send anonymous telemetry
+        thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("reset",))
+        thread_telemetry.start()
+
+        collection_name = self.collection.name
+        self.db.reset()
+        self.collection = self.config.db._get_or_create_collection(collection_name)
+        # Todo: Automatically recreating a collection with the same name cannot be the best way to handle a reset.
+        # A downside of this implementation is, if you have two instances,
+        # the other instance will not get the updated `self.collection` attribute.
+        # A better way would be to create the collection if it is called again after being reset.
+        # That means, checking if collection exists in the db-consuming methods, and creating it if it doesn't.
+        # That's an extra steps for all uses, just to satisfy a niche use case in a niche method. For now, this will do.
+
+    @retry(stop=stop_after_attempt(3), wait=wait_fixed(1))
+    def _send_telemetry_event(self, method: str, extra_metadata: Optional[dict] = None):
+        if not self.config.collect_metrics:
+            return
+
+        with threading.Lock():
+            url = "https://api.embedchain.ai/api/v1/telemetry/"
+            metadata = {
+                "s_id": self.s_id,
+                "version": importlib.metadata.version(__package__ or __name__),
+                "method": method,
+                "language": "py",
+                "u_id": self.u_id,
+            }
+            if extra_metadata:
+                metadata.update(extra_metadata)
+
+            response = requests.post(url, json={"metadata": metadata})
+            if response.status_code != 200:
+                logging.warning(f"Telemetry event failed with status code {response.status_code}")
@@ -0,0 +1,180 @@
+import json
+import logging
+from typing import Any, Dict, Type, TypeVar, Union
+
+T = TypeVar("T", bound="JSONSerializable")
+
+# NOTE: Through inheritance, all of our classes should be children of JSONSerializable. (highest level)
+# NOTE: The @register_deserializable decorator should be added to all user facing child classes. (lowest level)
+
+
+def register_deserializable(cls: Type[T]) -> Type[T]:
+    """
+    A class decorator to register a class as deserializable.
+
+    When a class is decorated with @register_deserializable, it becomes
+    a part of the set of classes that the JSONSerializable class can
+    deserialize.
+
+    Deserialization is in essence loading attributes from a json file.
+    This decorator is a security measure put in place to make sure that
+    you don't load attributes that were initially part of another class.
+
+    Example:
+        @register_deserializable
+        class ChildClass(JSONSerializable):
+            def __init__(self, ...):
+                # initialization logic
+
+    Args:
+        cls (Type): The class to be registered.
+
+    Returns:
+        Type: The same class, after registration.
+    """
+    JSONSerializable.register_class_as_deserializable(cls)
+    return cls
+
+
+class JSONSerializable:
+    """
+    A class to represent a JSON serializable object.
+
+    This class provides methods to serialize and deserialize objects,
+    as well as save serialized objects to a file and load them back.
+    """
+
+    _deserializable_classes = set()  # Contains classes that are whitelisted for deserialization.
+
+    def serialize(self) -> str:
+        """
+        Serialize the object to a JSON-formatted string.
+
+        Returns:
+            str: A JSON string representation of the object.
+        """
+        try:
+            return json.dumps(self, default=self._auto_encoder, ensure_ascii=False)
+        except Exception as e:
+            logging.error(f"Serialization error: {e}")
+            return "{}"
+
+    @classmethod
+    def deserialize(cls, json_str: str) -> Any:
+        """
+        Deserialize a JSON-formatted string to an object.
+        If it fails, a default class is returned instead.
+        Note: This *returns* an instance, it's not automatically loaded on the calling class.
+
+        Example:
+            app = App.deserialize(json_str)
+
+        Args:
+            json_str (str): A JSON string representation of an object.
+
+        Returns:
+            Object: The deserialized object.
+        """
+        try:
+            return json.loads(json_str, object_hook=cls._auto_decoder)
+        except Exception as e:
+            logging.error(f"Deserialization error: {e}")
+            # Return a default instance in case of failure
+            return cls()
+
+    @staticmethod
+    def _auto_encoder(obj: Any) -> Union[Dict[str, Any], None]:
+        """
+        Automatically encode an object for JSON serialization.
+
+        Args:
+            obj (Object): The object to be encoded.
+
+        Returns:
+            dict: A dictionary representation of the object.
+        """
+        if hasattr(obj, "__dict__"):
+            dct = obj.__dict__.copy()
+            for key, value in list(
+                dct.items()
+            ):  # We use list() to get a copy of items to avoid dictionary size change during iteration.
+                try:
+                    # Recursive: If the value is an instance of a subclass of JSONSerializable,
+                    # serialize it using the JSONSerializable serialize method.
+                    if isinstance(value, JSONSerializable):
+                        serialized_value = value.serialize()
+                        # The value is stored as a serialized string.
+                        dct[key] = json.loads(serialized_value)
+                    else:
+                        json.dumps(value)  # Try to serialize the value.
+                except TypeError:
+                    del dct[key]  # If it fails, remove the key-value pair from the dictionary.
+
+            dct["__class__"] = obj.__class__.__name__
+            return dct
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+    @classmethod
+    def _auto_decoder(cls, dct: Dict[str, Any]) -> Any:
+        """
+        Automatically decode a dictionary to an object during JSON deserialization.
+
+        Args:
+            dct (dict): The dictionary representation of an object.
+
+        Returns:
+            Object: The decoded object or the original dictionary if decoding is not possible.
+        """
+        class_name = dct.pop("__class__", None)
+        if class_name:
+            if not hasattr(cls, "_deserializable_classes"):  # Additional safety check
+                raise AttributeError(f"`{class_name}` has no registry of allowed deserializations.")
+            if class_name not in {cl.__name__ for cl in cls._deserializable_classes}:
+                raise KeyError(f"Deserialization of class `{class_name}` is not allowed.")
+            target_class = next((cl for cl in cls._deserializable_classes if cl.__name__ == class_name), None)
+            if target_class:
+                obj = target_class.__new__(target_class)
+                for key, value in dct.items():
+                    default_value = getattr(target_class, key, None)
+                    setattr(obj, key, value or default_value)
+                return obj
+        return dct
+
+    def save_to_file(self, filename: str) -> None:
+        """
+        Save the serialized object to a file.
+
+        Args:
+            filename (str): The path to the file where the object should be saved.
+        """
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(self.serialize())
+
+    @classmethod
+    def load_from_file(cls, filename: str) -> Any:
+        """
+        Load and deserialize an object from a file.
+
+        Args:
+            filename (str): The path to the file from which the object should be loaded.
+
+        Returns:
+            Object: The deserialized object.
+        """
+        with open(filename, "r", encoding="utf-8") as f:
+            json_str = f.read()
+            return cls.deserialize(json_str)
+
+    @classmethod
+    def register_class_as_deserializable(cls, target_class: Type[T]) -> None:
+        """
+        Register a class as deserializable. This is a classmethod and globally shared.
+
+        This method adds the target class to the set of classes that
+        can be deserialized. This is a security measure to ensure only
+        whitelisted classes are deserialized.
+
+        Args:
+            target_class (Type): The class to be registered.
+        """
+        cls._deserializable_classes.add(target_class)
@@ -0,0 +1,12 @@
+from embedchain.helper_classes.json_serializable import JSONSerializable
+
+
+class BaseLoader(JSONSerializable):
+    def __init__(self):
+        pass
+
+    def load_data():
+        """
+        Implemented by child classes
+        """
+        pass
@@ -4,8 +4,12 @@ from urllib.parse import urljoin, urlparse
 import requests
 from bs4 import BeautifulSoup

+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader

-class DocsSiteLoader:
+
+@register_deserializable
+class DocsSiteLoader(BaseLoader):
    def __init__(self):
        self.visited_links = set()

@@ -1,7 +1,11 @@
 from langchain.document_loaders import Docx2txtLoader

+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader

-class DocxFileLoader:
+
+@register_deserializable
+class DocxFileLoader(BaseLoader):
    def load_data(self, url):
        """Load data from a .docx file."""
        loader = Docx2txtLoader(url)
@@ -1,4 +1,9 @@
-class LocalQnaPairLoader:
+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader
+
+
+@register_deserializable
+class LocalQnaPairLoader(BaseLoader):
    def load_data(self, content):
        """Load data from a local QnA pair."""
        question, answer = content
@@ -1,4 +1,9 @@
-class LocalTextLoader:
+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader
+
+
+@register_deserializable
+class LocalTextLoader(BaseLoader):
    def load_data(self, content):
        """Load data from a local text file."""
        meta_data = {
@@ -0,0 +1,43 @@
+import logging
+import os
+
+try:
+    from llama_index import download_loader
+except ImportError:
+    raise ImportError("Notion requires extra dependencies. Install with `pip install embedchain[community]`") from None
+
+
+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader
+from embedchain.utils import clean_string
+
+
+@register_deserializable
+class NotionLoader(BaseLoader):
+    def load_data(self, source):
+        """Load data from a PDF file."""
+
+        NotionPageReader = download_loader("NotionPageReader")
+
+        # Reformat Id to match notion expectation
+        id = source[-32:]
+        formatted_id = f"{id[:8]}-{id[8:12]}-{id[12:16]}-{id[16:20]}-{id[20:]}"
+        logging.debug(f"Extracted notion page id as: {formatted_id}")
+
+        # Get page through the notion api
+        integration_token = os.getenv("NOTION_INTEGRATION_TOKEN")
+        reader = NotionPageReader(integration_token=integration_token)
+        documents = reader.load_data(page_ids=[formatted_id])
+
+        # Extract text
+        raw_text = documents[0].text
+
+        # Clean text
+        text = clean_string(raw_text)
+
+        return [
+            {
+                "content": text,
+                "meta_data": {"url": f"notion-{formatted_id}"},
+            }
+        ]
@@ -1,9 +1,12 @@
 from langchain.document_loaders import PyPDFLoader

+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader
 from embedchain.utils import clean_string


-class PdfFileLoader:
+@register_deserializable
+class PdfFileLoader(BaseLoader):
    def load_data(self, url):
        """Load data from a PDF file."""
        loader = PyPDFLoader(url)
@@ -4,11 +4,14 @@ import requests
 from bs4 import BeautifulSoup
 from bs4.builder import ParserRejectedMarkup

+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader
 from embedchain.loaders.web_page import WebPageLoader
 from embedchain.utils import is_readable


-class SitemapLoader:
+@register_deserializable
+class SitemapLoader(BaseLoader):
    def load_data(self, sitemap_url):
        """
        This method takes a sitemap URL as input and retrieves
@@ -3,10 +3,13 @@ import logging
 import requests
 from bs4 import BeautifulSoup

+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader
 from embedchain.utils import clean_string


-class WebPageLoader:
+@register_deserializable
+class WebPageLoader(BaseLoader):
    def load_data(self, url):
        """Load data from a web page."""
        response = requests.get(url)
@@ -1,9 +1,12 @@
 from langchain.document_loaders import YoutubeLoader

+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.loaders.base_loader import BaseLoader
 from embedchain.utils import clean_string


-class YoutubeVideoLoader:
+@register_deserializable
+class YoutubeVideoLoader(BaseLoader):
    def load_data(self, url):
        """Load data from a Youtube video."""
        loader = YoutubeLoader.from_youtube_url(url, add_video_info=True)
@@ -6,3 +6,4 @@ class Providers(Enum):
    ANTHROPHIC = "ANTHPROPIC"
    VERTEX_AI = "VERTEX_AI"
    GPT4ALL = "GPT4ALL"
+    AZURE_OPENAI = "AZURE_OPENAI"
@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class VectorDatabases(Enum):
+    CHROMADB = "CHROMADB"
+    ELASTICSEARCH = "ELASTICSEARCH"
@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+# vector length created by embedding fn
+class VectorDimensions(Enum):
+    GPT4ALL = 384
+    OPENAI = 1536
+    VERTEX_AI = 768
+    HUGGING_FACE = 384
@@ -1,2 +1,4 @@
 from .EmbeddingFunctions import EmbeddingFunctions  # noqa: F401
 from .Providers import Providers  # noqa: F401
+from .VectorDatabases import VectorDatabases  # noqa: F401
+from .VectorDimensions import VectorDimensions  # noqa: F401
@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class DataType(Enum):
+    YOUTUBE_VIDEO = "youtube_video"
+    PDF_FILE = "pdf_file"
+    WEB_PAGE = "web_page"
+    SITEMAP = "sitemap"
+    DOCX = "docx"
+    DOCS_SITE = "docs_site"
+    TEXT = "text"
+    QNA_PAIR = "qna_pair"
+    NOTION = "notion"
@@ -1,5 +1,10 @@
+import logging
+import os
 import re
 import string
+from typing import Any
+
+from embedchain.models.data_type import DataType


 def clean_string(text):
@@ -43,5 +48,149 @@ def is_readable(s):
    :param s: string
    :return: True if the string is more than 95% printable.
    """
-    printable_ratio = sum(c in string.printable for c in s) / len(s)
+    try:
+        printable_ratio = sum(c in string.printable for c in s) / len(s)
+    except ZeroDivisionError:
+        logging.warning("Empty string processed as unreadable")
+        printable_ratio = 0
    return printable_ratio > 0.95  # 95% of characters are printable
+
+
+def use_pysqlite3():
+    """
+    Swap std-lib sqlite3 with pysqlite3.
+    """
+    import platform
+    import sqlite3
+
+    if platform.system() == "Linux" and sqlite3.sqlite_version_info < (3, 35, 0):
+        try:
+            # According to the Chroma team, this patch only works on Linux
+            import datetime
+            import subprocess
+            import sys
+
+            subprocess.check_call(
+                [sys.executable, "-m", "pip", "install", "pysqlite3-binary", "--quiet", "--disable-pip-version-check"]
+            )
+
+            __import__("pysqlite3")
+            sys.modules["sqlite3"] = sys.modules.pop("pysqlite3")
+
+            # Let the user know what happened.
+            current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S,%f")[:-3]
+            print(
+                f"{current_time} [embedchain] [INFO]",
+                "Swapped std-lib sqlite3 with pysqlite3 for ChromaDb compatibility.",
+                f"Your original version was {sqlite3.sqlite_version}.",
+            )
+        except Exception as e:
+            # Escape all exceptions
+            current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S,%f")[:-3]
+            print(
+                f"{current_time} [embedchain] [ERROR]",
+                "Failed to swap std-lib sqlite3 with pysqlite3 for ChromaDb compatibility.",
+                "Error:",
+                e,
+            )
+
+
+def format_source(source: str, limit: int = 20) -> str:
+    """
+    Format a string to only take the first x and last x letters.
+    This makes it easier to display a URL, keeping familiarity while ensuring a consistent length.
+    If the string is too short, it is not sliced.
+    """
+    if len(source) > 2 * limit:
+        return source[:limit] + "..." + source[-limit:]
+    return source
+
+
+def detect_datatype(source: Any) -> DataType:
+    """
+    Automatically detect the datatype of the given source.
+
+    :param source: the source to base the detection on
+    :return: data_type string
+    """
+    from urllib.parse import urlparse
+
+    try:
+        if not isinstance(source, str):
+            raise ValueError("Source is not a string and thus cannot be a URL.")
+        url = urlparse(source)
+        # Check if both scheme and netloc are present. Local file system URIs are acceptable too.
+        if not all([url.scheme, url.netloc]) and url.scheme != "file":
+            raise ValueError("Not a valid URL.")
+    except ValueError:
+        url = False
+
+    formatted_source = format_source(str(source), 30)
+
+    if url:
+        from langchain.document_loaders.youtube import \
+            ALLOWED_NETLOCK as YOUTUBE_ALLOWED_NETLOCS
+
+        if url.netloc in YOUTUBE_ALLOWED_NETLOCS:
+            logging.debug(f"Source of `{formatted_source}` detected as `youtube_video`.")
+            return DataType.YOUTUBE_VIDEO
+
+        if url.netloc in {"notion.so", "notion.site"}:
+            logging.debug(f"Source of `{formatted_source}` detected as `notion`.")
+            return DataType.NOTION
+
+        if url.path.endswith(".pdf"):
+            logging.debug(f"Source of `{formatted_source}` detected as `pdf_file`.")
+            return DataType.PDF_FILE
+
+        if url.path.endswith(".xml"):
+            logging.debug(f"Source of `{formatted_source}` detected as `sitemap`.")
+            return DataType.SITEMAP
+
+        if url.path.endswith(".docx"):
+            logging.debug(f"Source of `{formatted_source}` detected as `docx`.")
+            return DataType.DOCX
+
+        if "docs" in url.netloc or ("docs" in url.path and url.scheme != "file"):
+            # `docs_site` detection via path is not accepted for local filesystem URIs,
+            # because that would mean all paths that contain `docs` are now doc sites, which is too aggressive.
+            logging.debug(f"Source of `{formatted_source}` detected as `docs_site`.")
+            return DataType.DOCS_SITE
+
+        # If none of the above conditions are met, it's a general web page
+        logging.debug(f"Source of `{formatted_source}` detected as `web_page`.")
+        return DataType.WEB_PAGE
+
+    elif not isinstance(source, str):
+        # For datatypes where source is not a string.
+
+        if isinstance(source, tuple) and len(source) == 2 and isinstance(source[0], str) and isinstance(source[1], str):
+            logging.debug(f"Source of `{formatted_source}` detected as `qna_pair`.")
+            return DataType.QNA_PAIR
+
+        # Raise an error if it isn't a string and also not a valid non-string type (one of the previous).
+        # We could stringify it, but it is better to raise an error and let the user decide how they want to do that.
+        raise TypeError(
+            "Source is not a string and a valid non-string type could not be detected. If you want to embed it, please stringify it, for instance by using `str(source)` or `(', ').join(source)`."  # noqa: E501
+        )
+
+    elif os.path.isfile(source):
+        # For datatypes that support conventional file references.
+        # Note: checking for string is not necessary anymore.
+
+        if source.endswith(".docx"):
+            logging.debug(f"Source of `{formatted_source}` detected as `docx`.")
+            return DataType.DOCX
+
+        # If the source is a valid file, that's not detectable as a type, an error is raised.
+        # It does not fallback to text.
+        raise ValueError(
+            "Source points to a valid file, but based on the filename, no `data_type` can be detected. Please be aware, that not all data_types allow conventional file references, some require the use of the `file URI scheme`. Please refer to the embedchain documentation (https://docs.embedchain.ai/advanced/data_types#remote-data-types)."  # noqa: E501
+        )
+
+    else:
+        # Source is not a URL.
+
+        # Use text as final fallback.
+        logging.debug(f"Source of `{formatted_source}` detected as `text`.")
+        return DataType.TEXT
@@ -1,9 +1,11 @@
-class BaseVectorDB:
+from embedchain.helper_classes.json_serializable import JSONSerializable
+
+
+class BaseVectorDB(JSONSerializable):
    """Base class for vector database."""

    def __init__(self):
        self.client = self._get_or_create_db()
-        self.collection = self._get_or_create_collection()

    def _get_or_create_db(self):
        """Get or create the database."""
@@ -11,3 +13,18 @@ class BaseVectorDB:

    def _get_or_create_collection(self):
        raise NotImplementedError
+
+    def get(self):
+        raise NotImplementedError
+
+    def add(self):
+        raise NotImplementedError
+
+    def query(self):
+        raise NotImplementedError
+
+    def count(self):
+        raise NotImplementedError
+
+    def reset(self):
+        raise NotImplementedError
@@ -1,41 +1,127 @@
 import logging
+from typing import Any, Dict, List
+
+from chromadb.errors import InvalidDimensionException
+from langchain.docstore.document import Document
+
+try:
+    import chromadb
+except RuntimeError:
+    from embedchain.utils import use_pysqlite3
+
+    use_pysqlite3()
+    import chromadb

-import chromadb
 from chromadb.config import Settings

+from embedchain.helper_classes.json_serializable import register_deserializable
 from embedchain.vectordb.base_vector_db import BaseVectorDB


+@register_deserializable
 class ChromaDB(BaseVectorDB):
    """Vector database using ChromaDB."""

-    def __init__(self, db_dir=None, embedding_fn=None, host=None, port=None):
+    def __init__(self, db_dir=None, embedding_fn=None, host=None, port=None, chroma_settings={}):
        self.embedding_fn = embedding_fn

        if not hasattr(embedding_fn, "__call__"):
            raise ValueError("Embedding function is not a function")

+        self.settings = Settings()
+        for key, value in chroma_settings.items():
+            if hasattr(self.settings, key):
+                setattr(self.settings, key, value)
+
        if host and port:
            logging.info(f"Connecting to ChromaDB server: {host}:{port}")
-            self.settings = Settings(chroma_server_host=host, chroma_server_http_port=port)
-            self.client = chromadb.HttpClient(self.settings)
+            self.settings.chroma_server_host = host
+            self.settings.chroma_server_http_port = port
+            self.settings.chroma_api_impl = "chromadb.api.fastapi.FastAPI"
+
        else:
            if db_dir is None:
                db_dir = "db"
-            self.settings = Settings(anonymized_telemetry=False, allow_reset=True)
-            self.client = chromadb.PersistentClient(
-                path=db_dir,
-                settings=self.settings,
-            )
+
+            self.settings.persist_directory = db_dir
+            self.settings.is_persistent = True
+
+        self.client = chromadb.Client(self.settings)
        super().__init__()

    def _get_or_create_db(self):
        """Get or create the database."""
        return self.client

-    def _get_or_create_collection(self):
+    def _get_or_create_collection(self, name):
        """Get or create the collection."""
-        return self.client.get_or_create_collection(
-            "embedchain_store",
+        self.collection = self.client.get_or_create_collection(
+            name=name,
            embedding_function=self.embedding_fn,
        )
+        return self.collection
+
+    def get(self, ids: List[str], where: Dict[str, any]) -> List[str]:
+        """
+        Get existing doc ids present in vector database
+        :param ids: list of doc ids to check for existance
+        :param where: Optional. to filter data
+        """
+        existing_docs = self.collection.get(
+            ids=ids,
+            where=where,  # optional filter
+        )
+
+        return set(existing_docs["ids"])
+
+    def add(self, documents: List[str], metadatas: List[object], ids: List[str]) -> Any:
+        """
+        add data in vector database
+        :param documents: list of texts to add
+        :param metadatas: list of metadata associated with docs
+        :param ids: ids of docs
+        """
+        self.collection.add(documents=documents, metadatas=metadatas, ids=ids)
+
+    def _format_result(self, results):
+        return [
+            (Document(page_content=result[0], metadata=result[1] or {}), result[2])
+            for result in zip(
+                results["documents"][0],
+                results["metadatas"][0],
+                results["distances"][0],
+            )
+        ]
+
+    def query(self, input_query: List[str], n_results: int, where: Dict[str, any]) -> List[str]:
+        """
+        query contents from vector data base based on vector similarity
+        :param input_query: list of query string
+        :param n_results: no of similar documents to fetch from database
+        :param where: Optional. to filter data
+        :return: The content of the document that matched your query.
+        """
+        try:
+            result = self.collection.query(
+                query_texts=[
+                    input_query,
+                ],
+                n_results=n_results,
+                where=where,
+            )
+        except InvalidDimensionException as e:
+            raise InvalidDimensionException(
+                e.message()
+                + ". This is commonly a side-effect when an embedding function, different from the one used to add the embeddings, is used to retrieve an embedding from the database."  # noqa E501
+            ) from None
+
+        results_formatted = self._format_result(result)
+        contents = [result[0].page_content for result in results_formatted]
+        return contents
+
+    def count(self) -> int:
+        return self.collection.count()
+
+    def reset(self):
+        # Delete all data from the database
+        self.client.reset()
@@ -0,0 +1,138 @@
+from typing import Any, Callable, Dict, List
+
+try:
+    from elasticsearch import Elasticsearch
+    from elasticsearch.helpers import bulk
+except ImportError:
+    raise ImportError(
+        "Elasticsearch requires extra dependencies. Install with `pip install embedchain[elasticsearch]`"
+    ) from None
+
+from embedchain.config import ElasticsearchDBConfig
+from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.models.VectorDimensions import VectorDimensions
+from embedchain.vectordb.base_vector_db import BaseVectorDB
+
+
+@register_deserializable
+class ElasticsearchDB(BaseVectorDB):
+    def __init__(
+        self,
+        es_config: ElasticsearchDBConfig = None,
+        embedding_fn: Callable[[list[str]], list[str]] = None,
+        vector_dim: VectorDimensions = None,
+        collection_name: str = None,
+    ):
+        """
+        Elasticsearch as vector database
+        :param es_config. elasticsearch database config to be used for connection
+        :param embedding_fn: Function to generate embedding vectors.
+        :param vector_dim: Vector dimension generated by embedding fn
+        :param collection_name: Optional. Collection name for the database.
+        """
+        if not hasattr(embedding_fn, "__call__"):
+            raise ValueError("Embedding function is not a function")
+        if es_config is None:
+            raise ValueError("ElasticsearchDBConfig is required")
+        if vector_dim is None:
+            raise ValueError("Vector Dimension is required to refer correct index and mapping")
+        if collection_name is None:
+            raise ValueError("collection name is required. It cannot be empty")
+        self.embedding_fn = embedding_fn
+        self.client = Elasticsearch(es_config.ES_URL, **es_config.ES_EXTRA_PARAMS)
+        self.vector_dim = vector_dim
+        self.es_index = f"{collection_name}_{self.vector_dim}"
+        index_settings = {
+            "mappings": {
+                "properties": {
+                    "text": {"type": "text"},
+                    "embeddings": {"type": "dense_vector", "index": False, "dims": self.vector_dim},
+                }
+            }
+        }
+        if not self.client.indices.exists(index=self.es_index):
+            # create index if not exist
+            print("Creating index", self.es_index, index_settings)
+            self.client.indices.create(index=self.es_index, body=index_settings)
+        super().__init__()
+
+    def _get_or_create_db(self):
+        return self.client
+
+    def _get_or_create_collection(self, name):
+        """Note: nothing to return here. Discuss later"""
+
+    def get(self, ids: List[str], where: Dict[str, any]) -> List[str]:
+        """
+        Get existing doc ids present in vector database
+        :param ids: list of doc ids to check for existance
+        :param where: Optional. to filter data
+        """
+        query = {"bool": {"must": [{"ids": {"values": ids}}]}}
+        if "app_id" in where:
+            app_id = where["app_id"]
+            query["bool"]["must"].append({"term": {"metadata.app_id": app_id}})
+        response = self.client.search(index=self.es_index, query=query, _source=False)
+        docs = response["hits"]["hits"]
+        ids = [doc["_id"] for doc in docs]
+        return set(ids)
+
+    def add(self, documents: List[str], metadatas: List[object], ids: List[str]) -> Any:
+        """
+        add data in vector database
+        :param documents: list of texts to add
+        :param metadatas: list of metadata associated with docs
+        :param ids: ids of docs
+        """
+        docs = []
+        embeddings = self.embedding_fn(documents)
+        for id, text, metadata, embeddings in zip(ids, documents, metadatas, embeddings):
+            docs.append(
+                {
+                    "_index": self.es_index,
+                    "_id": id,
+                    "_source": {"text": text, "metadata": metadata, "embeddings": embeddings},
+                }
+            )
+        bulk(self.client, docs)
+        self.client.indices.refresh(index=self.es_index)
+        return
+
+    def query(self, input_query: List[str], n_results: int, where: Dict[str, any]) -> List[str]:
+        """
+        query contents from vector data base based on vector similarity
+        :param input_query: list of query string
+        :param n_results: no of similar documents to fetch from database
+        :param where: Optional. to filter data
+        """
+        input_query_vector = self.embedding_fn(input_query)
+        query_vector = input_query_vector[0]
+        query = {
+            "script_score": {
+                "query": {"bool": {"must": [{"exists": {"field": "text"}}]}},
+                "script": {
+                    "source": "cosineSimilarity(params.input_query_vector, 'embeddings') + 1.0",
+                    "params": {"input_query_vector": query_vector},
+                },
+            }
+        }
+        if "app_id" in where:
+            app_id = where["app_id"]
+            query["script_score"]["query"]["bool"]["must"] = [{"term": {"metadata.app_id": app_id}}]
+        _source = ["text"]
+        response = self.client.search(index=self.es_index, query=query, _source=_source, size=n_results)
+        docs = response["hits"]["hits"]
+        contents = [doc["_source"]["text"] for doc in docs]
+        return contents
+
+    def count(self) -> int:
+        query = {"match_all": {}}
+        response = self.client.count(index=self.es_index, query=query)
+        doc_count = response["count"]
+        return doc_count
+
+    def reset(self):
+        # Delete all data from the database
+        if self.client.indices.exists(index=self.es_index):
+            # delete index in Es
+            self.client.indices.delete(index=self.es_index)
@@ -0,0 +1,8 @@
+__pycache__/
+database
+db
+pyenv
+venv
+.env
+.git
+trash_files/
@@ -0,0 +1,8 @@
+__pycache__
+db
+database
+pyenv
+venv
+.env
+trash_files/
+.ideas.md
@@ -0,0 +1,11 @@
+FROM python:3.11 AS backend
+
+WORKDIR /usr/src/api
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE 5000
+
+CMD ["python", "api_server.py"]
@@ -0,0 +1,3 @@
+# API Server
+
+This is a docker template to create your own API Server using the embedchain package. To know more about the API Server and how to use it, go [here](https://docs.embedchain.ai/examples/api_server).
@@ -0,0 +1,55 @@
+from flask import Flask, jsonify, request
+
+from embedchain import App
+
+app = Flask(__name__)
+
+
+def initialize_chat_bot():
+    global chat_bot
+    chat_bot = App()
+
+
+@app.route("/add", methods=["POST"])
+def add():
+    data = request.get_json()
+    data_type = data.get("data_type")
+    url_or_text = data.get("url_or_text")
+    if data_type and url_or_text:
+        try:
+            chat_bot.add(data_type, url_or_text)
+            return jsonify({"data": f"Added {data_type}: {url_or_text}"}), 200
+        except Exception:
+            return jsonify({"error": f"Failed to add {data_type}: {url_or_text}"}), 500
+    return jsonify({"error": "Invalid request. Please provide 'data_type' and 'url_or_text' in JSON format."}), 400
+
+
+@app.route("/query", methods=["POST"])
+def query():
+    data = request.get_json()
+    question = data.get("question")
+    if question:
+        try:
+            response = chat_bot.query(question)
+            return jsonify({"data": response}), 200
+        except Exception:
+            return jsonify({"error": "An error occurred. Please try again!"}), 500
+    return jsonify({"error": "Invalid request. Please provide 'question' in JSON format."}), 400
+
+
+@app.route("/chat", methods=["POST"])
+def chat():
+    data = request.get_json()
+    question = data.get("question")
+    if question:
+        try:
+            response = chat_bot.chat(question)
+            return jsonify({"data": response}), 200
+        except Exception:
+            return jsonify({"error": "An error occurred. Please try again!"}), 500
+    return jsonify({"error": "Invalid request. Please provide 'question' in JSON format."}), 400
+
+
+if __name__ == "__main__":
+    initialize_chat_bot()
+    app.run(host="0.0.0.0", port=5000, debug=False)
@@ -0,0 +1,13 @@
+version: "3.9"
+
+services:
+  backend:
+    container_name: embedchain_api
+    restart: unless-stopped
+    build:
+      context: .
+      dockerfile: Dockerfile
+    env_file:
+      - variables.env
+    ports:
+      - "5000:5000"
@@ -0,0 +1,2 @@
+flask==2.3.2
+embedchain==0.0.30
@@ -0,0 +1 @@
+OPENAI_API_KEY=""
@@ -0,0 +1,8 @@
+__pycache__/
+database
+db
+pyenv
+venv
+.env
+.git
+trash_files/
@@ -0,0 +1,7 @@
+__pycache__
+db
+database
+pyenv
+venv
+.env
+trash_files/
@@ -0,0 +1,9 @@
+FROM python:3.11 AS backend
+
+WORKDIR /usr/src/discord_bot
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+
+CMD ["python", "discord_bot.py"]
@@ -0,0 +1,3 @@
+# Discord Bot
+
+This is a docker template to create your own Discord bot using the embedchain package. To know more about the bot and how to use it, go [here](https://docs.embedchain.ai/examples/discord_bot).
@@ -0,0 +1,65 @@
+import os
+
+import discord
+from discord.ext import commands
+from dotenv import load_dotenv
+
+from embedchain import App
+
+load_dotenv()
+intents = discord.Intents.default()
+intents.message_content = True
+
+bot = commands.Bot(command_prefix="/ec ", intents=intents)
+root_folder = os.getcwd()
+
+
+def initialize_chat_bot():
+    global chat_bot
+    chat_bot = App()
+
+
+@bot.event
+async def on_ready():
+    print(f"Logged in as {bot.user.name}")
+    initialize_chat_bot()
+
+
+@bot.event
+async def on_command_error(ctx, error):
+    if isinstance(error, commands.CommandNotFound):
+        await send_response(ctx, "Invalid command. Please refer to the documentation for correct syntax.")
+    else:
+        print("Error occurred during command execution:", error)
+
+
+@bot.command()
+async def add(ctx, data_type: str, *, url_or_text: str):
+    print(f"User: {ctx.author.name}, Data Type: {data_type}, URL/Text: {url_or_text}")
+    try:
+        chat_bot.add(data_type, url_or_text)
+        await send_response(ctx, f"Added {data_type} : {url_or_text}")
+    except Exception as e:
+        await send_response(ctx, f"Failed to add {data_type} : {url_or_text}")
+        print("Error occurred during 'add' command:", e)
+
+
+@bot.command()
+async def query(ctx, *, question: str):
+    print(f"User: {ctx.author.name}, Query: {question}")
+    try:
+        response = chat_bot.chat(question)
+        await send_response(ctx, response)
+    except Exception as e:
+        await send_response(ctx, "An error occurred. Please try again!")
+        print("Error occurred during 'query' command:", e)
+
+
+async def send_response(ctx, message):
+    if ctx.guild is None:
+        await ctx.send(message)
+    else:
+        await ctx.reply(message)
+
+
+bot.run(os.environ["DISCORD_BOT_TOKEN"])
@@ -0,0 +1,11 @@
+version: "3.9"
+
+services:
+  backend:
+    container_name: embedchain_discord_bot
+    restart: unless-stopped
+    build:
+      context: .
+      dockerfile: Dockerfile
+    env_file:
+      - variables.env
@@ -0,0 +1,3 @@
+discord==2.3.1
+embedchain==0.0.30
+python-dotenv==1.0.0
@@ -0,0 +1,2 @@
+OPENAI_API_KEY=""
+DISCORD_BOT_TOKEN=""
@@ -0,0 +1 @@
+.git
@@ -0,0 +1,18 @@
+## 🐳 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! 🎉
@@ -0,0 +1,7 @@
+__pycache__/
+database
+pyenv
+venv
+.env
+.git
+trash_files/
@@ -0,0 +1,6 @@
+__pycache__
+database
+pyenv
+venv
+.env
+trash_files/
@@ -0,0 +1,11 @@
+FROM python:3.11 AS backend
+
+WORKDIR /usr/src/app/backend
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["python", "server.py"]
@@ -0,0 +1,14 @@
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+
+
+class APIKey(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    key = db.Column(db.String(255), nullable=False)
+
+
+class BotList(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(255), nullable=False)
+    slug = db.Column(db.String(255), nullable=False, unique=True)
@@ -0,0 +1,5 @@
+import os
+
+ROOT_DIRECTORY = os.getcwd()
+DB_DIRECTORY_OPEN_AI = os.path.join(os.getcwd(), "database", "open_ai")
+DB_DIRECTORY_OPEN_SOURCE = os.path.join(os.getcwd(), "database", "open_source")
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Taranjeet Singh	387b042a49	feat: Bump version to 0.0.53 (#552 )	2023-09-05 09:04:37 +05:30
Taranjeet Singh	b3837572be	fix: Add upgrade for pip install (#551 )	2023-09-05 09:02:48 +05:30
Taranjeet Singh	d4e6462e4d	feat: Make poe bot run as an app instead of server. (#550 )	2023-09-05 08:59:41 +05:30
omahs	60d5daaaf5	docs: fix typos (#548 )	2023-09-05 03:45:53 +05:30
sw8fbar	3e66ddf69a	feat: where filter in vector database (#518 )	2023-09-05 02:19:59 +05:30
Tarun Jain	202fd2d5b6	Add community showcase details for Embedchain in one shot (#544 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-05 00:20:20 +05:30
wangJm	eecdbc5e06	Upgrade the chromadb version to 0.4.8 and open its settings configuration. (#517 )	2023-09-04 12:01:08 +05:30
cachho	433c4157e0	chore: linting (#543 )	2023-09-04 01:48:50 +05:30
cachho	8be8990507	feat: discord bot (#465 )	2023-09-04 01:23:01 +05:30
Taranjeet Singh	2cfeb5ed80	bump version to 0.0.52 (#542 )	2023-09-04 01:21:45 +05:30
cachho	0d4ad07d7b	Feat/serialize deserialize (#508 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-04 01:20:18 +05:30
Qihang	2aa25a5169	Bump up LangChain version and bugfix (#536 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-04 01:11:09 +05:30
Joseph Chancey	c07fbc07b1	added contribution img to readme using contrib.rocks embedding (#495 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-04 01:09:14 +05:30
Taranjeet Singh	12eb16d60b	bump version to 0.0.51 (#540 )	2023-09-04 01:04:10 +05:30
Dev Khant	ec9f454ad1	System prompt at App level (#484 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-04 00:55:43 +05:30
Ikko Eltociear Ashimine	9f1f17a611	Fix typo in README.md (#513 ) Co-authored-by: cachho <admin@ch-webdev.com> Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-04 00:54:18 +05:30
aryankhanna475	94369657ef	Showcase Update 01-09 (#527 ) Co-authored-by: Sahil Kumar Yadav <sahilyadav902@gmail.com> Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-04 00:52:35 +05:30
Taranjeet Singh	490d7db601	Bump version to 0.0.50 (#530 )	2023-09-02 05:56:06 +05:30
Taranjeet Singh	ea18b80f90	fix: update chroma init for host & port (#529 )	2023-09-02 05:52:10 +05:30
Deshraj Yadav	70077f4e46	Update package version to 0.0.49 (#515 )	2023-08-30 11:25:46 -07:00
cachho	85106c7c7e	fix: remove stale code (#514 )	2023-08-30 11:19:41 -07:00
Taranjeet Singh	1b19d0d19c	bump version to 0.0.48 (#503 )	2023-08-29 00:31:50 +05:30
Taranjeet Singh	13f01e399c	fix: add tiktoken as required dependency in pyproject (#502 )	2023-08-29 00:29:12 +05:30
Taranjeet Singh	261e2d088c	Bump version to 0.0.47 (#501 )	2023-08-29 00:00:35 +05:30
Taranjeet Singh	b0ae3e95c7	fix: update poe bot creation docs (#500 )	2023-08-28 23:59:34 +05:30
cachho	fc633dadeb	feat: poe bot (#492 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-08-28 23:47:01 +05:30
Taranjeet Singh	aafb334916	fix: improve CTA of book meeting (#496 )	2023-08-28 08:19:47 +05:30
Taranjeet Singh	04d851e802	fix: update discord link (#494 )	2023-08-28 05:33:03 +05:30
Taranjeet Singh	de31c63dac	feat: Add cal.com link for feedback (#493 )	2023-08-28 05:12:54 +05:30
Deshraj Yadav	c068f58543	[version]: bump package version to 0.0.46	2023-08-27 12:24:37 -07:00
Deshraj Yadav	70df373807	[feat]: add support for sending anonymous user_id in telemetry (#491 )	2023-08-28 00:53:42 +05:30
Deshraj Yadav	4388f6bfc2	[bug-fix] fix issue related to bot memory when using multiple bots at the same time (#486 )	2023-08-25 21:59:39 -07:00
Taranjeet Singh	d0956a0dc1	Bump version to 0.0.45 (#479 )	2023-08-25 03:22:04 +05:30
cachho	ccf515cadd	Fix/use poetry for build (#478 )	2023-08-25 03:20:57 +05:30
Taranjeet Singh	a6e4235bb0	fix: update docs (#477 )	2023-08-25 03:16:15 +05:30
Taranjeet Singh	9ba408086e	Bump version to 0.0.44 (#476 )	2023-08-25 03:12:22 +05:30
cachho	bbb3bca1c7	fix: python version string (#475 )	2023-08-25 03:10:48 +05:30
Taranjeet Singh	564036a166	Bump version to 0.0.43 (#474 )	2023-08-25 03:05:27 +05:30
cachho	abf99ce5ea	chore: add release workflow (#397 )	2023-08-25 03:04:07 +05:30
Taranjeet Singh	f0f5c34acb	Bump version to 0.0.42 (#473 )	2023-08-25 02:55:29 +05:30
cachho	ed319531bf	fix: dependencies (#416 )	2023-08-25 02:53:25 +05:30
Dev Khant	d8d0e0e5d1	Add whatsapp bot poetry dependencies (#466 )	2023-08-23 10:15:25 -07:00
Girish S	27c91bbd2d	Create documentation_issue.yml as Github Issue Template for documentation (#460 )	2023-08-20 13:36:44 +05:30
Taranjeet Singh	f76d9740c6	Bump version to 0.0.41 (#459 )	2023-08-20 02:44:22 +05:30
Deshraj Yadav	f29443a0fc	[feat] Add support for creating whatsapp bot using embedchain (#458 )	2023-08-20 02:42:48 +05:30
Taranjeet Singh	35b022d6bc	Add discord link (#456 )	2023-08-19 11:05:00 +05:30
Taranjeet Singh	0dd1faf57f	Github: Improve issue template. (#455 )	2023-08-19 10:31:05 +05:30
Taranjeet Singh	b57f096b27	Bump version to 0.0.40 (#454 )	2023-08-17 01:53:03 +05:30
cachho	4c8876f032	feat: add method - detect format / data_type (#380 )	2023-08-17 01:48:24 +05:30
Taranjeet Singh	f92e890aa1	Bump version to 0.0.39 (#453 )	2023-08-17 01:39:22 +05:30
cachho	849de5e8ab	feat: system prompt (#448 )	2023-08-17 01:27:01 +05:30
Dev Khant	7585bc557b	Add guide links to readme (#451 )	2023-08-16 22:55:13 +05:30
cachho	4021d93168	chore: linting (#449 )	2023-08-16 04:57:19 +05:30
Jonas	28e06be26f	fix: reset destroys app (#319 ) Co-authored-by: cachho <admin@ch-webdev.com>	2023-08-15 05:22:02 +05:30
cachho	39861ec1e8	fix: add telemetry to add_local (#437 )	2023-08-15 03:12:10 +05:30
Sahil Kumar Yadav	e3ae84b80d	add: WhatsApp, Slack and Telegram bots (#438 )	2023-08-15 03:10:25 +05:30
Taranjeet Singh	09c02954ba	Bump version to 0.0.38 (#442 )	2023-08-15 03:01:11 +05:30
cachho	66b661660b	feat: session id for telemetry (#440 )	2023-08-15 02:58:09 +05:30
cachho	c26559a2d3	fix: notion install error message (#439 )	2023-08-15 02:57:23 +05:30
Taranjeet Singh	c5da46f8b0	update: discord bot docs (#435 )	2023-08-12 06:00:21 +05:30
Sahil Kumar Yadav	0b72269e18	add: support for discord bot (#412 )	2023-08-12 05:52:27 +05:30
cachho	a232d1b779	refactor: do not instantiate all loaders (#418 )	2023-08-12 05:32:40 +05:30
Taranjeet Singh	3cab4415b7	Bump version to 0.0.37 (#431 )	2023-08-12 05:07:51 +05:30
Taranjeet Singh	d494d99c06	docs: update variable name (#430 )	2023-08-12 04:58:37 +05:30
cachho	163f437582	feat: anonymous telemetry (#423 )	2023-08-12 04:57:11 +05:30
cachho	1e0d967bb5	chore: linting (#428 )	2023-08-10 23:42:38 -07:00
Sahil Kumar Yadav	a86deb2675	add: API server(#422 ) Add an example of api server so that devs can quickly get up a bot running along with its api	2023-08-11 11:30:51 +05:30
Taranjeet Singh	d51c508b40	Bump version to 0.0.36 (#426 )	2023-08-11 09:50:39 +05:30
aryankhanna475	af8b3081fa	feat: Update showcase section in the docs (#421 )	2023-08-11 09:44:45 +05:30
Taranjeet Singh	1dbe7daac1	fix: Update embedding field name for Elastiscearch mapping (#425 )	2023-08-11 09:43:52 +05:30
Taranjeet Singh	e56f91a239	Bump version to 0.0.35 (#424 )	2023-08-11 09:29:31 +05:30
Prashant Chaudhary	0179141b2e	feat: add support for Elastcisearch as vector data source (#402 )	2023-08-11 09:23:56 +05:30
cachho	f0abfea55d	chore: linting (#414 )	2023-08-11 01:53:42 +05:30
Taranjeet Singh	77e223be52	Bump version to 0.0.34 (#420 )	2023-08-10 04:48:34 +05:30
Taranjeet Singh	c96df72cd0	Fix: lazy load Notion loader (#419 )	2023-08-10 04:44:02 +05:30
cachho	ce6eb39009	feat: notion loader (#405 )	2023-08-09 13:15:22 +05:30
Jonas	eeac84e2d9	feat: collection name everywhere (#310 ) Co-authored-by: cachho <admin@ch-webdev.com>	2023-08-09 13:08:35 +05:30
Taranjeet Singh	1ee1e671d1	Bump version to 0.0.33 (#411 )	2023-08-09 12:59:45 +05:30
cachho	2ef7c0b736	fix: escape pysqlite swapping (#410 )	2023-08-09 12:54:41 +05:30
aryankhanna475	f2b563e42a	Additions to the community showcase (#401 ) Co-authored-by: Sahil Kumar Yadav <sahilyadav902@gmail.com>	2023-08-09 12:39:36 +05:30
Taranjeet Singh	7a718643a3	bump version to 0.0.32 (#409 )	2023-08-09 12:28:35 +05:30
Taranjeet Singh	1f0f0c93b7	fix: Pass deployment name as param for azure api (#406 )	2023-08-09 12:25:26 +05:30
Taranjeet Singh	030e3521a9	Bump version to 0.0.31 (#408 )	2023-08-09 12:17:57 +05:30
cachho	fdf5d1928d	test: added chunker unit tests (#325 )	2023-08-09 09:12:30 +05:30
cachho	65011a67d4	fix: is readable - zero division error (#383 )	2023-08-09 09:06:26 +05:30
Sahil Kumar Yadav	ec09a8a6fc	example: embedchain playground (#384 )	2023-08-08 08:43:05 -07:00
cachho	5e94980aaa	fix: no logging in pysqlite replacement (#378 )	2023-07-27 07:00:01 -07:00
aryankhanna475	8b619756b6	update: docs showcase (#377 )	2023-07-27 06:58:22 -07:00
cachho	35b43edb20	fix: typo in readme example (#373 )	2023-07-27 06:56:48 -07:00
cachho	02cbde2fc1	docs: fix argument out of order (#374 )	2023-07-27 06:56:18 -07:00
cachho	a868fce036	fix: remove debug logging (#379 )	2023-07-27 06:55:00 -07:00
cachho	079e35b205	fix: chroma pysqlite version (#350 )	2023-07-27 13:12:27 +05:30
Deshraj Yadav	8c91b75b98	[Feature]: Add support for azure openai model (#372 )	2023-07-27 13:03:32 +05:30
cachho	55bfd7cafe	refactor: loader chunker typing (#324 )	2023-07-26 23:14:57 +05:30
cachho	a8552686b4	docs: add back query config (#365 )	2023-07-26 23:13:56 +05:30
Alessandro Panzieri	12a2f78dcb	add "d" on "Embedchain" in citation section title (#369 )	2023-07-26 22:57:01 +05:30
aaishikdutta	cce6d5ddab	fix: Personapp not working with config (#368 )	2023-07-26 22:04:11 +05:30
cachho	088346c4fc	docs: fix template (#364 )	2023-07-25 00:46:50 -07:00
aaishikdutta	7fa7b9e199	Update discord badge in readme.md (#361 )	2023-07-24 09:19:54 -07:00
aaishikdutta	cac15c147f	added fix for documentation (#362 )	2023-07-24 01:18:37 -07:00
aaishikdutta	c54dd1e7bb	Fixed test case for chroma db (#358 )	2023-07-22 16:17:01 -07:00
aaishikdutta	c9c56a4b26	fixed dry_run not working in PersonApp (#357 )	2023-07-21 22:59:20 -07:00
Taranjeet Singh	acbdb800d3	Bump version to 0.0.30 (#355 )	2023-07-22 07:44:38 +05:30
Taranjeet Singh	49711c92b7	bug: fix online bug in chat endpoint (#354 )	2023-07-22 07:42:17 +05:30
aaishikdutta	c4797eb121	fix: fix PersonOpenSourceApp query error (#353 )	2023-07-22 00:14:07 +05:30
Taranjeet Singh	bea4e9e6d1	Bump version to 0.0.29 (#349 )	2023-07-21 13:10:21 +05:30
Taranjeet Singh	9687ec2c1a	fix: init metadata as empty (#348 )	2023-07-21 13:08:46 +05:30