[OpenSearch] Add support for filtering docs based on app_id in opensearch db (#729)

Signed-off-by: Osama Nabih <nabih_the_4th@yahoo.com>

Makefile

@@ -7,8 +7,19 @@ PROJECT_NAME := embedchain
 .PHONY: install format lint clean test ci_lint ci_test
 
 install:
-	$(PIP) install --upgrade pip
-	$(PIP) install -e .[dev]
+	poetry install
+
+install_es:
+	poetry install --extras elasticsearch
+
+install_opensearch:
+	poetry install --extras opensearch
+
+shell:
+	poetry shell
+
+py_shell:
+	poetry run python
 
 format:
 	$(PYTHON) -m black .

README.md

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

docs/advanced/app_types.mdx

@@ -63,7 +63,7 @@ app = OpenSourceApp()
 - Here there is no need to setup any api keys. You just need to install embedchain package and these will get automatically installed. 📦
 - Once you have imported and instantiated the app, every functionality from here onwards is the same for either type of app. 📚
 - `OpenSourceApp` is opinionated. It uses the best open source embedding model and LLM on the market.
-- extra dependencies are required for this app type. Install them with `pip install embedchain[opensource]`.
+- extra dependencies are required for this app type. Install them with `pip install --upgrade embedchain[opensource]`.
 
 ### CustomApp
 
@@ -71,10 +71,10 @@ app = OpenSourceApp()
 from embedchain import CustomApp
 from embedchain.config import (CustomAppConfig, ElasticsearchDBConfig,
                                EmbedderConfig, LlmConfig)
-from embedchain.embedder.vertexai_embedder import VertexAiEmbedder
-from embedchain.llm.vertex_ai_llm import VertexAiLlm
+from embedchain.embedder.vertexai import VertexAiEmbedder
+from embedchain.llm.vertex_ai import VertexAiLlm
 from embedchain.models import EmbeddingFunctions, Providers
-from embedchain.vectordb.elasticsearch_db import Elasticsearch
+from embedchain.vectordb.elasticsearch import Elasticsearch
 
 # short
 app = CustomApp(llm=VertexAiLlm(), db=Elasticsearch(), embedder=VertexAiEmbedder())

docs/advanced/data_types.mdx

@@ -82,6 +82,8 @@ 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:
@@ -91,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:
@@ -102,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

docs/advanced/interface_types.mdx

@@ -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:
@@ -70,6 +70,6 @@ app.reset()
 Counts the number of embeddings (chunks) in the database.
 
 ```python
-print(app.count())
+print(app.db.count())
 # returns: 481
 ```

docs/advanced/query_configuration.mdx

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

docs/advanced/testing.mdx

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

docs/advanced/vector_database.mdx

@@ -2,33 +2,117 @@
 title: '💾 Vector Database'
 ---
 
-We support `Chroma` and `Elasticsearch` as two vector database. 
+We support `Chroma`, `Elasticsearch` and `OpenSearch` as vector databases.
 `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 parameters 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.
+
+
+## OpenSearch 🔍
+
+To use OpenSearch as a vector database with a CustomApp, follow these simple steps:
+
+1. Set the `OPENAI_API_KEY` environment variable:
+
+```
+OPENAI_API_KEY=sk-xxxx
+```
+
+2. Define the OpenSearch configuration in your Python code:
+
+```python
+from embedchain import CustomApp
+from embedchain.config import OpenSearchDBConfig
+from embedchain.embedder.openai import OpenAIEmbedder
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.opensearch import OpenSearchDB
+
+opensearch_url = "https://localhost:9200"
+http_auth = ("username", "password")
+
+db_config = OpenSearchDBConfig(
+    opensearch_url=opensearch_url,
+    http_auth=http_auth,
+    collection_name="embedchain-app",
+    use_ssl=True,
+    timeout=30,
+)
+db = OpenSearchDB(config=db_config)
+```
+
+2. Instantiate the app and add data:
+
+```python
+app = CustomApp(llm=OpenAILlm(), embedder=OpenAIEmbedder(), db=db)
+app.add("https://en.wikipedia.org/wiki/Elon_Musk")
+app.add("https://www.forbes.com/profile/elon-musk")
+app.add("https://www.britannica.com/biography/Elon-Musk")
+```
+
+3. You're all set! Start querying using the following command:
+
+```python
+app.query("What is the net worth of Elon Musk?")
+```

docs/examples/discord_bot.mdx

@@ -26,7 +26,7 @@ Send Messages (under Text Permissions)
 1. Install embedchain python package:
 
 ```bash
-pip install "embedchain[discord]"
+pip install --upgrade "embedchain[discord]"
 ```
 
 2. Launch your Discord bot:
@@ -53,6 +53,10 @@ python -m embedchain.bots.discord --include-question
 ```text
 /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`.
 
 🎉 Happy Chatting! 🎉

docs/examples/poe_bot.mdx

@@ -7,7 +7,7 @@ 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).

docs/examples/whatsapp_bot.mdx

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

docs/integration/langsmith.mdx

@@ -0,0 +1,51 @@
+---
+title: '🛠️ LangSmith'
+description: 'Integrate with Langsmith to debug and monitor your LLM app'
+---
+
+Embedchain now supports integration with [LangSmith](https://www.langchain.com/langsmith).
+
+To use langsmith, you need to do the following steps
+
+1. Have an account on langsmith and keep the environment variables in handy
+2. Set the environments variables in your app so that embedchain has context about it.
+3. Just use embedchain and everything will be logged to LangSmith, so that you can better test and monitor your application.
+
+Lets cover each step in detail.
+
+* First make sure that you a LangSmith account created and have all the necessary variables handy. LangSmith has a [good documentation](https://docs.smith.langchain.com/) on how to get started with their service.
+
+* Once you have the account setup, we will need the following environment variables
+
+```bash
+export LANGCHAIN_TRACING_V2=true
+export LANGCHAIN_ENDPOINT=https://api.smith.langchain.com
+export LANGCHAIN_API_KEY=<your-api-key>
+export LANGCHAIN_PROJECT=<your-project>  # if not specified, defaults to "default"
+```
+
+If you are using Python, you can use the following code to set environment variables
+
+```python
+import os
+
+os.environ['LANGCHAIN_TRACING_V2'] = 'true'
+os.environ['LANGCHAIN_ENDPOINT'] = 'https://api.smith.langchain.com'
+os.environ['LANGCHAIN_API_KEY'] = <your-api-key>
+os.environ['LANGCHAIN_PROJECT] = <your-project>
+```
+
+* Now create an app using embedchain and everything will be automatically visible in the LangSmith
+
+
+```python
+from embedchain import App
+
+app = App()
+app.add("https://en.wikipedia.org/wiki/Elon_Musk")
+app.query("How many companies did Elon found?")
+```
+
+* Now the entire log for this will be visible in langsmith.
+
+<img src="/images/langsmith.png"/>

docs/introduction.mdx

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

docs/mint.json

@@ -19,6 +19,10 @@
     {
       "name": "Discord",
       "url": "https://discord.gg/6PzXDgEjG5"
+    },
+    {
+      "name":"Slack",
+      "url":"https://join.slack.com/t/embedchain/shared_invite/zt-22uwz3c46-Zg7cIh5rOBteT_xe1jwLDw"
     }
   ],
   "topbarCtaButton": {
@@ -38,6 +42,10 @@
       "group": "Examples",
       "pages": ["examples/full_stack", "examples/api_server", "examples/discord_bot", "examples/slack_bot", "examples/telegram_bot", "examples/whatsapp_bot", "examples/poe_bot"]
     },
+    {
+      "group": "Integration",
+      "pages": ["integration/langsmith"]
+    },
     {
       "group": "Contribution Guidelines",
       "pages": ["contribution/dev", "contribution/docs"]
@@ -48,7 +56,8 @@
     "twitter": "https://twitter.com/embedchain",
     "github": "https://github.com/embedchain/embedchain",
     "linkedin": "https://www.linkedin.com/company/embedchain",
-    "website": "https://embedchain.ai"
+    "website": "https://embedchain.ai",
+    "slack":"https://join.slack.com/t/embedchain/shared_invite/zt-22uwz3c46-Zg7cIh5rOBteT_xe1jwLDw"
   },
   "backgroundImage": "/background.png",
   "isWhiteLabeled": true

docs/quickstart.mdx

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

embedchain-js/.eslintignore

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

embedchain-js/.eslintrc

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

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

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

embedchain-js/.gitignore

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

embedchain-js/.husky/commit-msg

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

embedchain-js/.husky/pre-commit

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

embedchain-js/CITATION.cff

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

embedchain-js/LICENSE

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

embedchain-js/README.md

@@ -0,0 +1,263 @@
+# embedchainjs
+
+[![Discord](https://dcbadge.vercel.app/api/server/CUU9FPhRNt?style=flat)](https://discord.gg/CUU9FPhRNt)
+[![Twitter](https://img.shields.io/twitter/follow/embedchain)](https://twitter.com/embedchain)
+[![Substack](https://img.shields.io/badge/Substack-%23006f5c.svg?logo=substack)](https://embedchain.substack.com/)
+
+embedchain is a framework to easily create LLM powered bots over any dataset. embedchainjs is Javascript version of embedchain. If you want a python version, check out [embedchain-python](https://github.com/embedchain/embedchain)
+
+# 🤝 Let's Talk Embedchain!
+
+Schedule a [Feedback Session](https://cal.com/taranjeetio/ec) with Taranjeet, the founder, to discuss any issues, provide feedback, or explore improvements.
+
+# How it works
+
+It abstracts the entire process of loading dataset, chunking it, creating embeddings and then storing in vector database.
+
+You can add a single or multiple dataset using `.add` and `.addLocal` function and then use `.query` function to find an answer from the added datasets.
+
+If you want to create a Naval Ravikant bot which has 2 of his blog posts, as well as a question and answer pair you supply, all you need to do is add the links to the blog posts and the QnA pair and embedchain will create a bot for you.
+
+```javascript
+const dotenv = require("dotenv");
+dotenv.config();
+const { App } = require("embedchain");
+
+//Run the app commands inside an async function only
+async function testApp() {
+  const navalChatBot = await App();
+
+  // Embed Online Resources
+  await navalChatBot.add("web_page", "https://nav.al/feedback");
+  await navalChatBot.add("web_page", "https://nav.al/agi");
+  await navalChatBot.add(
+    "pdf_file",
+    "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf"
+  );
+
+  // Embed Local Resources
+  await navalChatBot.addLocal("qna_pair", [
+    "Who is Naval Ravikant?",
+    "Naval Ravikant is an Indian-American entrepreneur and investor.",
+  ]);
+
+  const result = await navalChatBot.query(
+    "What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"
+  );
+  console.log(result);
+  // answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
+}
+
+testApp();
+```
+
+# Getting Started
+
+## Installation
+
+- First make sure that you have the package installed. If not, then install it using `npm`
+
+```bash
+npm install embedchain && npm install -S openai@^3.3.0
+```
+
+- Currently, it is only compatible with openai 3.X, not the latest version 4.X. Please make sure to use the right version, otherwise you will see the `ChromaDB` error `TypeError: OpenAIApi.Configuration is not a constructor`
+
+- Make sure that dotenv package is installed and your `OPENAI_API_KEY` in a file called `.env` in the root folder. You can install dotenv by
+
+```js
+npm install dotenv
+```
+
+- Download and install Docker on your device by visiting [this link](https://www.docker.com/). You will need this to run Chroma vector database on your machine.
+
+- Run the following commands to setup Chroma container in Docker
+
+```bash
+git clone https://github.com/chroma-core/chroma.git
+cd chroma
+docker-compose up -d --build
+```
+
+- Once Chroma container has been set up, run it inside Docker
+
+## Usage
+
+- We use OpenAI's embedding model to create embeddings for chunks and ChatGPT API as LLM to get answer given the relevant docs. Make sure that you have an OpenAI account and an API key. If you have dont have an API key, you can create one by visiting [this link](https://platform.openai.com/account/api-keys).
+
+- Once you have the API key, set it in an environment variable called `OPENAI_API_KEY`
+
+```js
+// Set this inside your .env file
+OPENAI_API_KEY = "sk-xxxx";
+```
+
+- Load the environment variables inside your .js file using the following commands
+
+```js
+const dotenv = require("dotenv");
+dotenv.config();
+```
+
+- Next import the `App` class from embedchain and use `.add` function to add any dataset.
+- Now your app is created. You can use `.query` function to get the answer for any query.
+
+```js
+const dotenv = require("dotenv");
+dotenv.config();
+const { App } = require("embedchain");
+
+async function testApp() {
+  const navalChatBot = await App();
+
+  // Embed Online Resources
+  await navalChatBot.add("web_page", "https://nav.al/feedback");
+  await navalChatBot.add("web_page", "https://nav.al/agi");
+  await navalChatBot.add(
+    "pdf_file",
+    "https://navalmanack.s3.amazonaws.com/Eric-Jorgenson_The-Almanack-of-Naval-Ravikant_Final.pdf"
+  );
+
+  // Embed Local Resources
+  await navalChatBot.addLocal("qna_pair", [
+    "Who is Naval Ravikant?",
+    "Naval Ravikant is an Indian-American entrepreneur and investor.",
+  ]);
+
+  const result = await navalChatBot.query(
+    "What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?"
+  );
+  console.log(result);
+  // answer: Naval argues that humans possess the unique capacity to understand explanations or concepts to the maximum extent possible in this physical reality.
+}
+
+testApp();
+```
+
+- If there is any other app instance in your script or app, you can change the import as
+
+```javascript
+const { App: EmbedChainApp } = require("embedchain");
+
+// or
+
+const { App: ECApp } = require("embedchain");
+```
+
+## Format supported
+
+We support the following formats:
+
+### PDF File
+
+To add any pdf file, use the data_type as `pdf_file`. Eg:
+
+```javascript
+await app.add("pdf_file", "a_valid_url_where_pdf_file_can_be_accessed");
+```
+
+### Web Page
+
+To add any web page, use the data_type as `web_page`. Eg:
+
+```javascript
+await app.add("web_page", "a_valid_web_page_url");
+```
+
+### QnA Pair
+
+To supply your own QnA pair, use the data_type as `qna_pair` and enter a tuple. Eg:
+
+```javascript
+await app.addLocal("qna_pair", ["Question", "Answer"]);
+```
+
+### More Formats coming soon
+
+- If you want to add any other format, please create an [issue](https://github.com/embedchain/embedchainjs/issues) and we will add it to the list of supported formats.
+
+## Testing
+
+Before you consume valueable tokens, you should make sure that the embedding you have done works and that it's receiving the correct document from the database.
+
+For this you can use the `dryRun` method.
+
+Following the example above, add this to your script:
+
+```js
+let result = await naval_chat_bot.dryRun("What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?");console.log(result);
+
+'''
+Use the following pieces of context to answer the query at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
+terms of the unseen. And I think that’s critical. That is what humans do uniquely that no other creature, no other computer, no other intelligence—biological or artificial—that we have ever encountered does. And not only do we do it uniquely, but if we were to meet an alien species that also had the power to generate these good explanations, there is no explanation that they could generate that we could not understand. We are maximally capable of understanding. There is no concept out there that is possible in this physical reality that a human being, given sufficient time and resources and
+Query: What unique capacity does Naval argue humans possess when it comes to understanding explanations or concepts?
+Helpful Answer:
+'''
+```
+
+_The embedding is confirmed to work as expected. It returns the right document, even if the question is asked slightly different. No prompt tokens have been consumed._
+
+**The dry run will still consume tokens to embed your query, but it is only ~1/15 of the prompt.**
+
+# How does it work?
+
+Creating a chat bot over any dataset needs the following steps to happen
+
+- load the data
+- create meaningful chunks
+- create embeddings for each chunk
+- store the chunks in vector database
+
+Whenever a user asks any query, following process happens to find the answer for the query
+
+- create the embedding for query
+- find similar documents for this query from vector database
+- pass similar documents as context to LLM to get the final answer.
+
+The process of loading the dataset and then querying involves multiple steps and each steps has nuances of it is own.
+
+- How should I chunk the data? What is a meaningful chunk size?
+- How should I create embeddings for each chunk? Which embedding model should I use?
+- How should I store the chunks in vector database? Which vector database should I use?
+- Should I store meta data along with the embeddings?
+- How should I find similar documents for a query? Which ranking model should I use?
+
+These questions may be trivial for some but for a lot of us, it needs research, experimentation and time to find out the accurate answers.
+
+embedchain is a framework which takes care of all these nuances and provides a simple interface to create bots over any dataset.
+
+In the first release, we are making it easier for anyone to get a chatbot over any dataset up and running in less than a minute. All you need to do is create an app instance, add the data sets using `.add` function and then use `.query` function to get the relevant answer.
+
+# Tech Stack
+
+embedchain is built on the following stack:
+
+- [Langchain](https://github.com/hwchase17/langchain) as an LLM framework to load, chunk and index data
+- [OpenAI's Ada embedding model](https://platform.openai.com/docs/guides/embeddings) to create embeddings
+- [OpenAI's ChatGPT API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) as LLM to get answers given the context
+- [Chroma](https://github.com/chroma-core/chroma) as the vector database to store embeddings
+
+# Team
+
+## Author
+
+- Taranjeet Singh ([@taranjeetio](https://twitter.com/taranjeetio))
+
+## Maintainer
+
+- [cachho](https://github.com/cachho)
+- [sahilyadav902](https://github.com/sahilyadav902)
+
+## Citation
+
+If you utilize this repository, please consider citing it with:
+```
+@misc{embedchain,
+  author = {Taranjeet Singh},
+  title = {Embechain: Framework to easily create LLM powered bots over any dataset},
+  year = {2023},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/embedchain/embedchainjs}},
+}
+```

embedchain-js/commitlint.config.js

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

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

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

embedchain-js/embedchain/chunkers/BaseChunker.ts

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

embedchain-js/embedchain/chunkers/PdfFile.ts

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

embedchain-js/embedchain/chunkers/QnaPair.ts

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

embedchain-js/embedchain/chunkers/WebPage.ts

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

embedchain-js/embedchain/chunkers/index.ts

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

embedchain-js/embedchain/embedchain.ts

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

embedchain-js/embedchain/index.ts

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

embedchain-js/embedchain/loaders/BaseLoader.ts

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

embedchain-js/embedchain/loaders/LocalQnaPair.ts

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

embedchain-js/embedchain/loaders/PdfFile.ts

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

embedchain-js/embedchain/loaders/WebPage.ts

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

embedchain-js/embedchain/loaders/index.ts

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

embedchain-js/embedchain/models/ChunkResult.ts

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

embedchain-js/embedchain/models/DataDict.ts

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

embedchain-js/embedchain/models/DataType.ts

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

embedchain-js/embedchain/models/FormattedResult.ts

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

embedchain-js/embedchain/models/Input.ts

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

embedchain-js/embedchain/models/LoaderResult.ts

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

embedchain-js/embedchain/models/Metadata.ts

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

embedchain-js/embedchain/models/Method.ts

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

embedchain-js/embedchain/models/QnAPair.ts

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

embedchain-js/embedchain/models/index.ts

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

embedchain-js/embedchain/utils.ts

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

embedchain-js/embedchain/vectordb/BaseVectorDb.ts

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

embedchain-js/embedchain/vectordb/ChromaDb.ts

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

embedchain-js/embedchain/vectordb/index.ts

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

embedchain-js/index.js

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

embedchain-js/jest.config.js

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

embedchain-js/lint-staged.config.js

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

embedchain-js/package.json

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

embedchain-js/tsconfig.build.json

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

embedchain-js/tsconfig.json

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

embedchain/__init__.py

@@ -2,11 +2,10 @@ import importlib.metadata
 
 __version__ = importlib.metadata.version(__package__ or __name__)
 
-from embedchain.apps.App import App  # noqa: F401
-from embedchain.apps.CustomApp import CustomApp  # noqa: F401
+from embedchain.apps.app import App  # noqa: F401
+from embedchain.apps.custom_app import CustomApp  # noqa: F401
 from embedchain.apps.Llama2App import Llama2App  # noqa: F401
-from embedchain.apps.OpenSourceApp import OpenSourceApp  # noqa: F401
+from embedchain.apps.open_source_app import OpenSourceApp  # noqa: F401
 from embedchain.apps.PersonApp import (PersonApp,  # noqa: F401
                                        PersonOpenSourceApp)
-from embedchain.vectordb.chroma_db import ChromaDB  # noqa: F401
-from embedchain.vectordb.elasticsearch_db import ElasticsearchDB  # noqa: F401
+from embedchain.vectordb.chroma import ChromaDB  # noqa: F401

embedchain/apps/Llama2App.py

@@ -1,11 +1,11 @@
 from typing import Optional
 
-from embedchain.apps.CustomApp import CustomApp
+from embedchain.apps.custom_app import CustomApp
 from embedchain.config import CustomAppConfig
-from embedchain.embedder.openai_embedder import OpenAiEmbedder
-from embedchain.helper_classes.json_serializable import register_deserializable
-from embedchain.llm.llama2_llm import Llama2Llm
-from embedchain.vectordb.chroma_db import ChromaDB
+from embedchain.embedder.openai import OpenAIEmbedder
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.llm.llama2 import Llama2Llm
+from embedchain.vectordb.chroma import ChromaDB
 
 
 @register_deserializable
@@ -29,5 +29,5 @@ class Llama2App(CustomApp):
             config = CustomAppConfig()
 
         super().__init__(
-            config=config, llm=Llama2Llm(), db=ChromaDB(), embedder=OpenAiEmbedder(), system_prompt=system_prompt
+            config=config, llm=Llama2Llm(), db=ChromaDB(), embedder=OpenAIEmbedder(), system_prompt=system_prompt
         )

embedchain/apps/PersonApp.py

@@ -1,12 +1,12 @@
 from string import Template
 
-from embedchain.apps.App import App
-from embedchain.apps.OpenSourceApp import OpenSourceApp
+from embedchain.apps.app import App
+from embedchain.apps.open_source_app import OpenSourceApp
 from embedchain.config import BaseLlmConfig
-from embedchain.config.apps.BaseAppConfig import BaseAppConfig
+from embedchain.config.apps.base_app_config import BaseAppConfig
 from embedchain.config.llm.base_llm_config import (DEFAULT_PROMPT,
                                                    DEFAULT_PROMPT_WITH_HISTORY)
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/apps/app.py

@@ -3,10 +3,10 @@ from typing import Optional
 from embedchain.config import (AppConfig, BaseEmbedderConfig, BaseLlmConfig,
                                ChromaDbConfig)
 from embedchain.embedchain import EmbedChain
-from embedchain.embedder.openai_embedder import OpenAiEmbedder
-from embedchain.helper_classes.json_serializable import register_deserializable
-from embedchain.llm.openai_llm import OpenAiLlm
-from embedchain.vectordb.chroma_db import ChromaDB
+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
@@ -47,8 +47,8 @@ class App(EmbedChain):
         if config is None:
             config = AppConfig()
 
-        llm = OpenAiLlm(config=llm_config)
-        embedder = OpenAiEmbedder(config=BaseEmbedderConfig(model="text-embedding-ada-002"))
+        llm = OpenAILlm(config=llm_config)
+        embedder = OpenAIEmbedder(config=BaseEmbedderConfig(model="text-embedding-ada-002"))
         database = ChromaDB(config=chromadb_config)
 
         super().__init__(config, llm, db=database, embedder=embedder, system_prompt=system_prompt)

embedchain/apps/custom_app.py

@@ -2,10 +2,10 @@ from typing import Optional
 
 from embedchain.config import CustomAppConfig
 from embedchain.embedchain import EmbedChain
-from embedchain.embedder.base_embedder import BaseEmbedder
-from embedchain.helper_classes.json_serializable import register_deserializable
-from embedchain.llm.base_llm import BaseLlm
-from embedchain.vectordb.base_vector_db import BaseVectorDB
+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
@@ -35,7 +35,7 @@ class CustomApp(EmbedChain):
         :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_llm import OpenAiLlm`, defaults to None
