Bump version to 0.0.59 (#651 )

Docs: where context filter (#547 )
Docs: use LlmConfig instead of QueryConfig (#626 )
2023-09-24 18:15:29 -07:00 · 2023-09-24 13:32:27 -07:00 · 2023-09-24 11:48:03 -07:00 · 2023-09-24 11:42:14 -07:00 · 2023-09-24 09:53:06 -07:00 · 2023-09-24 09:49:59 -07:00
159 changed files with 24071 additions and 1805 deletions
@@ -1,6 +1,7 @@
 # embedchain

 [![PyPI](https://img.shields.io/pypi/v/embedchain)](https://pypi.org/project/embedchain/)
+[![Slack](https://img.shields.io/badge/slack-embedchain-brightgreen.svg?logo=slack)](https://join.slack.com/t/embedchain/shared_invite/zt-22uwz3c46-Zg7cIh5rOBteT_xe1jwLDw)
 [![Discord](https://dcbadge.vercel.app/api/server/6PzXDgEjG5?style=flat)](https://discord.gg/CUU9FPhRNt)
 [![Twitter](https://img.shields.io/twitter/follow/embedchain)](https://twitter.com/embedchain)
 [![Substack](https://img.shields.io/badge/Substack-%23006f5c.svg?logo=substack)](https://embedchain.substack.com/)
@@ -8,6 +9,10 @@

 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)

+## Community
+
+* Join embedchain community on slack by accepting [this invite](https://join.slack.com/t/embedchain/shared_invite/zt-22uwz3c46-Zg7cIh5rOBteT_xe1jwLDw)
+
 ## 🤝 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.
@@ -15,7 +20,7 @@ Book a [1-on-1 Session](https://cal.com/taranjeetio/ec) with Taranjeet, the foun
 ## 🔧 Quick install

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

 ## 🔍 Demo
@@ -56,12 +61,12 @@ elon_bot = App()

 # Embed online resources
 elon_bot.add("https://en.wikipedia.org/wiki/Elon_Musk")
-elon_bot.add("https://tesla.com/elon-musk")
+elon_bot.add("https://www.forbes.com/profile/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?")
-# Answer: Elon Musk runs four companies: Tesla, SpaceX, Neuralink, and The Boring Company
+elon_bot.query("How many companies does Elon Musk run and name those?")
+# Answer: Elon Musk currently runs several companies. As of my knowledge, he is the CEO and lead designer of SpaceX, the CEO and product architect of Tesla, Inc., the CEO and founder of Neuralink, and the CEO and founder of The Boring Company. However, please note that this information may change over time, so it's always good to verify the latest updates.
 ```

 ## 🤝 Contributing
@@ -71,6 +76,9 @@ 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

@@ -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`

@@ -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,22 +63,33 @@ 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]`.
+- extra dependencies are required for this app type. Install them with `pip install --upgrade embedchain[opensource]`.

 ### CustomApp

 ```python
 from embedchain import CustomApp
-from embedchain.config import CustomAppConfig
-from embedchain.models import Providers, EmbeddingFunctions
+from embedchain.config import (CustomAppConfig, ElasticsearchDBConfig,
+                               EmbedderConfig, LlmConfig)
+from embedchain.embedder.vertexai import VertexAiEmbedder
+from embedchain.llm.vertex_ai import VertexAiLlm
+from embedchain.models import EmbeddingFunctions, Providers
+from embedchain.vectordb.elasticsearch import Elasticsearch

-config = CustomAppConfig(embedding_fn=EmbeddingFunctions.OPENAI, provider=Providers.OPENAI)
-app = CustomApp(config)
+# short
+app = CustomApp(llm=VertexAiLlm(), db=Elasticsearch(), embedder=VertexAiEmbedder())
+# with configs
+app = CustomApp(
+    config=CustomAppConfig(log_level="INFO"),
+    llm=VertexAiLlm(config=LlmConfig(number_documents=5)),
+    db=Elasticsearch(config=ElasticsearchDBConfig(es_url="...")),
+    embedder=VertexAiEmbedder(config=EmbedderConfig()),
+)
 ```

 - `CustomApp` is not opinionated.
- Configuration required. It's for advanced users who want to mix and match different embedding models and LLMs. Configuration required.
- while it's doing that, it's still providing abstractions through `Providers`.
+- Configuration required. It's for advanced users who want to mix and match different embedding models and LLMs.
+- while it's doing that, it's still providing abstractions by allowing you to import Classes from `embedchain.llm`, `embedchain.vectordb`, and `embedchain.embedder`.
 - paid and free/open source providers included.
 - Once you have imported and instantiated the app, every functionality from here onwards is the same for either type of app. 📚
 - Following providers are available for an LLM
@@ -87,6 +98,7 @@ app = CustomApp(config)
    - VERTEX_AI
    - GPT4ALL
    - AZURE_OPENAI
+    - LLAMA2
 - Following embedding functions are available for an embedding function
    - OPENAI
    - HUGGING_FACE
@@ -103,7 +115,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
@@ -4,6 +4,16 @@ title: '⚙️ Custom configurations'

 Embedchain is made to work out of the box. However, for advanced users we're also offering configuration options. All of these configuration options are optional and have sane defaults.

+## Concept
+The main `App` class is available in the following varieties: `CustomApp`, `OpenSourceApp` and `Llama2App` and `App`. The first is fully configurable, the others are opinionated in some aspects.
+
+The `App` class has three subclasses: `llm`, `db` and `embedder`. These are the core ingredients that make up an EmbedChain app.
+App plus each one of the subclasses have a `config` attribute.
+You can pass a `Config` instance as an argument during initialization to persistently configure a class.
+These configs can be imported from `embedchain.config`
+
+There are `set` methods for some things that should not (only) be set at start-up, like `app.db.set_collection_name`.
+
 ## Examples

 ### General
@@ -11,31 +21,31 @@ Embedchain is made to work out of the box. However, for advanced users we're als
 Here's the readme example with configuration options.

 ```python
-import os
 from embedchain import App
-from embedchain.config import AppConfig, AddConfig, QueryConfig, ChunkerConfig
-from chromadb.utils import embedding_functions
+from embedchain.config import AppConfig, AddConfig, LlmConfig, ChunkerConfig

 # Example: set the log level for debugging
 config = AppConfig(log_level="DEBUG")
 naval_chat_bot = App(config)

 # Example: specify a custom collection name
-config = AppConfig(collection_name="naval_chat_bot")
-naval_chat_bot = App(config)
+naval_chat_bot.db.set_collection_name("naval_chat_bot")

 # Example: define your own chunker config for `youtube_video`
 chunker_config = ChunkerConfig(chunk_size=1000, chunk_overlap=100, length_function=len)
-naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44", AddConfig(chunker=chunker_config))
+# Example: Add your chunker config to an AddConfig to actually use it
+add_config = AddConfig(chunker=chunker_config)
+naval_chat_bot.add("https://www.youtube.com/watch?v=3qHkcs3kG44", config=add_config)

+# Example: Reset to default
 add_config = AddConfig()
 naval_chat_bot.add("https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf", config=add_config)
 naval_chat_bot.add("https://nav.al/feedback", config=add_config)
 naval_chat_bot.add("https://nav.al/agi", config=add_config)
-
 naval_chat_bot.add(("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."), config=add_config)

-query_config = QueryConfig()
+# Change the number of documents.
+query_config = LlmConfig(number_documents=5)
 print(naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", config=query_config))
 ```

@@ -44,11 +54,13 @@ print(naval_chat_bot.query("What unique capacity does Naval argue humans possess
 Here's the example of using custom prompt template with `.query`

 ```python
-from embedchain.config import QueryConfig
-from embedchain.embedchain import App
 from string import Template
+
 import wikipedia

+from embedchain import App
+from embedchain.config import LlmConfig
+
 einstein_chat_bot = App()

 # Embed Wikipedia page
@@ -56,7 +68,8 @@ page = wikipedia.page("Albert Einstein")
 einstein_chat_bot.add(page.content)

 # Example: use your own custom template with `$context` and `$query`
-einstein_chat_template = Template("""
+einstein_chat_template = Template(
+    """
        You are Albert Einstein, a German-born theoretical physicist,
        widely ranked among the greatest and most influential scientists of all time.

@@ -67,17 +80,19 @@ einstein_chat_template = Template("""
        Keep the response brief. If you don't know the answer, just say that you don't know, don't try to make up an answer.

        Human: $query
-        Albert Einstein:""")
-query_config = QueryConfig(template=einstein_chat_template, system_prompt="You are Albert Einstein.")
+        Albert Einstein:"""
+)
+# Example: Use the template, also add a system prompt.
+llm_config = LlmConfig(template=einstein_chat_template, system_prompt="You are Albert Einstein.")
 queries = [
-        "Where did you complete your studies?",
-        "Why did you win nobel prize?",
-        "Why did you divorce your first wife?",
+    "Where did you complete your studies?",
+    "Why did you win nobel prize?",
+    "Why did you divorce your first wife?",
 ]
 for query in queries:
-        response = einstein_chat_bot.query(query, config=query_config)
-        print("Query: ", query)
-        print("Response: ", response)
+    response = einstein_chat_bot.query(query, config=llm_config)
+    print("Query: ", query)
+    print("Response: ", response)

 # Output
 # Query:  Where did you complete your studies?
@@ -19,7 +19,7 @@ Otherwise, you will not know when, for instance, an invalid filepath is interpre
 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 it's raw text instead of following links.
+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

@@ -73,6 +73,17 @@ app.add('https://example.com/content/intro.docx', data_type="docx")
 app.add('content/intro.docx', data_type="docx")
 ```

+### CSV file
+
+To add any csv file, use the data_type as `csv`. `csv` allows remote urls and conventional file paths. Headers are included for each line, so if you have an `age` column, `18` will be added as `age: 18`. Eg:
+
+```python
+app.add('https://example.com/content/sheet.csv', data_type="csv")
+app.add('content/sheet.csv', data_type="csv")
+```
+
+Note: There is a size limit allowed for csv file beyond which it can throw error. This limit is set by the LLMs. Please consider chunking large csv files into smaller csv files.
+
 ### Code documentation website loader

 To add any code documentation website as a loader, use the data_type as `docs_site`. Eg:
@@ -82,7 +93,7 @@ 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 use notion you must install the extra dependencies with `pip install --upgrade embedchain[notion]`.

 To load a notion page, use the data_type as `notion`. Since it is hard to automatically detect, forcing this is advised.
 The next argument must **end** with the `notion page id`. The id is a 32-character string. Eg:
@@ -93,6 +104,14 @@ app.add("my-page-cfbc134ca6464fc980d0391613959196", "notion")
 app.add("https://www.notion.so/my-page-cfbc134ca6464fc980d0391613959196", "notion")
 ```

+### Mdx file
+
+To add any mdx file to your app, use the data_type (first argument to `.add()` method) as `mdx`. Note that this supports support mdx file present on machine, so this should be a file path. Eg:
+
+```python
+app.add('path/to/file.mdx', data_type='mdx')
+```
+
 ## Local Data Types

 ### Text
@@ -138,4 +157,4 @@ print(naval_chat_bot.query("What unique capacity does Naval argue humans possess

 ## 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.
+- 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.

@@ -36,18 +36,18 @@ print(naval_chat_bot.chat("what did the author say about happiness?"))

 #### Dry Run

-Dry Run is an option in the `query` and `chat` methods that allows the user to not send their constructed prompt to the LLM, to save money. It's used for [testing](/advanced/testing#dry-run).
+Dry Run is an option in the `add`, `query` and `chat` methods that allows the user to display the data chunks and their constructed prompt which is not sent to the LLM, to save money. It's used for [testing](/advanced/testing#dry-run).


 ### Stream Response

 - You can add config to your query method to stream responses like ChatGPT does. You would require a downstream handler to render the chunk in your desirable format. Supports both OpenAI model and OpenSourceApp. 📊

- To use this, instantiate a `QueryConfig` or `ChatConfig` object with `stream=True`. Then pass it to the `.chat()` or `.query()` method. The following example iterates through the chunks and prints them as they appear.
+- To use this, instantiate a `LlmConfig` or `ChatConfig` object with `stream=True`. Then pass it to the `.chat()` or `.query()` method. The following example iterates through the chunks and prints them as they appear.

 ```python
 app = App()
-query_config = QueryConfig(stream = True)
+query_config = LlmConfig(stream = True)
 resp = app.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", query_config)

 for chunk in resp:
@@ -72,4 +72,4 @@ Counts the number of embeddings (chunks) in the database.
 ```python
 print(app.count())
 # returns: 481
-```
+```
@@ -53,7 +53,7 @@ Default values of chunker config parameters for different `data_type`:

 _coming soon_

-## QueryConfig
+## LlmConfig

 |option|description|type|default|
 |---|---|---|---|
@@ -67,6 +67,8 @@ _coming soon_
 |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|
+|where|filter for context search.|dict|None|
+

 ## ChatConfig

@@ -8,6 +8,7 @@ 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/))
@@ -69,6 +70,7 @@ Embedchain community has been super active in creating demos on top of Embedchai

 ## 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
@@ -6,11 +6,9 @@ title: '🧪 Testing'

 ### Dry Run

-Before you consume valueable tokens, you should make sure that the embedding you have done works and that it's receiving the correct document from the database.
+Before you consume valueable tokens, you should make sure that data chunks are properly created and the embedding you have done works and that it's receiving the correct document from the database.

-For this you can use the `dry_run` option in your `query` or `chat` method.
-
-Following the example above, add this to your script:
+- For `query` or `chat` method, you can add this to your script:

 ```python
 print(naval_chat_bot.query('Can you tell me who Naval Ravikant is?', dry_run=True))
@@ -26,4 +24,17 @@ A: Naval Ravikant is an Indian-American entrepreneur and investor.

 _The embedding is confirmed to work as expected. It returns the right document, even if the question is asked slightly different. No prompt tokens have been consumed._

-**The dry run will still consume tokens to embed your query, but it is only ~1/15 of the prompt.**
+The dry run will still consume tokens to embed your query, but it is only **~1/15 of the prompt.**
+
+
+- For `add` method, you can add this to your script:
+
+```python
+print(naval_chat_bot.add('https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', dry_run=True))
+
+'''
+{'chunks': ['THE ALMANACK OF NAVAL RAVIKANT', 'GETTING RICH IS NOT JUST ABOUT LUCK;', 'HAPPINESS IS NOT JUST A TRAIT WE ARE'], 'metadata': [{'source': 'C:\\Users\\Dev\\AppData\\Local\\Temp\\tmp3g5mjoiz\\tmp.pdf', 'page': 0, 'url': 'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', 'data_type': 'pdf_file'}, {'source': 'C:\\Users\\Dev\\AppData\\Local\\Temp\\tmp3g5mjoiz\\tmp.pdf', 'page': 2, 'url': 'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', 'data_type': 'pdf_file'}, {'source': 'C:\\Users\\Dev\\AppData\\Local\\Temp\\tmp3g5mjoiz\\tmp.pdf', 'page': 2, 'url': 'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf', 'data_type': 'pdf_file'}], 'count': 7358, 'type': <DataType.PDF_FILE: 'pdf_file'>}
+
+# less items to show for readability
+'''
+```
@@ -5,30 +5,66 @@ 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`. 
+## Elasticsearch
+
+### Minimal Example
+
+In order to use `Elasticsearch` as vector database we need to use App type `CustomApp`.
+
+1. Set the environment variables in a `.env` file.
+```
+OPENAI_API_KEY=sk-SECRETKEY
+ELASTICSEARCH_API_KEY=SECRETKEY==
+ELASTICSEARCH_URL=https://secret-domain.europe-west3.gcp.cloud.es.io:443
+```
+Please note that the key needs certain privileges. For testing you can just toggle off `restrict privileges` under `/app/management/security/api_keys/` in your web interface.
+
+2. Load the app
+```python
+from embedchain import CustomApp
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.elasticsearch import ElasticsearchDB
+
+es_app = CustomApp(
+    llm=OpenAILlm(),
+    embedder=OpenAiEmbedder(),
+    db=ElasticsearchDB(),
+)
+```
+
+### More custom settings
+
+You can get a URL for elasticsearch in the cloud, or run it locally. 
+The following example shows you how to configure embedchain to work with a locally running elasticsearch.
+
+Instead of using an API key, we use http login credentials. The localhost url can be defined in .env or in the config.
+
 ```python
 import os
+
 from embedchain import CustomApp
 from embedchain.config import CustomAppConfig, ElasticsearchDBConfig
-from embedchain.models import Providers, EmbeddingFunctions, VectorDatabases
-
-os.environ["OPENAI_API_KEY"] = 'OPENAI_API_KEY'
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.elasticsearch import ElasticsearchDB

 es_config = ElasticsearchDBConfig(
-	# elasticsearch url or list of nodes url with different hosts and ports.
-	es_url='http://localhost:9200',
-	# pass named parameters supported by Python Elasticsearch client
-	ca_certs="/path/to/http_ca.crt",
-	basic_auth=("username", "password")
+    # elasticsearch url or list of nodes url with different hosts and ports.
+    es_url='https://localhost:9200',
+    # pass named parameters supported by Python Elasticsearch client
+    http_auth=("elastic", "secret"),
+    ca_certs="~/binaries/elasticsearch-8.7.0/config/certs/http_ca.crt" # your cert path
+    # verify_certs=False # Alternative, if you aren't using certs
+) # pass named parameters supported by elasticsearch-py
+
+es_app = CustomApp(
+    config=CustomAppConfig(log_level="INFO"),
+    llm=OpenAILlm(),
+    embedder=OpenAiEmbedder(),
+    db=ElasticsearchDB(config=es_config),
 )
-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 paramaters supported by Python Elasticsearch client.
+3. This should log your connection details to the console.
+4. Alternatively to a URL, you `ElasticsearchDBConfig` accepts `es_url` as a list of nodes url with different hosts and ports.
+5. Additionally we can pass named parameters supported by Python Elasticsearch client.
@@ -8,40 +8,54 @@ title: '🤖 Discord Bot'
 - 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 variables.env file.
+- 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
-Read Messages/View Channel (under General Permissions)
 Send Messages (under Text Permissions)
-Read Message History (under Text Permissions)
-Mention everyone (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.
+- 🎉 The bot has been successfully added to your server. But it's still offline.

-### 🐳 Docker Setup
+### Take the bot online
+
+1. Install embedchain python package:

- To setup your discord bot using docker, run the following command inside this folder using your terminal.
 ```bash
-docker-compose up --build
+pip install --upgrade "embedchain[discord]"
+```
+
+2. Launch your Discord bot:
+
+
+```bash
+python -m embedchain.bots.discord
+```
+
+If you prefer to see the question and not only the answer, run it with
+
+```bash
+python -m embedchain.bots.discord --include-question
 ```
-📝 Note: The build command might take a while to install all the packages depending on your system resources.

 ### 🚀 Usage Instructions

 - Go to the server where you have added your bot.
- You can add data sources to the bot using the command:
+- You can add data sources to the bot using the slash command:
 ```text
-/ec add <data_type> <url_or_text>
+/add <data_type> <url_or_text>
 ```
- You can ask your queries from the bot using the command:
+- You can ask your queries from the bot using the slash command:
 ```text
-/ec query <question>
+/query <question>
+```
+- You can chat with the bot using the slash command:
+```text
+/chat <question>
 ```
 📝 Note: To use the bot privately, you can message the bot directly by right clicking the bot and selecting `Message`.

@@ -7,42 +7,53 @@ title: '🔮 Poe Bot'
 1. Install embedchain python package:

 ```bash
-pip install embedchain[poe]
+pip install --upgrade "embedchain[poe]"
 ```

 2. Create a free account on [Poe](https://www.poe.com?utm_source=embedchain).
-3. Click "Create Bot" button on top left
+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. Start the bot.
+8. You will need to set `OPENAI_API_KEY` for generating embeddings and using LLM. Copy your OpenAI API key from [here](https://platform.openai.com/account/api-keys) and paste it in `.env` as `OPENAI_API_KEY`.
+9. Now create your bot using the following code snippet.

 ```bash
-python -m embedchain.bots.poe
+# make sure that you have set OPENAI_API_KEY and POE_API_KEY in .env file
+from embedchain.bots import PoeBot
+
+poe_bot = PoeBot()
+
+# add as many data sources as you want
+poe_bot.add("https://en.wikipedia.org/wiki/Adam_D%27Angelo")
+poe_bot.add("https://www.youtube.com/watch?v=pJQVAqmKua8")
+
+# start the bot
+# this start the poe bot server on port 8080 by default
+poe_bot.start()
 ```

-If you want to run the bot on another port, you can pass `--port option` like
+10. You can paste the above in a file called `your_script.py` and then simply do

 ```bash
-python -m embedchain.bots.poe --port 5000
+python your_script.py
 ```

-9. Click `Run check` to make sure your machine can be reached.
-10. Make sure your bot is private if that's what you want.
-11. Click `Create bot` at the bottom to finally create the bot
-12. Now you bot is created.
+Now your bot will start running at port `8080` by default.
+
+11. You can refer the [Supported Data formats](https://docs.embedchain.ai/advanced/data_types) section to refer the supported data types in embedchain.
+
+12. Click `Run check` to make sure your machine can be reached.
+13. Make sure your bot is private if that's what you want.
+14. Click `Create bot` at the bottom to finally create the bot
+15. Now your bot is created.

 ### 💬 How to use

- To include data sources, use this command:
-```text
-/add <url_or_text>
-```
-
- You can refer the [Supported Data formats](https://docs.embedchain.ai/advanced/data_types) section to refer the supported data types in embedchain.
-
- To ask the bot questions, just type your query:
+- 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.
@@ -2,27 +2,25 @@
 title: '💼 Slack Bot'
 ---

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

 ### 🚀 Usage Instructions

@@ -7,7 +7,7 @@ title: '💬 WhatsApp Bot'
 1. Install embedchain python package:

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

 2. Launch your WhatsApp bot:
@@ -20,12 +20,16 @@ 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")
+naval_chat_bot.add("The Meanings of Life", 'text', metadata={'chapter': 'philosphy'})

 # Embed Local Resources
 naval_chat_bot.add(("Who is Naval Ravikant?", "Naval Ravikant is an Indian-American entrepreneur and investor."))

 naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?")
 # Answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
+
+# with where context filter
+naval_chat_bot.query("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?", where={'chapter': 'philosophy'})
 ```

 ## 🚀 How it works?
@@ -6,7 +6,7 @@ description: '💡 Start building LLM powered bots under 30 seconds'
 Install embedchain python package:

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

 Creating a chatbot involves 3 steps:
@@ -27,9 +27,9 @@ elon_musk_bot = App()

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

-response = elon_musk_bot.query("How many companies does Elon Musk run?")
+response = elon_musk_bot.query("How many companies does Elon Musk run and name those?")
 print(response)
-# Answer: 'Elon Musk runs four companies: Tesla, SpaceX, Neuralink, and The Boring Company.'
+# Answer: 'Elon Musk currently runs several companies. As of my knowledge, he is the CEO and lead designer of SpaceX, the CEO and product architect of Tesla, Inc., the CEO and founder of Neuralink, and the CEO and founder of The Boring Company. However, please note that this information may change over time, so it's always good to verify the latest updates.'
 ```
@@ -0,0 +1,2 @@
+node_modules
+dist
@@ -0,0 +1,56 @@
+{
+    // Configuration for JavaScript files
+    "extends": [
+      "airbnb-base",
+      "plugin:prettier/recommended"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "error",
+        {
+          "singleQuote": true,
+          "endOfLine": "auto"
+        }
+      ]
+    },
+    "overrides": [
+      // Configuration for TypeScript files
+      {
+        "files": ["**/*.ts", "**/__tests__/*.test.ts"],
+        "plugins": [
+          "@typescript-eslint",
+          "unused-imports",
+          "simple-import-sort"
+        ],
+        "extends": [
+          "airbnb-typescript",
+          "plugin:prettier/recommended"
+        ],
+        "parserOptions": {
+          "project": "./tsconfig.json"
+        },
+        "rules": {
+          "prettier/prettier": [
+            "error",
+            {
+              "singleQuote": true,
+              "endOfLine": "auto"
+            }
+          ],
+          "@typescript-eslint/comma-dangle": "off", // Avoid conflict rule between Eslint and Prettier
+          "@typescript-eslint/consistent-type-imports": "error", // Ensure `import type` is used when it's necessary
+          "import/prefer-default-export": "off", // Named export is easier to refactor automatically
+          "simple-import-sort/imports": "error", // Import configuration for `eslint-plugin-simple-import-sort`
+          "simple-import-sort/exports": "error", // Export configuration for `eslint-plugin-simple-import-sort`
+          "@typescript-eslint/no-unused-vars": "off",
+          "react/jsx-filename-extension": "off", // Gives error
+          "unused-imports/no-unused-imports": "error",
+          "unused-imports/no-unused-vars": [
+            "error",
+            { "argsIgnorePattern": "^_" }
+          ]
+        }
+      }
+    ]
+  }
+  
@@ -0,0 +1,47 @@
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+      - run: npm run build
+      - uses: actions/upload-artifact@v3
+        with:
+          name: dist
+          path: dist
+      - uses: actions/upload-artifact@v3
+        with:
+          name: types
+          path: types
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - uses: actions/download-artifact@v3
+        with:
+          name: dist
+          path: dist
+      - uses: actions/download-artifact@v3
+        with:
+          name: types
+          path: types
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
@@ -0,0 +1,138 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+.ideas.md
+.todos.md
+
+# Custom
+dist
+types
+build
@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit $1
@@ -0,0 +1,5 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+# Disable concurent to run `check-types` after ESLint in lint-staged
+npx lint-staged --concurrent false
@@ -0,0 +1,8 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- family-names: "Singh"
+  given-names: "Taranjeet"
+title: "Embedchain"
+date-released: 2023-06-25
+url: "https://github.com/embedchain/embedchainjs"
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -0,0 +1,263 @@
+# embedchainjs
+
+[![Discord](https://dcbadge.vercel.app/api/server/CUU9FPhRNt?style=flat)](https://discord.gg/CUU9FPhRNt)
+[![Twitter](https://img.shields.io/twitter/follow/embedchain)](https://twitter.com/embedchain)
+[![Substack](https://img.shields.io/badge/Substack-%23006f5c.svg?logo=substack)](https://embedchain.substack.com/)
+
+embedchain is a framework to easily create LLM powered bots over any dataset. embedchainjs is Javascript version of embedchain. If you want a python version, check out [embedchain-python](https://github.com/embedchain/embedchain)
+
+# 🤝 Let's Talk Embedchain!
+
+Schedule a [Feedback Session](https://cal.com/taranjeetio/ec) with Taranjeet, the founder, to discuss any issues, provide feedback, or explore improvements.
+
+# How it works
+
+It abstracts the entire process of loading dataset, chunking it, creating embeddings and then storing in vector database.
+
+You can add a single or multiple dataset using `.add` and `.addLocal` function and then use `.query` function to find an answer from the added datasets.
+
+If you want to create a Naval Ravikant bot which has 2 of his blog posts, as well as a question and answer pair you supply, all you need to do is add the links to the blog posts and the QnA pair and embedchain will create a bot for you.
+
+```javascript
+const dotenv = require("dotenv");
+dotenv.config();
+const { App } = require("embedchain");
+
+//Run the app commands inside an async function only
+async function testApp() {
+  const navalChatBot = await App();
+
+  // Embed Online Resources
+  await navalChatBot.add("web_page", "https://nav.al/feedback");
+  await navalChatBot.add("web_page", "https://nav.al/agi");
+  await navalChatBot.add(
+    "pdf_file",
+    "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf"
+  );
+
+  // Embed Local Resources
+  await navalChatBot.addLocal("qna_pair", [
+    "Who is Naval Ravikant?",
+    "Naval Ravikant is an Indian-American entrepreneur and investor.",
+  ]);
+
+  const result = await navalChatBot.query(
+    "What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"
+  );
+  console.log(result);
+  // answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
+}
+
+testApp();
+```
+
+# Getting Started
+
+## Installation
+
+- First make sure that you have the package installed. If not, then install it using `npm`
+
+```bash
+npm install embedchain && npm install -S openai@^3.3.0
+```
+
+- Currently, it is only compatible with openai 3.X, not the latest version 4.X. Please make sure to use the right version, otherwise you will see the `ChromaDB` error `TypeError: OpenAIApi.Configuration is not a constructor`
+
+- Make sure that dotenv package is installed and your `OPENAI_API_KEY` in a file called `.env` in the root folder. You can install dotenv by
+
+```js
+npm install dotenv
+```
+
+- Download and install Docker on your device by visiting [this link](https://www.docker.com/). You will need this to run Chroma vector database on your machine.
+
+- Run the following commands to setup Chroma container in Docker
+
+```bash
+git clone https://github.com/chroma-core/chroma.git
+cd chroma
+docker-compose up -d --build
+```
+
+- Once Chroma container has been set up, run it inside Docker
+
+## Usage
+
+- We use OpenAI's embedding model to create embeddings for chunks and ChatGPT API as LLM to get answer given the relevant docs. Make sure that you have an OpenAI account and an API key. If you have dont have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
+
+- Once you have the API key, set it in an environment variable called `OPENAI_API_KEY`
+
+```js
+// Set this inside your .env file
+OPENAI_API_KEY = "sk-xxxx";
+```
+
+- Load the environment variables inside your .js file using the following commands
+
+```js
+const dotenv = require("dotenv");
+dotenv.config();
+```
+
+- Next import the `App` class from embedchain and use `.add` function to add any dataset.
+- Now your app is created. You can use `.query` function to get the answer for any query.
+
+```js
+const dotenv = require("dotenv");
+dotenv.config();
+const { App } = require("embedchain");
+
+async function testApp() {
+  const navalChatBot = await App();
+
+  // Embed Online Resources
+  await navalChatBot.add("web_page", "https://nav.al/feedback");
+  await navalChatBot.add("web_page", "https://nav.al/agi");
+  await navalChatBot.add(
+    "pdf_file",
+    "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf"
+  );
+
+  // Embed Local Resources
+  await navalChatBot.addLocal("qna_pair", [
+    "Who is Naval Ravikant?",
+    "Naval Ravikant is an Indian-American entrepreneur and investor.",
+  ]);
+
+  const result = await navalChatBot.query(
+    "What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"
+  );
+  console.log(result);
+  // answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
+}
+
+testApp();
+```
+
+- If there is any other app instance in your script or app, you can change the import as
+
+```javascript
+const { App: EmbedChainApp } = require("embedchain");
+
+// or
+
+const { App: ECApp } = require("embedchain");
+```
+
+## Format supported
+
+We support the following formats:
+
+### PDF File
+
+To add any pdf file, use the data_type as `pdf_file`. Eg:
+
+```javascript
+await app.add("pdf_file", "a_valid_url_where_pdf_file_can_be_accessed");
+```
+
+### Web Page
+
+To add any web page, use the data_type as `web_page`. Eg:
+
+```javascript
+await app.add("web_page", "a_valid_web_page_url");
+```
+
+### QnA Pair
+
+To supply your own QnA pair, use the data_type as `qna_pair` and enter a tuple. Eg:
+
+```javascript
+await app.addLocal("qna_pair", ["Question", "Answer"]);
+```
+
+### More Formats coming soon
+
+- If you want to add any other format, please create an [issue](https://github.com/embedchain/embedchainjs/issues) and we will add it to the list of supported formats.
+
+## Testing
+
+Before you consume valueable tokens, you should make sure that the embedding you have done works and that it's receiving the correct document from the database.
+
+For this you can use the `dryRun` method.
+
+Following the example above, add this to your script:
+
+```js
+let result = await naval_chat_bot.dryRun("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?");console.log(result);
+
+'''
+Use the following pieces of context to answer the query at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
+terms of the unseen. And I think that’s critical. That is what humans do uniquely that no other creature, no other computer, no other intelligence—biological or artificial—that we have ever encountered does. And not only do we do it uniquely, but if we were to meet an alien species that also had the power to generate these good explanations, there is no explanation that they could generate that we could not understand. We are maximally capable of understanding. There is no concept out there that is possible in this physical reality that a human being, given sufficient time and resources and
+Query: What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?
+Helpful Answer:
+'''
+```
+
+_The embedding is confirmed to work as expected. It returns the right document, even if the question is asked slightly different. No prompt tokens have been consumed._
+
+**The dry run will still consume tokens to embed your query, but it is only ~1/15 of the prompt.**
+
+# How does it work?
+
+Creating a chat bot over any dataset needs the following steps to happen
+
+- load the data
+- create meaningful chunks
+- create embeddings for each chunk
+- store the chunks in vector database
+
+Whenever a user asks any query, following process happens to find the answer for the query
+
+- create the embedding for query
+- find similar documents for this query from vector database
+- pass similar documents as context to LLM to get the final answer.
+
+The process of loading the dataset and then querying involves multiple steps and each steps has nuances of it is own.
+
+- How should I chunk the data? What is a meaningful chunk size?
+- How should I create embeddings for each chunk? Which embedding model should I use?
+- How should I store the chunks in vector database? Which vector database should I use?
+- Should I store meta data along with the embeddings?
+- How should I find similar documents for a query? Which ranking model should I use?
+
+These questions may be trivial for some but for a lot of us, it needs research, experimentation and time to find out the accurate answers.
+
+embedchain is a framework which takes care of all these nuances and provides a simple interface to create bots over any dataset.
+
+In the first release, we are making it easier for anyone to get a chatbot over any dataset up and running in less than a minute. All you need to do is create an app instance, add the data sets using `.add` function and then use `.query` function to get the relevant answer.
+
+# Tech Stack
+
+embedchain is built on the following stack:
+
+- [Langchain](https://github.com/hwchase17/langchain) as an LLM framework to load, chunk and index data
+- [OpenAI's Ada embedding model](https://platform.openai.com/docs/guides/embeddings) to create embeddings
+- [OpenAI's ChatGPT API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) as LLM to get answers given the context
+- [Chroma](https://github.com/chroma-core/chroma) as the vector database to store embeddings
+
+# Team
+
+## Author
+
+- Taranjeet Singh ([@taranjeetio](https://twitter.com/taranjeetio))
+
+## Maintainer
+
+- [cachho](https://github.com/cachho)
+- [sahilyadav902](https://github.com/sahilyadav902)
+
+## Citation
+
+If you utilize this repository, please consider citing it with:
+```
+@misc{embedchain,
+  author = {Taranjeet Singh},
+  title = {Embechain: Framework to easily create LLM powered bots over any dataset},
+  year = {2023},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/embedchain/embedchainjs}},
+}
+```
@@ -0,0 +1 @@
+module.exports = { extends: ['@commitlint/config-conventional'] };
@@ -0,0 +1,66 @@
+import { EmbedChainApp } from '../embedchain';
+
+const mockAdd = jest.fn();
+const mockAddLocal = jest.fn();
+const mockQuery = jest.fn();
+
+jest.mock('../embedchain', () => {
+  return {
+    EmbedChainApp: jest.fn().mockImplementation(() => {
+      return {
+        add: mockAdd,
+        addLocal: mockAddLocal,
+        query: mockQuery,
+      };
+    }),
+  };
+});
+
+describe('Test App', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('tests the App', async () => {
+    mockQuery.mockResolvedValue(
+      'Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.'
+    );
+
+    const navalChatBot = await new EmbedChainApp(undefined, false);
+
+    // Embed Online Resources
+    await navalChatBot.add('web_page', 'https://nav.al/feedback');
+    await navalChatBot.add('web_page', 'https://nav.al/agi');
+    await navalChatBot.add(
+      'pdf_file',
+      'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf'
+    );
+
+    // Embed Local Resources
+    await navalChatBot.addLocal('qna_pair', [
+      'Who is Naval Ravikant?',
+      'Naval Ravikant is an Indian-American entrepreneur and investor.',
+    ]);
+
+    const result = await navalChatBot.query(
+      'What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?'
+    );
+
+    expect(mockAdd).toHaveBeenCalledWith('web_page', 'https://nav.al/feedback');
+    expect(mockAdd).toHaveBeenCalledWith('web_page', 'https://nav.al/agi');
+    expect(mockAdd).toHaveBeenCalledWith(
+      'pdf_file',
+      'https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf'
+    );
+    expect(mockAddLocal).toHaveBeenCalledWith('qna_pair', [
+      'Who is Naval Ravikant?',
+      'Naval Ravikant is an Indian-American entrepreneur and investor.',
+    ]);
+    expect(mockQuery).toHaveBeenCalledWith(
+      'What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?'
+    );
+    expect(result).toBe(
+      'Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.'
+    );
+  });
+});
@@ -0,0 +1,44 @@
+import { createHash } from 'crypto';
+import type { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import type { BaseLoader } from '../loaders';
+import type { Input, LoaderResult } from '../models';
+import type { ChunkResult } from '../models/ChunkResult';
+
+class BaseChunker {
+  textSplitter: RecursiveCharacterTextSplitter;
+
+  constructor(textSplitter: RecursiveCharacterTextSplitter) {
+    this.textSplitter = textSplitter;
+  }
+
+  async createChunks(loader: BaseLoader, url: Input): Promise<ChunkResult> {
+    const documents: ChunkResult['documents'] = [];
+    const ids: ChunkResult['ids'] = [];
+    const datas: LoaderResult = await loader.loadData(url);
+    const metadatas: ChunkResult['metadatas'] = [];
+
+    const dataPromises = datas.map(async (data) => {
+      const { content, metaData } = data;
+      const chunks: string[] = await this.textSplitter.splitText(content);
+      chunks.forEach((chunk) => {
+        const chunkId = createHash('sha256')
+          .update(chunk + metaData.url)
+          .digest('hex');
+        ids.push(chunkId);
+        documents.push(chunk);
+        metadatas.push(metaData);
+      });
+    });
+
+    await Promise.all(dataPromises);
+
+    return {
+      documents,
+      ids,
+      metadatas,
+    };
+  }
+}
+
+export { BaseChunker };
@@ -0,0 +1,26 @@
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import { BaseChunker } from './BaseChunker';
+
+interface TextSplitterChunkParams {
+  chunkSize: number;
+  chunkOverlap: number;
+  keepSeparator: boolean;
+}
+
+const TEXT_SPLITTER_CHUNK_PARAMS: TextSplitterChunkParams = {
+  chunkSize: 1000,
+  chunkOverlap: 0,
+  keepSeparator: false,
+};
+
+class PdfFileChunker extends BaseChunker {
+  constructor() {
+    const textSplitter = new RecursiveCharacterTextSplitter(
+      TEXT_SPLITTER_CHUNK_PARAMS
+    );
+    super(textSplitter);
+  }
+}
+
+export { PdfFileChunker };
@@ -0,0 +1,26 @@
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import { BaseChunker } from './BaseChunker';
+
+interface TextSplitterChunkParams {
+  chunkSize: number;
+  chunkOverlap: number;
+  keepSeparator: boolean;
+}
+
+const TEXT_SPLITTER_CHUNK_PARAMS: TextSplitterChunkParams = {
+  chunkSize: 300,
+  chunkOverlap: 0,
+  keepSeparator: false,
+};
+
+class QnaPairChunker extends BaseChunker {
+  constructor() {
+    const textSplitter = new RecursiveCharacterTextSplitter(
+      TEXT_SPLITTER_CHUNK_PARAMS
+    );
+    super(textSplitter);
+  }
+}
+
+export { QnaPairChunker };
@@ -0,0 +1,26 @@
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+
+import { BaseChunker } from './BaseChunker';
+
+interface TextSplitterChunkParams {
+  chunkSize: number;
+  chunkOverlap: number;
+  keepSeparator: boolean;
+}
+
+const TEXT_SPLITTER_CHUNK_PARAMS: TextSplitterChunkParams = {
+  chunkSize: 500,
+  chunkOverlap: 0,
+  keepSeparator: false,
+};
+
+class WebPageChunker extends BaseChunker {
+  constructor() {
+    const textSplitter = new RecursiveCharacterTextSplitter(
+      TEXT_SPLITTER_CHUNK_PARAMS
+    );
+    super(textSplitter);
+  }
+}
+
+export { WebPageChunker };
@@ -0,0 +1,6 @@
+import { BaseChunker } from './BaseChunker';
+import { PdfFileChunker } from './PdfFile';
+import { QnaPairChunker } from './QnaPair';
+import { WebPageChunker } from './WebPage';
+
+export { BaseChunker, PdfFileChunker, QnaPairChunker, WebPageChunker };
@@ -0,0 +1,317 @@
+/* eslint-disable max-classes-per-file */
+import type { Collection } from 'chromadb';
+import type { QueryResponse } from 'chromadb/dist/main/types';
+import * as fs from 'fs';
+import { Document } from 'langchain/document';
+import OpenAI from 'openai';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+
+import type { BaseChunker } from './chunkers';
+import { PdfFileChunker, QnaPairChunker, WebPageChunker } from './chunkers';
+import type { BaseLoader } from './loaders';
+import { LocalQnaPairLoader, PdfFileLoader, WebPageLoader } from './loaders';
+import type {
+  DataDict,
+  DataType,
+  FormattedResult,
+  Input,
+  LocalInput,
+  Metadata,
+  Method,
+  RemoteInput,
+} from './models';
+import { ChromaDB } from './vectordb';
+import type { BaseVectorDB } from './vectordb/BaseVectorDb';
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+class EmbedChain {
+  dbClient: any;
+
+  // TODO: Definitely assign
+  collection!: Collection;
+
+  userAsks: [DataType, Input][] = [];
+
+  initApp: Promise<void>;
+
+  collectMetrics: boolean;
+
+  sId: string; // sessionId
+
+  constructor(db?: BaseVectorDB, collectMetrics: boolean = true) {
+    if (!db) {
+      this.initApp = this.setupChroma();
+    } else {
+      this.initApp = this.setupOther(db);
+    }
+
+    this.collectMetrics = collectMetrics;
+
+    // Send anonymous telemetry
+    this.sId = uuidv4();
+    this.sendTelemetryEvent('init');
+  }
+
+  async setupChroma(): Promise<void> {
+    const db = new ChromaDB();
+    await db.initDb;
+    this.dbClient = db.client;
+    if (db.collection) {
+      this.collection = db.collection;
+    } else {
+      // TODO: Add proper error handling
+      console.error('No collection');
+    }
+  }
+
+  async setupOther(db: BaseVectorDB): Promise<void> {
+    await db.initDb;
+    // TODO: Figure out how we can initialize an unknown database.
+    // this.dbClient = db.client;
+    // this.collection = db.collection;
+    this.userAsks = [];
+  }
+
+  static getLoader(dataType: DataType) {
+    const loaders: { [t in DataType]: BaseLoader } = {
+      pdf_file: new PdfFileLoader(),
+      web_page: new WebPageLoader(),
+      qna_pair: new LocalQnaPairLoader(),
+    };
+    return loaders[dataType];
+  }
+
+  static getChunker(dataType: DataType) {
+    const chunkers: { [t in DataType]: BaseChunker } = {
+      pdf_file: new PdfFileChunker(),
+      web_page: new WebPageChunker(),
+      qna_pair: new QnaPairChunker(),
+    };
+    return chunkers[dataType];
+  }
+
+  public async add(dataType: DataType, url: RemoteInput) {
+    const loader = EmbedChain.getLoader(dataType);
+    const chunker = EmbedChain.getChunker(dataType);
+    this.userAsks.push([dataType, url]);
+    const { documents, countNewChunks } = await this.loadAndEmbed(
+      loader,
+      chunker,
+      url
+    );
+
+    if (this.collectMetrics) {
+      const wordCount = documents.reduce(
+        (sum, document) => sum + document.split(' ').length,
+        0
+      );
+
+      this.sendTelemetryEvent('add', {
+        data_type: dataType,
+        word_count: wordCount,
+        chunks_count: countNewChunks,
+      });
+    }
+  }
+
+  public async addLocal(dataType: DataType, content: LocalInput) {
+    const loader = EmbedChain.getLoader(dataType);
+    const chunker = EmbedChain.getChunker(dataType);
+    this.userAsks.push([dataType, content]);
+    const { documents, countNewChunks } = await this.loadAndEmbed(
+      loader,
+      chunker,
+      content
+    );
+
+    if (this.collectMetrics) {
+      const wordCount = documents.reduce(
+        (sum, document) => sum + document.split(' ').length,
+        0
+      );
+
+      this.sendTelemetryEvent('add_local', {
+        data_type: dataType,
+        word_count: wordCount,
+        chunks_count: countNewChunks,
+      });
+    }
+  }
+
+  protected async loadAndEmbed(
+    loader: any,
+    chunker: BaseChunker,
+    src: Input
+  ): Promise<{
+    documents: string[];
+    metadatas: Metadata[];
+    ids: string[];
+    countNewChunks: number;
+  }> {
+    const embeddingsData = await chunker.createChunks(loader, src);
+    let { documents, ids, metadatas } = embeddingsData;
+
+    const existingDocs = await this.collection.get({ ids });
+    const existingIds = new Set(existingDocs.ids);
+
+    if (existingIds.size > 0) {
+      const dataDict: DataDict = {};
+      for (let i = 0; i < ids.length; i += 1) {
+        const id = ids[i];
+        if (!existingIds.has(id)) {
+          dataDict[id] = { doc: documents[i], meta: metadatas[i] };
+        }
+      }
+
+      if (Object.keys(dataDict).length === 0) {
+        console.log(`All data from ${src} already exists in the database.`);
+        return { documents: [], metadatas: [], ids: [], countNewChunks: 0 };
+      }
+      ids = Object.keys(dataDict);
+      const dataValues = Object.values(dataDict);
+      documents = dataValues.map(({ doc }) => doc);
+      metadatas = dataValues.map(({ meta }) => meta);
+    }
+
+    const countBeforeAddition = await this.count();
+    await this.collection.add({ documents, metadatas, ids });
+    const countNewChunks = (await this.count()) - countBeforeAddition;
+    console.log(
+      `Successfully saved ${src}. New chunks count: ${countNewChunks}`
+    );
+    return { documents, metadatas, ids, countNewChunks };
+  }
+
+  static async formatResult(
+    results: QueryResponse
+  ): Promise<FormattedResult[]> {
+    return results.documents[0].map((document: any, index: number) => {
+      const metadata = results.metadatas[0][index] || {};
+      // TODO: Add proper error handling
+      const distance = results.distances ? results.distances[0][index] : null;
+      return [new Document({ pageContent: document, metadata }), distance];
+    });
+  }
+
+  static async getOpenAiAnswer(prompt: string) {
+    const messages: OpenAI.Chat.CreateChatCompletionRequestMessage[] = [
+      { role: 'user', content: prompt },
+    ];
+    const response = await openai.chat.completions.create({
+      model: 'gpt-3.5-turbo',
+      messages,
+      temperature: 0,
+      max_tokens: 1000,
+      top_p: 1,
+    });
+    return (
+      response.choices[0].message?.content ?? 'Response could not be processed.'
+    );
+  }
+
+  protected async retrieveFromDatabase(inputQuery: string) {
+    const result = await this.collection.query({
+      nResults: 1,
+      queryTexts: [inputQuery],
+    });
+    const resultFormatted = await EmbedChain.formatResult(result);
+    const content = resultFormatted[0][0].pageContent;
+    return content;
+  }
+
+  static generatePrompt(inputQuery: string, context: any) {
+    const prompt = `Use the following pieces of context to answer the query at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.\n${context}\nQuery: ${inputQuery}\nHelpful Answer:`;
+    return prompt;
+  }
+
+  static async getAnswerFromLlm(prompt: string) {
+    const answer = await EmbedChain.getOpenAiAnswer(prompt);
+    return answer;
+  }
+
+  public async query(inputQuery: string) {
+    const context = await this.retrieveFromDatabase(inputQuery);
+    const prompt = EmbedChain.generatePrompt(inputQuery, context);
+    const answer = await EmbedChain.getAnswerFromLlm(prompt);
+    this.sendTelemetryEvent('query');
+    return answer;
+  }
+
+  public async dryRun(input_query: string) {
+    const context = await this.retrieveFromDatabase(input_query);
+    const prompt = EmbedChain.generatePrompt(input_query, context);
+    return prompt;
+  }
+
+  /**
+   * Count the number of embeddings.
+   * @returns {Promise<number>}: The number of embeddings.
+   */
+  public count(): Promise<number> {
+    return this.collection.count();
+  }
+
+  protected async sendTelemetryEvent(method: Method, extraMetadata?: object) {
+    if (!this.collectMetrics) {
+      return;
+    }
+    const url = 'https://api.embedchain.ai/api/v1/telemetry/';
+
+    // Read package version from filesystem (because it's not in the ts root dir)
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+    const metadata = {
+      s_id: this.sId,
+      version: packageJson.version,
+      method,
+      language: 'js',
+      ...extraMetadata,
+    };
+
+    const maxRetries = 3;
+
+    // Retry the fetch
+    for (let i = 0; i < maxRetries; i += 1) {
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const response = await fetch(url, {
+          method: 'POST',
+          body: JSON.stringify({ metadata }),
+        });
+
+        if (response.ok) {
+          // Break out of the loop if the request was successful
+          break;
+        } else {
+          // Log the unsuccessful response (optional)
+          console.error(
+            `Telemetry: Attempt ${i + 1} failed with status:`,
+            response.status
+          );
+        }
+      } catch (error) {
+        // Log the error (optional)
+        console.error(`Telemetry: Attempt ${i + 1} failed with error:`, error);
+      }
+
+      // If this was the last attempt, throw an error or handle the failure
+      if (i === maxRetries - 1) {
+        console.error('Telemetry: Max retries reached');
+      }
+    }
+  }
+}
+
+class EmbedChainApp extends EmbedChain {
+  // The EmbedChain app.
+  // Has two functions: add and query.
+  // adds(dataType, url): adds the data from the given URL to the vector db.
+  // query(query): finds answer to the given query using vector database and LLM.
+}
+
+export { EmbedChainApp };
@@ -0,0 +1,7 @@
+import { EmbedChainApp } from './embedchain';
+
+export const App = async () => {
+  const app = new EmbedChainApp();
+  await app.initApp;
+  return app;
+};
@@ -0,0 +1,5 @@
+import type { Input, LoaderResult } from '../models';
+
+export abstract class BaseLoader {
+  abstract loadData(src: Input): Promise<LoaderResult>;
+}
@@ -0,0 +1,21 @@
+import type { LoaderResult, QnaPair } from '../models';
+import { BaseLoader } from './BaseLoader';
+
+class LocalQnaPairLoader extends BaseLoader {
+  // eslint-disable-next-line class-methods-use-this
+  async loadData(content: QnaPair): Promise<LoaderResult> {
+    const [question, answer] = content;
+    const contentText = `Q: ${question}\nA: ${answer}`;
+    const metaData = {
+      url: 'local',
+    };
+    return [
+      {
+        content: contentText,
+        metaData,
+      },
+    ];
+  }
+}
+
+export { LocalQnaPairLoader };
@@ -0,0 +1,58 @@
+import type { TextContent } from 'pdfjs-dist/types/src/display/api';
+
+import type { LoaderResult, Metadata } from '../models';
+import { cleanString } from '../utils';
+import { BaseLoader } from './BaseLoader';
+
+const pdfjsLib = require('pdfjs-dist');
+
+interface Page {
+  page_content: string;
+}
+
+class PdfFileLoader extends BaseLoader {
+  static async getPagesFromPdf(url: string): Promise<Page[]> {
+    const loadingTask = pdfjsLib.getDocument(url);
+    const pdf = await loadingTask.promise;
+    const { numPages } = pdf;
+
+    const promises = Array.from({ length: numPages }, async (_, i) => {
+      const page = await pdf.getPage(i + 1);
+      const pageText: TextContent = await page.getTextContent();
+      const pageContent: string = pageText.items
+        .map((item) => ('str' in item ? item.str : ''))
+        .join(' ');
+
+      return {
+        page_content: pageContent,
+      };
+    });
+
+    return Promise.all(promises);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async loadData(url: string): Promise<LoaderResult> {
+    const pages: Page[] = await PdfFileLoader.getPagesFromPdf(url);
+    const output: LoaderResult = [];
+
+    if (!pages.length) {
+      throw new Error('No data found');
+    }
+
+    pages.forEach((page) => {
+      let content: string = page.page_content;
+      content = cleanString(content);
+      const metaData: Metadata = {
+        url,
+      };
+      output.push({
+        content,
+        metaData,
+      });
+    });
+    return output;
+  }
+}
+
+export { PdfFileLoader };
@@ -0,0 +1,51 @@
+import axios from 'axios';
+import { JSDOM } from 'jsdom';
+
+import { cleanString } from '../utils';
+import { BaseLoader } from './BaseLoader';
+
+class WebPageLoader extends BaseLoader {
+  // eslint-disable-next-line class-methods-use-this
+  async loadData(url: string) {
+    const response = await axios.get(url);
+    const html = response.data;
+    const dom = new JSDOM(html);
+    const { document } = dom.window;
+    const unwantedTags = [
+      'nav',
+      'aside',
+      'form',
+      'header',
+      'noscript',
+      'svg',
+      'canvas',
+      'footer',
+      'script',
+      'style',
+    ];
+    unwantedTags.forEach((tagName) => {
+      const elements = document.getElementsByTagName(tagName);
+      Array.from(elements).forEach((element) => {
+        // eslint-disable-next-line no-param-reassign
+        (element as HTMLElement).textContent = ' ';
+      });
+    });
+
+    const output = [];
+    let content = document.body.textContent;
+    if (!content) {
+      throw new Error('Web page content is empty.');
+    }
+    content = cleanString(content);
+    const metaData = {
+      url,
+    };
+    output.push({
+      content,
+      metaData,
+    });
+    return output;
+  }
+}
+
+export { WebPageLoader };
@@ -0,0 +1,6 @@
+import { BaseLoader } from './BaseLoader';
+import { LocalQnaPairLoader } from './LocalQnaPair';
+import { PdfFileLoader } from './PdfFile';
+import { WebPageLoader } from './WebPage';
+
+export { BaseLoader, LocalQnaPairLoader, PdfFileLoader, WebPageLoader };
@@ -0,0 +1,7 @@
+import type { Metadata } from './Metadata';
+
+export type ChunkResult = {
+  documents: string[];
+  ids: string[];
+  metadatas: Metadata[];
+};
@@ -0,0 +1,10 @@
+import type { ChunkResult } from './ChunkResult';
+
+type Data = {
+  doc: ChunkResult['documents'][0];
+  meta: ChunkResult['metadatas'][0];
+};
+
+export type DataDict = {
+  [id: string]: Data;
+};
@@ -0,0 +1 @@
+export type DataType = 'pdf_file' | 'web_page' | 'qna_pair';
@@ -0,0 +1,3 @@
+import type { Document } from 'langchain/document';
+
+export type FormattedResult = [Document, number | null];
@@ -0,0 +1,7 @@
+import type { QnaPair } from './QnAPair';
+
+export type RemoteInput = string;
+
+export type LocalInput = QnaPair;
+
+export type Input = RemoteInput | LocalInput;
@@ -0,0 +1,3 @@
+import type { Metadata } from './Metadata';
+
+export type LoaderResult = { content: any; metaData: Metadata }[];
@@ -0,0 +1,3 @@
+export type Metadata = {
+  url: string;
+};
@@ -0,0 +1 @@
+export type Method = 'init' | 'query' | 'add' | 'add_local';
@@ -0,0 +1,4 @@
+type Question = string;
+type Answer = string;
+
+export type QnaPair = [Question, Answer];
@@ -0,0 +1,21 @@
+import { DataDict } from './DataDict';
+import { DataType } from './DataType';
+import { FormattedResult } from './FormattedResult';
+import { Input, LocalInput, RemoteInput } from './Input';
+import { LoaderResult } from './LoaderResult';
+import { Metadata } from './Metadata';
+import { Method } from './Method';
+import { QnaPair } from './QnAPair';
+
+export {
+  DataDict,
+  DataType,
+  FormattedResult,
+  Input,
+  LoaderResult,
+  LocalInput,
+  Metadata,
+  Method,
+  QnaPair,
+  RemoteInput,
+};
@@ -0,0 +1,26 @@
+/**
+ * This function takes in a string and performs a series of text cleaning operations.
+ * @param {str} text: The text to be cleaned. This is expected to be a string.
+ * @returns {str}: The cleaned text after all the cleaning operations have been performed.
+ */
+export function cleanString(text: string): string {
+  // Replacement of newline characters:
+  let cleanedText = text.replace(/\n/g, ' ');
+
+  // Stripping and reducing multiple spaces to single:
+  cleanedText = cleanedText.trim().replace(/\s+/g, ' ');
+
+  // Removing backslashes:
+  cleanedText = cleanedText.replace(/\\/g, '');
+
+  // Replacing hash characters:
+  cleanedText = cleanedText.replace(/#/g, ' ');
+
+  // Eliminating consecutive non-alphanumeric characters:
+  // This regex identifies consecutive non-alphanumeric characters (i.e., not a word character [a-zA-Z0-9_] and not a whitespace) in the string
+  // and replaces each group of such characters with a single occurrence of that character.
+  // For example, "!!! hello !!!" would become "! hello !".
+  cleanedText = cleanedText.replace(/([^\w\s])\1*/g, '$1');
+
+  return cleanedText;
+}
@@ -0,0 +1,14 @@
+class BaseVectorDB {
+  initDb: Promise<void>;
+
+  constructor() {
+    this.initDb = this.getClientAndCollection();
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected async getClientAndCollection(): Promise<void> {
+    throw new Error('getClientAndCollection() method is not implemented');
+  }
+}
+
+export { BaseVectorDB };
@@ -0,0 +1,38 @@
+import type { Collection } from 'chromadb';
+import { ChromaClient, OpenAIEmbeddingFunction } from 'chromadb';
+
+import { BaseVectorDB } from './BaseVectorDb';
+
+const embedder = new OpenAIEmbeddingFunction({
+  openai_api_key: process.env.OPENAI_API_KEY ?? '',
+});
+
+class ChromaDB extends BaseVectorDB {
+  client: ChromaClient | undefined;
+
+  collection: Collection | null = null;
+
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor() {
+    super();
+  }
+
+  protected async getClientAndCollection(): Promise<void> {
+    this.client = new ChromaClient({ path: 'http://localhost:8000' });
+    try {
+      this.collection = await this.client.getCollection({
+        name: 'embedchain_store',
+        embeddingFunction: embedder,
+      });
+    } catch (err) {
+      if (!this.collection) {
+        this.collection = await this.client.createCollection({
+          name: 'embedchain_store',
+          embeddingFunction: embedder,
+        });
+      }
+    }
+  }
+}
+
+export { ChromaDB };
@@ -0,0 +1,3 @@
+import { ChromaDB } from './ChromaDb';
+
+export { ChromaDB };
@@ -0,0 +1,9 @@
+const { EmbedChainApp } = require("./embedchain/embedchain");
+
+async function App() {
+  const app = new EmbedChainApp();
+  await app.init_app;
+  return app;
+}
+
+module.exports = { App };
@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testPathIgnorePatterns: ['.d.ts'],
+};
@@ -0,0 +1,5 @@
+module.exports = {
+  '*.{js,ts}': ['eslint --fix', 'eslint'],
+  '**/*.ts?(x)': () => 'npm run check-types',
+  '*.json': ['prettier --write'],
+};
@@ -0,0 +1,53 @@
+{
+  "name": "embedchain",
+  "version": "0.0.8",
+  "description": "embedchain is a framework to easily create LLM powered bots over any dataset",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json --listFiles",
+    "prepare": "husky install",
+    "test": "jest",
+    "check-types": "tsc --noEmit --pretty"
+  },
+  "author": "Taranjeet Singh",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "axios": "^1.4.0",
+    "chromadb": "^1.5.6",
+    "jsdom": "^22.1.0",
+    "langchain": "^0.0.136",
+    "openai": "^4.3.1",
+    "pdfjs-dist": "^3.8.162",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.1.2",
+    "@commitlint/config-conventional": "^17.1.0",
+    "@commitlint/cz-commitlint": "^17.1.2",
+    "@types/jest": "^29.5.1",
+    "@types/jsdom": "^21.1.1",
+    "@typescript-eslint/eslint-plugin": "^5.41.0",
+    "@typescript-eslint/parser": "^5.41.0",
+    "eslint": "^8.34.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-simple-import-sort": "^8.0.0",
+    "eslint-plugin-testing-library": "^5.9.1",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "husky": "^8.0.1",
+    "jest": "^29.5.0",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.1.0",
+    "ts-loader": "^9.4.2",
+    "typescript": "^5.2.2"
+  }
+}
@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["embedchain/__tests__"]
+}
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "CommonJS",
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "embedchain",
+    "sourceMap": true,
+    "declaration": true,
+    "declarationDir": "types",
+    "esModuleInterop": true
+  },
+  "include": ["embedchain/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}
@@ -8,3 +8,4 @@ from embedchain.apps.Llama2App import Llama2App  # noqa: F401
 from embedchain.apps.OpenSourceApp import OpenSourceApp  # noqa: F401
 from embedchain.apps.PersonApp import (PersonApp,  # noqa: F401
                                       PersonOpenSourceApp)
+from embedchain.vectordb.chroma import ChromaDB  # noqa: F401
@@ -1,61 +1,54 @@
 from typing import Optional

-import openai
-
-from embedchain.config import AppConfig, ChatConfig
+from embedchain.config import (AppConfig, BaseEmbedderConfig, BaseLlmConfig,
+                               ChromaDbConfig)
 from embedchain.embedchain import EmbedChain
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.chroma import ChromaDB


+@register_deserializable
 class App(EmbedChain):
    """
-    The EmbedChain app.
-    Has two functions: add and query.
+    The EmbedChain app in it's simplest and most straightforward form.
+    An opinionated choice of LLM, vector database and embedding model.

-    adds(data_type, url): adds the data from the given URL to the vector db.
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
    query(query): finds answer to the given query using vector database and LLM.
-    dry_run(query): test your prompt without consuming tokens.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
    """

-    def __init__(self, config: AppConfig = None, system_prompt: Optional[str] = None):
+    def __init__(
+        self,
+        config: AppConfig = None,
+        llm_config: BaseLlmConfig = None,
+        chromadb_config: Optional[ChromaDbConfig] = None,
+        system_prompt: Optional[str] = None,
+    ):
        """
-        :param config: AppConfig instance to load as configuration. Optional.
-        :param system_prompt: System prompt string. Optional.
+        Initialize a new `CustomApp` instance. You only have a few choices to make.
+
+        :param config: Config for the app instance.
+        This is the most basic configuration, that does not fall into the LLM, database or embedder category,
+        defaults to None
+        :type config: AppConfig, optional
+        :param llm_config: Allows you to configure the LLM, e.g. how many documents to return,
+        example: `from embedchain.config import LlmConfig`, defaults to None
+        :type llm_config: BaseLlmConfig, optional
+        :param chromadb_config: Allows you to configure the vector database,
+        example: `from embedchain.config import ChromaDbConfig`, defaults to None
+        :type chromadb_config: Optional[ChromaDbConfig], optional
+        :param system_prompt: System prompt that will be provided to the LLM as such, defaults to None
+        :type system_prompt: Optional[str], optional
        """
        if config is None:
            config = AppConfig()

-        super().__init__(config, system_prompt)
+        llm = OpenAILlm(config=llm_config)
+        embedder = OpenAiEmbedder(config=BaseEmbedderConfig(model="text-embedding-ada-002"))
+        database = ChromaDB(config=chromadb_config)

-    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",
-            messages=messages,
-            temperature=config.temperature,
-            max_tokens=config.max_tokens,
-            top_p=config.top_p,
-            stream=config.stream,
-        )
-
-        if config.stream:
-            return self._stream_llm_model_response(response)
-        else:
-            return response["choices"][0]["message"]["content"]
-
-    def _stream_llm_model_response(self, response):
-        """
-        This is a generator for streaming response from the OpenAI completions API
-        """
-        for line in response:
-            chunk = line["choices"][0].get("delta", {}).get("content", "")
-            yield chunk
+        super().__init__(config, llm, db=database, embedder=embedder, system_prompt=system_prompt)
@@ -1,160 +1,83 @@
-import logging
-from typing import List, Optional
+from typing import Optional

-from langchain.schema import BaseMessage
-
-from embedchain.config import ChatConfig, CustomAppConfig
+from embedchain.config import CustomAppConfig
 from embedchain.embedchain import EmbedChain
-from embedchain.models import Providers
+from embedchain.embedder.base import BaseEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.base import BaseLlm
+from embedchain.vectordb.base import BaseVectorDB


+@register_deserializable
 class CustomApp(EmbedChain):
    """
-    The custom EmbedChain app.
-    Has two functions: add and query.
+    Embedchain's custom app allows for most flexibility.

-    adds(data_type, url): adds the data from the given URL to the vector db.
+    You can craft your own mix of various LLMs, vector databases and embedding model/functions.
+
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
    query(query): finds answer to the given query using vector database and LLM.
-    dry_run(query): test your prompt without consuming tokens.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
    """

-    def __init__(self, config: CustomAppConfig = None, system_prompt: Optional[str] = None):
+    def __init__(
+        self,
+        config: Optional[CustomAppConfig] = None,
+        llm: BaseLlm = None,
+        db: BaseVectorDB = None,
+        embedder: BaseEmbedder = 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.
+        Initialize a new `CustomApp` instance. You have to choose a LLM, database and embedder.
+
+        :param config: Config for the app instance. This is the most basic configuration,
+        that does not fall into the LLM, database or embedder category, defaults to None
+        :type config: Optional[CustomAppConfig], optional
+        :param llm: LLM Class instance. example: `from embedchain.llm.openai import OpenAILlm`, defaults to None
+        :type llm: BaseLlm
+        :param db: The database to use for storing and retrieving embeddings,
+        example: `from embedchain.vectordb.chroma_db import ChromaDb`, defaults to None
+        :type db: BaseVectorDB
+        :param embedder: The embedder (embedding model and function) use to calculate embeddings.
+        example: `from embedchain.embedder.gpt4all_embedder import GPT4AllEmbedder`, defaults to None
+        :type embedder: BaseEmbedder
+        :param system_prompt: System prompt that will be provided to the LLM as such, defaults to None
+        :type system_prompt: Optional[str], optional
+        :raises ValueError: LLM, database or embedder has not been defined.
+        :raises TypeError: LLM, database or embedder is not a valid class instance.
        """
+        # Config is not required, it has a default
        if config is None:
-            raise ValueError("Config must be provided for custom app")
+            config = CustomAppConfig()

-        self.provider = config.provider
+        if llm is None:
+            raise ValueError("LLM must be provided for custom app. Please import from `embedchain.llm`.")
+        if db is None:
+            raise ValueError("Database must be provided for custom app. Please import from `embedchain.vectordb`.")
+        if embedder is None:
+            raise ValueError("Embedder must be provided for custom app. Please import from `embedchain.embedder`.")

-        if config.provider == Providers.GPT4ALL:
-            from embedchain import OpenSourceApp
-
-            # 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, system_prompt)
-
-    def set_llm_model(self, provider: Providers):
-        self.provider = provider
-        if provider == Providers.GPT4ALL:
-            raise ValueError(
-                "GPT4ALL needs to be instantiated with the model known, please create a new app instance instead"
+        if not isinstance(config, CustomAppConfig):
+            raise TypeError(
+                "Config is not a `CustomAppConfig` instance. "
+                "Please make sure the type is right and that you are passing an instance."
+            )
+        if not isinstance(llm, BaseLlm):
+            raise TypeError(
+                "LLM is not a `BaseLlm` instance. "
+                "Please make sure the type is right and that you are passing an instance."
+            )
+        if not isinstance(db, BaseVectorDB):
+            raise TypeError(
+                "Database is not a `BaseVectorDB` instance. "
+                "Please make sure the type is right and that you are passing an instance."
+            )
+        if not isinstance(embedder, BaseEmbedder):
+            raise TypeError(
+                "Embedder is not a `BaseEmbedder` instance. "
+                "Please make sure the type is right and that you are passing an instance."
            )

-    def get_llm_model_answer(self, prompt, config: ChatConfig):
-        # TODO: Quitting the streaming response here for now.
-        # Idea: https://gist.github.com/jvelezmagic/03ddf4c452d011aae36b2a0f73d72f68
-        if config.stream:
-            raise NotImplementedError(
-                "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)
-
-            if self.provider == Providers.ANTHROPHIC:
-                return CustomApp._get_athrophic_answer(prompt, config)
-
-            if self.provider == Providers.VERTEX_AI:
-                return CustomApp._get_vertex_answer(prompt, config)
-
-            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 ModuleNotFoundError(e.msg) from None
-
-    @staticmethod
-    def _get_openai_answer(prompt: str, config: ChatConfig) -> str:
-        from langchain.chat_models import ChatOpenAI
-
-        chat = ChatOpenAI(
-            temperature=config.temperature,
-            model=config.model or "gpt-3.5-turbo",
-            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_athrophic_answer(prompt: str, config: ChatConfig) -> str:
-        from langchain.chat_models import ChatAnthropic
-
-        chat = ChatAnthropic(temperature=config.temperature, model=config.model)
-
-        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, system_prompt=config.system_prompt)
-
-        return chat(messages).content
-
-    @staticmethod
-    def _get_vertex_answer(prompt: str, config: ChatConfig) -> str:
-        from langchain.chat_models import ChatVertexAI
-
-        chat = ChatVertexAI(temperature=config.temperature, model=config.model, max_output_tokens=config.max_tokens)
-
-        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_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
-
-        messages = []
-        if system_prompt:
-            messages.append(SystemMessage(content=system_prompt))
-        messages.append(HumanMessage(content=prompt))
-        return messages
-
-    def _stream_llm_model_response(self, response):
-        """
-        This is a generator for streaming response from the OpenAI completions API
-        """
-        for line in response:
-            chunk = line["choices"][0].get("delta", {}).get("content", "")
-            yield chunk
+        super().__init__(config=config, llm=llm, db=db, embedder=embedder, system_prompt=system_prompt)
@@ -1,40 +1,33 @@
-import os
 from typing import Optional

-from langchain.llms import Replicate
-
-from embedchain.config import AppConfig, ChatConfig
-from embedchain.embedchain import EmbedChain
+from embedchain.apps.CustomApp import CustomApp
+from embedchain.config import CustomAppConfig
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.llama2 import Llama2Llm
+from embedchain.vectordb.chroma import ChromaDB


-class Llama2App(EmbedChain):
+@register_deserializable
+class Llama2App(CustomApp):
    """
    The EmbedChain Llama2App class.
-    Has two functions: add and query.

-    adds(data_type, url): adds the data from the given URL to the vector db.
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
    query(query): finds answer to the given query using vector database and LLM.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
    """

-    def __init__(self, config: AppConfig = None, system_prompt: Optional[str] = None):
+    def __init__(self, config: CustomAppConfig = None, system_prompt: Optional[str] = None):
        """
-        :param config: AppConfig instance to load as configuration. Optional.
+        :param config: CustomAppConfig 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.")

        if config is None:
-            config = AppConfig()
+            config = CustomAppConfig()

-        super().__init__(config, system_prompt)
-
-    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},
+        super().__init__(
+            config=config, llm=Llama2Llm(), db=ChromaDB(), embedder=OpenAiEmbedder(), system_prompt=system_prompt
        )
-        return llm(prompt)
@@ -1,69 +1,78 @@
 import logging
-from typing import Iterable, Union, Optional
+from typing import Optional

-from embedchain.config import ChatConfig, OpenSourceAppConfig
+from embedchain.config import (BaseEmbedderConfig, BaseLlmConfig,
+                               ChromaDbConfig, OpenSourceAppConfig)
 from embedchain.embedchain import EmbedChain
+from embedchain.embedder.gpt4all import GPT4AllEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.gpt4all import GPT4ALLLlm
+from embedchain.vectordb.chroma import ChromaDB

 gpt4all_model = None


+@register_deserializable
 class OpenSourceApp(EmbedChain):
    """
-    The OpenSource app.
-    Same as App, but uses an open source embedding model and LLM.
+    The embedchain Open Source App.
+    Comes preconfigured with the best open source LLM, embedding model, database.

-    Has two function: add and query.
-
-    adds(data_type, url): adds the data from the given URL to the vector db.
+    Methods:
+    add(source, data_type): adds the data from the given URL to the vector db.
    query(query): finds answer to the given query using vector database and LLM.
+    chat(query): finds answer to the given query using vector database and LLM, with conversation history.
    """

-    def __init__(self, config: OpenSourceAppConfig = None, system_prompt: Optional[str] = None):
+    def __init__(
+        self,
+        config: OpenSourceAppConfig = None,
+        llm_config: BaseLlmConfig = None,
+        chromadb_config: Optional[ChromaDbConfig] = 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.
+        Initialize a new `CustomApp` instance.
+        Since it's opinionated you don't have to choose a LLM, database and embedder.
+        However, you can configure those.
+
+        :param config: Config for the app instance. This is the most basic configuration,
+        that does not fall into the LLM, database or embedder category, defaults to None
+        :type config: OpenSourceAppConfig, optional
+        :param llm_config: Allows you to configure the LLM, e.g. how many documents to return.
+        example: `from embedchain.config import LlmConfig`, defaults to None
+        :type llm_config: BaseLlmConfig, optional
+        :param chromadb_config: Allows you to configure the open source database,
+        example: `from embedchain.config import ChromaDbConfig`, defaults to None
+        :type chromadb_config: Optional[ChromaDbConfig], optional
+        :param system_prompt: System prompt that will be provided to the LLM as such.
+        Please don't use for the time being, as it's not supported., defaults to None
+        :type system_prompt: Optional[str], optional
+        :raises TypeError: `OpenSourceAppConfig` or `LlmConfig` invalid.
        """
        logging.info("Loading open source embedding model. This may take some time...")  # noqa:E501
        if not config:
            config = OpenSourceAppConfig()

-        if not config.model:
-            raise ValueError("OpenSourceApp needs a model to be instantiated. Maybe you passed the wrong config type?")
-
-        self.instance = OpenSourceApp._get_instance(config.model)
-
-        logging.info("Successfully loaded open source embedding model.")
-        super().__init__(config, system_prompt)
-
-    def get_llm_model_answer(self, prompt, config: ChatConfig):
-        return self._get_gpt4all_answer(prompt=prompt, config=config)
-
-    @staticmethod
-    def _get_instance(model):
-        try:
-            from gpt4all import GPT4All
-        except ModuleNotFoundError:
-            raise ModuleNotFoundError(
-                "The GPT4All python package is not installed. Please install it with `pip install embedchain[opensource]`"  # noqa E501
-            ) from None
-
-        return GPT4All(model)
-
-    def _get_gpt4all_answer(self, prompt: str, config: ChatConfig) -> Union[str, Iterable]:
-        if config.model and config.model != self.config.model:
-            raise RuntimeError(
-                "OpenSourceApp does not support switching models at runtime. Please create a new app instance."
+        if not isinstance(config, OpenSourceAppConfig):
+            raise TypeError(
+                "OpenSourceApp needs a OpenSourceAppConfig passed to it. "
+                "You can import it with `from embedchain.config import OpenSourceAppConfig`"
            )

-        if self.system_prompt or config.system_prompt:
-            raise ValueError("OpenSourceApp does not support `system_prompt`")
+        if not llm_config:
+            llm_config = BaseLlmConfig(model="orca-mini-3b.ggmlv3.q4_0.bin")
+        elif not isinstance(llm_config, BaseLlmConfig):
+            raise TypeError(
+                "The LlmConfig passed to OpenSourceApp is invalid. "
+                "You can import it with `from embedchain.config import LlmConfig`"
+            )
+        elif not llm_config.model:
+            llm_config.model = "orca-mini-3b.ggmlv3.q4_0.bin"

-        response = self.instance.generate(
-            prompt=prompt,
-            streaming=config.stream,
-            top_p=config.top_p,
-            max_tokens=config.max_tokens,
-            temp=config.temperature,
-        )
-        return response
+        llm = GPT4ALLLlm(config=llm_config)
+        embedder = GPT4AllEmbedder(config=BaseEmbedderConfig(model="all-MiniLM-L6-v2"))
+        logging.error("Successfully loaded open source embedding model.")
+        database = ChromaDB(config=chromadb_config)
+
+        super().__init__(config, llm=llm, db=database, embedder=embedder, system_prompt=system_prompt)
@@ -2,12 +2,14 @@ from string import Template

 from embedchain.apps.App import App
 from embedchain.apps.OpenSourceApp import OpenSourceApp
-from embedchain.config import ChatConfig, QueryConfig
+from embedchain.config import BaseLlmConfig
 from embedchain.config.apps.BaseAppConfig import BaseAppConfig
-from embedchain.config.QueryConfig import (DEFAULT_PROMPT,
-                                           DEFAULT_PROMPT_WITH_HISTORY)
+from embedchain.config.llm.base_llm_config import (DEFAULT_PROMPT,
+                                                   DEFAULT_PROMPT_WITH_HISTORY)
+from embedchain.helper.json_serializable import register_deserializable


+@register_deserializable
 class EmbedChainPersonApp:
    """
    Base class to create a person bot.
@@ -17,20 +19,30 @@ class EmbedChainPersonApp:
    :param config: BaseAppConfig instance to load as configuration.
    """

-    def __init__(self, person, config: BaseAppConfig = None):
+    def __init__(self, person: str, config: BaseAppConfig = None):
+        """Initialize a new person app
+
+        :param person: Name of the person that's imitated.
+        :type person: str
+        :param config: Configuration class instance, defaults to None
+        :type config: BaseAppConfig, optional
+        """
        self.person = person
        self.person_prompt = f"You are {person}. Whatever you say, you will always say in {person} style."  # noqa:E501
        super().__init__(config)

-    def add_person_template_to_config(self, default_prompt: str, config: ChatConfig = None):
+    def add_person_template_to_config(self, default_prompt: str, config: BaseLlmConfig = None):
        """
        This method checks if the config object contains a prompt template
        if yes it adds the person prompt to it and return the updated config
        else it creates a config object with the default prompt added to the person prompt

-        :param default_prompt: it is the default prompt for query or chat methods
-        :param config: Optional. The `ChatConfig` instance to use as
-        configuration options.
+        :param default_prompt:  it is the default prompt for query or chat methods
+        :type default_prompt: str
+        :param config: _description_, defaults to None
+        :type config: BaseLlmConfig, optional
+        :return: The `ChatConfig` instance to use as configuration options.
+        :rtype: _type_
        """
        template = Template(self.person_prompt + " " + default_prompt)

@@ -43,38 +55,40 @@ class EmbedChainPersonApp:
                config.template = template
        else:
            # if no config is present at all, initialize the config with person prompt and default template
-            config = QueryConfig(
+            config = BaseLlmConfig(
                template=template,
            )

        return config


+@register_deserializable
 class PersonApp(EmbedChainPersonApp, App):
    """
    The Person app.
    Extends functionality from EmbedChainPersonApp and App
    """

-    def query(self, input_query, config: QueryConfig = None, dry_run=False):
-        config = self.add_person_template_to_config(DEFAULT_PROMPT, config)
-        return super().query(input_query, config, dry_run)
+    def query(self, input_query, config: BaseLlmConfig = None, dry_run=False):
+        config = self.add_person_template_to_config(DEFAULT_PROMPT, config, where=None)
+        return super().query(input_query, config, dry_run, where=None)

-    def chat(self, input_query, config: ChatConfig = None, dry_run=False):
+    def chat(self, input_query, config: BaseLlmConfig = None, dry_run=False, where=None):
        config = self.add_person_template_to_config(DEFAULT_PROMPT_WITH_HISTORY, config)
-        return super().chat(input_query, config, dry_run)
+        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, dry_run=False):
+    def query(self, input_query, config: BaseLlmConfig = None, dry_run=False):
        config = self.add_person_template_to_config(DEFAULT_PROMPT, config)
        return super().query(input_query, config, dry_run)

-    def chat(self, input_query, config: ChatConfig = None, dry_run=False):
+    def chat(self, input_query, config: BaseLlmConfig = None, dry_run=False):
        config = self.add_person_template_to_config(DEFAULT_PROMPT_WITH_HISTORY, config)
        return super().chat(input_query, config, dry_run)
@@ -0,0 +1,5 @@
+from embedchain.bots.poe import PoeBot  # noqa: F401
+from embedchain.bots.whatsapp import WhatsAppBot  # noqa: F401
+
+# TODO: fix discord import
+# from embedchain.bots.discord import DiscordBot
@@ -1,23 +1,44 @@
+from typing import Any
+
 from embedchain import CustomApp
-from embedchain.config import AddConfig, CustomAppConfig, QueryConfig
-from embedchain.models import EmbeddingFunctions, Providers
+from embedchain.config import AddConfig, CustomAppConfig, LlmConfig
+from embedchain.embedder.openai import OpenAiEmbedder
+from embedchain.helper.json_serializable import (JSONSerializable,
+                                                 register_deserializable)
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.chroma import ChromaDB


-class BaseBot:
-    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)
+@register_deserializable
+class BaseBot(JSONSerializable):
+    def __init__(self):
+        self.app = CustomApp(config=CustomAppConfig(), llm=OpenAILlm(), db=ChromaDB(), embedder=OpenAiEmbedder())

-    def add(self, data, config: AddConfig = None):
-        """Add data to the bot"""
+    def add(self, data: Any, config: AddConfig = None):
+        """
+        Add data to the bot (to the vector database).
+        Auto-dectects type only, so some data types might not be usable.
+
+        :param data: data to embed
+        :type data: Any
+        :param config: configuration class instance, defaults to None
+        :type config: AddConfig, optional
+        """
        config = config if config else AddConfig()
        self.app.add(data, config=config)

-    def query(self, query, config: QueryConfig = None):
-        """Query bot"""
-        config = config if config else QueryConfig()
+    def query(self, query: str, config: LlmConfig = None) -> str:
+        """
+        Query the bot
+
+        :param query: the user query
+        :type query: str
+        :param config: configuration class instance, defaults to None
+        :type config: LlmConfig, optional
+        :return: Answer
+        :rtype: str
+        """
+        config = config
        return self.app.query(query, config=config)

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

-from fastapi_poe import PoeBot, run
-
-from embedchain.config import QueryConfig
+from embedchain.helper.json_serializable import register_deserializable

 from .base import BaseBot

-
-class EcPoeBot(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
+try:
+    from fastapi_poe import PoeBot, run
+except ModuleNotFoundError:
+    raise ModuleNotFoundError(
+        "The required dependencies for Poe are not installed." 'Please install with `pip install "embedchain[poe]"`'
+    ) from None


 def start_command():
@@ -72,7 +31,56 @@ def start_command():
    # 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(EcPoeBot(), api_key=args.api_key or os.environ.get("POE_API_KEY"))
+    run(PoeBot(), api_key=args.api_key or os.environ.get("POE_API_KEY"))
+
+
+@register_deserializable
+class PoeBot(BaseBot, PoeBot):
+    def __init__(self):
+        self.history_length = 5
+        super().__init__()
+
+    async def get_response(self, query):
+        last_message = query.query[-1].content
+        try:
+            history = (
+                [f"{m.role}: {m.content}" for m in query.query[-(self.history_length + 1) : -1]]
+                if len(query.query) > 0
+                else None
+            )
+        except Exception as e:
+            logging.error(f"Error when processing the chat history. Message is being sent without history. Error: {e}")
+        answer = self.handle_message(last_message, history)
+        yield self.text_event(answer)
+
+    def handle_message(self, message, history: Optional[List[str]] = None):
+        if message.startswith("/add "):
+            response = self.add_data(message)
+        else:
+            response = self.ask_bot(message, history)
+        return response
+
+    # def add_data(self, message):
+    #     data = message.split(" ")[-1]
+    #     try:
+    #         self.add(data)
+    #         response = f"Added data from: {data}"
+    #     except Exception:
+    #         logging.exception(f"Failed to add data {data}.")
+    #         response = "Some error occurred while adding data."
+    #     return response
+
+    def ask_bot(self, message, history: List[str]):
+        try:
+            self.app.llm.set_history(history=history)
+            response = self.query(message)
+        except Exception:
+            logging.exception(f"Failed to query {message}.")
+            response = "An error occurred. Please try again!"
+        return response
+
+    def start(self):
+        start_command()


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

-from flask import Flask, request
-from twilio.twiml.messaging_response import MessagingResponse
+from embedchain.helper.json_serializable import register_deserializable

 from .base import BaseBot


+@register_deserializable
 class WhatsAppBot(BaseBot):
    def __init__(self):
+        try:
+            self.flask = importlib.import_module("flask")
+            self.twilio = importlib.import_module("twilio")
+        except ModuleNotFoundError:
+            raise ModuleNotFoundError(
+                "The required dependencies for WhatsApp are not installed. "
+                'Please install with `pip install --upgrade "embedchain[whatsapp]"`'
+            ) from None
        super().__init__()

    def handle_message(self, message):
@@ -39,7 +48,7 @@ class WhatsAppBot(BaseBot):
        return response

    def start(self, host="0.0.0.0", port=5000, debug=True):
-        app = Flask(__name__)
+        app = self.flask.Flask(__name__)

        def signal_handler(sig, frame):
            logging.info("\nGracefully shutting down the WhatsAppBot...")
@@ -49,9 +58,9 @@ class WhatsAppBot(BaseBot):

        @app.route("/chat", methods=["POST"])
        def chat():
-            incoming_message = request.values.get("Body", "").lower()
+            incoming_message = self.flask.request.values.get("Body", "").lower()
            response = self.handle_message(incoming_message)
-            twilio_response = MessagingResponse()
+            twilio_response = self.twilio.twiml.messaging_response.MessagingResponse()
            twilio_response.message(response)
            return str(twilio_response)

@@ -1,9 +1,10 @@
 import hashlib

+from embedchain.helper.json_serializable import JSONSerializable
 from embedchain.models.data_type import DataType


-class BaseChunker:
+class BaseChunker(JSONSerializable):
    def __init__(self, text_splitter):
        """Initialize the chunker."""
        self.text_splitter = text_splitter
@@ -21,14 +22,17 @@ class BaseChunker:
        documents = []
        ids = []
        idMap = {}
-        datas = loader.load_data(src)
+        data_result = loader.load_data(src)
+        data_records = data_result["data"]
+        doc_id = data_result["doc_id"]
        metadatas = []
-        for data in datas:
+        for data in data_records:
            content = data["content"]

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

            chunks = self.get_chunks(content)
@@ -44,6 +48,7 @@ class BaseChunker:
            "documents": documents,
            "ids": ids,
            "metadatas": metadatas,
+            "doc_id": doc_id,
        }

    def get_chunks(self, content):
@@ -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.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.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.json_serializable import register_deserializable
+
+
+@register_deserializable
+class MdxChunker(BaseChunker):
+    """Chunker for mdx files."""
+
+    def __init__(self, config: Optional[ChunkerConfig] = None):
+        if config is None:
+            config = ChunkerConfig(chunk_size=1000, 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.json_serializable import register_deserializable


+@register_deserializable
 class NotionChunker(BaseChunker):
    """Chunker for notion."""

@@ -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.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.json_serializable import register_deserializable


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

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+from embedchain.chunkers.base_chunker import BaseChunker
+from embedchain.config.AddConfig import ChunkerConfig
+
+
+class TableChunker(BaseChunker):
+    """Chunker for tables, for instance csv, google sheets or databases."""
+
+    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.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.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.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.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.
@@ -38,5 +42,13 @@ class AddConfig(BaseConfig):
        chunker: Optional[ChunkerConfig] = None,
        loader: Optional[LoaderConfig] = None,
    ):
+        """
+        Initializes a configuration class instance for the `add` method.
+
+        :param chunker: Chunker config, defaults to None
+        :type chunker: Optional[ChunkerConfig], optional
+        :param loader: Loader config, defaults to None
+        :type loader: Optional[LoaderConfig], optional
+        """
        self.loader = loader
        self.chunker = chunker
@@ -1,10 +1,21 @@
-class BaseConfig:
+from typing import Any, Dict
+
+from embedchain.helper.json_serializable import JSONSerializable
+
+
+class BaseConfig(JSONSerializable):
    """
    Base config.
    """

    def __init__(self):
+        """Initializes a configuration class for a class."""
        pass

-    def as_dict(self):
+    def as_dict(self) -> Dict[str, Any]:
+        """Return config object as a dict
+
+        :return: config object as dict
+        :rtype: Dict[str, Any]
+        """
        return vars(self)
@@ -1,87 +0,0 @@
-from string import Template
-from typing import Optional
-
-from embedchain.config.QueryConfig import QueryConfig
-
-DEFAULT_PROMPT = """
-  You are a chatbot having a conversation with a human. You are given chat
-  history and context.
-  You need to answer the query considering context, chat history and your knowledge base. If you don't know the answer or the answer is neither contained in the context nor in history, then simply say "I don't know".
-
-  $context
-
-  History: $history
-
-  Query: $query
-
-  Helpful Answer:
-"""  # noqa:E501
-
-DEFAULT_PROMPT_TEMPLATE = Template(DEFAULT_PROMPT)
-
-
-class ChatConfig(QueryConfig):
-    """
-    Config for the `chat` method, inherits from `QueryConfig`.
-    """
-
-    def __init__(
-        self,
-        number_documents=None,
-        template: Template = None,
-        model=None,
-        temperature=None,
-        max_tokens=None,
-        top_p=None,
-        stream: bool = False,
-        deployment_name=None,
-        system_prompt: Optional[str] = None,
-    ):
-        """
-        Initializes the ChatConfig instance.
-
-        :param number_documents: Number of documents to pull from the database as
-        context.
-        :param template: Optional. The `Template` instance to use as a template for
-        prompt.
-        :param model: Optional. Controls the OpenAI model used.
-        :param temperature: Optional. Controls the randomness of the model's output.
-        Higher values (closer to 1) make output more random,lower values make it more
-        deterministic.
-        :param max_tokens: Optional. Controls how many tokens are generated.
-        :param top_p: Optional. Controls the diversity of words.Higher values
-        (closer to 1) make word selection more diverse, lower values make words less
-        diverse.
-        :param stream: Optional. Control if response is streamed back to the user
-        :param deployment_name: t.b.a.
-        :param system_prompt: Optional. System prompt string.
-        :raises ValueError: If the template is not valid as template should contain
-        $context and $query and $history
-        """
-        if template is None:
-            template = DEFAULT_PROMPT_TEMPLATE
-
-        # History is set as 0 to ensure that there is always a history, that way,
-        # there don't have to be two templates. Having two templates would make it
-        # complicated because the history is not user controlled.
-        super().__init__(
-            number_documents=number_documents,
-            template=template,
-            model=model,
-            temperature=temperature,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            history=[0],
-            stream=stream,
-            deployment_name=deployment_name,
-            system_prompt=system_prompt,
-        )
-
-    def set_history(self, history):
-        """
-        Chat history is not user provided and not set at initialization time
-
-        :param history: (string) history to set
-        """
-        self.history = history
-        return
@@ -1,143 +0,0 @@
-import re
-from string import Template
-from typing import Optional
-
-from embedchain.config.BaseConfig import BaseConfig
-
-DEFAULT_PROMPT = """
-  Use the following pieces of context to answer the query at the end.
-  If you don't know the answer, just say that you don't know, don't try to make up an answer.
-
-  $context
-
-  Query: $query
-
-  Helpful Answer:
-"""  # noqa:E501
-
-DEFAULT_PROMPT_WITH_HISTORY = """
-  Use the following pieces of context to answer the query at the end.
-  If you don't know the answer, just say that you don't know, don't try to make up an answer.
-  I will provide you with our conversation history.
-
-  $context
-
-  History: $history
-
-  Query: $query
-
-  Helpful Answer:
-"""  # noqa:E501
-
-DOCS_SITE_DEFAULT_PROMPT = """
-  Use the following pieces of context to answer the query at the end.
-  If you don't know the answer, just say that you don't know, don't try to make up an answer. Wherever possible, give complete code snippet. Dont make up any code snippet on your own.
-
-  $context
-
-  Query: $query
-
-  Helpful Answer:
-"""  # noqa:E501
-
-DEFAULT_PROMPT_TEMPLATE = Template(DEFAULT_PROMPT)
-DEFAULT_PROMPT_WITH_HISTORY_TEMPLATE = Template(DEFAULT_PROMPT_WITH_HISTORY)
-DOCS_SITE_PROMPT_TEMPLATE = Template(DOCS_SITE_DEFAULT_PROMPT)
-query_re = re.compile(r"\$\{*query\}*")
-context_re = re.compile(r"\$\{*context\}*")
-history_re = re.compile(r"\$\{*history\}*")
-
-
-class QueryConfig(BaseConfig):
-    """
-    Config for the `query` method.
-    """
-
-    def __init__(
-        self,
-        number_documents=None,
-        template: Template = None,
-        model=None,
-        temperature=None,
-        max_tokens=None,
-        top_p=None,
-        history=None,
-        stream: bool = False,
-        deployment_name=None,
-        system_prompt: Optional[str] = None,
-    ):
-        """
-        Initializes the QueryConfig instance.
-
-        :param number_documents: Number of documents to pull from the database as
-        context.
-        :param template: Optional. The `Template` instance to use as a template for
-        prompt.
-        :param model: Optional. Controls the OpenAI model used.
-        :param temperature: Optional. Controls the randomness of the model's output.
-        Higher values (closer to 1) make output more random, lower values make it more
-        deterministic.
-        :param max_tokens: Optional. Controls how many tokens are generated.
-        :param top_p: Optional. Controls the diversity of words. Higher values
-        (closer to 1) make word selection more diverse, lower values make words less
-        diverse.
-        :param history: Optional. A list of strings to consider as history.
-        :param stream: Optional. Control if response is streamed back to user
-        :param deployment_name: t.b.a.
-        :param system_prompt: Optional. System prompt string.
-        :raises ValueError: If the template is not valid as template should
-        contain $context and $query (and optionally $history).
-        """
-        if number_documents is None:
-            self.number_documents = 1
-        else:
-            self.number_documents = number_documents
-
-        if not history:
-            self.history = None
-        else:
-            if len(history) == 0:
-                self.history = None
-            else:
-                self.history = history
-
-        if template is None:
-            if self.history is None:
-                template = DEFAULT_PROMPT_TEMPLATE
-            else:
-                template = DEFAULT_PROMPT_WITH_HISTORY_TEMPLATE
-
-        self.temperature = temperature if temperature else 0
-        self.max_tokens = max_tokens if max_tokens else 1000
-        self.model = model
-        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
-        else:
-            if self.history is None:
-                raise ValueError("`template` should have `query` and `context` keys")
-            else:
-                raise ValueError("`template` should have `query`, `context` and `history` keys")
-
-        if not isinstance(stream, bool):
-            raise ValueError("`stream` should be bool")
-        self.stream = stream
-
-    def validate_template(self, template: Template):
-        """
-        validate the template
-
-        :param template: the template to validate
-        :return: Boolean, valid (true) or invalid (false)
-        """
-        if self.history is None:
-            return re.search(query_re, template.template) and re.search(context_re, template.template)
-        else:
-            return (
-                re.search(query_re, template.template)
-                and re.search(context_re, template.template)
-                and re.search(history_re, template.template)
-            )
@@ -1,9 +1,13 @@
-from .AddConfig import AddConfig, ChunkerConfig  # noqa: F401
-from .apps.AppConfig import AppConfig  # noqa: F401
-from .apps.CustomAppConfig import CustomAppConfig  # noqa: F401
-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
+# flake8: noqa: F401
+
+from .AddConfig import AddConfig, ChunkerConfig
+from .apps.AppConfig import AppConfig
+from .apps.CustomAppConfig import CustomAppConfig
+from .apps.OpenSourceAppConfig import OpenSourceAppConfig
+from .BaseConfig import BaseConfig
+from .embedder.BaseEmbedderConfig import BaseEmbedderConfig
+from .embedder.BaseEmbedderConfig import BaseEmbedderConfig as EmbedderConfig
+from .llm.base_llm_config import BaseLlmConfig
+from .llm.base_llm_config import BaseLlmConfig as LlmConfig
+from .vectordbs.ChromaDbConfig import ChromaDbConfig
+from .vectordbs.ElasticsearchDBConfig import ElasticsearchDBConfig
@@ -1,17 +1,11 @@
-import os
 from typing import Optional

-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.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.
@@ -19,45 +13,23 @@ class AppConfig(BaseAppConfig):

    def __init__(
        self,
-        log_level=None,
-        host=None,
-        port=None,
-        id=None,
-        collection_name=None,
+        log_level: str = "WARNING",
+        id: Optional[str] = None,
        collect_metrics: Optional[bool] = None,
+        collection_name: Optional[str] = None,
    ):
        """
-        :param log_level: Optional. (String) Debug level
-        ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'].
-        :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,
-            collection_name=collection_name,
-            collect_metrics=collect_metrics,
-        )
+        Initializes a configuration class instance for an App. This is the simplest form of an embedchain app.
+        Most of the configuration is done in the `App` class itself.

-    @staticmethod
-    def default_embedding_function():
+        :param log_level: Debug level ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], defaults to "WARNING"
+        :type log_level: str, optional
+        :param id: ID of the app. Document metadata will have this id., defaults to None
+        :type id: Optional[str], optional
+        :param collect_metrics: Send anonymous telemetry to improve embedchain, defaults to True
+        :type collect_metrics: Optional[bool], optional
+        :param collection_name: Default collection name. It's recommended to use app.db.set_collection_name() instead,
+        defaults to None
+        :type collection_name: Optional[str], optional
        """
-        Sets embedding function to default (`text-embedding-ada-002`).
-
-        :raises ValueError: If the template is not valid as template should contain
-        $context and $query
-        :returns: The default embedding function for the app class.
-        """
-        if os.getenv("OPENAI_API_KEY") is None and os.getenv("OPENAI_ORGANIZATION") is None:
-            raise ValueError("OPENAI_API_KEY or OPENAI_ORGANIZATION environment variables not provided")  # noqa:E501
-        return embedding_functions.OpenAIEmbeddingFunction(
-            api_key=os.getenv("OPENAI_API_KEY"),
-            organization_id=os.getenv("OPENAI_ORGANIZATION"),
-            model_name="text-embedding-ada-002",
-        )
+        super().__init__(log_level=log_level, id=id, collect_metrics=collect_metrics, collection_name=collection_name)
@@ -1,90 +1,56 @@
 import logging
+from typing import Optional

 from embedchain.config.BaseConfig import BaseConfig
-from embedchain.config.vectordbs import ElasticsearchDBConfig
-from embedchain.models import VectorDatabases, VectorDimensions
+from embedchain.helper.json_serializable import JSONSerializable
+from embedchain.vectordb.base import BaseVectorDB


-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,
-        collection_name=None,
+        log_level: str = "WARNING",
+        db: Optional[BaseVectorDB] = None,
+        id: Optional[str] = None,
        collect_metrics: bool = True,
-        db_type: VectorDatabases = None,
-        vector_dim: VectorDimensions = None,
-        es_config: ElasticsearchDBConfig = None,
+        collection_name: Optional[str] = None,
    ):
        """
-        :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 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
+        Initializes a configuration class instance for an App.
+        Most of the configuration is done in the `App` class itself.
+
+        :param log_level: Debug level ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], defaults to "WARNING"
+        :type log_level: str, optional
+        :param db: A database class. It is recommended to set this directly in the `App` class, not this config,
+        defaults to None
+        :type db: Optional[BaseVectorDB], optional
+        :param id: ID of the app. Document metadata will have this id., defaults to None
+        :type id: Optional[str], optional
+        :param collect_metrics: Send anonymous telemetry to improve embedchain, defaults to True
+        :type collect_metrics: Optional[bool], optional
+        :param collection_name: Default collection name. It's recommended to use app.db.set_collection_name() instead,
+        defaults to None
+        :type collection_name: Optional[str], optional
        """
        self._setup_logging(log_level)
-        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,
-        )
        self.id = id
        self.collect_metrics = True if (collect_metrics is True or collect_metrics is None) else False
-        return
+        self.collection_name = collection_name

-    @staticmethod
-    def get_db(db, embedding_fn, host, port, db_type, vector_dim, collection_name, es_config):
-        """
-        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.
-        :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
+            self._db = db
+            logging.warning(
+                "DEPRECATION WARNING: Please supply the database as the second parameter during app init. "
+                "Such as `app(config=config, db=db)`."
            )

-        from embedchain.vectordb.chroma_db import ChromaDB
-
-        return ChromaDB(embedding_fn=embedding_fn, host=host, port=port)
+        if collection_name:
+            logging.warning("DEPRECATION WARNING: Please supply the collection name to the database config.")
+        return

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

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

-from embedchain.config.vectordbs import ElasticsearchDBConfig
-from embedchain.models import (EmbeddingFunctions, Providers, VectorDatabases,
-                               VectorDimensions)
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.vectordb.base import BaseVectorDB

 from .BaseAppConfig import BaseAppConfig

 load_dotenv()


+@register_deserializable
 class CustomAppConfig(BaseAppConfig):
    """
    Config to initialize an embedchain custom `App` instance, with extra config options.
@@ -19,121 +18,29 @@ class CustomAppConfig(BaseAppConfig):

    def __init__(
        self,
-        log_level=None,
-        embedding_fn: EmbeddingFunctions = None,
-        embedding_fn_model=None,
-        db=None,
-        host=None,
-        port=None,
-        id=None,
-        collection_name=None,
-        provider: Providers = None,
-        open_source_app_config=None,
-        deployment_name=None,
+        log_level: str = "WARNING",
+        db: Optional[BaseVectorDB] = None,
+        id: Optional[str] = None,
        collect_metrics: Optional[bool] = None,
-        db_type: VectorDatabases = None,
-        es_config: ElasticsearchDBConfig = None,
+        collection_name: Optional[str] = None,
    ):
        """
-        :param log_level: Optional. (String) Debug level
-        ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'].
-        :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 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
+        Initializes a configuration class instance for an Custom App.
+        Most of the configuration is done in the `CustomApp` class itself.
+
+        :param log_level: Debug level ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], defaults to "WARNING"
+        :type log_level: str, optional
+        :param db: A database class. It is recommended to set this directly in the `CustomApp` class, not this config,
+        defaults to None
+        :type db: Optional[BaseVectorDB], optional
+        :param id: ID of the app. Document metadata will have this id., defaults to None
+        :type id: Optional[str], optional
+        :param collect_metrics: Send anonymous telemetry to improve embedchain, defaults to True
+        :type collect_metrics: Optional[bool], optional
+        :param collection_name: Default collection name. It's recommended to use app.db.set_collection_name() instead,
+        defaults to None
+        :type collection_name: Optional[str], optional
        """
-        if provider:
-            self.provider = provider
-        else:
-            raise ValueError("CustomApp must have a provider assigned.")
-
-        self.open_source_app_config = open_source_app_config
-
        super().__init__(
-            log_level=log_level,
-            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,
+            log_level=log_level, db=db, id=id, collect_metrics=collect_metrics, collection_name=collection_name
        )
-
-    @staticmethod
-    def langchain_default_concept(embeddings: Any):
-        """
-        Langchains default function layout for embeddings.
-        """
-
-        def embed_function(texts: Documents) -> Embeddings:
-            return embeddings.embed_documents(texts)
-
-        return embed_function
-
-    @staticmethod
-    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
-            )
-
-        if embedding_function == EmbeddingFunctions.OPENAI:
-            from langchain.embeddings import OpenAIEmbeddings
-
-            if model:
-                embeddings = OpenAIEmbeddings(model=model)
-            else:
-                if deployment_name:
-                    embeddings = OpenAIEmbeddings(deployment=deployment_name)
-                else:
-                    embeddings = OpenAIEmbeddings()
-            return CustomAppConfig.langchain_default_concept(embeddings)
-
-        elif embedding_function == EmbeddingFunctions.HUGGING_FACE:
-            from langchain.embeddings import HuggingFaceEmbeddings
-
-            embeddings = HuggingFaceEmbeddings(model_name=model)
-            return CustomAppConfig.langchain_default_concept(embeddings)
-
-        elif embedding_function == EmbeddingFunctions.VERTEX_AI:
-            from langchain.embeddings import VertexAIEmbeddings
-
-            embeddings = VertexAIEmbeddings(model_name=model)
-            return CustomAppConfig.langchain_default_concept(embeddings)
-
-        elif embedding_function == EmbeddingFunctions.GPT4ALL:
-            # Note: We could use langchains GPT4ALL embedding, but it's not available in all versions.
-            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,10 +1,11 @@
 from typing import Optional

-from chromadb.utils import embedding_functions
+from embedchain.helper.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.
@@ -12,48 +13,28 @@ class OpenSourceAppConfig(BaseAppConfig):

    def __init__(
        self,
-        log_level=None,
-        host=None,
-        port=None,
-        id=None,
-        collection_name=None,
+        log_level: str = "WARNING",
+        id: Optional[str] = None,
        collect_metrics: Optional[bool] = None,
-        model=None,
+        model: str = "orca-mini-3b.ggmlv3.q4_0.bin",
+        collection_name: Optional[str] = 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.
+        Initializes a configuration class instance for an Open Source App.
+
+        :param log_level: Debug level ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], defaults to "WARNING"
+        :type log_level: str, optional
+        :param id: ID of the app. Document metadata will have this id., defaults to None
+        :type id: Optional[str], optional
+        :param collect_metrics: Send anonymous telemetry to improve embedchain, defaults to True
+        :type collect_metrics: Optional[bool], optional
+        :param model: GPT4ALL uses the model to instantiate the class.
+        Unlike `App`, it has to be provided before querying, defaults to "orca-mini-3b.ggmlv3.q4_0.bin"
+        :type model: str, optional
+        :param collection_name: Default collection name. It's recommended to use app.db.set_collection_name() instead,
+        defaults to None
+        :type collection_name: Optional[str], optional
        """
        self.model = model or "orca-mini-3b.ggmlv3.q4_0.bin"

-        super().__init__(
-            log_level=log_level,
-            embedding_fn=OpenSourceAppConfig.default_embedding_function(),
-            host=host,
-            port=port,
-            id=id,
-            collection_name=collection_name,
-            collect_metrics=collect_metrics,
-        )
-
-    @staticmethod
-    def default_embedding_function():
-        """
-        Sets embedding function to default (`all-MiniLM-L6-v2`).
-
-        :returns: The default embedding function
-        """
-        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
+        super().__init__(log_level=log_level, id=id, collect_metrics=collect_metrics, collection_name=collection_name)
@@ -0,0 +1,18 @@
+from typing import Optional
+
+from embedchain.helper.json_serializable import register_deserializable
+
+
+@register_deserializable
+class BaseEmbedderConfig:
+    def __init__(self, model: Optional[str] = None, deployment_name: Optional[str] = None):
+        """
+        Initialize a new instance of an embedder config class.
+
+        :param model: model name of the llm embedding model (not applicable to all providers), defaults to None
+        :type model: Optional[str], optional
+        :param deployment_name: deployment name for llm embedding model, defaults to None
+        :type deployment_name: Optional[str], optional
+        """
+        self.model = model
+        self.deployment_name = deployment_name
@@ -0,0 +1,146 @@
+import re
+from string import Template
+from typing import Any, Dict, Optional
+
+from embedchain.config.BaseConfig import BaseConfig
+from embedchain.helper.json_serializable import register_deserializable
+
+DEFAULT_PROMPT = """
+  Use the following pieces of context to answer the query at the end.
+  If you don't know the answer, just say that you don't know, don't try to make up an answer.
+
+  $context
+
+  Query: $query
+
+  Helpful Answer:
+"""  # noqa:E501
+
+DEFAULT_PROMPT_WITH_HISTORY = """
+  Use the following pieces of context to answer the query at the end.
+  If you don't know the answer, just say that you don't know, don't try to make up an answer.
+  I will provide you with our conversation history.
+
+  $context
+
+  History: $history
+
+  Query: $query
+
+  Helpful Answer:
+"""  # noqa:E501
+
+DOCS_SITE_DEFAULT_PROMPT = """
+  Use the following pieces of context to answer the query at the end.
+  If you don't know the answer, just say that you don't know, don't try to make up an answer. Wherever possible, give complete code snippet. Dont make up any code snippet on your own.
+
+  $context
+
+  Query: $query
+
+  Helpful Answer:
+"""  # noqa:E501
+
+DEFAULT_PROMPT_TEMPLATE = Template(DEFAULT_PROMPT)
+DEFAULT_PROMPT_WITH_HISTORY_TEMPLATE = Template(DEFAULT_PROMPT_WITH_HISTORY)
+DOCS_SITE_PROMPT_TEMPLATE = Template(DOCS_SITE_DEFAULT_PROMPT)
+query_re = re.compile(r"\$\{*query\}*")
+context_re = re.compile(r"\$\{*context\}*")
+history_re = re.compile(r"\$\{*history\}*")
+
+
+@register_deserializable
+class BaseLlmConfig(BaseConfig):
+    """
+    Config for the `query` method.
+    """
+
+    def __init__(
+        self,
+        number_documents: int = 1,
+        template: Optional[Template] = None,
+        model: Optional[str] = None,
+        temperature: float = 0,
+        max_tokens: int = 1000,
+        top_p: float = 1,
+        stream: bool = False,
+        deployment_name: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        where: Dict[str, Any] = None,
+    ):
+        """
+        Initializes a configuration class instance for the LLM.
+
+        Takes the place of the former `QueryConfig` or `ChatConfig`.
+        Use `LlmConfig` as an alias to `BaseLlmConfig`.
+
+        :param number_documents:  Number of documents to pull from the database as
+        context, defaults to 1
+        :type number_documents: int, optional
+        :param template:  The `Template` instance to use as a template for
+        prompt, defaults to None
+        :type template: Optional[Template], optional
+        :param model: Controls the OpenAI model used, defaults to None
+        :type model: Optional[str], optional
+        :param temperature:  Controls the randomness of the model's output.
+        Higher values (closer to 1) make output more random, lower values make it more deterministic, defaults to 0
+        :type temperature: float, optional
+        :param max_tokens: Controls how many tokens are generated, defaults to 1000
+        :type max_tokens: int, optional
+        :param top_p: Controls the diversity of words. Higher values (closer to 1) make word selection more diverse,
+        defaults to 1
+        :type top_p: float, optional
+        :param stream: Control if response is streamed back to user, defaults to False
+        :type stream: bool, optional
+        :param deployment_name: t.b.a., defaults to None
+        :type deployment_name: Optional[str], optional
+        :param system_prompt: System prompt string, defaults to None
+        :type system_prompt: Optional[str], optional
+        :param where: A dictionary of key-value pairs to filter the database results., defaults to None
+        :type where: Dict[str, Any], optional
+        :raises ValueError: If the template is not valid as template should
+        contain $context and $query (and optionally $history)
+        :raises ValueError: Stream is not boolean
+        """
+        if template is None:
+            template = DEFAULT_PROMPT_TEMPLATE
+
+        self.number_documents = number_documents
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.model = model
+        self.top_p = top_p
+        self.deployment_name = deployment_name
+        self.system_prompt = system_prompt
+
+        if self.validate_template(template):
+            self.template = template
+        else:
+            raise ValueError("`template` should have `query` and `context` keys and potentially `history` (if used).")
+
+        if not isinstance(stream, bool):
+            raise ValueError("`stream` should be bool")
+        self.stream = stream
+        self.where = where
+
+    def validate_template(self, template: Template) -> bool:
+        """
+        validate the template
+
+        :param template: the template to validate
+        :type template: Template
+        :return: valid (true) or invalid (false)
+        :rtype: bool
+        """
+        return re.search(query_re, template.template) and re.search(context_re, template.template)
+
+    def _validate_template_history(self, template: Template) -> bool:
+        """
+        validate the template with history
+
+        :param template: the template to validate
+        :type template: Template
+        :return: valid (true) or invalid (false)
+        :rtype: bool
+        """
+        return re.search(history_re, template.template)
@@ -0,0 +1,29 @@
+from typing import Optional
+
+from embedchain.config.BaseConfig import BaseConfig
+
+
+class BaseVectorDbConfig(BaseConfig):
+    def __init__(
+        self,
+        collection_name: Optional[str] = None,
+        dir: str = "db",
+        host: Optional[str] = None,
+        port: Optional[str] = None,
+    ):
+        """
+        Initializes a configuration class instance for the vector database.
+
+        :param collection_name: Default name for the collection, defaults to None
+        :type collection_name: Optional[str], optional
+        :param dir: Path to the database directory, where the database is stored, defaults to "db"
+        :type dir: str, optional
+        :param host: Database connection remote host. Use this if you run Embedchain as a client, defaults to None
+        :type host: Optional[str], optional
+        :param host: Database connection remote port. Use this if you run Embedchain as a client, defaults to None
+        :type port: Optional[str], optional
+        """
+        self.collection_name = collection_name or "embedchain_store"
+        self.dir = dir
+        self.host = host
+        self.port = port
@@ -0,0 +1,37 @@
+from typing import Optional
+
+from embedchain.config.vectordbs.BaseVectorDbConfig import BaseVectorDbConfig
+from embedchain.helper.json_serializable import register_deserializable
+
+
+@register_deserializable
+class ChromaDbConfig(BaseVectorDbConfig):
+    def __init__(
+        self,
+        collection_name: Optional[str] = None,
+        dir: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Optional[str] = None,
+        allow_reset=False,
+        chroma_settings: Optional[dict] = None,
+    ):
+        """
+        Initializes a configuration class instance for ChromaDB.
+
+        :param collection_name: Default name for the collection, defaults to None
+        :type collection_name: Optional[str], optional
+        :param dir: Path to the database directory, where the database is stored, defaults to None
+        :type dir: Optional[str], optional
+        :param host: Database connection remote host. Use this if you run Embedchain as a client, defaults to None
+        :type host: Optional[str], optional
+        :param port: Database connection remote port. Use this if you run Embedchain as a client, defaults to None
+        :type port: Optional[str], optional
+        :param allow_reset: Resets the database. defaults to False
+        :type allow_reset: bool
+        :param chroma_settings: Chroma settings dict, defaults to None
+        :type chroma_settings: Optional[dict], optional
+        """
+
+        self.chroma_settings = chroma_settings
+        self.allow_reset = allow_reset
+        super().__init__(collection_name=collection_name, dir=dir, host=host, port=port)
@@ -1,15 +1,46 @@
-from typing import Dict, List, Union
+import os
+from typing import Dict, List, Optional, Union

-from embedchain.config.BaseConfig import BaseConfig
+from embedchain.config.vectordbs.BaseVectorDbConfig import BaseVectorDbConfig
+from embedchain.helper.json_serializable import 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.
-    """
+@register_deserializable
+class ElasticsearchDBConfig(BaseVectorDbConfig):
+    def __init__(
+        self,
+        collection_name: Optional[str] = None,
+        dir: Optional[str] = None,
+        es_url: Union[str, List[str]] = None,
+        **ES_EXTRA_PARAMS: Dict[str, any],
+    ):
+        """
+        Initializes a configuration class instance for an Elasticsearch client.

-    def __init__(self, es_url: Union[str, List[str]] = None, **ES_EXTRA_PARAMS: Dict[str, any]):
-        self.ES_URL = es_url
+        :param collection_name: Default name for the collection, defaults to None
+        :type collection_name: Optional[str], optional
+        :param dir: Path to the database directory, where the database is stored, defaults to None
+        :type dir: Optional[str], optional
+        :param es_url: elasticsearch url or list of nodes url to be used for connection, defaults to None
+        :type es_url: Union[str, List[str]], optional
+        :param ES_EXTRA_PARAMS: extra params dict that can be passed to elasticsearch.
+        :type ES_EXTRA_PARAMS: Dict[str, Any], optional
+        """
+        # self, es_url: Union[str, List[str]] = None, **ES_EXTRA_PARAMS: Dict[str, any]):
+        self.ES_URL = es_url or os.environ.get("ELASTICSEARCH_URL")
+        if not self.ES_URL:
+            raise AttributeError(
+                "Elasticsearch needs a URL attribute, "
+                "this can either be passed to `ElasticsearchDBConfig` or as `ELASTICSEARCH_URL` in `.env`"
+            )
        self.ES_EXTRA_PARAMS = ES_EXTRA_PARAMS
+        # Load API key from .env if it's not explicitly passed.
+        # Can only set one of 'api_key', 'basic_auth', and 'bearer_auth'
+        if (
+            not self.ES_EXTRA_PARAMS.get("api_key")
+            and not self.ES_EXTRA_PARAMS.get("basic_auth")
+            and not self.ES_EXTRA_PARAMS.get("bearer_auth")
+            and not self.ES_EXTRA_PARAMS.get("http_auth")
+        ):
+            self.ES_EXTRA_PARAMS["api_key"] = os.environ.get("ELASTICSEARCH_API_KEY")
+        super().__init__(collection_name=collection_name, dir=dir)
@@ -1,16 +1,24 @@
+from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.chunkers.docs_site import DocsSiteChunker
 from embedchain.chunkers.docx_file import DocxFileChunker
+from embedchain.chunkers.mdx import MdxChunker
 from embedchain.chunkers.notion import NotionChunker
 from embedchain.chunkers.pdf_file import PdfFileChunker
 from embedchain.chunkers.qna_pair import QnaPairChunker
+from embedchain.chunkers.table import TableChunker
 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.config.AddConfig import ChunkerConfig, LoaderConfig
+from embedchain.helper.json_serializable import JSONSerializable
+from embedchain.loaders.base_loader import BaseLoader
+from embedchain.loaders.csv import CsvLoader
 from embedchain.loaders.docs_site_loader import DocsSiteLoader
 from embedchain.loaders.docx_file import DocxFileLoader
 from embedchain.loaders.local_qna_pair import LocalQnaPairLoader
 from embedchain.loaders.local_text import LocalTextLoader
+from embedchain.loaders.mdx import MdxLoader
 from embedchain.loaders.pdf_file import PdfFileLoader
 from embedchain.loaders.sitemap import SitemapLoader
 from embedchain.loaders.web_page import WebPageLoader
@@ -18,7 +26,7 @@ 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
@@ -26,16 +34,28 @@ class DataFormatter:
    """

    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)
+        """
+        Initialize a dataformatter, set data type and chunker based on datatype.

-    def _get_loader(self, data_type: DataType, config):
+        :param data_type: The type of the data to load and chunk.
+        :type data_type: DataType
+        :param config: AddConfig instance with nested loader and chunker config attributes.
+        :type config: AddConfig
+        """
+        self.loader = self._get_loader(data_type=data_type, config=config.loader)
+        self.chunker = self._get_chunker(data_type=data_type, config=config.chunker)
+
+    def _get_loader(self, data_type: DataType, config: LoaderConfig) -> BaseLoader:
        """
        Returns the appropriate data loader for the given data type.

        :param data_type: The type of the data to load.
-        :return: The loader for the given data type.
+        :type data_type: DataType
+        :param config: Config to initialize the loader with.
+        :type config: LoaderConfig
        :raises ValueError: If an unsupported data type is provided.
+        :return: The loader for the given data type.
+        :rtype: BaseLoader
        """
        loaders = {
            DataType.YOUTUBE_VIDEO: YoutubeVideoLoader,
@@ -46,11 +66,13 @@ class DataFormatter:
            DataType.DOCX: DocxFileLoader,
            DataType.SITEMAP: SitemapLoader,
            DataType.DOCS_SITE: DocsSiteLoader,
+            DataType.CSV: CsvLoader,
+            DataType.MDX: MdxLoader,
        }
        lazy_loaders = {DataType.NOTION}
        if data_type in loaders:
-            loader_class = loaders[data_type]
-            loader = loader_class()
+            loader_class: type = loaders[data_type]
+            loader: BaseLoader = loader_class()
            return loader
        elif data_type in lazy_loaders:
            if data_type == DataType.NOTION:
@@ -62,13 +84,16 @@ class DataFormatter:
        else:
            raise ValueError(f"Unsupported data type: {data_type}")

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

        :param data_type: The type of the data to chunk.
-        :return: The chunker for the given data type.
+        :type data_type: DataType
+        :param config: Config to initialize the chunker with.
+        :type config: ChunkerConfig
        :raises ValueError: If an unsupported data type is provided.
+        :return: The chunker for the given data type.
+        :rtype: BaseChunker
        """
        chunker_classes = {
            DataType.YOUTUBE_VIDEO: YoutubeVideoChunker,
@@ -80,10 +105,12 @@ class DataFormatter:
            DataType.WEB_PAGE: WebPageChunker,
            DataType.DOCS_SITE: DocsSiteChunker,
            DataType.NOTION: NotionChunker,
+            DataType.CSV: TableChunker,
+            DataType.MDX: MdxChunker,
        }
        if data_type in chunker_classes:
-            chunker_class = chunker_classes[data_type]
-            chunker = chunker_class(config)
+            chunker_class: type = chunker_classes[data_type]
+            chunker: BaseChunker = chunker_class(config)
            chunker.set_data_type(data_type)
            return chunker
        else:
@@ -6,61 +6,124 @@ import os
 import threading
 import uuid
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Any, Dict, List, Optional, Tuple

 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 import AddConfig, BaseLlmConfig
 from embedchain.config.apps.BaseAppConfig import BaseAppConfig
-from embedchain.config.QueryConfig import DOCS_SITE_PROMPT_TEMPLATE
 from embedchain.data_formatter import DataFormatter
+from embedchain.embedder.base import BaseEmbedder
+from embedchain.helper.json_serializable import JSONSerializable
+from embedchain.llm.base import BaseLlm
 from embedchain.loaders.base_loader import BaseLoader
-from embedchain.models.data_type import DataType
+from embedchain.models.data_type import DataType, DirectDataType, IndirectDataType, SpecialDataType
 from embedchain.utils import detect_datatype
+from embedchain.vectordb.base import BaseVectorDB

 load_dotenv()

 ABS_PATH = os.getcwd()
-DB_DIR = os.path.join(ABS_PATH, "db")
 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, system_prompt: Optional[str] = None):
+class EmbedChain(JSONSerializable):
+    def __init__(
+        self,
+        config: BaseAppConfig,
+        llm: BaseLlm,
+        db: BaseVectorDB = None,
+        embedder: BaseEmbedder = None,
+        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.
+        :param config: Configuration just for the app, not the db or llm or embedder.
+        :type config: BaseAppConfig
+        :param llm: Instance of the LLM you want to use.
+        :type llm: BaseLlm
+        :param db: Instance of the Database to use, defaults to None
+        :type db: BaseVectorDB, optional
+        :param embedder: instance of the embedder to use, defaults to None
+        :type embedder: BaseEmbedder, optional
+        :param system_prompt: System prompt to use in the llm query, defaults to None
+        :type system_prompt: Optional[str], optional
+        :raises ValueError: No database or embedder provided.
        """

        self.config = config
-        self.system_prompt = system_prompt
-        self.collection = self.config.db._get_or_create_collection(self.config.collection_name)
-        self.db = self.config.db
+
+        # Add subclasses
+        ## Llm
+        self.llm = llm
+        ## Database
+        # Database has support for config assignment for backwards compatibility
+        if db is None and (not hasattr(self.config, "db") or self.config.db is None):
+            raise ValueError("App requires Database.")
+        self.db = db or self.config.db
+        ## Embedder
+        if embedder is None:
+            raise ValueError("App requires Embedder.")
+        self.embedder = embedder
+
+        # Initialize database
+        self.db._set_embedder(self.embedder)
+        self.db._initialize()
+        # Set collection name from app config for backwards compatibility.
+        if config.collection_name:
+            self.db.set_collection_name(config.collection_name)
+
+        # Add variables that are "shortcuts"
+        if system_prompt:
+            self.llm.config.system_prompt = system_prompt
+
+        # Attributes that aren't subclass related.
        self.user_asks = []
-        self.is_docs_site_instance = False
-        self.online = False
-        self.memory = ConversationBufferMemory()

        # 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()
+        # NOTE: Uncomment the next two lines when running tests to see if any test fires a telemetry event.
+        # if (self.config.collect_metrics):
+        #     raise ConnectionRefusedError("Collection of metrics should not be allowed.")
        thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("init",))
        thread_telemetry.start()

-    def _load_or_generate_user_id(self):
+    @property
+    def collect_metrics(self):
+        return self.config.collect_metrics
+
+    @collect_metrics.setter
+    def collect_metrics(self, value):
+        if not isinstance(value, bool):
+            raise ValueError(f"Boolean value expected but got {type(value)}.")
+        self.config.collect_metrics = value
+
+    @property
+    def online(self):
+        return self.llm.online
+
+    @online.setter
+    def online(self, value):
+        if not isinstance(value, bool):
+            raise ValueError(f"Boolean value expected but got {type(value)}.")
+        self.llm.online = value
+
+    def _load_or_generate_user_id(self) -> str:
        """
        Loads the user id from the config file if it exists, otherwise generates a new
        one and saves it to the config file.
+
+        :return: user id
+        :rtype: str
        """
        if not os.path.exists(CONFIG_DIR):
            os.makedirs(CONFIG_DIR)
@@ -79,10 +142,11 @@ class EmbedChain:

    def add(
        self,
-        source,
+        source: Any,
        data_type: Optional[DataType] = None,
-        metadata: Optional[Dict] = None,
+        metadata: Optional[Dict[str, Any]] = None,
        config: Optional[AddConfig] = None,
+        dry_run=False,
    ):
        """
        Adds the data from the given URL to the vector db.
@@ -90,12 +154,19 @@ class EmbedChain:
        and then stores the embedding to vector database.

        :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.
+        :type source: Any
+        :param data_type: Automatically detected, but can be forced with this argument. The type of the data to add,
+        defaults to None
+        :type data_type: Optional[DataType], optional
+        :param metadata: Metadata associated with the data source., defaults to None
+        :type metadata: Optional[Dict[str, Any]], optional
+        :param config: The `AddConfig` instance to use as configuration options., defaults to None
+        :type config: Optional[AddConfig], optional
+        :raises ValueError: Invalid data type
+        :param dry_run: Optional. A dry run displays the chunks to ensure that the loader and chunker work as intended.
+        deafaults to False
        :return: source_id, a md5-hash of the source, in hexadecimal representation.
+        :rtype: str
        """
        if config is None:
            config = AddConfig()
@@ -129,12 +200,17 @@ class EmbedChain:

        data_formatter = DataFormatter(data_type, config)
        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
+        documents, metadatas, _ids, new_chunks = self.load_and_embed_v2(
+            data_formatter.loader, data_formatter.chunker, source, metadata, source_id, dry_run
        )
        if data_type in {DataType.DOCS_SITE}:
            self.is_docs_site_instance = True

+        if dry_run:
+            data_chunks_info = {"chunks": documents, "metadata": metadatas, "count": len(documents), "type": data_type}
+            logging.debug(f"Dry run info : {data_chunks_info}")
+            return data_chunks_info
+
        # 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.
@@ -146,39 +222,65 @@ class EmbedChain:

        return source_id

-    def add_local(self, source, data_type=None, metadata=None, config: AddConfig = None):
+    def add_local(
+        self,
+        source: Any,
+        data_type: Optional[DataType] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        config: Optional[AddConfig] = None,
+    ):
        """
-        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.

+        Warning:
+            This method is deprecated and will be removed in future versions. Use `add` instead.
+
        :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: md5-hash of the source, in hexadecimal representation.
+        :type source: Any
+        :param data_type: Automatically detected, but can be forced with this argument. The type of the data to add,
+        defaults to None
+        :type data_type: Optional[DataType], optional
+        :param metadata: Metadata associated with the data source., defaults to None
+        :type metadata: Optional[Dict[str, Any]], optional
+        :param config: The `AddConfig` instance to use as configuration options., defaults to None
+        :type config: Optional[AddConfig], optional
+        :raises ValueError: Invalid data type
+        :return: source_id, a md5-hash of the source, in hexadecimal representation.
+        :rtype: str
        """
        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: BaseLoader, chunker: BaseChunker, src, metadata=None, source_id=None):
-        """
-        Loads the data from the given URL, chunks it, and adds it to database.
+    def load_and_embed(
+        self,
+        loader: BaseLoader,
+        chunker: BaseChunker,
+        src: Any,
+        metadata: Optional[Dict[str, Any]] = None,
+        source_id: Optional[str] = None,
+        dry_run=False,
+    ) -> Tuple[List[str], Dict[str, Any], List[str], int]:
+        """The loader to use to load the data.

        :param loader: The loader to use to load the data.
+        :type loader: BaseLoader
        :param chunker: The chunker to use to chunk the data.
-        :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.
+        :type chunker: BaseChunker
+        :param src: The data to be handled by the loader.
+        Can be a URL for remote sources or local content for local loaders.
+        :type src: Any
+        :param metadata: Metadata associated with the data source., defaults to None
+        :type metadata: Dict[str, Any], optional
+        :param source_id: Hexadecimal hash of the source., defaults to None
+        :type source_id: str, optional
+        :param dry_run: Optional. A dry run returns chunks and doesn't update DB.
+        :type dry_run: bool, defaults to False
        :return: (List) documents (embedded text), (List) metadata, (list) ids, (int) number of chunks
+        :rtype: Tuple[List[str], Dict[str, Any], List[str], int]
        """
        embeddings_data = chunker.create_chunks(loader, src)

@@ -190,17 +292,21 @@ class EmbedChain:
        # 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_ids = self.db.get(
+        db_result = self.db.get(
            ids=ids,
            where=where,  # optional filter
        )
+        existing_ids = set(db_result["ids"])

        if len(existing_ids):
            data_dict = {id: (doc, meta) for id, doc, meta in zip(ids, documents, metadatas)}
            data_dict = {id: value for id, value in data_dict.items() if id not in existing_ids}

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

@@ -225,6 +331,154 @@ class EmbedChain:
            new_metadatas.append(m)
        metadatas = new_metadatas

+        if dry_run:
+            return list(documents), metadatas, ids, 0
+
+        # Count before, to calculate a delta in the end.
+        chunks_before_addition = self.db.count()
+
+        self.db.add(documents=documents, metadatas=metadatas, ids=ids)
+        count_new_chunks = self.db.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 _get_existing_doc_id(self, chunker: BaseChunker, src: Any):
+        """
+        Get id of existing document for a given source, based on the data type
+        """
+        # Find existing embeddings for the source
+        # Depending on the data type, existing embeddings are checked for.
+        if chunker.data_type.value in [item.value for item in DirectDataType]:
+            # DirectDataTypes can't be updated.
+            # Think of a text:
+            #   Either it's the same, then it won't change, so it's not an update.
+            #   Or it's different, then it will be added as a new text.
+            return None
+        elif chunker.data_type.value in [item.value for item in IndirectDataType]:
+            # These types have a indirect source reference
+            # As long as the reference is the same, they can be updated.
+            existing_embeddings_data = self.db.get(
+                where={
+                    "url": src,
+                },
+                limit=1,
+            )
+            if len(existing_embeddings_data.get("metadatas", [])) > 0:
+                return existing_embeddings_data["metadatas"][0]["doc_id"]
+            else:
+                return None
+        elif chunker.data_type.value in [item.value for item in SpecialDataType]:
+            # These types don't contain indirect references.
+            # Through custom logic, they can be attributed to a source and be updated.
+            if chunker.data_type == DataType.QNA_PAIR:
+                # QNA_PAIRs update the answer if the question already exists.
+                existing_embeddings_data = self.db.get(
+                    where={
+                        "question": src[0],
+                    },
+                    limit=1,
+                )
+                if len(existing_embeddings_data.get("metadatas", [])) > 0:
+                    return existing_embeddings_data["metadatas"][0]["doc_id"]
+                else:
+                    return None
+            else:
+                raise NotImplementedError(
+                    f"SpecialDataType {chunker.data_type} must have a custom logic to check for existing data"
+                )
+        else:
+            raise TypeError(
+                f"{chunker.data_type} is type {type(chunker.data_type)}. "
+                "When it should be  DirectDataType, IndirectDataType or SpecialDataType."
+            )
+
+    def load_and_embed_v2(
+        self,
+        loader: BaseLoader,
+        chunker: BaseChunker,
+        src: Any,
+        metadata: Optional[Dict[str, Any]] = None,
+        source_id: Optional[str] = None,
+        dry_run=False,
+    ):
+        """
+        Loads the data from the given URL, chunks it, and adds it to database.
+
+        :param loader: The loader to use to load the data.
+        :param chunker: The chunker to use to chunk the data.
+        :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.
+        :param dry_run: Optional. A dry run returns chunks and doesn't update DB.
+        :type dry_run: bool, defaults to False
+        :return: (List) documents (embedded text), (List) metadata, (list) ids, (int) number of chunks
+        """
+        existing_doc_id = self._get_existing_doc_id(chunker=chunker, src=src)
+
+        # Create chunks
+        embeddings_data = chunker.create_chunks(loader, src)
+
+        # spread chunking results
+        documents = embeddings_data["documents"]
+        metadatas = embeddings_data["metadatas"]
+        ids = embeddings_data["ids"]
+        new_doc_id = embeddings_data["doc_id"]
+
+        if existing_doc_id and existing_doc_id == new_doc_id:
+            print("Doc content has not changed. Skipping creating chunks and embeddings")
+            return [], [], [], 0
+
+        # this means that doc content has changed.
+        if existing_doc_id and existing_doc_id != new_doc_id:
+            print("Doc content has changed. Recomputing chunks and embeddings intelligently.")
+            self.db.delete({"doc_id": existing_doc_id})
+
+        # 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}
+        db_result = self.db.get(
+            ids=ids,
+            where=where,  # optional filter
+        )
+        existing_ids = set(db_result["ids"])
+
+        if len(existing_ids):
+            data_dict = {id: (doc, meta) for id, doc, meta in zip(ids, documents, metadatas)}
+            data_dict = {id: value for id, value in data_dict.items() if id not in existing_ids}
+
+            if not data_dict:
+                src_copy = src
+                if len(src_copy) > 50:
+                    src_copy = src[:50] + "..."
+                print(f"All data from {src_copy} already exists in the database.")
+                # Make sure to return a matching return type
+                return [], [], [], 0
+
+            ids = list(data_dict.keys())
+            documents, metadatas = zip(*data_dict.values())
+
+        # 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
+
+        if dry_run:
+            return list(documents), metadatas, ids, 0
+
        # Count before, to calculate a delta in the end.
        chunks_before_addition = self.count()

@@ -243,224 +497,150 @@ class EmbedChain:
            )
        ]

-    def get_llm_model_answer(self):
-        """
-        Usually implemented by child class
-        """
-        raise NotImplementedError
-
-    def retrieve_from_database(self, input_query, config: QueryConfig):
+    def retrieve_from_database(self, input_query: str, config: Optional[BaseLlmConfig] = None, where=None) -> List[str]:
        """
        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.
-        :return: The content of the document that matched your query.
+        :type input_query: str
+        :param config: The query configuration, defaults to None
+        :type config: Optional[BaseLlmConfig], optional
+        :param where: A dictionary of key-value pairs to filter the database results, defaults to None
+        :type where: _type_, optional
+        :return: List of contents of the document that matched your query
+        :rtype: List[str]
        """
-        where = {"app_id": self.config.id} if self.config.id is not None else {}  # optional filter
+        query_config = config or self.llm.config
+
+        if where is not None:
+            where = where
+        elif query_config is not None and query_config.where is not None:
+            where = query_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,
+            n_results=query_config.number_documents,
            where=where,
        )

        return contents

-    def _append_search_and_context(self, context, web_search_result):
-        return f"{context}\nWeb Search Result: {web_search_result}"
-
-    def generate_prompt(self, input_query, contexts, config: QueryConfig, **kwargs):
-        """
-        Generates a prompt based on the given query and context, ready to be
-        passed to an LLM
-
-        :param input_query: The query to use.
-        :param contexts: List of similar documents to the query used as context.
-        :param config: Optional. The `QueryConfig` instance to use as
-        configuration options.
-        :return: The prompt
-        """
-        context_string = (" | ").join(contexts)
-        web_search_result = kwargs.get("web_search_result", "")
-        if web_search_result:
-            context_string = self._append_search_and_context(context_string, web_search_result)
-        if not config.history:
-            prompt = config.template.substitute(context=context_string, query=input_query)
-        else:
-            prompt = config.template.substitute(context=context_string, query=input_query, history=config.history)
-        return prompt
-
-    def get_answer_from_llm(self, prompt, config: ChatConfig):
-        """
-        Gets an answer based on the given query and context by passing it
-        to an LLM.
-
-        :param query: The query to use.
-        :param context: Similar documents to the query used as context.
-        :return: The answer.
-        """
-
-        return self.get_llm_model_answer(prompt, config)
-
-    def access_search_and_get_results(self, input_query):
-        from langchain.tools import DuckDuckGoSearchRun
-
-        search = DuckDuckGoSearchRun()
-        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: str, config: BaseLlmConfig = None, dry_run=False, where: Optional[Dict] = None) -> str:
        """
        Queries the vector database based on the given input query.
        Gets relevant doc based on the query and then passes it to an
        LLM as context to get the answer.

        :param input_query: The query to use.
-        :param config: Optional. The `QueryConfig` instance to use as
-        configuration options.
-        :param dry_run: Optional. A dry run does everything except send the resulting prompt to
-        the LLM. The purpose is to test the prompt, not the response.
-        You can use it to test your prompt, including the context provided
-        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.
-        :return: The answer to the query.
+        :type input_query: str
+        :param config: The `LlmConfig` instance to use as configuration options. This is used for one method call.
+        To persistently use a config, declare it during app init., defaults to None
+        :type config: Optional[BaseLlmConfig], optional
+        :param dry_run: A dry run does everything except send the resulting prompt to
+        the LLM. The purpose is to test the prompt, not the response., defaults to False
+        :type dry_run: bool, optional
+        :param where: A dictionary of key-value pairs to filter the database results., defaults to None
+        :type where: Optional[Dict[str, str]], optional
+        :return: The answer to the query or the dry run result
+        :rtype: str
        """
-        if config is None:
-            config = QueryConfig()
-        if self.is_docs_site_instance:
-            config.template = DOCS_SITE_PROMPT_TEMPLATE
-            config.number_documents = 5
-        k = {}
-        if self.online:
-            k["web_search_result"] = self.access_search_and_get_results(input_query)
-        contexts = self.retrieve_from_database(input_query, config)
-        prompt = self.generate_prompt(input_query, contexts, config, **k)
-        logging.info(f"Prompt: {prompt}")
-
-        if dry_run:
-            return prompt
-
-        answer = self.get_answer_from_llm(prompt, config)
+        contexts = self.retrieve_from_database(input_query=input_query, config=config, where=where)
+        answer = self.llm.query(input_query=input_query, contexts=contexts, config=config, dry_run=dry_run)

        # 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
-        else:
-            return self._stream_query_response(answer)
+        return answer

-    def _stream_query_response(self, answer):
-        streamed_answer = ""
-        for chunk in answer:
-            streamed_answer = streamed_answer + chunk
-            yield chunk
-        logging.info(f"Answer: {streamed_answer}")
-
-    def chat(self, input_query, config: ChatConfig = None, dry_run=False):
+    def chat(
+        self,
+        input_query: str,
+        config: Optional[BaseLlmConfig] = None,
+        dry_run=False,
+        where: Optional[Dict[str, str]] = None,
+    ) -> str:
        """
        Queries the vector database on the given input query.
        Gets relevant doc based on the query and then passes it to an
        LLM as context to get the answer.

        Maintains the whole conversation in memory.
+
        :param input_query: The query to use.
-        :param config: Optional. The `ChatConfig` instance to use as
-        configuration options.
-        :param dry_run: Optional. A dry run does everything except send the resulting prompt to
-        the LLM. The purpose is to test the prompt, not the response.
-        You can use it to test your prompt, including the context provided
-        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.
-        :return: The answer to the query.
+        :type input_query: str
+        :param config: The `LlmConfig` instance to use as configuration options. This is used for one method call.
+        To persistently use a config, declare it during app init., defaults to None
+        :type config: Optional[BaseLlmConfig], optional
+        :param dry_run: A dry run does everything except send the resulting prompt to
+        the LLM. The purpose is to test the prompt, not the response., defaults to False
+        :type dry_run: bool, optional
+        :param where: A dictionary of key-value pairs to filter the database results., defaults to None
+        :type where: Optional[Dict[str, str]], optional
+        :return: The answer to the query or the dry run result
+        :rtype: str
        """
-        if config is None:
-            config = ChatConfig()
-        if self.is_docs_site_instance:
-            config.template = DOCS_SITE_PROMPT_TEMPLATE
-            config.number_documents = 5
-        k = {}
-        if self.online:
-            k["web_search_result"] = self.access_search_and_get_results(input_query)
-        contexts = self.retrieve_from_database(input_query, config)
-
-        chat_history = self.memory.load_memory_variables({})["history"]
-
-        if chat_history:
-            config.set_history(chat_history)
-
-        prompt = self.generate_prompt(input_query, contexts, config, **k)
-        logging.info(f"Prompt: {prompt}")
-
-        if dry_run:
-            return prompt
-
-        answer = self.get_answer_from_llm(prompt, config)
-
-        self.memory.chat_memory.add_user_message(input_query)
+        contexts = self.retrieve_from_database(input_query=input_query, config=config, where=where)
+        answer = self.llm.chat(input_query=input_query, contexts=contexts, config=config, dry_run=dry_run)

        # Send anonymous telemetry
        thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("chat",))
        thread_telemetry.start()

-        if isinstance(answer, str):
-            self.memory.chat_memory.add_ai_message(answer)
-            logging.info(f"Answer: {answer}")
-            return answer
-        else:
-            # this is a streamed response and needs to be handled differently.
-            return self._stream_chat_response(answer)
+        return answer

-    def _stream_chat_response(self, answer):
-        streamed_answer = ""
-        for chunk in answer:
-            streamed_answer = streamed_answer + chunk
-            yield chunk
-        self.memory.chat_memory.add_ai_message(streamed_answer)
-        logging.info(f"Answer: {streamed_answer}")
-
-    def set_collection(self, collection_name):
+    def set_collection_name(self, name: str):
        """
-        Set the collection to use.
+        Set the name of the collection. A collection is an isolated space for vectors.

-        :param collection_name: The name of the collection to use.
+        Using `app.db.set_collection_name` method is preferred to this.
+
+        :param name: Name of the collection.
+        :type name: str
        """
-        self.collection = self.config.db._get_or_create_collection(collection_name)
+        self.db.set_collection_name(name)
+        # Create the collection if it does not exist
+        self.db._get_or_create_collection(name)
+        # TODO: Check whether it is necessary to assign to the `self.collection` attribute,
+        # since the main purpose is the creation.

    def count(self) -> int:
        """
        Count the number of embeddings.

+        DEPRECATED IN FAVOR OF `db.count()`
+
        :return: The number of embeddings.
+        :rtype: int
        """
+        logging.warning("DEPRECATION WARNING: Please use `app.db.count()` instead of `app.count()`.")
        return self.db.count()

    def reset(self):
        """
        Resets the database. Deletes all embeddings irreversibly.
        `App` does not have to be reinitialized after using this method.
+
+        DEPRECATED IN FAVOR OF `db.reset()`
        """
        # Send anonymous telemetry
        thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("reset",))
        thread_telemetry.start()

-        collection_name = self.collection.name
+        logging.warning("DEPRECATION WARNING: Please use `app.db.reset()` instead of `App.reset()`.")
        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):
+        """
+        Send telemetry event to the embedchain server. This is anonymous. It can be toggled off in `AppConfig`.
+        """
        if not self.config.collect_metrics:
            return

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Deshraj Yadav	bc89b6ea74	Bump version to 0.0.59 (#651 )	2023-09-24 18:15:29 -07:00
sw8fbar	f0742dffa2	Docs: where context filter (#547 )	2023-09-24 13:32:27 -07:00
cachho	6c71a1020d	Docs: use LlmConfig instead of QueryConfig (#626 )	2023-09-24 11:48:03 -07:00
Dev Khant	1db3e43adf	Add support for `dry_run` in `load_and_embed_v2` method (#634 )	2023-09-24 11:42:14 -07:00
Ayush Mishra	cb59b0b5e4	Bump embedchain package version in examples (#639 )	2023-09-24 09:53:06 -07:00
Dev Khant	8e0f05055e	Add chat feature to discord_bot example (#643 )	2023-09-24 09:49:59 -07:00
Naman Jain	4768bacf1c	docs: large csv file error (#644 )	2023-09-24 09:48:36 -07:00
Raghav Tyagi	dc206c0999	Fixed minor grammatical issues in documentation: Interface Types (#648 )	2023-09-24 09:47:47 -07:00
Dev Khant	77e1983b2e	bug: app.online fixed (#647 )	2023-09-23 16:10:18 -07:00
Dev Khant	d344ee226c	Set telemetry flag as a top level attribute (#462 )	2023-09-18 10:29:14 +05:30
cachho	3d0e4141bf	refactor: get existing doc id method (#616 )	2023-09-17 23:22:12 +05:30
Dev Khant	01fb216ff7	allow_reset as constructor argument (#618 )	2023-09-15 07:26:02 -07:00
David Talson	a662b2a6c6	change app.count to app.db.count (#620 )	2023-09-14 19:39:57 -07:00
Subhadip Mandal	b1af82eba8	Changed Tesla url to Forbes Url (#615 ) Co-authored-by: Subhadip <mnhacker2001@gmail.com>	2023-09-14 08:57:41 +05:30
Taranjeet Singh	378ef5246e	feat: bump version to 0.0.58 (#617 )	2023-09-14 02:20:31 +05:30
Lovepreet Singh	606814f10e	Fix a typo - accpeting -> accepting (#614 )	2023-09-14 02:07:06 +05:30
David Talson	5e06a0d001	Fix/dont print the entire text when data type is text (#605 )	2023-09-14 02:06:23 +05:30
cachho	c0e3274375	Fix/chat (#609 )	2023-09-14 02:04:27 +05:30
cachho	119ec5e405	fix: elastic search (#600 )	2023-09-13 23:28:18 +05:30
cachho	79efa51941	fix: url metadata for all datatypes (#613 )	2023-09-13 10:19:48 -07:00
Deshraj Yadav	701d0b21ef	[chore] fix lint issues (#607 )	2023-09-12 20:04:31 -07:00
Taranjeet Singh	0f23d5f967	feat: bump version to 0.0.57 (#606 )	2023-09-13 08:17:54 +05:30
Taranjeet Singh	36b26e08c3	feat: add support for mdx file (#604 )	2023-09-13 05:13:18 +05:30
cachho	ac08638a63	fix: do not mock get (#598 )	2023-09-12 22:42:17 +05:30
cachho	03146946fa	chore: linting (#597 )	2023-09-12 21:34:38 +05:30
cachho	0f9a10c598	fix: use template from tempory `LlmConfig` (#590 )	2023-09-12 21:33:58 +05:30
Taranjeet Singh	2bd6881361	feat: Add embedding manager (#570 )	2023-09-12 12:13:53 +05:30
Taranjeet Singh	ba208f5b48	feature: bump version to 0.0.56 (#595 )	2023-09-12 09:52:01 +05:30
Dev Khant	bdef85f7db	Handle if no module found for bots (#564 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-12 09:29:35 +05:30
cachho	2cb47938fd	fix: llama2 - use config with specific defaults (#594 )	2023-09-12 09:28:42 +05:30
cachho	dfe0b414ac	refactor: use llama hub instead of llama index (#592 )	2023-09-12 09:26:58 +05:30
cachho	1864f4cb38	fix: serialize non serializable (#589 )	2023-09-12 09:25:46 +05:30
Dev Khant	7c39d9f0c1	Add dry_run to add() (#545 )	2023-09-12 09:20:31 +05:30
Deshraj Yadav	79f5a1d052	[chore]: Rename modules for better readability and maintainability (#587 )	2023-09-11 07:01:40 +05:30
Deshraj Yadav	6fed75bb45	Remove elasticsearch as mandatory dependency (#585 )	2023-09-09 22:20:24 -07:00
Taranjeet Singh	352ed3b6a1	fix: update slack link (#583 )	2023-09-10 04:46:18 +05:30
Taranjeet Singh	b37691711c	feat: add slack community (#582 )	2023-09-10 04:43:49 +05:30
Dev Khant	13fda2efe1	fix: --upgrade flag for all pip instances (#557 )	2023-09-08 08:12:55 +05:30
Taranjeet Singh	3c3d98b9c3	feat: add embedchain javascript package (#576 )	2023-09-07 05:52:44 +05:30
Taranjeet Singh	f582d70031	release: bump version to 0.0.54 (#575 )	2023-09-07 05:43:18 +05:30
cachho	1ac8aef4de	docs: update docstrings (#565 )	2023-09-07 05:34:44 +05:30
Dev Khant	4754372fcd	Add flask and twilio to extras (#559 )	2023-09-06 04:29:50 +05:30
cachho	eac85779eb	chore: linting (#556 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-06 04:29:29 +05:30
cachho	b0d8711b65	fix: Elasticsearch - use correct class attributes (#566 )	2023-09-06 04:28:40 +05:30
cachho	f0844ed923	fix: pin gpt4all version (#563 )	2023-09-06 04:27:38 +05:30
Dev Khant	129242534d	Lint and formatting fixes (#554 ) Co-authored-by: cachho <admin@ch-webdev.com> Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-06 04:24:19 +05:30
Taranjeet Singh	6481b555b4	fix: typo in poe bot docs (#569 )	2023-09-06 04:19:44 +05:30
Taranjeet Singh	794e51494e	fix: update Poe bot docs (#568 )	2023-09-06 02:32:49 +05:30
cachho	3059e96041	feat: Slack bot (#469 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-05 13:48:52 +05:30
cachho	bd595f84e8	feat: csv loader (#470 ) Co-authored-by: Taranjeet Singh <reachtotj@gmail.com>	2023-09-05 13:48:03 +05:30
cachho	344e7470f6	refactor: classes and configs (#528 )	2023-09-05 13:42:58 +05:30
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
				`@@ -0,0 +1 @@`
				`module.exports = { extends: ['@commitlint/config-conventional'] };`
				`@@ -0,0 +1 @@`
				`export type DataType = 'pdf_file' \| 'web_page' \| 'qna_pair';`
				`@@ -0,0 +1 @@`
				`export type Method = 'init' \| 'query' \| 'add' \| 'add_local';`