+        :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

embedchain/apps/open_source_app.py

@@ -4,10 +4,10 @@ from typing import Optional
 from embedchain.config import (BaseEmbedderConfig, BaseLlmConfig,
                                ChromaDbConfig, OpenSourceAppConfig)
 from embedchain.embedchain import EmbedChain
-from embedchain.embedder.gpt4all_embedder import GPT4AllEmbedder
-from embedchain.helper_classes.json_serializable import register_deserializable
-from embedchain.llm.gpt4all_llm import GPT4ALLLlm
-from embedchain.vectordb.chroma_db import ChromaDB
+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
 

embedchain/bots/base.py

@@ -2,17 +2,17 @@ from typing import Any
 
 from embedchain import CustomApp
 from embedchain.config import AddConfig, CustomAppConfig, LlmConfig
-from embedchain.embedder.openai_embedder import OpenAiEmbedder
-from embedchain.helper_classes.json_serializable import (
-    JSONSerializable, register_deserializable)
-from embedchain.llm.openai_llm import OpenAiLlm
-from embedchain.vectordb.chroma_db import ChromaDB
+from embedchain.embedder.openai import OpenAIEmbedder
+from embedchain.helper.json_serializable import (JSONSerializable,
+                                                 register_deserializable)
+from embedchain.llm.openai import OpenAILlm
+from embedchain.vectordb.chroma import ChromaDB
 
 
 @register_deserializable
 class BaseBot(JSONSerializable):
     def __init__(self):
-        self.app = CustomApp(config=CustomAppConfig(), llm=OpenAiLlm(), db=ChromaDB(), embedder=OpenAiEmbedder())
+        self.app = CustomApp(config=CustomAppConfig(), llm=OpenAILlm(), db=ChromaDB(), embedder=OpenAIEmbedder())
 
     def add(self, data: Any, config: AddConfig = None):
         """

embedchain/bots/discord.py

@@ -2,14 +2,21 @@ import argparse
 import logging
 import os
 
-import discord
-from discord import app_commands
-from discord.ext import commands
-
-from embedchain.helper_classes.json_serializable import register_deserializable
+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)

embedchain/bots/poe.py

@@ -3,12 +3,17 @@ import logging
 import os
 from typing import List, Optional
 
-from fastapi_poe import PoeBot, run
-
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.helper.json_serializable import register_deserializable
 
 from .base import BaseBot
 
+try:
+    from fastapi_poe import PoeBot, run
+except ModuleNotFoundError:
+    raise ModuleNotFoundError(
+        "The required dependencies for Poe are not installed." 'Please install with `pip install "embedchain[poe]"`'
+    ) from None
+
 
 def start_command():
     parser = argparse.ArgumentParser(description="EmbedChain PoeBot command line interface")

embedchain/bots/slack.py

@@ -5,7 +5,7 @@ import signal
 import sys
 
 from embedchain import App
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.helper.json_serializable import register_deserializable
 
 from .base import BaseBot
 
@@ -14,7 +14,8 @@ try:
     from slack_sdk import WebClient
 except ModuleNotFoundError:
     raise ModuleNotFoundError(
-        "The required dependencies for Slack are not installed." 'Please install with `pip install "embedchain[slack]"`'
+        "The required dependencies for Slack are not installed."
+        'Please install with `pip install --upgrade "embedchain[slack]"`'
     ) from None
 
 

embedchain/bots/whatsapp.py

@@ -4,7 +4,7 @@ import logging
 import signal
 import sys
 
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.helper.json_serializable import register_deserializable
 
 from .base import BaseBot
 

embedchain/chunkers/base_chunker.py

@@ -1,6 +1,6 @@
 import hashlib
 
-from embedchain.helper_classes.json_serializable import JSONSerializable
+from embedchain.helper.json_serializable import JSONSerializable
 from embedchain.models.data_type import DataType
 
 
@@ -22,14 +22,17 @@ class BaseChunker(JSONSerializable):
         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)
@@ -45,6 +48,7 @@ class BaseChunker(JSONSerializable):
             "documents": documents,
             "ids": ids,
             "metadatas": metadatas,
+            "doc_id": doc_id,
         }
 
     def get_chunks(self, content):

embedchain/chunkers/docs_site.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/chunkers/docx_file.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/chunkers/mdx.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+from embedchain.chunkers.base_chunker import BaseChunker
+from embedchain.config.add_config 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)

embedchain/chunkers/notion.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/chunkers/pdf_file.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/chunkers/qna_pair.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/chunkers/table.py

@@ -3,7 +3,7 @@ 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.config.add_config import ChunkerConfig
 
 
 class TableChunker(BaseChunker):

embedchain/chunkers/text.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/chunkers/web_page.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/chunkers/youtube_video.py

@@ -3,8 +3,8 @@ from typing import Optional
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 from embedchain.chunkers.base_chunker import BaseChunker
-from embedchain.config.AddConfig import ChunkerConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.add_config import ChunkerConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/config/__init__.py

@@ -1,13 +1,14 @@
 # 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 .add_config import AddConfig, ChunkerConfig
+from .apps.app_config import AppConfig
+from .apps.custom_app_config import CustomAppConfig
+from .apps.open_source_app_config import OpenSourceAppConfig
+from .base_config import BaseConfig
+from .embedder.base import BaseEmbedderConfig
+from .embedder.base 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
+from .vectordb.chroma import ChromaDbConfig
+from .vectordb.elasticsearch import ElasticsearchDBConfig
+from .vectordb.opensearch import OpenSearchDBConfig

embedchain/config/add_config.py

@@ -1,7 +1,7 @@
 from typing import Callable, Optional
 
-from embedchain.config.BaseConfig import BaseConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.base_config import BaseConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/config/apps/app_config.py

@@ -1,8 +1,8 @@
 from typing import Optional
 
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.helper.json_serializable import register_deserializable
 
-from .BaseAppConfig import BaseAppConfig
+from .base_app_config import BaseAppConfig
 
 
 @register_deserializable

embedchain/config/apps/base_app_config.py

@@ -1,9 +1,9 @@
 import logging
 from typing import Optional
 
-from embedchain.config.BaseConfig import BaseConfig
-from embedchain.helper_classes.json_serializable import JSONSerializable
-from embedchain.vectordb.base_vector_db import BaseVectorDB
+from embedchain.config.base_config import BaseConfig
+from embedchain.helper.json_serializable import JSONSerializable
+from embedchain.vectordb.base import BaseVectorDB
 
 
 class BaseAppConfig(BaseConfig, JSONSerializable):

embedchain/config/apps/custom_app_config.py

@@ -2,10 +2,10 @@ from typing import Optional
 
 from dotenv import load_dotenv
 
-from embedchain.helper_classes.json_serializable import register_deserializable
-from embedchain.vectordb.base_vector_db import BaseVectorDB
+from embedchain.helper.json_serializable import register_deserializable
+from embedchain.vectordb.base import BaseVectorDB
 
-from .BaseAppConfig import BaseAppConfig
+from .base_app_config import BaseAppConfig
 
 load_dotenv()
 

embedchain/config/apps/open_source_app_config.py

@@ -1,8 +1,8 @@
 from typing import Optional
 
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.helper.json_serializable import register_deserializable
 
-from .BaseAppConfig import BaseAppConfig
+from .base_app_config import BaseAppConfig
 
 
 @register_deserializable

embedchain/config/base_config.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict
 
-from embedchain.helper_classes.json_serializable import JSONSerializable
+from embedchain.helper.json_serializable import JSONSerializable
 
 
 class BaseConfig(JSONSerializable):

embedchain/config/embedder/base.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable

embedchain/config/llm/base_llm_config.py

@@ -2,8 +2,8 @@ import re
 from string import Template
 from typing import Any, Dict, Optional
 
-from embedchain.config.BaseConfig import BaseConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.base_config 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.

embedchain/config/vectordb/base.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from embedchain.config.BaseConfig import BaseConfig
+from embedchain.config.base_config import BaseConfig
 
 
 class BaseVectorDbConfig(BaseConfig):

embedchain/config/vectordb/chroma.py

@@ -1,7 +1,7 @@
 from typing import Optional
 
-from embedchain.config.vectordbs.BaseVectorDbConfig import BaseVectorDbConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.vectordb.base import BaseVectorDbConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable
@@ -12,6 +12,7 @@ class ChromaDbConfig(BaseVectorDbConfig):
         dir: Optional[str] = None,
         host: Optional[str] = None,
         port: Optional[str] = None,
+        allow_reset=False,
         chroma_settings: Optional[dict] = None,
     ):
         """
@@ -25,11 +26,12 @@ class ChromaDbConfig(BaseVectorDbConfig):
         :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
         """
-        """
-        :param chroma_settings: Optional. Chroma settings for connection.
-        """
+
         self.chroma_settings = chroma_settings
+        self.allow_reset = allow_reset
         super().__init__(collection_name=collection_name, dir=dir, host=host, port=port)

embedchain/config/vectordb/elasticsearch.py

@@ -1,7 +1,8 @@
+import os
 from typing import Dict, List, Optional, Union
 
-from embedchain.config.vectordbs.BaseVectorDbConfig import BaseVectorDbConfig
-from embedchain.helper_classes.json_serializable import register_deserializable
+from embedchain.config.vectordb.base import BaseVectorDbConfig
+from embedchain.helper.json_serializable import register_deserializable
 
 
 @register_deserializable
@@ -26,7 +27,20 @@ class ElasticsearchDBConfig(BaseVectorDbConfig):
         :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
+        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)

embedchain/config/vectordb/opensearch.py

@@ -0,0 +1,37 @@
+from typing import Dict, Optional, Tuple
+
+from embedchain.config.vectordb.base import BaseVectorDbConfig
+from embedchain.helper.json_serializable import register_deserializable
+
+
+@register_deserializable
+class OpenSearchDBConfig(BaseVectorDbConfig):
+    def __init__(
+        self,
+        opensearch_url: str,
+        http_auth: Tuple[str, str],
+        vector_dimension: int = 1536,
+        collection_name: Optional[str] = None,
+        dir: Optional[str] = None,
+        **extra_params: Dict[str, any],
+    ):
+        """
+        Initializes a configuration class instance for an OpenSearch client.
+
+        :param collection_name: Default name for the collection, defaults to None
+        :type collection_name: Optional[str], optional
+        :param opensearch_url: URL of the OpenSearch domain
+        :type opensearch_url: str, Eg, "http://localhost:9200"
+        :param http_auth: Tuple of username and password
+        :type http_auth: Tuple[str, str], Eg, ("username", "password")
+        :param vector_dimension: Dimension of  the vector, defaults to 1536 (openai embedding model)
+        :type vector_dimension: int, optional
+        :param dir: Path to the database directory, where the database is stored, defaults to None
+        :type dir: Optional[str], optional
+        """
+        self.opensearch_url = opensearch_url
+        self.http_auth = http_auth
+        self.vector_dimension = vector_dimension
+        self.extra_params = extra_params
+
+        super().__init__(collection_name=collection_name, dir=dir)

embedchain/data_formatter/data_formatter.py

@@ -1,6 +1,7 @@
 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
@@ -9,14 +10,15 @@ 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_classes.json_serializable import JSONSerializable
+from embedchain.config.add_config 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
@@ -65,6 +67,7 @@ class DataFormatter(JSONSerializable):
             DataType.SITEMAP: SitemapLoader,
             DataType.DOCS_SITE: DocsSiteLoader,
             DataType.CSV: CsvLoader,
+            DataType.MDX: MdxLoader,
         }
         lazy_loaders = {DataType.NOTION}
         if data_type in loaders:
@@ -103,6 +106,7 @@ class DataFormatter(JSONSerializable):
             DataType.DOCS_SITE: DocsSiteChunker,
             DataType.NOTION: NotionChunker,
             DataType.CSV: TableChunker,
+            DataType.MDX: MdxChunker,
         }
         if data_type in chunker_classes:
             chunker_class: type = chunker_classes[data_type]

embedchain/embedchain.py

@@ -6,23 +6,25 @@ import os
 import threading
 import uuid
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 import requests
 from dotenv import load_dotenv
+from langchain.docstore.document import Document
 from tenacity import retry, stop_after_attempt, wait_fixed
 
 from embedchain.chunkers.base_chunker import BaseChunker
 from embedchain.config import AddConfig, BaseLlmConfig
-from embedchain.config.apps.BaseAppConfig import BaseAppConfig
+from embedchain.config.apps.base_app_config import BaseAppConfig
 from embedchain.data_formatter import DataFormatter
-from embedchain.embedder.base_embedder import BaseEmbedder
-from embedchain.helper_classes.json_serializable import JSONSerializable
-from embedchain.llm.base_llm import BaseLlm
+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_vector_db import BaseVectorDB
+from embedchain.vectordb.base import BaseVectorDB
 
 load_dotenv()
 
@@ -59,16 +61,13 @@ class EmbedChain(JSONSerializable):
         """
 
         self.config = config
-
-        # Add subclasses
-        ## Llm
+        # 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
+        # Embedder
         if embedder is None:
             raise ValueError("App requires Embedder.")
         self.embedder = embedder
@@ -96,6 +95,26 @@ class EmbedChain(JSONSerializable):
         thread_telemetry = threading.Thread(target=self._send_telemetry_event, args=("init",))
         thread_telemetry.start()
 
+    @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
@@ -125,6 +144,7 @@ class EmbedChain(JSONSerializable):
         data_type: Optional[DataType] = 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.
@@ -141,6 +161,8 @@ class EmbedChain(JSONSerializable):
         :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
         """
@@ -176,12 +198,17 @@ class EmbedChain(JSONSerializable):
 
         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(
+            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.
@@ -226,6 +253,56 @@ class EmbedChain(JSONSerializable):
         )
         return self.add(source=source, data_type=data_type, metadata=metadata, config=config)
 
+    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(
         self,
         loader: BaseLoader,
@@ -233,44 +310,59 @@ class EmbedChain(JSONSerializable):
         src: Any,
         metadata: Optional[Dict[str, Any]] = None,
         source_id: Optional[str] = None,
-    ) -> Tuple[List[str], Dict[str, Any], List[str], int]:
-        """The loader to use to load the data.
+        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.
-        :type loader: BaseLoader
         :param chunker: The chunker to use to chunk the data.
-        :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 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
-        :rtype: Tuple[List[str], Dict[str, Any], List[str], int]
         """
+        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}
-        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
 
@@ -295,6 +387,9 @@ class EmbedChain(JSONSerializable):
             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()
 
@@ -303,6 +398,16 @@ class EmbedChain(JSONSerializable):
         print((f"Successfully saved {src} ({chunker.data_type}). New chunks count: {count_new_chunks}"))
         return list(documents), metadatas, ids, count_new_chunks
 
+    def _format_result(self, results):
+        return [
+            (Document(page_content=result[0], metadata=result[1] or {}), result[2])
+            for result in zip(
+                results["documents"][0],
+                results["metadatas"][0],
+                results["distances"][0],
+            )
+        ]
+
     def 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.

embedchain/embedder/base.py

@@ -1,6 +1,6 @@
 from typing import Any, Callable, Optional
 
-from embedchain.config.embedder.BaseEmbedderConfig import BaseEmbedderConfig
+from embedchain.config.embedder.base import BaseEmbedderConfig
 
 try:
     from chromadb.api.types import Documents, Embeddings
@@ -51,6 +51,8 @@ class BaseEmbedder:
         :param vector_dimension: vector dimension size
         :type vector_dimension: int
         """
+        if not isinstance(vector_dimension, int):
+            raise TypeError("vector dimension must be int")
         self.vector_dimension = vector_dimension
 
     @staticmethod

embedchain/embedder/gpt4all.py

@@ -3,8 +3,8 @@ from typing import Optional
 from chromadb.utils import embedding_functions
 
 from embedchain.config import BaseEmbedderConfig
-from embedchain.embedder.base_embedder import BaseEmbedder
-from embedchain.models import EmbeddingFunctions
+from embedchain.embedder.base import BaseEmbedder
+from embedchain.models import VectorDimensions
 
 
 class GPT4AllEmbedder(BaseEmbedder):
@@ -17,5 +17,5 @@ class GPT4AllEmbedder(BaseEmbedder):
         embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(model_name=self.config.model)
         self.set_embedding_fn(embedding_fn=embedding_fn)
 
-        vector_dimension = EmbeddingFunctions.GPT4ALL.value
+        vector_dimension = VectorDimensions.GPT4ALL.value
         self.set_vector_dimension(vector_dimension=vector_dimension)