From 30051be9e92b8f1f7f608441d843c521c499f802 Mon Sep 17 00:00:00 2001
From: Ross Smith <ross-p-smith@users.noreply.github.com>
Date: Wed, 31 Jan 2024 23:09:46 +0000
Subject: [PATCH] Run black/flake8 against code base (#243)

* Run black against code base

* Amending imports

* Add flake8 config
---
 .flake8                                       |   3 +
 code/admin/Admin.py                           |  29 +-
 code/admin/pages/01_Ingest_Data.py            | 156 +++++++----
 code/admin/pages/02_Explore_Data.py           |  42 ++-
 code/admin/pages/03_Delete_Data.py            |  35 ++-
 code/admin/pages/04_Configuration.py          | 226 ++++++++++------
 code/app/app.py                               | 247 +++++++++++-------
 code/batch/AddURLEmbeddings.py                |  39 +--
 code/batch/BatchPushResults.py                |  37 ++-
 code/batch/BatchStartProcessing.py            |  38 ++-
 code/batch/function_app.py                    |   4 +-
 code/utilities/common/Answer.py               |  41 +--
 code/utilities/common/SourceDocument.py       | 119 +++++----
 .../document_chunking/DocumentChunkingBase.py |   9 +-
 .../document_chunking/FixedSizeOverlap.py     |  18 +-
 code/utilities/document_chunking/Layout.py    |  20 +-
 code/utilities/document_chunking/Page.py      |  29 +-
 code/utilities/document_chunking/Paragraph.py |   7 +-
 .../utilities/document_chunking/Strategies.py |  23 +-
 code/utilities/document_chunking/__init__.py  |   8 +-
 .../document_loading/DocumentLoadingBase.py   |   5 +-
 code/utilities/document_loading/Layout.py     |  20 +-
 code/utilities/document_loading/Read.py       |  14 +-
 code/utilities/document_loading/Strategies.py |  17 +-
 code/utilities/document_loading/Web.py        |  14 +-
 .../document_loading/WordDocument.py          |  22 +-
 code/utilities/document_loading/__init__.py   |  12 +-
 .../helpers/AzureBlobStorageHelper.py         | 154 ++++++++---
 .../helpers/AzureFormRecognizerHelper.py      |  90 +++++--
 code/utilities/helpers/AzureSearchHelper.py   |  51 ++--
 code/utilities/helpers/ConfigHelper.py        | 135 +++++-----
 .../helpers/DocumentChunkingHelper.py         |  20 +-
 .../helpers/DocumentLoadingHelper.py          |  12 +-
 .../helpers/DocumentProcessorHelper.py        |  16 +-
 code/utilities/helpers/EnvHelper.py           | 142 ++++++----
 code/utilities/helpers/LLMHelper.py           |  44 +++-
 code/utilities/helpers/OrchestratorHelper.py  |  23 +-
 code/utilities/loggers/ConversationLogger.py  |  48 ++--
 code/utilities/loggers/TokenLogger.py         |  16 +-
 code/utilities/orchestrator/LangChainAgent.py |  84 ++++--
 .../utilities/orchestrator/OpenAIFunctions.py | 109 +++++---
 .../orchestrator/OrchestratorBase.py          |  55 ++--
 code/utilities/orchestrator/Strategies.py     |  11 +-
 code/utilities/orchestrator/__init__.py       |  13 +-
 code/utilities/parser/OutputParserTool.py     |  53 ++--
 code/utilities/parser/ParserBase.py           |  12 +-
 code/utilities/parser/__init__.py             |   6 +-
 code/utilities/tools/AnswerProcessingBase.py  |   7 +-
 code/utilities/tools/AnsweringToolBase.py     |   9 +-
 code/utilities/tools/ContentSafetyChecker.py  |  43 +--
 code/utilities/tools/PostPromptTool.py        |  70 +++--
 code/utilities/tools/QuestionAnswerTool.py    |  49 ++--
 code/utilities/tools/TextProcessingTool.py    |  37 +--
 extensions/backend/http_cwyod/__init__.py     |  43 ++-
 tests/test_AzureBlobStorage.py                |   3 +-
 tests/test_ContentSafetyChecker.py            |   8 +-
 tests/test_DocumentChunking.py                |  65 ++---
 tests/test_DocumentLoading.py                 |  14 +-
 tests/test_DocumentProcessor.py               |  42 ++-
 tests/test_Orchestrator.py                    |  32 ++-
 tests/test_OutputParserTool.py                | 116 ++++----
 61 files changed, 1822 insertions(+), 1044 deletions(-)
 create mode 100644 .flake8

diff --git a/.flake8 b/.flake8
new file mode 100644
index 000000000..73646ac28
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,3 @@
+[flake8]
+max-line-length = 88
+extend-ignore = E203, E501
\ No newline at end of file
diff --git a/code/admin/Admin.py b/code/admin/Admin.py
index e0112ac9a..8e4ba8b27 100644
--- a/code/admin/Admin.py
+++ b/code/admin/Admin.py
@@ -1,17 +1,24 @@
 import streamlit as st
 import os
 import logging
+import sys
 from dotenv import load_dotenv
-load_dotenv()
 
-import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+load_dotenv()
 
-logger = logging.getLogger('azure.core.pipeline.policies.http_logging_policy').setLevel(logging.WARNING)
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 
+logger = logging.getLogger("azure.core.pipeline.policies.http_logging_policy").setLevel(
+    logging.WARNING
+)
 
 
-st.set_page_config(page_title="Admin", page_icon=os.path.join('images','favicon.ico'), layout="wide", menu_items=None)
+st.set_page_config(
+    page_title="Admin",
+    page_icon=os.path.join("images", "favicon.ico"),
+    layout="wide",
+    menu_items=None,
+)
 
 mod_page_style = """
             <style>
@@ -23,14 +30,16 @@
 st.markdown(mod_page_style, unsafe_allow_html=True)
 
 
-col1, col2, col3 = st.columns([1,2,1])
+col1, col2, col3 = st.columns([1, 2, 1])
 with col1:
-    st.image(os.path.join('images','logo.png'))
-    
+    st.image(os.path.join("images", "logo.png"))
+
 st.write("# Chat with your data Solution Accelerator")
 
-st.write("""
+st.write(
+    """
          * If you want to ingest data (pdf, websites, etc.), then use the `Ingest Data` tab
          * If you want to explore how your data was chunked, check the `Explore Data` tab
          * If you want to adapt the underlying prompts, logging settings and others, use the `Configuration` tab
-         """)
\ No newline at end of file
+         """
+)
diff --git a/code/admin/pages/01_Ingest_Data.py b/code/admin/pages/01_Ingest_Data.py
index 760e36947..9b25b2a80 100644
--- a/code/admin/pages/01_Ingest_Data.py
+++ b/code/admin/pages/01_Ingest_Data.py
@@ -1,5 +1,5 @@
 import streamlit as st
-import os, json
+import os
 from typing import Optional
 import mimetypes
 import traceback
@@ -10,13 +10,22 @@
 from azure.storage.blob import BlobServiceClient, generate_blob_sas, ContentSettings
 import urllib.parse
 import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 from utilities.helpers.ConfigHelper import ConfigHelper
 from dotenv import load_dotenv
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
 load_dotenv()
 
-logger = logging.getLogger('azure.core.pipeline.policies.http_logging_policy').setLevel(logging.WARNING)
-st.set_page_config(page_title="Ingest Data", page_icon=os.path.join('images','favicon.ico'), layout="wide", menu_items=None)
+logger = logging.getLogger("azure.core.pipeline.policies.http_logging_policy").setLevel(
+    logging.WARNING
+)
+st.set_page_config(
+    page_title="Ingest Data",
+    page_icon=os.path.join("images", "favicon.ico"),
+    layout="wide",
+    menu_items=None,
+)
 mod_page_style = """
             <style>
             #MainMenu {visibility: hidden;}
@@ -25,92 +34,145 @@
             </style>
             """
 st.markdown(mod_page_style, unsafe_allow_html=True)
-    
+
+
 def remote_convert_files_and_add_embeddings(process_all=False):
-    backend_url = urllib.parse.urljoin(os.getenv('BACKEND_URL','http://localhost:7071'), "/api/BatchStartProcessing")
+    backend_url = urllib.parse.urljoin(
+        os.getenv("BACKEND_URL", "http://localhost:7071"), "/api/BatchStartProcessing"
+    )
     params = {}
-    if os.getenv('FUNCTION_KEY') != None:
-        params['code'] = os.getenv('FUNCTION_KEY')
-        params['clientId'] = "clientKey"
+    if os.getenv("FUNCTION_KEY") is not None:
+        params["code"] = os.getenv("FUNCTION_KEY")
+        params["clientId"] = "clientKey"
     if process_all:
-        params['process_all'] = "true"
+        params["process_all"] = "true"
     try:
         response = requests.post(backend_url, params=params)
         if response.status_code == 200:
-            st.success(f"{response.text}\nPlease note this is an asynchronous process and may take a few minutes to complete.")
+            st.success(
+                f"{response.text}\nPlease note this is an asynchronous process and may take a few minutes to complete."
+            )
         else:
             st.error(f"Error: {response.text}")
-    except Exception as e:
+    except Exception:
         st.error(traceback.format_exc())
 
+
 def add_urls():
     params = {}
-    if os.getenv('FUNCTION_KEY') != None:
-        params['code'] = os.getenv('FUNCTION_KEY')
-        params['clientId'] = "clientKey"
-    urls = st.session_state['urls'].split('\n')
+    if os.getenv("FUNCTION_KEY") is not None:
+        params["code"] = os.getenv("FUNCTION_KEY")
+        params["clientId"] = "clientKey"
+    urls = st.session_state["urls"].split("\n")
     for url in urls:
-        body = {
-            "url": url
-        }
-        backend_url = urllib.parse.urljoin(os.getenv('BACKEND_URL','http://localhost:7071'), "/api/AddURLEmbeddings")
+        body = {"url": url}
+        backend_url = urllib.parse.urljoin(
+            os.getenv("BACKEND_URL", "http://localhost:7071"), "/api/AddURLEmbeddings"
+        )
         r = requests.post(url=backend_url, params=params, json=body)
         if not r.ok:
-            raise ValueError(f'Error {r.status_code}: {r.text}')
+            raise ValueError(f"Error {r.status_code}: {r.text}")
         else:
-            st.success(f'Embeddings added successfully for {url}')
+            st.success(f"Embeddings added successfully for {url}")
 
 
-def upload_file(bytes_data: bytes, file_name: str, content_type: Optional[str] = None):    
+def upload_file(bytes_data: bytes, file_name: str, content_type: Optional[str] = None):
     # Upload a new file
-    st.session_state['filename'] = file_name
-    if content_type == None:
+    st.session_state["filename"] = file_name
+    if content_type is None:
         content_type = mimetypes.MimeTypes().guess_type(file_name)[0]
-        charset = f"; charset={chardet.detect(bytes_data)['encoding']}" if content_type == 'text/plain' else ''
-        content_type = content_type if content_type != None else 'text/plain'
-    account_name = os.getenv('AZURE_BLOB_ACCOUNT_NAME')
-    account_key =  os.getenv('AZURE_BLOB_ACCOUNT_KEY')
-    container_name = os.getenv('AZURE_BLOB_CONTAINER_NAME')
-    if account_name == None or account_key == None or container_name == None:
-        raise ValueError("Please provide values for AZURE_BLOB_ACCOUNT_NAME, AZURE_BLOB_ACCOUNT_KEY and AZURE_BLOB_CONTAINER_NAME")
+        charset = (
+            f"; charset={chardet.detect(bytes_data)['encoding']}"
+            if content_type == "text/plain"
+            else ""
+        )
+        content_type = content_type if content_type is not None else "text/plain"
+    account_name = os.getenv("AZURE_BLOB_ACCOUNT_NAME")
+    account_key = os.getenv("AZURE_BLOB_ACCOUNT_KEY")
+    container_name = os.getenv("AZURE_BLOB_CONTAINER_NAME")
+    if account_name is None or account_key is None or container_name is None:
+        raise ValueError(
+            "Please provide values for AZURE_BLOB_ACCOUNT_NAME, AZURE_BLOB_ACCOUNT_KEY and AZURE_BLOB_CONTAINER_NAME"
+        )
     connect_str = f"DefaultEndpointsProtocol=https;AccountName={account_name};AccountKey={account_key};EndpointSuffix=core.windows.net"
-    blob_service_client : BlobServiceClient = BlobServiceClient.from_connection_string(connect_str)
+    blob_service_client: BlobServiceClient = BlobServiceClient.from_connection_string(
+        connect_str
+    )
     # Create a blob client using the local file name as the name for the blob
-    blob_client = blob_service_client.get_blob_client(container=container_name, blob=file_name)
+    blob_client = blob_service_client.get_blob_client(
+        container=container_name, blob=file_name
+    )
     # Upload the created file
-    blob_client.upload_blob(bytes_data, overwrite=True, content_settings=ContentSettings(content_type=content_type+charset))
+    blob_client.upload_blob(
+        bytes_data,
+        overwrite=True,
+        content_settings=ContentSettings(content_type=content_type + charset),
+    )
     # Generate a SAS URL to the blob and return it
-    st.session_state['file_url'] = blob_client.url + '?' + generate_blob_sas(account_name, container_name, file_name,account_key=account_key,  permission="r", expiry=datetime.utcnow() + timedelta(hours=3))
+    st.session_state["file_url"] = (
+        blob_client.url
+        + "?"
+        + generate_blob_sas(
+            account_name,
+            container_name,
+            file_name,
+            account_key=account_key,
+            permission="r",
+            expiry=datetime.utcnow() + timedelta(hours=3),
+        )
+    )
+
 
 try:
     with st.expander("Add documents in Batch", expanded=True):
         config = ConfigHelper.get_active_config_or_default()
-        file_type = [processor.document_type for processor in config.document_processors]
-        uploaded_files = st.file_uploader("Upload a document to add it to the Azure Storage Account, compute embeddings and add them to the Azure AI Search index. Check your configuration for available document processors.", type=file_type, accept_multiple_files=True)
+        file_type = [
+            processor.document_type for processor in config.document_processors
+        ]
+        uploaded_files = st.file_uploader(
+            "Upload a document to add it to the Azure Storage Account, compute embeddings and add them to the Azure AI Search index. Check your configuration for available document processors.",
+            type=file_type,
+            accept_multiple_files=True,
+        )
         if uploaded_files is not None:
             for up in uploaded_files:
                 # To read file as bytes:
                 bytes_data = up.getvalue()
-                if st.session_state.get('filename', '') != up.name:
+                if st.session_state.get("filename", "") != up.name:
                     # Upload a new file
                     upload_file(bytes_data, up.name)
             if len(uploaded_files) > 0:
-                st.success(f"{len(uploaded_files)} documents uploaded. Embeddings computation in progress. \nPlease note this is an asynchronous process and may take a few minutes to complete.\nYou can check for further details in the Azure Function logs.")
+                st.success(
+                    f"{len(uploaded_files)} documents uploaded. Embeddings computation in progress. \nPlease note this is an asynchronous process and may take a few minutes to complete.\nYou can check for further details in the Azure Function logs."
+                )
 
-        col1, col2, col3 = st.columns([2,1,2])
+        col1, col2, col3 = st.columns([2, 1, 2])
         # with col1:
         #     st.button("Process and ingest new files", on_click=remote_convert_files_and_add_embeddings)
         with col3:
-            st.button("Reprocess all documents in the Azure Storage account", on_click=remote_convert_files_and_add_embeddings, args=(True,))
+            st.button(
+                "Reprocess all documents in the Azure Storage account",
+                on_click=remote_convert_files_and_add_embeddings,
+                args=(True,),
+            )
 
     with st.expander("Add URLs to the knowledge base", expanded=True):
-        col1, col2 = st.columns([3,1])
-        with col1: 
-            st.text_area("Add a URLs and than click on 'Compute Embeddings'", placeholder="PLACE YOUR URLS HERE SEPARATED BY A NEW LINE", height=100, key="urls")
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            st.text_area(
+                "Add a URLs and than click on 'Compute Embeddings'",
+                placeholder="PLACE YOUR URLS HERE SEPARATED BY A NEW LINE",
+                height=100,
+                key="urls",
+            )
 
         with col2:
-            st.selectbox('Embeddings models', [os.getenv('AZURE_OPENAI_EMBEDDING_MODEL')], disabled=True)
+            st.selectbox(
+                "Embeddings models",
+                [os.getenv("AZURE_OPENAI_EMBEDDING_MODEL")],
+                disabled=True,
+            )
             st.button("Process and ingest web pages", on_click=add_urls, key="add_url")
 
-except Exception as e:
+except Exception:
     st.error(traceback.format_exc())
diff --git a/code/admin/pages/02_Explore_Data.py b/code/admin/pages/02_Explore_Data.py
index 68952c396..9231371dc 100644
--- a/code/admin/pages/02_Explore_Data.py
+++ b/code/admin/pages/02_Explore_Data.py
@@ -5,13 +5,22 @@
 import logging
 import pandas as pd
 import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 from utilities.helpers.AzureSearchHelper import AzureSearchHelper
 from dotenv import load_dotenv
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
 load_dotenv()
 
-logger = logging.getLogger('azure.core.pipeline.policies.http_logging_policy').setLevel(logging.WARNING)
-st.set_page_config(page_title="Explore Data", page_icon=os.path.join('images','favicon.ico'), layout="wide", menu_items=None)
+logger = logging.getLogger("azure.core.pipeline.policies.http_logging_policy").setLevel(
+    logging.WARNING
+)
+st.set_page_config(
+    page_title="Explore Data",
+    page_icon=os.path.join("images", "favicon.ico"),
+    layout="wide",
+    menu_items=None,
+)
 mod_page_style = """
             <style>
             #MainMenu {visibility: hidden;}
@@ -34,20 +43,25 @@
 
 
 try:
-    vector_store_helper : AzureSearchHelper = AzureSearchHelper()
+    vector_store_helper: AzureSearchHelper = AzureSearchHelper()
     search_client = vector_store_helper.get_vector_store().client
     # get unique document names by getting facets for title field
     results = search_client.search("*", facets=["title"])
-    unique_files = [filename['value'] for filename in results.get_facets()["title"]]
-    filename = st.selectbox('Select your file:', unique_files)
-    st.write('Showing chunks for:', filename)
-    
-    results = search_client.search("*", select="title, content, metadata", filter=f"title eq '{filename}'")
-    
-    data = [[json.loads(result['metadata'])['chunk'], result['content']] for result in results]
-    df = pd.DataFrame(data, columns=('Chunk', 'Content')).sort_values(by=['Chunk'])           
+    unique_files = [filename["value"] for filename in results.get_facets()["title"]]
+    filename = st.selectbox("Select your file:", unique_files)
+    st.write("Showing chunks for:", filename)
+
+    results = search_client.search(
+        "*", select="title, content, metadata", filter=f"title eq '{filename}'"
+    )
+
+    data = [
+        [json.loads(result["metadata"])["chunk"], result["content"]]
+        for result in results
+    ]
+    df = pd.DataFrame(data, columns=("Chunk", "Content")).sort_values(by=["Chunk"])
     st.table(df)
-    
 
-except Exception as e:
+
+except Exception:
     st.error(traceback.format_exc())
diff --git a/code/admin/pages/03_Delete_Data.py b/code/admin/pages/03_Delete_Data.py
index 811eb87a9..993804a62 100644
--- a/code/admin/pages/03_Delete_Data.py
+++ b/code/admin/pages/03_Delete_Data.py
@@ -3,13 +3,23 @@
 import traceback
 import logging
 import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
 from utilities.helpers.AzureSearchHelper import AzureSearchHelper
 from dotenv import load_dotenv
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
 load_dotenv()
 
-logger = logging.getLogger('azure.core.pipeline.policies.http_logging_policy').setLevel(logging.WARNING)
-st.set_page_config(page_title="Delete Data", page_icon=os.path.join('images','favicon.ico'), layout="wide", menu_items=None)
+logger = logging.getLogger("azure.core.pipeline.policies.http_logging_policy").setLevel(
+    logging.WARNING
+)
+st.set_page_config(
+    page_title="Delete Data",
+    page_icon=os.path.join("images", "favicon.ico"),
+    layout="wide",
+    menu_items=None,
+)
 mod_page_style = """
             <style>
             #MainMenu {visibility: hidden;}
@@ -30,9 +40,11 @@
 # Inject CSS with Markdown
 st.markdown(hide_table_row_index, unsafe_allow_html=True)
 
+
 def get_files():
     return search_client.search("*", select="id, title", include_total_count=True)
 
+
 def output_results(results):
     files = {}
     if results.get_count() == 0:
@@ -42,8 +54,8 @@ def output_results(results):
         st.write("Select files to delete:")
 
     for result in results:
-        id = result['id']
-        filename = result['title']
+        id = result["id"]
+        filename = result["title"]
         if filename in files:
             files[filename].append(id)
         else:
@@ -56,22 +68,23 @@ def output_results(results):
 def delete_files(files):
     ids_to_delete = []
     files_to_delete = []
-    
+
     for filename, ids in files.items():
         if st.session_state[filename]:
             files_to_delete.append(filename)
-            ids_to_delete += [{'id': id} for id in ids]
+            ids_to_delete += [{"id": id} for id in ids]
 
     if len(ids_to_delete) == 0:
         st.info("No files selected")
         st.stop()
-    
+
     search_client.delete_documents(ids_to_delete)
 
-    st.success('Deleted files: ' + str(files_to_delete))
+    st.success("Deleted files: " + str(files_to_delete))
+
 
 try:
-    vector_store_helper : AzureSearchHelper = AzureSearchHelper()
+    vector_store_helper: AzureSearchHelper = AzureSearchHelper()
     search_client = vector_store_helper.get_vector_store().client
 
     results = get_files()
@@ -81,5 +94,5 @@ def delete_files(files):
         with st.spinner("Deleting files..."):
             delete_files(files)
 
-except Exception as e:
+except Exception:
     st.error(traceback.format_exc())
diff --git a/code/admin/pages/04_Configuration.py b/code/admin/pages/04_Configuration.py
index 49b663fcd..09e604d94 100644
--- a/code/admin/pages/04_Configuration.py
+++ b/code/admin/pages/04_Configuration.py
@@ -1,17 +1,25 @@
 import streamlit as st
 import os
-import json
 import traceback
 import logging
 from dotenv import load_dotenv
 import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
 from utilities.helpers.ConfigHelper import ConfigHelper
 
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
 load_dotenv()
 
-logger = logging.getLogger('azure.core.pipeline.policies.http_logging_policy').setLevel(logging.WARNING)
-st.set_page_config(page_title="Configure Prompts", page_icon=os.path.join('images','favicon.ico'), layout="wide", menu_items=None)
+logger = logging.getLogger("azure.core.pipeline.policies.http_logging_policy").setLevel(
+    logging.WARNING
+)
+st.set_page_config(
+    page_title="Configure Prompts",
+    page_icon=os.path.join("images", "favicon.ico"),
+    layout="wide",
+    menu_items=None,
+)
 
 mod_page_style = """
             <style>
@@ -27,54 +35,72 @@
 # Populate all fields from Config values
 # # # if 'condense_question_prompt' not in st.session_state:
 # # #     st.session_state['condense_question_prompt'] = config.prompts.condense_question_prompt
-if 'answering_prompt' not in st.session_state:
-    st.session_state['answering_prompt'] = config.prompts.answering_prompt
-if 'post_answering_prompt' not in st.session_state:
-    st.session_state['post_answering_prompt'] = config.prompts.post_answering_prompt
-if 'enable_post_answering_prompt' not in st.session_state:
-    st.session_state['enable_post_answering_prompt'] = config.prompts.enable_post_answering_prompt
-if 'post_answering_filter_message' not in st.session_state:
-    st.session_state['post_answering_filter_message'] = config.messages.post_answering_filter
-if 'enable_content_safety' not in st.session_state:
-    st.session_state['enable_content_safety'] = config.prompts.enable_content_safety
-    
-if 'log_user_interactions' not in st.session_state:
-    st.session_state['log_user_interactions'] = config.logging.log_user_interactions
-if 'log_tokens' not in st.session_state:
-    st.session_state['log_tokens'] = config.logging.log_tokens
-    
-if 'orchestrator_strategy' not in st.session_state:
-    st.session_state['orchestrator_strategy'] = config.orchestrator.strategy.value
-    
-    
+if "answering_prompt" not in st.session_state:
+    st.session_state["answering_prompt"] = config.prompts.answering_prompt
+if "post_answering_prompt" not in st.session_state:
+    st.session_state["post_answering_prompt"] = config.prompts.post_answering_prompt
+if "enable_post_answering_prompt" not in st.session_state:
+    st.session_state[
+        "enable_post_answering_prompt"
+    ] = config.prompts.enable_post_answering_prompt
+if "post_answering_filter_message" not in st.session_state:
+    st.session_state[
+        "post_answering_filter_message"
+    ] = config.messages.post_answering_filter
+if "enable_content_safety" not in st.session_state:
+    st.session_state["enable_content_safety"] = config.prompts.enable_content_safety
+
+if "log_user_interactions" not in st.session_state:
+    st.session_state["log_user_interactions"] = config.logging.log_user_interactions
+if "log_tokens" not in st.session_state:
+    st.session_state["log_tokens"] = config.logging.log_tokens
+
+if "orchestrator_strategy" not in st.session_state:
+    st.session_state["orchestrator_strategy"] = config.orchestrator.strategy.value
+
+
 # # # def validate_question_prompt():
 # # #     if "{chat_history}" not in st.session_state.condense_question_prompt:
 # # #         st.warning("Your condense question prompt doesn't contain the variable `{chat_history}`")
 # # #     if "{question}" not in st.session_state.condense_question_prompt:
 # # #         st.warning("Your condense question prompt doesn't contain the variable `{question}`")
 
+
 def validate_answering_prompt():
     if "{sources}" not in st.session_state.answering_prompt:
         st.warning("Your answering prompt doesn't contain the variable `{sources}`")
     if "{question}" not in st.session_state.answering_prompt:
         st.warning("Your answering prompt doesn't contain the variable `{question}`")
-        
+
+
 def validate_post_answering_prompt():
-    if "post_answering_prompt" not in st.session_state or len(st.session_state.post_answering_prompt) == 0:
+    if (
+        "post_answering_prompt" not in st.session_state
+        or len(st.session_state.post_answering_prompt) == 0
+    ):
         pass
     if "{sources}" not in st.session_state.post_answering_prompt:
-        st.warning("Your post answering prompt doesn't contain the variable `{sources}`")
+        st.warning(
+            "Your post answering prompt doesn't contain the variable `{sources}`"
+        )
     if "{question}" not in st.session_state.post_answering_prompt:
-        st.warning("Your post answering prompt doesn't contain the variable `{question}`")
+        st.warning(
+            "Your post answering prompt doesn't contain the variable `{question}`"
+        )
     if "{answer}" not in st.session_state.post_answering_prompt:
         st.warning("Your post answering prompt doesn't contain the variable `{answer}`")
 
-try:  
+
+try:
     with st.expander("Orchestrator configuration", expanded=True):
-        cols = st.columns([2,4])
+        cols = st.columns([2, 4])
         with cols[0]:
-            st.selectbox("Orchestrator strategy", key='orchestrator_strategy' ,options=config.get_available_orchestration_strategies())
-    
+            st.selectbox(
+                "Orchestrator strategy",
+                key="orchestrator_strategy",
+                options=config.get_available_orchestration_strategies(),
+            )
+
     # # # condense_question_prompt_help = "This prompt is used to convert the user's input to a standalone question, using the context of the chat history."
     answering_prompt_help = "This prompt is used to answer the user's question, using the sources that were retrieved from the knowledge base."
     post_answering_prompt_help = "You can configure a post prompt that allows to fact-check or process the answer, given the sources, question and answer. This prompt needs to return `True` or `False`."
@@ -82,79 +108,109 @@ def validate_post_answering_prompt():
 
     with st.expander("Prompt configuration", expanded=True):
         # # # st.text_area("Condense question prompt", key='condense_question_prompt', on_change=validate_question_prompt, help=condense_question_prompt_help, height=200)
-        st.text_area("Answering prompt", key='answering_prompt', on_change=validate_answering_prompt, help=answering_prompt_help, height=400)
-
-        st.text_area("Post-answering prompt", key='post_answering_prompt', on_change=validate_post_answering_prompt, help=post_answering_prompt_help, height=200)
-        st.checkbox('Enable post-answering prompt', key='enable_post_answering_prompt')
-        st.text_area("Post-answering filter message", key='post_answering_filter_message', help=post_answering_filter_help, height=200)
-        
-        st.checkbox('Enable Azure AI Content Safety', key='enable_content_safety')
-
-    
-    document_processors = list(map(lambda x: {
-        "document_type": x.document_type, 
-        "chunking_strategy": x.chunking.chunking_strategy.value, 
-        "chunking_size": x.chunking.chunk_size,
-        "chunking_overlap": x.chunking.chunk_overlap, 
-        "loading_strategy": x.loading.loading_strategy.value,
-        }, config.document_processors))
+        st.text_area(
+            "Answering prompt",
+            key="answering_prompt",
+            on_change=validate_answering_prompt,
+            help=answering_prompt_help,
+            height=400,
+        )
+
+        st.text_area(
+            "Post-answering prompt",
+            key="post_answering_prompt",
+            on_change=validate_post_answering_prompt,
+            help=post_answering_prompt_help,
+            height=200,
+        )
+        st.checkbox("Enable post-answering prompt", key="enable_post_answering_prompt")
+        st.text_area(
+            "Post-answering filter message",
+            key="post_answering_filter_message",
+            help=post_answering_filter_help,
+            height=200,
+        )
+
+        st.checkbox("Enable Azure AI Content Safety", key="enable_content_safety")
+
+    document_processors = list(
+        map(
+            lambda x: {
+                "document_type": x.document_type,
+                "chunking_strategy": x.chunking.chunking_strategy.value,
+                "chunking_size": x.chunking.chunk_size,
+                "chunking_overlap": x.chunking.chunk_overlap,
+                "loading_strategy": x.loading.loading_strategy.value,
+            },
+            config.document_processors,
+        )
+    )
     with st.expander("Document processing configuration", expanded=True):
         edited_document_processors = st.data_editor(
-            data= document_processors,
+            data=document_processors,
             use_container_width=True,
             num_rows="dynamic",
             column_config={
-                "document_type": st.column_config.SelectboxColumn( 
-                    options= config.get_available_document_types()
+                "document_type": st.column_config.SelectboxColumn(
+                    options=config.get_available_document_types()
                 ),
                 "chunking_strategy": st.column_config.SelectboxColumn(
-                    options=[cs for cs in config.get_available_chunking_strategies()  ]
+                    options=[cs for cs in config.get_available_chunking_strategies()]
                 ),
                 "loading_strategy": st.column_config.SelectboxColumn(
                     options=[ls for ls in config.get_available_loading_strategies()]
-                )
-            }         
-         )               
-
-        
-    with st.expander("Logging configuration", expanded=True):       
-        st.checkbox('Log user input and output (questions, answers, chat history, sources)', key='log_user_interactions')
-        st.checkbox('Log tokens', key='log_tokens')
-    
-    if st.button("Save configuration"):
-        document_processors = list(map(lambda x: {
-            "document_type": x["document_type"],
-            "chunking": {
-                "strategy": x["chunking_strategy"],
-                "size": x["chunking_size"],
-                "overlap": x["chunking_overlap"]
+                ),
             },
-            "loading": {
-                "strategy": x["loading_strategy"],
-            }
-            }, edited_document_processors))
+        )
+
+    with st.expander("Logging configuration", expanded=True):
+        st.checkbox(
+            "Log user input and output (questions, answers, chat history, sources)",
+            key="log_user_interactions",
+        )
+        st.checkbox("Log tokens", key="log_tokens")
+
+    if st.button("Save configuration"):
+        document_processors = list(
+            map(
+                lambda x: {
+                    "document_type": x["document_type"],
+                    "chunking": {
+                        "strategy": x["chunking_strategy"],
+                        "size": x["chunking_size"],
+                        "overlap": x["chunking_overlap"],
+                    },
+                    "loading": {
+                        "strategy": x["loading_strategy"],
+                    },
+                },
+                edited_document_processors,
+            )
+        )
         current_config = {
             "prompts": {
-                "condense_question_prompt": "",###st.session_state['condense_question_prompt'],
-                "answering_prompt": st.session_state['answering_prompt'],
-                "post_answering_prompt": st.session_state['post_answering_prompt'],
-                "enable_post_answering_prompt": st.session_state['enable_post_answering_prompt'],
-                "enable_content_safety": st.session_state['enable_content_safety']
+                "condense_question_prompt": "",  # st.session_state['condense_question_prompt'],
+                "answering_prompt": st.session_state["answering_prompt"],
+                "post_answering_prompt": st.session_state["post_answering_prompt"],
+                "enable_post_answering_prompt": st.session_state[
+                    "enable_post_answering_prompt"
+                ],
+                "enable_content_safety": st.session_state["enable_content_safety"],
             },
             "messages": {
-                "post_answering_filter": st.session_state['post_answering_filter_message']
+                "post_answering_filter": st.session_state[
+                    "post_answering_filter_message"
+                ]
             },
-            "document_processors":  document_processors,
+            "document_processors": document_processors,
             "logging": {
-                "log_user_interactions": st.session_state['log_user_interactions'],
-                "log_tokens": st.session_state['log_tokens']
+                "log_user_interactions": st.session_state["log_user_interactions"],
+                "log_tokens": st.session_state["log_tokens"],
             },
-            "orchestrator": {
-                "strategy": st.session_state['orchestrator_strategy']
-            }
+            "orchestrator": {"strategy": st.session_state["orchestrator_strategy"]},
         }
         ConfigHelper.save_config_as_active(current_config)
         st.success("Configuration saved successfully!")
 
-except Exception as e:
+except Exception:
     st.error(traceback.format_exc())
diff --git a/code/app/app.py b/code/app/app.py
index deb08221e..3b92116b7 100644
--- a/code/app/app.py
+++ b/code/app/app.py
@@ -3,45 +3,52 @@
 import logging
 import requests
 import openai
-
-# Fixing MIME types for static files under Windows
 import mimetypes
-
-mimetypes.add_type('application/javascript', '.js')
-mimetypes.add_type('text/css', '.css')
-
 from flask import Flask, Response, request, jsonify
 from dotenv import load_dotenv
 import sys
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
 
-load_dotenv(os.path.join(os.path.dirname(__file__), '..', '..', '.env')) # Load environment variables from .env file
+# Fixing MIME types for static files under Windows
+mimetypes.add_type("application/javascript", ".js")
+mimetypes.add_type("text/css", ".css")
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+
+load_dotenv(
+    os.path.join(os.path.dirname(__file__), "..", "..", ".env")
+)  # Load environment variables from .env file
 
 app = Flask(__name__)
 
+
 @app.route("/", defaults={"path": "index.html"})
 @app.route("/<path:path>")
 def static_file(path):
     return app.send_static_file(path)
 
-@app.route('/api/config', methods=['GET'])
+
+@app.route("/api/config", methods=["GET"])
 def get_config():
     # Retrieve the environment variables or other configuration data
-    azure_speech_key = os.getenv('AZURE_SPEECH_SERVICE_KEY')
-    azure_speech_region = os.getenv('AZURE_SPEECH_SERVICE_REGION')
+    azure_speech_key = os.getenv("AZURE_SPEECH_SERVICE_KEY")
+    azure_speech_region = os.getenv("AZURE_SPEECH_SERVICE_REGION")
 
     # Return the configuration data as JSON
-    return jsonify({
-        'azureSpeechKey': azure_speech_key,
-        'azureSpeechRegion': azure_speech_region
-    })
+    return jsonify(
+        {"azureSpeechKey": azure_speech_key, "azureSpeechRegion": azure_speech_region}
+    )
+
 
 # ACS Integration Settings
 AZURE_SEARCH_SERVICE = os.environ.get("AZURE_SEARCH_SERVICE")
 AZURE_SEARCH_INDEX = os.environ.get("AZURE_SEARCH_INDEX")
 AZURE_SEARCH_KEY = os.environ.get("AZURE_SEARCH_KEY")
-AZURE_SEARCH_USE_SEMANTIC_SEARCH = os.environ.get("AZURE_SEARCH_USE_SEMANTIC_SEARCH", "False")
-AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG = os.environ.get("AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG", "default")
+AZURE_SEARCH_USE_SEMANTIC_SEARCH = os.environ.get(
+    "AZURE_SEARCH_USE_SEMANTIC_SEARCH", "False"
+)
+AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG = os.environ.get(
+    "AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG", "default"
+)
 AZURE_SEARCH_TOP_K = os.environ.get("AZURE_SEARCH_TOP_K", 5)
 AZURE_SEARCH_ENABLE_IN_DOMAIN = os.environ.get("AZURE_SEARCH_ENABLE_IN_DOMAIN", "true")
 AZURE_SEARCH_CONTENT_COLUMNS = os.environ.get("AZURE_SEARCH_CONTENT_COLUMNS")
@@ -57,24 +64,34 @@ def get_config():
 AZURE_OPENAI_TOP_P = os.environ.get("AZURE_OPENAI_TOP_P", 1.0)
 AZURE_OPENAI_MAX_TOKENS = os.environ.get("AZURE_OPENAI_MAX_TOKENS", 1000)
 AZURE_OPENAI_STOP_SEQUENCE = os.environ.get("AZURE_OPENAI_STOP_SEQUENCE")
-AZURE_OPENAI_SYSTEM_MESSAGE = os.environ.get("AZURE_OPENAI_SYSTEM_MESSAGE", "You are an AI assistant that helps people find information.")
-AZURE_OPENAI_API_VERSION = os.environ.get("AZURE_OPENAI_API_VERSION", "2023-06-01-preview")
+AZURE_OPENAI_SYSTEM_MESSAGE = os.environ.get(
+    "AZURE_OPENAI_SYSTEM_MESSAGE",
+    "You are an AI assistant that helps people find information.",
+)
+AZURE_OPENAI_API_VERSION = os.environ.get(
+    "AZURE_OPENAI_API_VERSION", "2023-06-01-preview"
+)
 AZURE_OPENAI_STREAM = os.environ.get("AZURE_OPENAI_STREAM", "true")
-AZURE_OPENAI_MODEL_NAME = os.environ.get("AZURE_OPENAI_MODEL_NAME", "gpt-35-turbo") # Name of the model, e.g. 'gpt-35-turbo' or 'gpt-4'
+AZURE_OPENAI_MODEL_NAME = os.environ.get(
+    "AZURE_OPENAI_MODEL_NAME", "gpt-35-turbo"
+)  # Name of the model, e.g. 'gpt-35-turbo' or 'gpt-4'
 AZURE_AUTH_TYPE = os.environ.get("AZURE_AUTH_TYPE", "keys")
 
 SHOULD_STREAM = True if AZURE_OPENAI_STREAM.lower() == "true" else False
 
+
 def is_chat_model():
-    if 'gpt-4' in AZURE_OPENAI_MODEL_NAME.lower():
+    if "gpt-4" in AZURE_OPENAI_MODEL_NAME.lower():
         return True
     return False
 
+
 def should_use_data():
     if AZURE_SEARCH_SERVICE and AZURE_SEARCH_INDEX and AZURE_SEARCH_KEY:
         return True
     return False
 
+
 def prepare_body_headers_with_data(request):
     request_messages = request.json["messages"]
 
@@ -83,7 +100,9 @@ def prepare_body_headers_with_data(request):
         "temperature": AZURE_OPENAI_TEMPERATURE,
         "max_tokens": AZURE_OPENAI_MAX_TOKENS,
         "top_p": AZURE_OPENAI_TOP_P,
-        "stop": AZURE_OPENAI_STOP_SEQUENCE.split("|") if AZURE_OPENAI_STOP_SEQUENCE else None,
+        "stop": AZURE_OPENAI_STOP_SEQUENCE.split("|")
+        if AZURE_OPENAI_STOP_SEQUENCE
+        else None,
         "stream": SHOULD_STREAM,
         "dataSources": [
             {
@@ -93,19 +112,34 @@ def prepare_body_headers_with_data(request):
                     "key": AZURE_SEARCH_KEY,
                     "indexName": AZURE_SEARCH_INDEX,
                     "fieldsMapping": {
-                        "contentField": AZURE_SEARCH_CONTENT_COLUMNS.split("|") if AZURE_SEARCH_CONTENT_COLUMNS else [],
-                        "titleField": AZURE_SEARCH_TITLE_COLUMN if AZURE_SEARCH_TITLE_COLUMN else None,
-                        "urlField": AZURE_SEARCH_URL_COLUMN if AZURE_SEARCH_URL_COLUMN else None,
-                        "filepathField": AZURE_SEARCH_FILENAME_COLUMN if AZURE_SEARCH_FILENAME_COLUMN else None
+                        "contentField": AZURE_SEARCH_CONTENT_COLUMNS.split("|")
+                        if AZURE_SEARCH_CONTENT_COLUMNS
+                        else [],
+                        "titleField": AZURE_SEARCH_TITLE_COLUMN
+                        if AZURE_SEARCH_TITLE_COLUMN
+                        else None,
+                        "urlField": AZURE_SEARCH_URL_COLUMN
+                        if AZURE_SEARCH_URL_COLUMN
+                        else None,
+                        "filepathField": AZURE_SEARCH_FILENAME_COLUMN
+                        if AZURE_SEARCH_FILENAME_COLUMN
+                        else None,
                     },
-                    "inScope": True if AZURE_SEARCH_ENABLE_IN_DOMAIN.lower() == "true" else False,
+                    "inScope": True
+                    if AZURE_SEARCH_ENABLE_IN_DOMAIN.lower() == "true"
+                    else False,
                     "topNDocuments": AZURE_SEARCH_TOP_K,
-                    "queryType": "semantic" if AZURE_SEARCH_USE_SEMANTIC_SEARCH.lower() == "true" else "simple",
-                    "semanticConfiguration": AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG if AZURE_SEARCH_USE_SEMANTIC_SEARCH.lower() == "true" and AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG else "",
-                    "roleInformation": AZURE_OPENAI_SYSTEM_MESSAGE
-                }
+                    "queryType": "semantic"
+                    if AZURE_SEARCH_USE_SEMANTIC_SEARCH.lower() == "true"
+                    else "simple",
+                    "semanticConfiguration": AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG
+                    if AZURE_SEARCH_USE_SEMANTIC_SEARCH.lower() == "true"
+                    and AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG
+                    else "",
+                    "roleInformation": AZURE_OPENAI_SYSTEM_MESSAGE,
+                },
             }
-        ]
+        ],
     }
 
     chatgpt_url = f"https://{AZURE_OPENAI_RESOURCE}.openai.azure.com/openai/deployments/{AZURE_OPENAI_MODEL}"
@@ -115,11 +149,11 @@ def prepare_body_headers_with_data(request):
         chatgpt_url += "/completions?api-version=2023-03-15-preview"
 
     headers = {
-        'Content-Type': 'application/json',
-        'api-key': AZURE_OPENAI_KEY,
-        'chatgpt_url': chatgpt_url,
-        'chatgpt_key': AZURE_OPENAI_KEY,
-        "x-ms-useragent": "GitHubSampleWebApp/PublicAPI/1.0.0"
+        "Content-Type": "application/json",
+        "api-key": AZURE_OPENAI_KEY,
+        "chatgpt_url": chatgpt_url,
+        "chatgpt_key": AZURE_OPENAI_KEY,
+        "x-ms-useragent": "GitHubSampleWebApp/PublicAPI/1.0.0",
     }
 
     return body, headers
@@ -132,16 +166,14 @@ def stream_with_data(body, headers, endpoint):
         "model": "",
         "created": 0,
         "object": "",
-        "choices": [{
-            "messages": []
-        }]
+        "choices": [{"messages": []}],
     }
     try:
         with s.post(endpoint, json=body, headers=headers, stream=True) as r:
             for line in r.iter_lines(chunk_size=10):
                 if line:
-                    lineJson = json.loads(line.lstrip(b'data:').decode('utf-8'))
-                    if 'error' in lineJson:
+                    lineJson = json.loads(line.lstrip(b"data:").decode("utf-8"))
+                    if "error" in lineJson:
                         yield json.dumps(lineJson).replace("\n", "\\n") + "\n"
                     response["id"] = lineJson["id"]
                     response["model"] = lineJson["model"]
@@ -150,16 +182,21 @@ def stream_with_data(body, headers, endpoint):
 
                     role = lineJson["choices"][0]["messages"][0]["delta"].get("role")
                     if role == "tool":
-                        response["choices"][0]["messages"].append(lineJson["choices"][0]["messages"][0]["delta"])
+                        response["choices"][0]["messages"].append(
+                            lineJson["choices"][0]["messages"][0]["delta"]
+                        )
                     elif role == "assistant":
-                        response["choices"][0]["messages"].append({
-                            "role": "assistant",
-                            "content": ""
-                        })
+                        response["choices"][0]["messages"].append(
+                            {"role": "assistant", "content": ""}
+                        )
                     else:
-                        deltaText = lineJson["choices"][0]["messages"][0]["delta"]["content"]
+                        deltaText = lineJson["choices"][0]["messages"][0]["delta"][
+                            "content"
+                        ]
                         if deltaText != "[DONE]":
-                            response["choices"][0]["messages"][1]["content"] += deltaText
+                            response["choices"][0]["messages"][1][
+                                "content"
+                            ] += deltaText
 
                     yield json.dumps(response).replace("\n", "\\n") + "\n"
     except Exception as e:
@@ -178,14 +215,18 @@ def conversation_with_data(request):
         return Response(json.dumps(r).replace("\n", "\\n"), status=status_code)
     else:
         if request.method == "POST":
-            return Response(stream_with_data(body, headers, endpoint), mimetype="application/json-lines")
+            return Response(
+                stream_with_data(body, headers, endpoint),
+                mimetype="application/json-lines",
+            )
         else:
             return Response(None, mimetype="application/json-lines")
 
+
 def stream_without_data(response):
     responseText = ""
     for line in response:
-        deltaText = line["choices"][0]["delta"].get('content')
+        deltaText = line["choices"][0]["delta"].get("content")
         if deltaText and deltaText != "[DONE]":
             responseText += deltaText
 
@@ -194,12 +235,7 @@ def stream_without_data(response):
             "model": line["model"],
             "created": line["created"],
             "object": line["object"],
-            "choices": [{
-                "messages": [{
-                    "role": "assistant",
-                    "content": responseText
-                }]
-            }]
+            "choices": [{"messages": [{"role": "assistant", "content": responseText}]}],
         }
         yield json.dumps(response_obj).replace("\n", "\\n") + "\n"
 
@@ -211,27 +247,21 @@ def conversation_without_data(request):
     openai.api_key = AZURE_OPENAI_KEY
 
     request_messages = request.json["messages"]
-    messages = [
-        {
-            "role": "system",
-            "content": AZURE_OPENAI_SYSTEM_MESSAGE
-        }
-    ]
+    messages = [{"role": "system", "content": AZURE_OPENAI_SYSTEM_MESSAGE}]
 
     for message in request_messages:
-        messages.append({
-            "role": message["role"] ,
-            "content": message["content"]
-        })
+        messages.append({"role": message["role"], "content": message["content"]})
 
     response = openai.ChatCompletion.create(
         engine=AZURE_OPENAI_MODEL,
-        messages = messages,
+        messages=messages,
         temperature=float(AZURE_OPENAI_TEMPERATURE),
         max_tokens=int(AZURE_OPENAI_MAX_TOKENS),
         top_p=float(AZURE_OPENAI_TOP_P),
-        stop=AZURE_OPENAI_STOP_SEQUENCE.split("|") if AZURE_OPENAI_STOP_SEQUENCE else None,
-        stream=SHOULD_STREAM
+        stop=AZURE_OPENAI_STOP_SEQUENCE.split("|")
+        if AZURE_OPENAI_STOP_SEQUENCE
+        else None,
+        stream=SHOULD_STREAM,
     )
 
     if not SHOULD_STREAM:
@@ -240,21 +270,28 @@ def conversation_without_data(request):
             "model": response.model,
             "created": response.created,
             "object": response.object,
-            "choices": [{
-                "messages": [{
-                    "role": "assistant",
-                    "content": response.choices[0].message.content
-                }]
-            }]
+            "choices": [
+                {
+                    "messages": [
+                        {
+                            "role": "assistant",
+                            "content": response.choices[0].message.content,
+                        }
+                    ]
+                }
+            ],
         }
 
         return jsonify(response_obj), 200
     else:
         if request.method == "POST":
-            return Response(stream_without_data(response), mimetype="application/json-lines")
+            return Response(
+                stream_without_data(response), mimetype="application/json-lines"
+            )
         else:
             return Response(None, mimetype="application/json-lines")
 
+
 @app.route("/api/conversation/azure_byod", methods=["GET", "POST"])
 def conversation_azure_byod():
     try:
@@ -266,32 +303,55 @@ def conversation_azure_byod():
     except Exception as e:
         errorMessage = str(e)
         logging.exception(f"Exception in /api/conversation/azure_byod | {errorMessage}")
-        return jsonify({"error": "Exception in /api/conversation/azure_byod. See log for more details."}), 500
+        return (
+            jsonify(
+                {
+                    "error": "Exception in /api/conversation/azure_byod. See log for more details."
+                }
+            ),
+            500,
+        )
+
 
-@app.route("/api/conversation/custom", methods=["GET","POST"])
+@app.route("/api/conversation/custom", methods=["GET", "POST"])
 def conversation_custom():
-    from utilities.helpers.OrchestratorHelper import Orchestrator, OrchestrationSettings
+    from utilities.helpers.OrchestratorHelper import Orchestrator
+
     message_orchestrator = Orchestrator()
 
     try:
-        user_message = request.json["messages"][-1]['content']
+        user_message = request.json["messages"][-1]["content"]
         conversation_id = request.json["conversation_id"]
-        user_assistant_messages = list(filter(lambda x: x['role'] in ('user','assistant'), request.json["messages"][0:-1]))
+        user_assistant_messages = list(
+            filter(
+                lambda x: x["role"] in ("user", "assistant"),
+                request.json["messages"][0:-1],
+            )
+        )
         chat_history = []
-        for i,k in enumerate(user_assistant_messages):
+        for i, k in enumerate(user_assistant_messages):
             if i % 2 == 0:
-                chat_history.append((user_assistant_messages[i]['content'],user_assistant_messages[i+1]['content']))
+                chat_history.append(
+                    (
+                        user_assistant_messages[i]["content"],
+                        user_assistant_messages[i + 1]["content"],
+                    )
+                )
         from utilities.helpers.ConfigHelper import ConfigHelper
-        messages = message_orchestrator.handle_message(user_message=user_message, chat_history=chat_history, conversation_id=conversation_id, orchestrator=ConfigHelper.get_active_config_or_default().orchestrator)
+
+        messages = message_orchestrator.handle_message(
+            user_message=user_message,
+            chat_history=chat_history,
+            conversation_id=conversation_id,
+            orchestrator=ConfigHelper.get_active_config_or_default().orchestrator,
+        )
 
         response_obj = {
             "id": "response.id",
             "model": os.getenv("AZURE_OPENAI_MODEL"),
             "created": "response.created",
             "object": "response.object",
-            "choices": [{
-                "messages": messages
-            }]
+            "choices": [{"messages": messages}],
         }
 
         return jsonify(response_obj), 200
@@ -299,6 +359,15 @@ def conversation_custom():
     except Exception as e:
         errorMessage = str(e)
         logging.exception(f"Exception in /api/conversation/custom | {errorMessage}")
-        return jsonify({"error": "Exception in /api/conversation/custom. See log for more details."}), 500
+        return (
+            jsonify(
+                {
+                    "error": "Exception in /api/conversation/custom. See log for more details."
+                }
+            ),
+            500,
+        )
+
+
 if __name__ == "__main__":
     app.run()
diff --git a/code/batch/AddURLEmbeddings.py b/code/batch/AddURLEmbeddings.py
index 4bed5bdae..69fa1c7a2 100644
--- a/code/batch/AddURLEmbeddings.py
+++ b/code/batch/AddURLEmbeddings.py
@@ -1,41 +1,48 @@
-import logging, traceback
+import logging
+import traceback
 import azure.functions as func
 import sys
-sys.path.append("..")
+
 from utilities.helpers.DocumentProcessorHelper import DocumentProcessor
 from utilities.helpers.ConfigHelper import ConfigHelper
 
-bp_add_url_embeddings = func.Blueprint() 
+sys.path.append("..")
+
+bp_add_url_embeddings = func.Blueprint()
+
 
 @bp_add_url_embeddings.route(route="AddURLEmbeddings")
 def add_url_embeddings(req: func.HttpRequest) -> func.HttpResponse:
-    logging.info('Python HTTP trigger function processed a request.')
+    logging.info("Python HTTP trigger function processed a request.")
     # Get Url from request
-    url = req.params.get('url')
+    url = req.params.get("url")
     if not url:
         try:
             req_body = req.get_json()
         except ValueError:
             pass
         else:
-            url = req_body.get('url')
-    # Check if url is present, compute embeddings and add them to VectorStore     
+            url = req_body.get("url")
+    # Check if url is present, compute embeddings and add them to VectorStore
     if url:
         try:
             config = ConfigHelper.get_active_config_or_default()
             document_processor = DocumentProcessor()
-            processors = list(filter(lambda x : x.document_type == "url" , config.document_processors))
+            processors = list(
+                filter(lambda x: x.document_type == "url", config.document_processors)
+            )
             document_processor.process(source_url=url, processors=processors)
-        except Exception as e:
+        except Exception:
             return func.HttpResponse(
-                f"Error: {traceback.format_exc()}",
-                status_code=500)
-        
+                f"Error: {traceback.format_exc()}", status_code=500
+            )
+
         return func.HttpResponse(
-            f"Embeddings added successfully for {url}",
-            status_code=200)
-        
+            f"Embeddings added successfully for {url}", status_code=200
+        )
+
     else:
         return func.HttpResponse(
             "Please pass a url on the query string or in the request body",
-            status_code=400)
+            status_code=400,
+        )
diff --git a/code/batch/BatchPushResults.py b/code/batch/BatchPushResults.py
index f84b758c2..33c62bf4d 100644
--- a/code/batch/BatchPushResults.py
+++ b/code/batch/BatchPushResults.py
@@ -1,22 +1,36 @@
-import logging, json
+import logging
+import json
 import azure.functions as func
 from urllib.parse import urlparse
 import sys
-sys.path.append("..")
+
 from utilities.helpers.AzureBlobStorageHelper import AzureBlobStorageClient
 from utilities.helpers.DocumentProcessorHelper import DocumentProcessor
 from utilities.helpers.ConfigHelper import ConfigHelper
 
+sys.path.append("..")
+
 bp_batch_push_results = func.Blueprint()
 
+
 def _get_file_name_from_message(msg: func.QueueMessage) -> str:
-    message_body = json.loads(msg.get_body().decode('utf-8'))
-    return message_body.get('filename', "/".join(urlparse(message_body.get('data', {}).get('url', '')).path.split('/')[2:]))
+    message_body = json.loads(msg.get_body().decode("utf-8"))
+    return message_body.get(
+        "filename",
+        "/".join(
+            urlparse(message_body.get("data", {}).get("url", "")).path.split("/")[2:]
+        ),
+    )
+
 
-@bp_batch_push_results.queue_trigger(arg_name='msg', queue_name='doc-processing', connection='AzureWebJobsStorage')
+@bp_batch_push_results.queue_trigger(
+    arg_name="msg", queue_name="doc-processing", connection="AzureWebJobsStorage"
+)
 def batch_push_results(msg: func.QueueMessage) -> None:
-    logging.info('Python queue trigger function processed a queue item: %s',
-                 msg.get_body().decode('utf-8'))
+    logging.info(
+        "Python queue trigger function processed a queue item: %s",
+        msg.get_body().decode("utf-8"),
+    )
     document_processor = DocumentProcessor()
     blob_client = AzureBlobStorageClient()
     # Get the file name from the message
@@ -25,7 +39,12 @@ def batch_push_results(msg: func.QueueMessage) -> None:
     file_sas = blob_client.get_blob_sas(file_name)
     # Get file extension's processors
     file_extension = file_name.split(".")[-1]
-    processors = list(filter(lambda x: x.document_type.lower() == file_extension.lower(), ConfigHelper.get_active_config_or_default().document_processors))
+    processors = list(
+        filter(
+            lambda x: x.document_type.lower() == file_extension.lower(),
+            ConfigHelper.get_active_config_or_default().document_processors,
+        )
+    )
     # Process the file
     document_processor.process(source_url=file_sas, processors=processors)
-    blob_client.upsert_blob_metadata(file_name, {'embeddings_added': 'true'})
+    blob_client.upsert_blob_metadata(file_name, {"embeddings_added": "true"})
diff --git a/code/batch/BatchStartProcessing.py b/code/batch/BatchStartProcessing.py
index ae6f0897e..1a1ce5e87 100644
--- a/code/batch/BatchStartProcessing.py
+++ b/code/batch/BatchStartProcessing.py
@@ -1,28 +1,44 @@
-import logging, json, os
+import logging
+import json
+import os
 import azure.functions as func
-from azure.storage.queue import QueueClient, BinaryBase64EncodePolicy
 import sys
-sys.path.append("..")
+from azure.storage.queue import QueueClient, BinaryBase64EncodePolicy
 from utilities.helpers.AzureBlobStorageHelper import AzureBlobStorageClient
 
+sys.path.append("..")
 bp_batch_start_processing = func.Blueprint()
 
-DOCUMENT_PROCESSING_QUEUE_NAME = os.getenv('DOCUMENT_PROCESSING_QUEUE_NAME', 'doc-processing')
+DOCUMENT_PROCESSING_QUEUE_NAME = os.getenv(
+    "DOCUMENT_PROCESSING_QUEUE_NAME", "doc-processing"
+)
+
 
 @bp_batch_start_processing.route(route="BatchStartProcessing")
 def batch_start_processing(req: func.HttpRequest) -> func.HttpResponse:
-    logging.info('Requested to start processing all documents received')
+    logging.info("Requested to start processing all documents received")
     # Set up Blob Storage Client
     azure_blob_storage_client = AzureBlobStorageClient()
     # Get all files from Blob Storage
     files_data = azure_blob_storage_client.get_all_files()
     # Filter out files that have already been processed
-    files_data = list(filter(lambda x : not x['embeddings_added'], files_data)) if req.params.get('process_all') != 'true' else files_data
-    files_data = list(map(lambda x: {'filename': x['filename']}, files_data))
+    files_data = (
+        list(filter(lambda x: not x["embeddings_added"], files_data))
+        if req.params.get("process_all") != "true"
+        else files_data
+    )
+    files_data = list(map(lambda x: {"filename": x["filename"]}, files_data))
     # Create the QueueClient object
-    queue_client = QueueClient.from_connection_string(azure_blob_storage_client.connect_str, DOCUMENT_PROCESSING_QUEUE_NAME, message_encode_policy=BinaryBase64EncodePolicy())
+    queue_client = QueueClient.from_connection_string(
+        azure_blob_storage_client.connect_str,
+        DOCUMENT_PROCESSING_QUEUE_NAME,
+        message_encode_policy=BinaryBase64EncodePolicy(),
+    )
     # Send a message to the queue for each file
     for fd in files_data:
-        queue_client.send_message(json.dumps(fd).encode('utf-8'))
- 
-    return func.HttpResponse(f"Conversion started successfully for {len(files_data)} documents.", status_code=200)
\ No newline at end of file
+        queue_client.send_message(json.dumps(fd).encode("utf-8"))
+
+    return func.HttpResponse(
+        f"Conversion started successfully for {len(files_data)} documents.",
+        status_code=200,
+    )
diff --git a/code/batch/function_app.py b/code/batch/function_app.py
index 83dbee193..fb8e84ce9 100644
--- a/code/batch/function_app.py
+++ b/code/batch/function_app.py
@@ -3,7 +3,9 @@
 from BatchPushResults import bp_batch_push_results
 from BatchStartProcessing import bp_batch_start_processing
 
-app = func.FunctionApp(http_auth_level=func.AuthLevel.FUNCTION) # change to ANONYMOUS for local debugging
+app = func.FunctionApp(
+    http_auth_level=func.AuthLevel.FUNCTION
+)  # change to ANONYMOUS for local debugging
 app.register_functions(bp_add_url_embeddings)
 app.register_functions(bp_batch_push_results)
 app.register_functions(bp_batch_start_processing)
diff --git a/code/utilities/common/Answer.py b/code/utilities/common/Answer.py
index 7d534b183..33222c64e 100644
--- a/code/utilities/common/Answer.py
+++ b/code/utilities/common/Answer.py
@@ -2,41 +2,52 @@
 from typing import List, Optional
 from .SourceDocument import SourceDocument
 
+
 class Answer:
-    def __init__(self, question: str, answer: str, source_documents: List[SourceDocument] = [], prompt_tokens: Optional[int] = 0, completion_tokens: Optional[int] = 0):
+    def __init__(
+        self,
+        question: str,
+        answer: str,
+        source_documents: List[SourceDocument] = [],
+        prompt_tokens: Optional[int] = 0,
+        completion_tokens: Optional[int] = 0,
+    ):
         self.question = question
         self.answer = answer
         self.source_documents = source_documents
         self.prompt_tokens = prompt_tokens
         self.completion_tokens = completion_tokens
-        
+
     def to_json(self):
         return json.dumps(self, cls=AnswerEncoder)
-    
+
     @classmethod
     def from_json(cls, json_string):
         return json.loads(json_string, cls=AnswerDecoder)
 
+
 class AnswerEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, Answer):
             return {
-                'question': obj.question,
-                'answer': obj.answer,
-                'source_documents': [doc.to_json() for doc in obj.source_documents],
-                'prompt_tokens': obj.prompt_tokens,
-                'completion_tokens': obj.completion_tokens
+                "question": obj.question,
+                "answer": obj.answer,
+                "source_documents": [doc.to_json() for doc in obj.source_documents],
+                "prompt_tokens": obj.prompt_tokens,
+                "completion_tokens": obj.completion_tokens,
             }
         return super().default(obj)
-    
+
+
 class AnswerDecoder(json.JSONDecoder):
     def decode(self, s, **kwargs):
         obj = super().decode(s, **kwargs)
         return Answer(
-            question=obj['question'],
-            answer=obj['answer'],
-            source_documents=[SourceDocument.from_json(doc) for doc in obj['source_documents']],
-            prompt_tokens=obj['prompt_tokens'],
-            completion_tokens=obj['completion_tokens']
+            question=obj["question"],
+            answer=obj["answer"],
+            source_documents=[
+                SourceDocument.from_json(doc) for doc in obj["source_documents"]
+            ],
+            prompt_tokens=obj["prompt_tokens"],
+            completion_tokens=obj["completion_tokens"],
         )
-    
\ No newline at end of file
diff --git a/code/utilities/common/SourceDocument.py b/code/utilities/common/SourceDocument.py
index f03b08e37..840a823ed 100644
--- a/code/utilities/common/SourceDocument.py
+++ b/code/utilities/common/SourceDocument.py
@@ -4,8 +4,18 @@
 from urllib.parse import urlparse, quote
 from ..helpers.AzureBlobStorageHelper import AzureBlobStorageClient
 
+
 class SourceDocument:
-    def __init__(self, content: str, source: str, id: Optional[str] = None, title: Optional[str]= None, chunk: Optional[int] = None, offset: Optional[int] = None, page_number: Optional[int] = None):
+    def __init__(
+        self,
+        content: str,
+        source: str,
+        id: Optional[str] = None,
+        title: Optional[str] = None,
+        chunk: Optional[int] = None,
+        offset: Optional[int] = None,
+        page_number: Optional[int] = None,
+    ):
         self.id = id
         self.content = content
         self.source = source
@@ -13,55 +23,60 @@ def __init__(self, content: str, source: str, id: Optional[str] = None, title: O
         self.chunk = chunk
         self.offset = offset
         self.page_number = page_number
-        
+
     def __str__(self):
         return f"SourceDocument(id={self.id}, title={self.title}, source={self.source}, chunk={self.chunk}, offset={self.offset}, page_number={self.page_number})"
-    
+
     def to_json(self):
         return json.dumps(self, cls=SourceDocumentEncoder)
-    
+
     @classmethod
     def from_json(cls, json_string):
         return json.loads(json_string, cls=SourceDocumentDecoder)
-    
+
     @classmethod
     def from_dict(cls, dict_obj):
         return cls(
-            dict_obj['id'],
-            dict_obj['content'],
-            dict_obj['source'],
-            dict_obj['title'],
-            dict_obj['chunk'],
-            dict_obj['offset'],
-            dict_obj['page_number']
+            dict_obj["id"],
+            dict_obj["content"],
+            dict_obj["source"],
+            dict_obj["title"],
+            dict_obj["chunk"],
+            dict_obj["offset"],
+            dict_obj["page_number"],
         )
-    
+
     @classmethod
     def from_metadata(
-        cls: Type['SourceDocument'],
+        cls: Type["SourceDocument"],
         content: str,
         metadata: dict,
         document_url: Optional[str],
         idx: Optional[int],
-    ) -> 'SourceDocument':   
+    ) -> "SourceDocument":
         parsed_url = urlparse(document_url)
-        file_url = parsed_url.scheme + '://' + parsed_url.netloc + parsed_url.path
+        file_url = parsed_url.scheme + "://" + parsed_url.netloc + parsed_url.path
         filename = parsed_url.path
         hash_key = hashlib.sha1(f"{file_url}_{idx}".encode("utf-8")).hexdigest()
         hash_key = f"doc_{hash_key}"
-        sas_placeholder = "_SAS_TOKEN_PLACEHOLDER_" if 'blob.core.windows.net' in parsed_url.netloc else ""
+        sas_placeholder = (
+            "_SAS_TOKEN_PLACEHOLDER_"
+            if "blob.core.windows.net" in parsed_url.netloc
+            else ""
+        )
         return cls(
-            id = metadata.get('id', hash_key),
-            content = content,
-            source = metadata.get('source', f"{file_url}{sas_placeholder}"),
-            title = metadata.get('title', filename),
-            chunk = metadata.get('chunk', idx),
-            offset = metadata.get('offset'),
-            page_number = metadata.get('page_number'),
+            id=metadata.get("id", hash_key),
+            content=content,
+            source=metadata.get("source", f"{file_url}{sas_placeholder}"),
+            title=metadata.get("title", filename),
+            chunk=metadata.get("chunk", idx),
+            offset=metadata.get("offset"),
+            page_number=metadata.get("page_number"),
         )
-    
+
     def convert_to_langchain_document(self):
         from langchain.docstore.document import Document
+
         return Document(
             page_content=self.content,
             metadata={
@@ -71,48 +86,52 @@ def convert_to_langchain_document(self):
                 "chunk": self.chunk,
                 "offset": self.offset,
                 "page_number": self.page_number,
-            }
+            },
         )
-        
+
     def get_filename(self, include_path=False):
-        filename = self.source.replace('_SAS_TOKEN_PLACEHOLDER_', '').replace('http://', '')
+        filename = self.source.replace("_SAS_TOKEN_PLACEHOLDER_", "").replace(
+            "http://", ""
+        )
         if include_path:
-            filename = filename.split('/')[-1]
+            filename = filename.split("/")[-1]
         else:
-            filename = filename.split('/')[-1].split('.')[0]
+            filename = filename.split("/")[-1].split(".")[0]
         return filename
-    
+
     def get_markdown_url(self):
-        url = quote(self.source, safe=':/')
-        if '_SAS_TOKEN_PLACEHOLDER_' in url:
+        url = quote(self.source, safe=":/")
+        if "_SAS_TOKEN_PLACEHOLDER_" in url:
             blob_client = AzureBlobStorageClient()
             container_sas = blob_client.get_container_sas()
             url = url.replace("_SAS_TOKEN_PLACEHOLDER_", container_sas)
         return f"[{self.title}]({url})"
-        
+
+
 class SourceDocumentEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, SourceDocument):
             return {
-                'id': obj.id,
-                'content': obj.content,
-                'source': obj.source,
-                'title': obj.title,
-                'chunk': obj.chunk,
-                'offset': obj.offset,
-                'page_number': obj.page_number
+                "id": obj.id,
+                "content": obj.content,
+                "source": obj.source,
+                "title": obj.title,
+                "chunk": obj.chunk,
+                "offset": obj.offset,
+                "page_number": obj.page_number,
             }
         return super().default(obj)
-    
+
+
 class SourceDocumentDecoder(json.JSONDecoder):
     def decode(self, s, **kwargs):
         obj = super().decode(s, **kwargs)
         return SourceDocument(
-            id=obj['id'],
-            content=obj['content'],
-            source=obj['source'],
-            title=obj['title'],
-            chunk=obj['chunk'],
-            offset=obj['offset'],
-            page_number=obj['page_number']
-        )
\ No newline at end of file
+            id=obj["id"],
+            content=obj["content"],
+            source=obj["source"],
+            title=obj["title"],
+            chunk=obj["chunk"],
+            offset=obj["offset"],
+            page_number=obj["page_number"],
+        )
diff --git a/code/utilities/document_chunking/DocumentChunkingBase.py b/code/utilities/document_chunking/DocumentChunkingBase.py
index ddd4a70ce..c2640de63 100644
--- a/code/utilities/document_chunking/DocumentChunkingBase.py
+++ b/code/utilities/document_chunking/DocumentChunkingBase.py
@@ -4,10 +4,13 @@
 from ..common.SourceDocument import SourceDocument
 from .Strategies import ChunkingSettings
 
+
 class DocumentChunkingBase(ABC):
     def __init__(self) -> None:
         pass
-    
+
     @abstractmethod
-    def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) -> List[SourceDocument]:        
-        pass
\ No newline at end of file
+    def chunk(
+        self, documents: List[SourceDocument], chunking: ChunkingSettings
+    ) -> List[SourceDocument]:
+        pass
diff --git a/code/utilities/document_chunking/FixedSizeOverlap.py b/code/utilities/document_chunking/FixedSizeOverlap.py
index 2c5e09a0c..5bb1d01d3 100644
--- a/code/utilities/document_chunking/FixedSizeOverlap.py
+++ b/code/utilities/document_chunking/FixedSizeOverlap.py
@@ -4,14 +4,21 @@
 from .Strategies import ChunkingSettings
 from ..common.SourceDocument import SourceDocument
 
+
 class FixedSizeOverlapDocumentChunking(DocumentChunkingBase):
     def __init__(self) -> None:
         pass
-        
-    def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) -> List[SourceDocument]:    
-        full_document_content = "".join(list(map(lambda document: document.content, documents)))
+
+    def chunk(
+        self, documents: List[SourceDocument], chunking: ChunkingSettings
+    ) -> List[SourceDocument]:
+        full_document_content = "".join(
+            list(map(lambda document: document.content, documents))
+        )
         document_url = documents[0].source
-        splitter = TokenTextSplitter.from_tiktoken_encoder(chunk_size=chunking.chunk_size, chunk_overlap=chunking.chunk_overlap)
+        splitter = TokenTextSplitter.from_tiktoken_encoder(
+            chunk_size=chunking.chunk_size, chunk_overlap=chunking.chunk_overlap
+        )
         chunked_content_list = splitter.split_text(full_document_content)
         # Create document for each chunk
         documents = []
@@ -24,7 +31,6 @@ def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) ->
                     metadata={"offset": chunk_offset},
                     idx=idx,
                 )
-            )            
+            )
             chunk_offset += len(chunked_content)
         return documents
-
diff --git a/code/utilities/document_chunking/Layout.py b/code/utilities/document_chunking/Layout.py
index cc4dc4563..df563420c 100644
--- a/code/utilities/document_chunking/Layout.py
+++ b/code/utilities/document_chunking/Layout.py
@@ -4,14 +4,21 @@
 from .Strategies import ChunkingSettings
 from ..common.SourceDocument import SourceDocument
 
+
 class LayoutDocumentChunking(DocumentChunkingBase):
     def __init__(self) -> None:
         pass
-        
-    def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) -> List[SourceDocument]:
-        full_document_content = "".join(list(map(lambda document: document.content, documents)))
+
+    def chunk(
+        self, documents: List[SourceDocument], chunking: ChunkingSettings
+    ) -> List[SourceDocument]:
+        full_document_content = "".join(
+            list(map(lambda document: document.content, documents))
+        )
         document_url = documents[0].source
-        splitter = MarkdownTextSplitter.from_tiktoken_encoder(chunk_size=chunking.chunk_size, chunk_overlap=chunking.chunk_overlap)
+        splitter = MarkdownTextSplitter.from_tiktoken_encoder(
+            chunk_size=chunking.chunk_size, chunk_overlap=chunking.chunk_overlap
+        )
         chunked_content_list = splitter.split_text(full_document_content)
         # Create document for each chunk
         documents = []
@@ -24,8 +31,7 @@ def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) ->
                     metadata={"offset": chunk_offset},
                     idx=idx,
                 )
-            )       
-            
+            )
+
             chunk_offset += len(chunked_content)
         return documents
-    
\ No newline at end of file
diff --git a/code/utilities/document_chunking/Page.py b/code/utilities/document_chunking/Page.py
index 03d0f4478..92ff78903 100644
--- a/code/utilities/document_chunking/Page.py
+++ b/code/utilities/document_chunking/Page.py
@@ -4,24 +4,31 @@
 from .Strategies import ChunkingSettings
 from ..common.SourceDocument import SourceDocument
 
+
 class PageDocumentChunking(DocumentChunkingBase):
     def __init__(self) -> None:
         pass
-        
-    def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) -> List[SourceDocument]:
+
+    def chunk(
+        self, documents: List[SourceDocument], chunking: ChunkingSettings
+    ) -> List[SourceDocument]:
         document_url = documents[0].source
-        splitter = MarkdownTextSplitter.from_tiktoken_encoder(chunk_size=chunking.chunk_size, chunk_overlap=chunking.chunk_overlap)
+        splitter = MarkdownTextSplitter.from_tiktoken_encoder(
+            chunk_size=chunking.chunk_size, chunk_overlap=chunking.chunk_overlap
+        )
         documents_chunked = []
         for idx, document in enumerate(documents):
             chunked_content_list = splitter.split_text(document.content)
             for chunked_content in chunked_content_list:
                 documents_chunked.append(
-                SourceDocument.from_metadata(
-                    content=chunked_content,
-                    document_url=document_url,
-                    metadata={"offset": document.offset, "page_number": document.page_number},
-                    idx=idx,
+                    SourceDocument.from_metadata(
+                        content=chunked_content,
+                        document_url=document_url,
+                        metadata={
+                            "offset": document.offset,
+                            "page_number": document.page_number,
+                        },
+                        idx=idx,
+                    )
                 )
-            )       
-        return documents_chunked  
-    
\ No newline at end of file
+        return documents_chunked
diff --git a/code/utilities/document_chunking/Paragraph.py b/code/utilities/document_chunking/Paragraph.py
index 97331fc79..8b2378331 100644
--- a/code/utilities/document_chunking/Paragraph.py
+++ b/code/utilities/document_chunking/Paragraph.py
@@ -3,10 +3,13 @@
 from .Strategies import ChunkingSettings
 from ..common.SourceDocument import SourceDocument
 
+
 class ParagraphDocumentChunking(DocumentChunkingBase):
     def __init__(self) -> None:
         pass
-    
+
     # TO DO: Implement the following chunking strategies
-    def chunk(self, documents: List[SourceDocument], chunking: ChunkingSettings) -> List[SourceDocument]:
+    def chunk(
+        self, documents: List[SourceDocument], chunking: ChunkingSettings
+    ) -> List[SourceDocument]:
         raise NotImplementedError("Paragraph chunking is not implemented yet")
diff --git a/code/utilities/document_chunking/Strategies.py b/code/utilities/document_chunking/Strategies.py
index f9e42e9d0..597b3840b 100644
--- a/code/utilities/document_chunking/Strategies.py
+++ b/code/utilities/document_chunking/Strategies.py
@@ -1,29 +1,36 @@
 from enum import Enum
 
+
 class ChunkingStrategy(Enum):
-    LAYOUT = 'layout'
-    PAGE = 'page'
-    FIXED_SIZE_OVERLAP = 'fixed_size_overlap'
-    PARAGRAPH = 'paragraph'
+    LAYOUT = "layout"
+    PAGE = "page"
+    FIXED_SIZE_OVERLAP = "fixed_size_overlap"
+    PARAGRAPH = "paragraph"
+
 
 def get_document_chunker(chunking_strategy: str):
     if chunking_strategy == ChunkingStrategy.LAYOUT.value:
         from .Layout import LayoutDocumentChunking
+
         return LayoutDocumentChunking()
     elif chunking_strategy == ChunkingStrategy.PAGE.value:
         from .Page import PageDocumentChunking
+
         return PageDocumentChunking()
     elif chunking_strategy == ChunkingStrategy.FIXED_SIZE_OVERLAP.value:
         from .FixedSizeOverlap import FixedSizeOverlapDocumentChunking
+
         return FixedSizeOverlapDocumentChunking()
     elif chunking_strategy == ChunkingStrategy.PARAGRAPH.value:
         from .Paragraph import ParagraphDocumentChunking
+
         return ParagraphDocumentChunking()
     else:
         raise Exception(f"Unknown chunking strategy: {chunking_strategy}")
-    
+
+
 class ChunkingSettings:
     def __init__(self, chunking: dict):
-        self.chunking_strategy = ChunkingStrategy(chunking['strategy'])
-        self.chunk_size = chunking['size']
-        self.chunk_overlap = chunking['overlap']
\ No newline at end of file
+        self.chunking_strategy = ChunkingStrategy(chunking["strategy"])
+        self.chunk_size = chunking["size"]
+        self.chunk_overlap = chunking["overlap"]
diff --git a/code/utilities/document_chunking/__init__.py b/code/utilities/document_chunking/__init__.py
index 5004ca1d9..d34531822 100644
--- a/code/utilities/document_chunking/__init__.py
+++ b/code/utilities/document_chunking/__init__.py
@@ -1,12 +1,12 @@
 import os
-from enum import Enum
 from typing import List
-import os.path, pkgutil
+import os.path
+import pkgutil
+
 
-from .Strategies import ChunkingSettings, ChunkingStrategy, get_document_chunker
-    
 # Get a list of all the classes defined in the module
 def get_all_classes() -> List[str]:
     return [name for _, name, _ in pkgutil.iter_modules([os.path.dirname(__file__)])]
 
+
 __all__ = get_all_classes()
diff --git a/code/utilities/document_loading/DocumentLoadingBase.py b/code/utilities/document_loading/DocumentLoadingBase.py
index 56f9f677a..1309a0383 100644
--- a/code/utilities/document_loading/DocumentLoadingBase.py
+++ b/code/utilities/document_loading/DocumentLoadingBase.py
@@ -3,10 +3,11 @@
 from abc import ABC, abstractmethod
 from ..common.SourceDocument import SourceDocument
 
+
 class DocumentLoadingBase(ABC):
     def __init__(self) -> None:
         pass
-    
+
     @abstractmethod
     def load(self, document_url: str) -> List[SourceDocument]:
-        pass
\ No newline at end of file
+        pass
diff --git a/code/utilities/document_loading/Layout.py b/code/utilities/document_loading/Layout.py
index 4c10a7d3c..c0fc53baa 100644
--- a/code/utilities/document_loading/Layout.py
+++ b/code/utilities/document_loading/Layout.py
@@ -3,21 +3,23 @@
 from ..helpers.AzureFormRecognizerHelper import AzureFormRecognizerClient
 from ..common.SourceDocument import SourceDocument
 
+
 class LayoutDocumentLoading(DocumentLoadingBase):
     def __init__(self) -> None:
         super().__init__()
-    
+
     def load(self, document_url: str) -> List[SourceDocument]:
         azure_form_recognizer_client = AzureFormRecognizerClient()
-        pages_content = azure_form_recognizer_client.begin_analyze_document_from_url(document_url, use_layout=True)
+        pages_content = azure_form_recognizer_client.begin_analyze_document_from_url(
+            document_url, use_layout=True
+        )
         documents = [
             SourceDocument(
-                content=page['page_text'],
+                content=page["page_text"],
                 source=document_url,
-                offset=page['offset'],
-                page_number=page['page_number'],
-                ) 
+                offset=page["offset"],
+                page_number=page["page_number"],
+            )
             for page in pages_content
-        ]            
-        return documents       
-    
\ No newline at end of file
+        ]
+        return documents
diff --git a/code/utilities/document_loading/Read.py b/code/utilities/document_loading/Read.py
index 4a980b1c4..1a0df2d35 100644
--- a/code/utilities/document_loading/Read.py
+++ b/code/utilities/document_loading/Read.py
@@ -3,21 +3,23 @@
 from ..helpers.AzureFormRecognizerHelper import AzureFormRecognizerClient
 from ..common.SourceDocument import SourceDocument
 
+
 class ReadDocumentLoading(DocumentLoadingBase):
     def __init__(self) -> None:
         super().__init__()
-    
+
     def load(self, document_url: str) -> List[SourceDocument]:
         azure_form_recognizer_client = AzureFormRecognizerClient()
-        pages_content = azure_form_recognizer_client.begin_analyze_document_from_url(document_url, use_layout=False)        
+        pages_content = azure_form_recognizer_client.begin_analyze_document_from_url(
+            document_url, use_layout=False
+        )
         documents = [
             SourceDocument(
-                content=page['page_text'],
+                content=page["page_text"],
                 source=document_url,
-                page_number=page['page_number'],
-                offset=page['offset'],
+                page_number=page["page_number"],
+                offset=page["offset"],
             )
             for page in pages_content
         ]
         return documents
-    
\ No newline at end of file
diff --git a/code/utilities/document_loading/Strategies.py b/code/utilities/document_loading/Strategies.py
index c32b8e98b..fe58b13d9 100644
--- a/code/utilities/document_loading/Strategies.py
+++ b/code/utilities/document_loading/Strategies.py
@@ -1,24 +1,29 @@
 from enum import Enum
 
+
 class LoadingStrategy(Enum):
-    LAYOUT = 'layout'
-    READ = 'read'
-    WEB = 'web'
-    DOCX = 'docx'
+    LAYOUT = "layout"
+    READ = "read"
+    WEB = "web"
+    DOCX = "docx"
+
 
 def get_document_loader(loader_strategy: str):
     if loader_strategy == LoadingStrategy.LAYOUT.value:
         from .Layout import LayoutDocumentLoading
+
         return LayoutDocumentLoading()
     elif loader_strategy == LoadingStrategy.READ.value:
         from .Read import ReadDocumentLoading
+
         return ReadDocumentLoading()
     elif loader_strategy == LoadingStrategy.WEB.value:
         from .Web import WebDocumentLoading
+
         return WebDocumentLoading()
     elif loader_strategy == LoadingStrategy.DOCX.value:
         from .WordDocument import WordDocumentLoading
+
         return WordDocumentLoading()
     else:
-        raise Exception(f"Unknown loader strategy: {loader_strategy}")    
-    
\ No newline at end of file
+        raise Exception(f"Unknown loader strategy: {loader_strategy}")
diff --git a/code/utilities/document_loading/Web.py b/code/utilities/document_loading/Web.py
index b4ec665b3..d9cea7c66 100644
--- a/code/utilities/document_loading/Web.py
+++ b/code/utilities/document_loading/Web.py
@@ -5,14 +5,15 @@
 from .DocumentLoadingBase import DocumentLoadingBase
 from ..common.SourceDocument import SourceDocument
 
+
 class WebDocumentLoading(DocumentLoadingBase):
     def __init__(self) -> None:
         super().__init__()
-    
+
     def load(self, document_url: str) -> List[SourceDocument]:
-        documents : List[Document] = WebBaseLoader(document_url).load() 
+        documents: List[Document] = WebBaseLoader(document_url).load()
         for document in documents:
-            document.page_content = re.sub('\n{3,}', '\n\n', document.page_content)
+            document.page_content = re.sub("\n{3,}", "\n\n", document.page_content)
             # Remove half non-ascii character from start/end of doc content
             pattern = re.compile(
                 r"[\x00-\x1f\x7f\u0080-\u00a0\u2000-\u3000\ufff0-\uffff]"
@@ -20,12 +21,11 @@ def load(self, document_url: str) -> List[SourceDocument]:
             document.page_content = re.sub(pattern, "", document.page_content)
             if document.page_content == "":
                 documents.remove(document)
-        source_documents : List[SourceDocument]  = [
+        source_documents: List[SourceDocument] = [
             SourceDocument(
                 content=document.page_content,
-                source=document.metadata['source'],
-            ) 
+                source=document.metadata["source"],
+            )
             for document in documents
         ]
         return source_documents
-    
\ No newline at end of file
diff --git a/code/utilities/document_loading/WordDocument.py b/code/utilities/document_loading/WordDocument.py
index 53ec84773..a3d92c21a 100644
--- a/code/utilities/document_loading/WordDocument.py
+++ b/code/utilities/document_loading/WordDocument.py
@@ -5,29 +5,30 @@
 from .DocumentLoadingBase import DocumentLoadingBase
 from ..common.SourceDocument import SourceDocument
 
+
 class WordDocumentLoading(DocumentLoadingBase):
     def __init__(self) -> None:
         super().__init__()
         self.doc_headings_to_markdown_tags = {
-            'Heading 1' : 'h1',
-            'Heading 2' : 'h2',
-            'Heading 3' : 'h3',
-            'Heading 4' : 'h4',
-            'Heading 5' : 'h5',
-            'Heading 6' : 'h6',
+            "Heading 1": "h1",
+            "Heading 2": "h2",
+            "Heading 3": "h3",
+            "Heading 4": "h4",
+            "Heading 5": "h5",
+            "Heading 6": "h6",
         }
-    
+
     def _download_document(self, document_url: str) -> BytesIO:
         response = requests.get(document_url)
         file = BytesIO(response.content)
         return file
-    
+
     def _get_opening_tag(self, heading_level: int) -> str:
         return f"<{self.doc_headings_to_markdown_tags.get(f'{heading_level}', '')}>"
-    
+
     def _get_closing_tag(self, heading_level: int) -> str:
         return f"</{self.doc_headings_to_markdown_tags.get(f'{heading_level}', '')}>"
-    
+
     def load(self, document_url: str) -> List[SourceDocument]:
         output = ""
         document = Document(self._download_document(document_url))
@@ -42,4 +43,3 @@ def load(self, document_url: str) -> List[SourceDocument]:
             )
         ]
         return documents
-        
\ No newline at end of file
diff --git a/code/utilities/document_loading/__init__.py b/code/utilities/document_loading/__init__.py
index 283364e80..d021d4fb9 100644
--- a/code/utilities/document_loading/__init__.py
+++ b/code/utilities/document_loading/__init__.py
@@ -1,14 +1,18 @@
 import os
 from typing import List
-import os.path, pkgutil
-from .Strategies import LoadingStrategy, get_document_loader
-    
+import os.path
+import pkgutil
+from .Strategies import LoadingStrategy
+
+
 class LoadingSettings:
     def __init__(self, loading):
-        self.loading_strategy = LoadingStrategy(loading['strategy'])
+        self.loading_strategy = LoadingStrategy(loading["strategy"])
+
 
 # Get a list of all the classes defined in the module
 def get_all_classes() -> List[str]:
     return [name for _, name, _ in pkgutil.iter_modules([os.path.dirname(__file__)])]
 
+
 __all__ = get_all_classes()
diff --git a/code/utilities/helpers/AzureBlobStorageHelper.py b/code/utilities/helpers/AzureBlobStorageHelper.py
index 72374a8ca..d19e83d85 100644
--- a/code/utilities/helpers/AzureBlobStorageHelper.py
+++ b/code/utilities/helpers/AzureBlobStorageHelper.py
@@ -1,32 +1,68 @@
 from typing import Optional
 from datetime import datetime, timedelta
-from azure.storage.blob import BlobServiceClient, generate_blob_sas, generate_container_sas, ContentSettings
+from azure.storage.blob import (
+    BlobServiceClient,
+    generate_blob_sas,
+    generate_container_sas,
+    ContentSettings,
+)
 from .EnvHelper import EnvHelper
 
-class AzureBlobStorageClient:
-    def __init__(self, account_name: Optional[str] = None, account_key: Optional[str] = None, container_name: Optional[str] = None):
 
-        env_helper : EnvHelper = EnvHelper()
+class AzureBlobStorageClient:
+    def __init__(
+        self,
+        account_name: Optional[str] = None,
+        account_key: Optional[str] = None,
+        container_name: Optional[str] = None,
+    ):
+        env_helper: EnvHelper = EnvHelper()
 
-        self.account_name = account_name if account_name else env_helper.AZURE_BLOB_ACCOUNT_NAME
-        self.account_key = account_key if account_key else env_helper.AZURE_BLOB_ACCOUNT_KEY
+        self.account_name = (
+            account_name if account_name else env_helper.AZURE_BLOB_ACCOUNT_NAME
+        )
+        self.account_key = (
+            account_key if account_key else env_helper.AZURE_BLOB_ACCOUNT_KEY
+        )
         self.connect_str = f"DefaultEndpointsProtocol=https;AccountName={self.account_name};AccountKey={self.account_key};EndpointSuffix=core.windows.net"
-        self.container_name : str = container_name if container_name else env_helper.AZURE_BLOB_CONTAINER_NAME
-        self.blob_service_client : BlobServiceClient = BlobServiceClient.from_connection_string(self.connect_str)
-
+        self.container_name: str = (
+            container_name if container_name else env_helper.AZURE_BLOB_CONTAINER_NAME
+        )
+        self.blob_service_client: BlobServiceClient = (
+            BlobServiceClient.from_connection_string(self.connect_str)
+        )
 
-    def upload_file(self, bytes_data, file_name, content_type='application/pdf'):
+    def upload_file(self, bytes_data, file_name, content_type="application/pdf"):
         # Create a blob client using the local file name as the name for the blob
-        blob_client = self.blob_service_client.get_blob_client(container=self.container_name, blob=file_name)
+        blob_client = self.blob_service_client.get_blob_client(
+            container=self.container_name, blob=file_name
+        )
         # Upload the created file
-        blob_client.upload_blob(bytes_data, overwrite=True, content_settings=ContentSettings(content_type=content_type))
+        blob_client.upload_blob(
+            bytes_data,
+            overwrite=True,
+            content_settings=ContentSettings(content_type=content_type),
+        )
         # Generate a SAS URL to the blob and return it
-        return blob_client.url + '?' + generate_blob_sas(self.account_name, self.container_name, file_name,account_key=self.account_key,  permission="r", expiry=datetime.utcnow() + timedelta(hours=3))
+        return (
+            blob_client.url
+            + "?"
+            + generate_blob_sas(
+                self.account_name,
+                self.container_name,
+                file_name,
+                account_key=self.account_key,
+                permission="r",
+                expiry=datetime.utcnow() + timedelta(hours=3),
+            )
+        )
 
     def download_file(self, file_name):
-        blob_client = self.blob_service_client.get_blob_client(container=self.container_name, blob=file_name)
+        blob_client = self.blob_service_client.get_blob_client(
+            container=self.container_name, blob=file_name
+        )
         return blob_client.download_blob().readall()
-    
+
     def delete_file(self, file_name):
         """
         Deletes a file from the Azure Blob Storage container.
@@ -37,51 +73,95 @@ def delete_file(self, file_name):
         Returns:
             None
         """
-        blob_client = self.blob_service_client.get_blob_client(container=self.container_name, blob=file_name)
+        blob_client = self.blob_service_client.get_blob_client(
+            container=self.container_name, blob=file_name
+        )
         blob_client.delete_blob()
 
     def get_all_files(self):
         # Get all files in the container from Azure Blob Storage
-        container_client = self.blob_service_client.get_container_client(self.container_name)
-        blob_list = container_client.list_blobs(include='metadata')
+        container_client = self.blob_service_client.get_container_client(
+            self.container_name
+        )
+        blob_list = container_client.list_blobs(include="metadata")
         # sas = generate_blob_sas(account_name, container_name, blob.name,account_key=account_key,  permission="r", expiry=datetime.utcnow() + timedelta(hours=3))
-        sas = generate_container_sas(self.account_name, self.container_name,account_key=self.account_key,  permission="r", expiry=datetime.utcnow() + timedelta(hours=3))
+        sas = generate_container_sas(
+            self.account_name,
+            self.container_name,
+            account_key=self.account_key,
+            permission="r",
+            expiry=datetime.utcnow() + timedelta(hours=3),
+        )
         files = []
         converted_files = {}
         for blob in blob_list:
-            if not blob.name.startswith('converted/'):
-                files.append({
-                    "filename" : blob.name,
-                    "converted": blob.metadata.get('converted', 'false') == 'true' if blob.metadata else False,
-                    "embeddings_added": blob.metadata.get('embeddings_added', 'false') == 'true' if blob.metadata else False,
-                    "fullpath": f"https://{self.account_name}.blob.core.windows.net/{self.container_name}/{blob.name}?{sas}",
-                    "converted_filename": blob.metadata.get('converted_filename', '') if blob.metadata else '',
-                    "converted_path": ""
-                    })
+            if not blob.name.startswith("converted/"):
+                files.append(
+                    {
+                        "filename": blob.name,
+                        "converted": blob.metadata.get("converted", "false") == "true"
+                        if blob.metadata
+                        else False,
+                        "embeddings_added": blob.metadata.get(
+                            "embeddings_added", "false"
+                        )
+                        == "true"
+                        if blob.metadata
+                        else False,
+                        "fullpath": f"https://{self.account_name}.blob.core.windows.net/{self.container_name}/{blob.name}?{sas}",
+                        "converted_filename": blob.metadata.get(
+                            "converted_filename", ""
+                        )
+                        if blob.metadata
+                        else "",
+                        "converted_path": "",
+                    }
+                )
             else:
-                converted_files[blob.name] = f"https://{self.account_name}.blob.core.windows.net/{self.container_name}/{blob.name}?{sas}"
+                converted_files[
+                    blob.name
+                ] = f"https://{self.account_name}.blob.core.windows.net/{self.container_name}/{blob.name}?{sas}"
 
         for file in files:
-            converted_filename = file.pop('converted_filename', '')
+            converted_filename = file.pop("converted_filename", "")
             if converted_filename in converted_files:
-                file['converted'] = True
-                file['converted_path'] = converted_files[converted_filename]
-        
+                file["converted"] = True
+                file["converted_path"] = converted_files[converted_filename]
+
         return files
 
     def upsert_blob_metadata(self, file_name, metadata):
-        blob_client = BlobServiceClient.from_connection_string(self.connect_str).get_blob_client(container=self.container_name, blob=file_name)
+        blob_client = BlobServiceClient.from_connection_string(
+            self.connect_str
+        ).get_blob_client(container=self.container_name, blob=file_name)
         # Read metadata from the blob
         blob_metadata = blob_client.get_blob_properties().metadata
         # Update metadata
         blob_metadata.update(metadata)
         # Add metadata to the blob
-        blob_client.set_blob_metadata(metadata= blob_metadata)
+        blob_client.set_blob_metadata(metadata=blob_metadata)
 
     def get_container_sas(self):
         # Generate a SAS URL to the container and return it
-        return "?" + generate_container_sas(account_name= self.account_name, container_name= self.container_name,account_key=self.account_key,  permission="r", expiry=datetime.utcnow() + timedelta(hours=1))
+        return "?" + generate_container_sas(
+            account_name=self.account_name,
+            container_name=self.container_name,
+            account_key=self.account_key,
+            permission="r",
+            expiry=datetime.utcnow() + timedelta(hours=1),
+        )
 
     def get_blob_sas(self, file_name):
         # Generate a SAS URL to the blob and return it
-        return f"https://{self.account_name}.blob.core.windows.net/{self.container_name}/{file_name}" + "?" + generate_blob_sas(account_name= self.account_name, container_name=self.container_name, blob_name= file_name, account_key= self.account_key, permission='r', expiry=datetime.utcnow() + timedelta(hours=1))
+        return (
+            f"https://{self.account_name}.blob.core.windows.net/{self.container_name}/{file_name}"
+            + "?"
+            + generate_blob_sas(
+                account_name=self.account_name,
+                container_name=self.container_name,
+                blob_name=file_name,
+                account_key=self.account_key,
+                permission="r",
+                expiry=datetime.utcnow() + timedelta(hours=1),
+            )
+        )
diff --git a/code/utilities/helpers/AzureFormRecognizerHelper.py b/code/utilities/helpers/AzureFormRecognizerHelper.py
index 92953f775..9fa8376ba 100644
--- a/code/utilities/helpers/AzureFormRecognizerHelper.py
+++ b/code/utilities/helpers/AzureFormRecognizerHelper.py
@@ -4,17 +4,24 @@
 import traceback
 from .EnvHelper import EnvHelper
 
+
 class AzureFormRecognizerClient:
     def __init__(self) -> None:
-        env_helper : EnvHelper = EnvHelper()
-        
-        self.AZURE_FORM_RECOGNIZER_ENDPOINT : str = env_helper.AZURE_FORM_RECOGNIZER_ENDPOINT
-        self.AZURE_FORM_RECOGNIZER_KEY : str = env_helper.AZURE_FORM_RECOGNIZER_KEY
-        
+        env_helper: EnvHelper = EnvHelper()
+
+        self.AZURE_FORM_RECOGNIZER_ENDPOINT: str = (
+            env_helper.AZURE_FORM_RECOGNIZER_ENDPOINT
+        )
+        self.AZURE_FORM_RECOGNIZER_KEY: str = env_helper.AZURE_FORM_RECOGNIZER_KEY
+
         self.document_analysis_client = DocumentAnalysisClient(
-            endpoint=self.AZURE_FORM_RECOGNIZER_ENDPOINT, credential=AzureKeyCredential(self.AZURE_FORM_RECOGNIZER_KEY), headers={"x-ms-useragent": "chat-with-your-data-solution-accelerator/1.0.0"}
+            endpoint=self.AZURE_FORM_RECOGNIZER_ENDPOINT,
+            credential=AzureKeyCredential(self.AZURE_FORM_RECOGNIZER_KEY),
+            headers={
+                "x-ms-useragent": "chat-with-your-data-solution-accelerator/1.0.0"
+            },
         )
-    
+
     form_recognizer_role_to_html = {
         "title": "h1",
         "sectionHeading": "h2",
@@ -22,30 +29,45 @@ def __init__(self) -> None:
         "pageFooter": None,
         "paragraph": "p",
     }
-        
+
     def _table_to_html(self, table):
         table_html = "<table>"
-        rows = [sorted([cell for cell in table.cells if cell.row_index == i], key=lambda cell: cell.column_index) for i in range(table.row_count)]
+        rows = [
+            sorted(
+                [cell for cell in table.cells if cell.row_index == i],
+                key=lambda cell: cell.column_index,
+            )
+            for i in range(table.row_count)
+        ]
         for row_cells in rows:
             table_html += "<tr>"
             for cell in row_cells:
-                tag = "th" if (cell.kind == "columnHeader" or cell.kind == "rowHeader") else "td"
+                tag = (
+                    "th"
+                    if (cell.kind == "columnHeader" or cell.kind == "rowHeader")
+                    else "td"
+                )
                 cell_spans = ""
-                if cell.column_span > 1: cell_spans += f" colSpan={cell.column_span}"
-                if cell.row_span > 1: cell_spans += f" rowSpan={cell.row_span}"
+                if cell.column_span > 1:
+                    cell_spans += f" colSpan={cell.column_span}"
+                if cell.row_span > 1:
+                    cell_spans += f" rowSpan={cell.row_span}"
                 table_html += f"<{tag}{cell_spans}>{html.escape(cell.content)}</{tag}>"
-            table_html +="</tr>"
+            table_html += "</tr>"
         table_html += "</table>"
         return table_html
 
-    def begin_analyze_document_from_url(self, source_url: str, use_layout: bool =True, paragraph_separator: str = ""): 
-        
+    def begin_analyze_document_from_url(
+        self, source_url: str, use_layout: bool = True, paragraph_separator: str = ""
+    ):
         offset = 0
         page_map = []
         model_id = "prebuilt-layout" if use_layout else "prebuilt-read"
 
         try:
-            poller = self.document_analysis_client.begin_analyze_document_from_url(model_id, document_url=source_url)
+            poller = self.document_analysis_client.begin_analyze_document_from_url(
+                model_id, document_url=source_url
+            )
             form_recognizer_results = poller.result()
 
             # (if using layout) mark all the positions of headers
@@ -55,22 +77,30 @@ def begin_analyze_document_from_url(self, source_url: str, use_layout: bool =Tru
                 # if paragraph.role!=None:
                 para_start = paragraph.spans[0].offset
                 para_end = paragraph.spans[0].offset + paragraph.spans[0].length
-                roles_start[para_start] = paragraph.role if paragraph.role!=None else "paragraph"
-                roles_end[para_end] = paragraph.role if paragraph.role!=None else "paragraph"
+                roles_start[para_start] = (
+                    paragraph.role if paragraph.role is not None else "paragraph"
+                )
+                roles_end[para_end] = (
+                    paragraph.role if paragraph.role is not None else "paragraph"
+                )
 
             for page_num, page in enumerate(form_recognizer_results.pages):
-                tables_on_page = [table for table in form_recognizer_results.tables if table.bounding_regions[0].page_number == page_num + 1]
+                tables_on_page = [
+                    table
+                    for table in form_recognizer_results.tables
+                    if table.bounding_regions[0].page_number == page_num + 1
+                ]
 
                 # (if using layout) mark all positions of the table spans in the page
                 page_offset = page.spans[0].offset
                 page_length = page.spans[0].length
-                table_chars = [-1]*page_length
+                table_chars = [-1] * page_length
                 for table_id, table in enumerate(tables_on_page):
                     for span in table.spans:
                         # replace all table spans with "table_id" in table_chars array
                         for i in range(span.length):
                             idx = span.offset - page_offset + i
-                            if idx >=0 and idx < page_length:
+                            if idx >= 0 and idx < page_length:
                                 table_chars[idx] = table_id
 
                 # build page text by replacing charcters in table spans with table html and replace the characters corresponding to headers with html headers, if using layout
@@ -82,24 +112,26 @@ def begin_analyze_document_from_url(self, source_url: str, use_layout: bool =Tru
                         if position in roles_start.keys():
                             role = roles_start[position]
                             html_role = self.form_recognizer_role_to_html.get(role)
-                            if html_role != None:
+                            if html_role is not None:
                                 page_text += f"<{html_role}>"
                         if position in roles_end.keys():
                             role = roles_end[position]
                             html_role = self.form_recognizer_role_to_html.get(role)
-                            if html_role != None:
+                            if html_role is not None:
                                 page_text += f"</{html_role}>"
-                                                    
+
                         page_text += form_recognizer_results.content[page_offset + idx]
-                        
-                    elif not table_id in added_tables:
+
+                    elif table_id not in added_tables:
                         page_text += self._table_to_html(tables_on_page[table_id])
                         added_tables.add(table_id)
 
                 page_text += " "
-                page_map.append({"page_number": page_num, "offset": offset, "page_text": page_text})
+                page_map.append(
+                    {"page_number": page_num, "offset": offset, "page_text": page_text}
+                )
                 offset += len(page_text)
-                
+
             return page_map
-        except Exception as e:
+        except Exception:
             raise ValueError(f"Error: {traceback.format_exc()}")
diff --git a/code/utilities/helpers/AzureSearchHelper.py b/code/utilities/helpers/AzureSearchHelper.py
index b265ac760..20dd6aa96 100644
--- a/code/utilities/helpers/AzureSearchHelper.py
+++ b/code/utilities/helpers/AzureSearchHelper.py
@@ -8,10 +8,11 @@
 from .LLMHelper import LLMHelper
 from .EnvHelper import EnvHelper
 
-class AzureSearchHelper():
+
+class AzureSearchHelper:
     def __init__(self):
         pass
-    
+
     def get_vector_store(self):
         llm_helper = LLMHelper()
         env_helper = EnvHelper()
@@ -30,7 +31,9 @@ def get_vector_store(self):
                 name="content_vector",
                 type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
                 searchable=True,
-                vector_search_dimensions=len(llm_helper.get_embedding_model().embed_query("Text")),
+                vector_search_dimensions=len(
+                    llm_helper.get_embedding_model().embed_query("Text")
+                ),
                 vector_search_configuration="default",
             ),
             SearchableField(
@@ -59,16 +62,18 @@ def get_vector_store(self):
                 filterable=True,
             ),
         ]
-        
+
         return AzureSearch(
-                azure_search_endpoint=env_helper.AZURE_SEARCH_SERVICE,
-                azure_search_key=env_helper.AZURE_SEARCH_KEY if env_helper.AZURE_AUTH_TYPE == "keys" else None,
-                index_name=env_helper.AZURE_SEARCH_INDEX,
-                embedding_function=llm_helper.get_embedding_model().embed_query,
-                fields=fields,
-                user_agent="langchain chatwithyourdata-sa",
-            )
-    
+            azure_search_endpoint=env_helper.AZURE_SEARCH_SERVICE,
+            azure_search_key=env_helper.AZURE_SEARCH_KEY
+            if env_helper.AZURE_AUTH_TYPE == "keys"
+            else None,
+            index_name=env_helper.AZURE_SEARCH_INDEX,
+            embedding_function=llm_helper.get_embedding_model().embed_query,
+            fields=fields,
+            user_agent="langchain chatwithyourdata-sa",
+        )
+
     def get_conversation_logger(self):
         llm_helper = LLMHelper()
         env_helper = EnvHelper()
@@ -93,7 +98,9 @@ def get_conversation_logger(self):
                 name="content_vector",
                 type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
                 searchable=True,
-                vector_search_dimensions=len(llm_helper.get_embedding_model().embed_query("Text")),
+                vector_search_dimensions=len(
+                    llm_helper.get_embedding_model().embed_query("Text")
+                ),
                 vector_search_configuration="default",
             ),
             SearchableField(
@@ -129,12 +136,14 @@ def get_conversation_logger(self):
                 filterable=True,
             ),
         ]
-        
+
         return AzureSearch(
-                azure_search_endpoint=env_helper.AZURE_SEARCH_SERVICE,
-                azure_search_key=env_helper.AZURE_SEARCH_KEY if env_helper.AZURE_AUTH_TYPE == "keys" else None,
-                index_name=env_helper.AZURE_SEARCH_CONVERSATIONS_LOG_INDEX,
-                embedding_function=llm_helper.get_embedding_model().embed_query,
-                fields=fields,
-                user_agent="langchain chatwithyourdata-sa",
-            )
\ No newline at end of file
+            azure_search_endpoint=env_helper.AZURE_SEARCH_SERVICE,
+            azure_search_key=env_helper.AZURE_SEARCH_KEY
+            if env_helper.AZURE_AUTH_TYPE == "keys"
+            else None,
+            index_name=env_helper.AZURE_SEARCH_CONVERSATIONS_LOG_INDEX,
+            embedding_function=llm_helper.get_embedding_model().embed_query,
+            fields=fields,
+            user_agent="langchain chatwithyourdata-sa",
+        )
diff --git a/code/utilities/helpers/ConfigHelper.py b/code/utilities/helpers/ConfigHelper.py
index 906817491..bb6473488 100644
--- a/code/utilities/helpers/ConfigHelper.py
+++ b/code/utilities/helpers/ConfigHelper.py
@@ -1,59 +1,72 @@
 import json
 from .AzureBlobStorageHelper import AzureBlobStorageClient
-from ..document_chunking import ChunkingSettings, ChunkingStrategy
+from ..document_chunking.Strategies import ChunkingSettings, ChunkingStrategy
 from ..document_loading import LoadingSettings, LoadingStrategy
 from .DocumentProcessorHelper import Processor
-from .OrchestratorHelper import Orchestrator, OrchestrationSettings, OrchestrationStrategy
+from .OrchestratorHelper import (
+    OrchestrationSettings,
+    OrchestrationStrategy,
+)
 from .EnvHelper import EnvHelper
 
 CONFIG_CONTAINER_NAME = "config"
 
+
 class Config:
     def __init__(self, config: dict):
-        self.prompts = Prompts(config['prompts'])
-        self.messages = Messages(config['messages'])
-        self.logging = Logging(config['logging'])
+        self.prompts = Prompts(config["prompts"])
+        self.messages = Messages(config["messages"])
+        self.logging = Logging(config["logging"])
         self.document_processors = [
             Processor(
-                document_type=c['document_type'], 
-                chunking=ChunkingSettings(c['chunking']), 
-                loading=LoadingSettings(c['loading'])
-            ) 
-            for c in config['document_processors']]
+                document_type=c["document_type"],
+                chunking=ChunkingSettings(c["chunking"]),
+                loading=LoadingSettings(c["loading"]),
+            )
+            for c in config["document_processors"]
+        ]
         self.env_helper = EnvHelper()
-        self.default_orchestration_settings = {'strategy' : self.env_helper.ORCHESTRATION_STRATEGY}
-        self.orchestrator = OrchestrationSettings(config.get('orchestrator', self.default_orchestration_settings))
-    
+        self.default_orchestration_settings = {
+            "strategy": self.env_helper.ORCHESTRATION_STRATEGY
+        }
+        self.orchestrator = OrchestrationSettings(
+            config.get("orchestrator", self.default_orchestration_settings)
+        )
+
     def get_available_document_types(self):
-        return ["txt", "pdf", "url", "html", "md", "jpeg", "jpg", "png", "docx"]    
-    
+        return ["txt", "pdf", "url", "html", "md", "jpeg", "jpg", "png", "docx"]
+
     def get_available_chunking_strategies(self):
         return [c.value for c in ChunkingStrategy]
-    
+
     def get_available_loading_strategies(self):
         return [c.value for c in LoadingStrategy]
-    
+
     def get_available_orchestration_strategies(self):
         return [c.value for c in OrchestrationStrategy]
-        
+
+
 # TODO: Change to AnsweringChain or something, Prompts is not a good name
 class Prompts:
     def __init__(self, prompts: dict):
-        self.condense_question_prompt = prompts['condense_question_prompt']
-        self.answering_prompt = prompts['answering_prompt']
-        self.post_answering_prompt = prompts['post_answering_prompt']
-        self.enable_post_answering_prompt = prompts['enable_post_answering_prompt']
-        self.enable_content_safety = prompts['enable_content_safety']
-        
+        self.condense_question_prompt = prompts["condense_question_prompt"]
+        self.answering_prompt = prompts["answering_prompt"]
+        self.post_answering_prompt = prompts["post_answering_prompt"]
+        self.enable_post_answering_prompt = prompts["enable_post_answering_prompt"]
+        self.enable_content_safety = prompts["enable_content_safety"]
+
+
 class Messages:
     def __init__(self, messages: dict):
-        self.post_answering_filter = messages['post_answering_filter']
+        self.post_answering_filter = messages["post_answering_filter"]
+
 
 class Logging:
     def __init__(self, logging: dict):
-        self.log_user_interactions = logging['log_user_interactions']
-        self.log_tokens = logging['log_tokens']
-        
+        self.log_user_interactions = logging["log_user_interactions"]
+        self.log_tokens = logging["log_tokens"]
+
+
 class ConfigHelper:
     @staticmethod
     def get_active_config_or_default():
@@ -61,16 +74,18 @@ def get_active_config_or_default():
             blob_client = AzureBlobStorageClient(container_name=CONFIG_CONTAINER_NAME)
             config = blob_client.download_file("active.json")
             config = Config(json.loads(config))
-        except: 
+        except Exception:
             print("Returning default config")
             config = ConfigHelper.get_default_config()
-        return config 
-    
+        return config
+
     @staticmethod
     def save_config_as_active(config):
         blob_client = AzureBlobStorageClient(container_name=CONFIG_CONTAINER_NAME)
-        blob_client = blob_client.upload_file(json.dumps(config, indent=2), "active.json", content_type='application/json')
-        
+        blob_client = blob_client.upload_file(
+            json.dumps(config, indent=2), "active.json", content_type="application/json"
+        )
+
     @staticmethod
     def get_default_config():
         default_config = {
@@ -109,86 +124,68 @@ def get_default_config():
 Question: {question}
 Answer: {answer}""",
                 "enable_post_answering_prompt": False,
-                "enable_content_safety": True
-                },
+                "enable_content_safety": True,
+            },
             "messages": {
                 "post_answering_filter": "I'm sorry, but I can't answer this question correctly. Please try again by altering or rephrasing your question."
             },
-            "document_processors": 
-                [  
-                 {
+            "document_processors": [
+                {
                     "document_type": "pdf",
                     "chunking": {
                         "strategy": ChunkingStrategy.LAYOUT,
                         "size": 500,
-                        "overlap": 100
+                        "overlap": 100,
                     },
-                    "loading": {
-                        "strategy": LoadingStrategy.LAYOUT
-                    }
+                    "loading": {"strategy": LoadingStrategy.LAYOUT},
                 },
                 {
                     "document_type": "txt",
                     "chunking": {
                         "strategy": ChunkingStrategy.LAYOUT,
                         "size": 500,
-                        "overlap": 100
+                        "overlap": 100,
                     },
-                    "loading": {
-                        "strategy": LoadingStrategy.WEB
-                    }
+                    "loading": {"strategy": LoadingStrategy.WEB},
                 },
                 {
                     "document_type": "url",
                     "chunking": {
                         "strategy": ChunkingStrategy.LAYOUT,
                         "size": 500,
-                        "overlap": 100
+                        "overlap": 100,
                     },
-                    "loading": {
-                        "strategy": LoadingStrategy.WEB
-                    }
+                    "loading": {"strategy": LoadingStrategy.WEB},
                 },
                 {
                     "document_type": "md",
                     "chunking": {
                         "strategy": ChunkingStrategy.LAYOUT,
                         "size": 500,
-                        "overlap": 100
+                        "overlap": 100,
                     },
-                    "loading": {
-                        "strategy": LoadingStrategy.WEB
-                    }
+                    "loading": {"strategy": LoadingStrategy.WEB},
                 },
                 {
                     "document_type": "html",
                     "chunking": {
                         "strategy": ChunkingStrategy.LAYOUT,
                         "size": 500,
-                        "overlap": 100
+                        "overlap": 100,
                     },
-                    "loading": {
-                        "strategy": LoadingStrategy.WEB
-                    }
+                    "loading": {"strategy": LoadingStrategy.WEB},
                 },
                 {
                     "document_type": "docx",
                     "chunking": {
                         "strategy": ChunkingStrategy.LAYOUT,
                         "size": 500,
-                        "overlap": 100
+                        "overlap": 100,
                     },
-                    "loading": {
-                        "strategy": LoadingStrategy.DOCX
-                    }
+                    "loading": {"strategy": LoadingStrategy.DOCX},
                 },
             ],
-            "logging": {
-                "log_user_interactions": True,
-                "log_tokens": True
-            },
-            "orchestrator": {
-                "strategy": "openai_function"
-            }
+            "logging": {"log_user_interactions": True, "log_tokens": True},
+            "orchestrator": {"strategy": "openai_function"},
         }
         return Config(default_config)
diff --git a/code/utilities/helpers/DocumentChunkingHelper.py b/code/utilities/helpers/DocumentChunkingHelper.py
index 3775fc062..10132afcb 100644
--- a/code/utilities/helpers/DocumentChunkingHelper.py
+++ b/code/utilities/helpers/DocumentChunkingHelper.py
@@ -1,14 +1,24 @@
 from typing import List
-from urllib.parse import urlparse
 from langchain.docstore.document import Document
-from ..document_chunking import get_document_chunker, ChunkingSettings, ChunkingStrategy
+from ..document_chunking.Strategies import (
+    get_document_chunker,
+    ChunkingSettings,
+    ChunkingStrategy,
+)
+
+__all__ = ["ChunkingStrategy"]
+
 
 class DocumentChunking:
     def __init__(self) -> None:
         pass
-    
-    def chunk(self, documents: List[Document], chunking: ChunkingSettings) -> List[Document]:
+
+    def chunk(
+        self, documents: List[Document], chunking: ChunkingSettings
+    ) -> List[Document]:
         chunker = get_document_chunker(chunking.chunking_strategy.value)
         if chunker is None:
-            raise Exception(f"Unknown chunking strategy: {chunking.chunking_strategy.value}")
+            raise Exception(
+                f"Unknown chunking strategy: {chunking.chunking_strategy.value}"
+            )
         return chunker.chunk(documents, chunking)
diff --git a/code/utilities/helpers/DocumentLoadingHelper.py b/code/utilities/helpers/DocumentLoadingHelper.py
index 33e9a44e3..c0d338a4b 100644
--- a/code/utilities/helpers/DocumentLoadingHelper.py
+++ b/code/utilities/helpers/DocumentLoadingHelper.py
@@ -1,13 +1,17 @@
 from typing import List
 from langchain.docstore.document import Document
-from ..document_loading import get_document_loader, LoadingSettings, LoadingStrategy
-       
+from ..document_loading import LoadingSettings
+from ..document_loading.Strategies import get_document_loader
+
+
 class DocumentLoading:
     def __init__(self) -> None:
         pass
-    
+
     def load(self, document_url: str, loading: LoadingSettings) -> List[Document]:
         loader = get_document_loader(loading.loading_strategy.value)
         if loader is None:
-            raise Exception(f"Unknown loader strategy: {loading.loading_strategy.value}")
+            raise Exception(
+                f"Unknown loader strategy: {loading.loading_strategy.value}"
+            )
         return loader.load(document_url)
diff --git a/code/utilities/helpers/DocumentProcessorHelper.py b/code/utilities/helpers/DocumentProcessorHelper.py
index d6eff068c..70bef27c7 100644
--- a/code/utilities/helpers/DocumentProcessorHelper.py
+++ b/code/utilities/helpers/DocumentProcessorHelper.py
@@ -7,28 +7,34 @@
 
 logger = logging.getLogger(__name__)
 
+
 class Processor(ChunkingSettings, LoadingSettings):
-    def __init__(self, document_type: str, chunking: ChunkingSettings, loading: LoadingSettings):
+    def __init__(
+        self, document_type: str, chunking: ChunkingSettings, loading: LoadingSettings
+    ):
         self.document_type = document_type
         self.chunking = chunking
         self.loading = loading
 
+
 class DocumentProcessor:
     def __init__(self):
         pass
-            
+
     def process(self, source_url: str, processors: List[Processor]):
         vector_store_helper = AzureSearchHelper()
         vector_store = vector_store_helper.get_vector_store()
-        for processor in processors:            
+        for processor in processors:
             try:
                 document_loading = DocumentLoading()
                 document_chunking = DocumentChunking()
-                documents : List[SourceDocument] = []
+                documents: List[SourceDocument] = []
                 documents = document_loading.load(source_url, processor.loading)
                 documents = document_chunking.chunk(documents, processor.chunking)
                 keys = list(map(lambda x: x.id, documents))
-                documents = [document.convert_to_langchain_document() for document in documents]
+                documents = [
+                    document.convert_to_langchain_document() for document in documents
+                ]
                 return vector_store.add_documents(documents=documents, keys=keys)
             except Exception as e:
                 logging.error(f"Error adding embeddings for {source_url}: {e}")
diff --git a/code/utilities/helpers/EnvHelper.py b/code/utilities/helpers/EnvHelper.py
index c0fc77275..0d0111fa6 100644
--- a/code/utilities/helpers/EnvHelper.py
+++ b/code/utilities/helpers/EnvHelper.py
@@ -5,77 +5,119 @@
 
 logger = logging.getLogger(__name__)
 
+
 class EnvHelper:
     def __init__(self, **kwargs) -> None:
         load_dotenv()
         # Azure Search
-        self.AZURE_SEARCH_SERVICE = os.getenv('AZURE_SEARCH_SERVICE', '')
-        self.AZURE_SEARCH_INDEX = os.getenv('AZURE_SEARCH_INDEX', '')
-        self.AZURE_SEARCH_KEY = os.getenv('AZURE_SEARCH_KEY', '')
-        self.AZURE_SEARCH_USE_SEMANTIC_SEARCH = os.getenv('AZURE_SEARCH_USE_SEMANTIC_SEARCH', '')
-        self.AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG = os.getenv('AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG', '')
-        self.AZURE_SEARCH_INDEX_IS_PRECHUNKED = os.getenv('AZURE_SEARCH_INDEX_IS_PRECHUNKED', '')
-        self.AZURE_SEARCH_TOP_K = os.getenv('AZURE_SEARCH_TOP_K', '')
-        self.AZURE_SEARCH_ENABLE_IN_DOMAIN = os.getenv('AZURE_SEARCH_ENABLE_IN_DOMAIN', '')
-        self.AZURE_SEARCH_FIELDS_ID = os.getenv('AZURE_SEARCH_FIELDS_ID', 'id')
-        self.AZURE_SEARCH_CONTENT_COLUMNS = os.getenv('AZURE_SEARCH_CONTENT_COLUMNS', 'content')
-        self.AZURE_SEARCH_CONTENT_VECTOR_COLUMNS = os.getenv('AZURE_SEARCH_CONTENT_VECTOR_COLUMNS', 'content_vector')
-        self.AZURE_SEARCH_DIMENSIONS = os.getenv('AZURE_SEARCH_DIMENSIONS', '1536')
-        self.AZURE_SEARCH_FILENAME_COLUMN = os.getenv('AZURE_SEARCH_FILENAME_COLUMN', 'filepath')
-        self.AZURE_SEARCH_TITLE_COLUMN = os.getenv('AZURE_SEARCH_TITLE_COLUMN', 'title')
-        self.AZURE_SEARCH_URL_COLUMN = os.getenv('AZURE_SEARCH_URL_COLUMN', 'url')
-        self.AZURE_SEARCH_FIELDS_TAG = os.getenv('AZURE_SEARCH_FIELDS_TAG', 'tag')
-        self.AZURE_SEARCH_FIELDS_METADATA = os.getenv('AZURE_SEARCH_FIELDS_METADATA', 'metadata')
-        self.AZURE_SEARCH_CONVERSATIONS_LOG_INDEX = os.getenv('AZURE_SEARCH_CONVERSATIONS_LOG_INDEX', 'conversations')
+        self.AZURE_SEARCH_SERVICE = os.getenv("AZURE_SEARCH_SERVICE", "")
+        self.AZURE_SEARCH_INDEX = os.getenv("AZURE_SEARCH_INDEX", "")
+        self.AZURE_SEARCH_KEY = os.getenv("AZURE_SEARCH_KEY", "")
+        self.AZURE_SEARCH_USE_SEMANTIC_SEARCH = os.getenv(
+            "AZURE_SEARCH_USE_SEMANTIC_SEARCH", ""
+        )
+        self.AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG = os.getenv(
+            "AZURE_SEARCH_SEMANTIC_SEARCH_CONFIG", ""
+        )
+        self.AZURE_SEARCH_INDEX_IS_PRECHUNKED = os.getenv(
+            "AZURE_SEARCH_INDEX_IS_PRECHUNKED", ""
+        )
+        self.AZURE_SEARCH_TOP_K = os.getenv("AZURE_SEARCH_TOP_K", "")
+        self.AZURE_SEARCH_ENABLE_IN_DOMAIN = os.getenv(
+            "AZURE_SEARCH_ENABLE_IN_DOMAIN", ""
+        )
+        self.AZURE_SEARCH_FIELDS_ID = os.getenv("AZURE_SEARCH_FIELDS_ID", "id")
+        self.AZURE_SEARCH_CONTENT_COLUMNS = os.getenv(
+            "AZURE_SEARCH_CONTENT_COLUMNS", "content"
+        )
+        self.AZURE_SEARCH_CONTENT_VECTOR_COLUMNS = os.getenv(
+            "AZURE_SEARCH_CONTENT_VECTOR_COLUMNS", "content_vector"
+        )
+        self.AZURE_SEARCH_DIMENSIONS = os.getenv("AZURE_SEARCH_DIMENSIONS", "1536")
+        self.AZURE_SEARCH_FILENAME_COLUMN = os.getenv(
+            "AZURE_SEARCH_FILENAME_COLUMN", "filepath"
+        )
+        self.AZURE_SEARCH_TITLE_COLUMN = os.getenv("AZURE_SEARCH_TITLE_COLUMN", "title")
+        self.AZURE_SEARCH_URL_COLUMN = os.getenv("AZURE_SEARCH_URL_COLUMN", "url")
+        self.AZURE_SEARCH_FIELDS_TAG = os.getenv("AZURE_SEARCH_FIELDS_TAG", "tag")
+        self.AZURE_SEARCH_FIELDS_METADATA = os.getenv(
+            "AZURE_SEARCH_FIELDS_METADATA", "metadata"
+        )
+        self.AZURE_SEARCH_CONVERSATIONS_LOG_INDEX = os.getenv(
+            "AZURE_SEARCH_CONVERSATIONS_LOG_INDEX", "conversations"
+        )
         self.AZURE_AUTH_TYPE = os.environ.get("AZURE_AUTH_TYPE", "keys")
         # Azure OpenAI
-        self.AZURE_OPENAI_RESOURCE = os.getenv('AZURE_OPENAI_RESOURCE', '')
-        self.AZURE_OPENAI_MODEL = os.getenv('AZURE_OPENAI_MODEL', '')
-        self.AZURE_OPENAI_KEY = os.getenv('AZURE_OPENAI_KEY', '')
-        self.AZURE_OPENAI_MODEL_NAME = os.getenv('AZURE_OPENAI_MODEL_NAME', '')
-        self.AZURE_OPENAI_TEMPERATURE = os.getenv('AZURE_OPENAI_TEMPERATURE', '')
-        self.AZURE_OPENAI_TOP_P = os.getenv('AZURE_OPENAI_TOP_P', '')
-        self.AZURE_OPENAI_MAX_TOKENS = os.getenv('AZURE_OPENAI_MAX_TOKENS', '')
-        self.AZURE_OPENAI_STOP_SEQUENCE = os.getenv('AZURE_OPENAI_STOP_SEQUENCE', '')
-        self.AZURE_OPENAI_SYSTEM_MESSAGE = os.getenv('AZURE_OPENAI_SYSTEM_MESSAGE', '')
-        self.AZURE_OPENAI_API_VERSION = os.getenv('AZURE_OPENAI_API_VERSION', '')
-        self.AZURE_OPENAI_STREAM = os.getenv('AZURE_OPENAI_STREAM', '')
-        self.AZURE_OPENAI_EMBEDDING_MODEL = os.getenv('AZURE_OPENAI_EMBEDDING_MODEL', '')
-         # Set env for OpenAI SDK
-        self.OPENAI_API_BASE = f"https://{os.getenv('AZURE_OPENAI_RESOURCE')}.openai.azure.com/"
+        self.AZURE_OPENAI_RESOURCE = os.getenv("AZURE_OPENAI_RESOURCE", "")
+        self.AZURE_OPENAI_MODEL = os.getenv("AZURE_OPENAI_MODEL", "")
+        self.AZURE_OPENAI_KEY = os.getenv("AZURE_OPENAI_KEY", "")
+        self.AZURE_OPENAI_MODEL_NAME = os.getenv("AZURE_OPENAI_MODEL_NAME", "")
+        self.AZURE_OPENAI_TEMPERATURE = os.getenv("AZURE_OPENAI_TEMPERATURE", "")
+        self.AZURE_OPENAI_TOP_P = os.getenv("AZURE_OPENAI_TOP_P", "")
+        self.AZURE_OPENAI_MAX_TOKENS = os.getenv("AZURE_OPENAI_MAX_TOKENS", "")
+        self.AZURE_OPENAI_STOP_SEQUENCE = os.getenv("AZURE_OPENAI_STOP_SEQUENCE", "")
+        self.AZURE_OPENAI_SYSTEM_MESSAGE = os.getenv("AZURE_OPENAI_SYSTEM_MESSAGE", "")
+        self.AZURE_OPENAI_API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION", "")
+        self.AZURE_OPENAI_STREAM = os.getenv("AZURE_OPENAI_STREAM", "")
+        self.AZURE_OPENAI_EMBEDDING_MODEL = os.getenv(
+            "AZURE_OPENAI_EMBEDDING_MODEL", ""
+        )
+        # Set env for OpenAI SDK
+        self.OPENAI_API_BASE = (
+            f"https://{os.getenv('AZURE_OPENAI_RESOURCE')}.openai.azure.com/"
+        )
         self.OPENAI_API_TYPE = "azure" if self.AZURE_AUTH_TYPE == "keys" else "azure_ad"
-        if self.AZURE_AUTH_TYPE == "keys": 
+        if self.AZURE_AUTH_TYPE == "keys":
             self.OPENAI_API_KEY = self.AZURE_OPENAI_KEY
         else:
-            self.OPENAI_API_KEY = DefaultAzureCredential(exclude_shared_token_cache_credential=True).get_token("https://cognitiveservices.azure.com/.default").token
+            self.OPENAI_API_KEY = (
+                DefaultAzureCredential(exclude_shared_token_cache_credential=True)
+                .get_token("https://cognitiveservices.azure.com/.default")
+                .token
+            )
         self.OPENAI_API_VERSION = self.AZURE_OPENAI_API_VERSION
         os.environ["OPENAI_API_TYPE"] = self.OPENAI_API_TYPE
-        os.environ["OPENAI_API_BASE"] = f"https://{os.getenv('AZURE_OPENAI_RESOURCE')}.openai.azure.com/"
+        os.environ[
+            "OPENAI_API_BASE"
+        ] = f"https://{os.getenv('AZURE_OPENAI_RESOURCE')}.openai.azure.com/"
         os.environ["OPENAI_API_KEY"] = self.OPENAI_API_KEY
         os.environ["OPENAI_API_VERSION"] = self.AZURE_OPENAI_API_VERSION
         # Azure Functions - Batch processing
-        self.BACKEND_URL = os.getenv('BACKEND_URL', '')
-        self.AzureWebJobsStorage = os.getenv('AzureWebJobsStorage', '')
-        self.DOCUMENT_PROCESSING_QUEUE_NAME = os.getenv('DOCUMENT_PROCESSING_QUEUE_NAME', '')
+        self.BACKEND_URL = os.getenv("BACKEND_URL", "")
+        self.AzureWebJobsStorage = os.getenv("AzureWebJobsStorage", "")
+        self.DOCUMENT_PROCESSING_QUEUE_NAME = os.getenv(
+            "DOCUMENT_PROCESSING_QUEUE_NAME", ""
+        )
         # Azure Blob Storage
-        self.AZURE_BLOB_ACCOUNT_NAME = os.getenv('AZURE_BLOB_ACCOUNT_NAME', '')
-        self.AZURE_BLOB_ACCOUNT_KEY = os.getenv('AZURE_BLOB_ACCOUNT_KEY', '')
-        self.AZURE_BLOB_CONTAINER_NAME = os.getenv('AZURE_BLOB_CONTAINER_NAME', '')
+        self.AZURE_BLOB_ACCOUNT_NAME = os.getenv("AZURE_BLOB_ACCOUNT_NAME", "")
+        self.AZURE_BLOB_ACCOUNT_KEY = os.getenv("AZURE_BLOB_ACCOUNT_KEY", "")
+        self.AZURE_BLOB_CONTAINER_NAME = os.getenv("AZURE_BLOB_CONTAINER_NAME", "")
         # Azure Form Recognizer
-        self.AZURE_FORM_RECOGNIZER_ENDPOINT = os.getenv('AZURE_FORM_RECOGNIZER_ENDPOINT', '')
-        self.AZURE_FORM_RECOGNIZER_KEY = os.getenv('AZURE_FORM_RECOGNIZER_KEY', '')
+        self.AZURE_FORM_RECOGNIZER_ENDPOINT = os.getenv(
+            "AZURE_FORM_RECOGNIZER_ENDPOINT", ""
+        )
+        self.AZURE_FORM_RECOGNIZER_KEY = os.getenv("AZURE_FORM_RECOGNIZER_KEY", "")
         # Azure App Insights
-        self.APPINSIGHTS_CONNECTION_STRING = os.getenv('APPINSIGHTS_CONNECTION_STRING', '')
+        self.APPINSIGHTS_CONNECTION_STRING = os.getenv(
+            "APPINSIGHTS_CONNECTION_STRING", ""
+        )
         # Azure AI Content Safety
-        self.AZURE_CONTENT_SAFETY_ENDPOINT = os.getenv('AZURE_CONTENT_SAFETY_ENDPOINT', '')
-        if 'https' not in self.AZURE_CONTENT_SAFETY_ENDPOINT and 'api.cognitive.microsoft.com' not in self.AZURE_CONTENT_SAFETY_ENDPOINT:
+        self.AZURE_CONTENT_SAFETY_ENDPOINT = os.getenv(
+            "AZURE_CONTENT_SAFETY_ENDPOINT", ""
+        )
+        if (
+            "https" not in self.AZURE_CONTENT_SAFETY_ENDPOINT
+            and "api.cognitive.microsoft.com" not in self.AZURE_CONTENT_SAFETY_ENDPOINT
+        ):
             self.AZURE_CONTENT_SAFETY_ENDPOINT = self.AZURE_FORM_RECOGNIZER_ENDPOINT
-        self.AZURE_CONTENT_SAFETY_KEY = os.getenv('AZURE_CONTENT_SAFETY_KEY', '')
+        self.AZURE_CONTENT_SAFETY_KEY = os.getenv("AZURE_CONTENT_SAFETY_KEY", "")
         # Orchestration Settings
-        self.ORCHESTRATION_STRATEGY = os.getenv('ORCHESTRATION_STRATEGY', 'openai_function')
-    
+        self.ORCHESTRATION_STRATEGY = os.getenv(
+            "ORCHESTRATION_STRATEGY", "openai_function"
+        )
+
     @staticmethod
     def check_env():
         for attr, value in EnvHelper().__dict__.items():
-            if value == '':
+            if value == "":
                 logging.warning(f"{attr} is not set in the environment variables.")
diff --git a/code/utilities/helpers/LLMHelper.py b/code/utilities/helpers/LLMHelper.py
index 74742ab5c..241088c16 100644
--- a/code/utilities/helpers/LLMHelper.py
+++ b/code/utilities/helpers/LLMHelper.py
@@ -5,6 +5,7 @@
 from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
 from .EnvHelper import EnvHelper
 
+
 class LLMHelper:
     def __init__(self):
         env_helper: EnvHelper = EnvHelper()
@@ -14,32 +15,49 @@ def __init__(self):
         openai.api_version = env_helper.AZURE_OPENAI_API_VERSION
         openai.api_base = env_helper.OPENAI_API_BASE
         openai.api_key = env_helper.OPENAI_API_KEY
-        
+
         self.llm_model = env_helper.AZURE_OPENAI_MODEL
-        self.llm_max_tokens = env_helper.AZURE_OPENAI_MAX_TOKENS if env_helper.AZURE_OPENAI_MAX_TOKENS != '' else None
+        self.llm_max_tokens = (
+            env_helper.AZURE_OPENAI_MAX_TOKENS
+            if env_helper.AZURE_OPENAI_MAX_TOKENS != ""
+            else None
+        )
         self.embedding_model = env_helper.AZURE_OPENAI_EMBEDDING_MODEL
-                    
+
     def get_llm(self):
-        return AzureChatOpenAI(deployment_name=self.llm_model, temperature=0, max_tokens=self.llm_max_tokens, openai_api_version=openai.api_version)
-    
+        return AzureChatOpenAI(
+            deployment_name=self.llm_model,
+            temperature=0,
+            max_tokens=self.llm_max_tokens,
+            openai_api_version=openai.api_version,
+        )
+
     # TODO: This needs to have a custom callback to stream back to the UI
     def get_streaming_llm(self):
-        return AzureChatOpenAI(streaming=True, callbacks=[StreamingStdOutCallbackHandler], deployment_name=self.llm_model, temperature=0, 
-                               max_tokens=self.llm_max_tokens, openai_api_version=openai.api_version)
-    
+        return AzureChatOpenAI(
+            streaming=True,
+            callbacks=[StreamingStdOutCallbackHandler],
+            deployment_name=self.llm_model,
+            temperature=0,
+            max_tokens=self.llm_max_tokens,
+            openai_api_version=openai.api_version,
+        )
+
     def get_embedding_model(self):
         return OpenAIEmbeddings(deployment=self.embedding_model, chunk_size=1)
-    
-    def get_chat_completion_with_functions(self, messages: List[dict], functions: List[dict], function_call: str="auto"):
+
+    def get_chat_completion_with_functions(
+        self, messages: List[dict], functions: List[dict], function_call: str = "auto"
+    ):
         return openai.ChatCompletion.create(
             deployment_id=self.llm_model,
             messages=messages,
             functions=functions,
             function_call=function_call,
-            )
-        
+        )
+
     def get_chat_completion(self, messages: List[dict]):
         return openai.ChatCompletion.create(
             deployment_id=self.llm_model,
             messages=messages,
-            )
+        )
diff --git a/code/utilities/helpers/OrchestratorHelper.py b/code/utilities/helpers/OrchestratorHelper.py
index 06135d1b0..9d404e81b 100644
--- a/code/utilities/helpers/OrchestratorHelper.py
+++ b/code/utilities/helpers/OrchestratorHelper.py
@@ -1,14 +1,25 @@
 from typing import List
-from langchain.docstore.document import Document
-from ..orchestrator import get_orchestrator, OrchestrationSettings, OrchestrationStrategy
+from ..orchestrator import OrchestrationSettings
+from ..orchestrator.Strategies import get_orchestrator, OrchestrationStrategy
+
+__all__ = ["OrchestrationStrategy"]
+
 
 class Orchestrator:
     def __init__(self) -> None:
         pass
-    
-    def handle_message(self, user_message: str, chat_history: List[dict], conversation_id: str , orchestrator: OrchestrationSettings, **kwargs: dict) -> dict:
+
+    def handle_message(
+        self,
+        user_message: str,
+        chat_history: List[dict],
+        conversation_id: str,
+        orchestrator: OrchestrationSettings,
+        **kwargs: dict,
+    ) -> dict:
         orchestrator = get_orchestrator(orchestrator.strategy.value)
         if orchestrator is None:
-            raise Exception(f"Unknown orchestration strategy: {orchestrator.strategy.value}")
+            raise Exception(
+                f"Unknown orchestration strategy: {orchestrator.strategy.value}"
+            )
         return orchestrator.handle_message(user_message, chat_history, conversation_id)
-    
\ No newline at end of file
diff --git a/code/utilities/loggers/ConversationLogger.py b/code/utilities/loggers/ConversationLogger.py
index d6ec5f479..6a54f8321 100644
--- a/code/utilities/loggers/ConversationLogger.py
+++ b/code/utilities/loggers/ConversationLogger.py
@@ -1,42 +1,46 @@
-from ..helpers.EnvHelper import EnvHelper
 from ..helpers.AzureSearchHelper import AzureSearchHelper
 from datetime import datetime
 import json
 
-class ConversationLogger():
+
+class ConversationLogger:
     def __init__(self):
         self.logger = AzureSearchHelper().get_conversation_logger()
-        
+
     def log(self, messages: list):
         self.log_user_message(messages)
         self.log_assistant_message(messages)
-        
+
     def log_user_message(self, messages: dict):
         text = ""
         metadata = {}
         for message in messages:
-            if message['role'] == "user":
-                metadata['type'] = message['role']
-                metadata['conversation_id'] = message.get('conversation_id')
-                metadata['created_at'] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
-                metadata['updated_at'] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
-                text = message['content']
-        self.logger.add_texts(texts=[text], metadatas=[metadata])                
-        
+            if message["role"] == "user":
+                metadata["type"] = message["role"]
+                metadata["conversation_id"] = message.get("conversation_id")
+                metadata["created_at"] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
+                metadata["updated_at"] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
+                text = message["content"]
+        self.logger.add_texts(texts=[text], metadatas=[metadata])
+
     def log_assistant_message(self, messages: dict):
         text = ""
         metadata = {}
         try:
-            metadata['conversation_id'] = set(filter(None, [message.get('conversation_id') for message in messages])).pop()
+            metadata["conversation_id"] = set(
+                filter(None, [message.get("conversation_id") for message in messages])
+            ).pop()
         except KeyError:
-            metadata['conversation_id'] = None
+            metadata["conversation_id"] = None
         for message in messages:
-            if message['role'] == "assistant":
-                metadata['type'] = message['role']
-                metadata['created_at'] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
-                metadata['updated_at'] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
-                text = message['content']
-            elif message['role'] == "tool":
-                metadata['sources'] = [source['id'] for source in json.loads(message["content"]).get("citations", [])]
+            if message["role"] == "assistant":
+                metadata["type"] = message["role"]
+                metadata["created_at"] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
+                metadata["updated_at"] = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
+                text = message["content"]
+            elif message["role"] == "tool":
+                metadata["sources"] = [
+                    source["id"]
+                    for source in json.loads(message["content"]).get("citations", [])
+                ]
         self.logger.add_texts(texts=[text], metadatas=[metadata])
-            
\ No newline at end of file
diff --git a/code/utilities/loggers/TokenLogger.py b/code/utilities/loggers/TokenLogger.py
index 0172766ec..77c3546b9 100644
--- a/code/utilities/loggers/TokenLogger.py
+++ b/code/utilities/loggers/TokenLogger.py
@@ -2,20 +2,20 @@
 from opencensus.ext.azure.log_exporter import AzureLogHandler
 from ..helpers.EnvHelper import EnvHelper
 
+
 class TokenLogger:
     def __init__(self, name: str = __name__):
-        env_helper : EnvHelper = EnvHelper()
+        env_helper: EnvHelper = EnvHelper()
         self.logger = logging.getLogger(name)
-        self.logger.addHandler(AzureLogHandler(connection_string=env_helper.APPINSIGHTS_CONNECTION_STRING))
+        self.logger.addHandler(
+            AzureLogHandler(connection_string=env_helper.APPINSIGHTS_CONNECTION_STRING)
+        )
         self.logger.setLevel(logging.INFO)
-    
+
     def get_logger(self):
         return self.logger
-    
+
     def log(self, message: str, custom_dimensions: dict):
         # Setting log properties
-        log_properties = {
-            "custom_dimensions": custom_dimensions
-        }
+        log_properties = {"custom_dimensions": custom_dimensions}
         self.logger.info(message, extra=log_properties)
-    
\ No newline at end of file
diff --git a/code/utilities/orchestrator/LangChainAgent.py b/code/utilities/orchestrator/LangChainAgent.py
index 65f9bba19..445cf1598 100644
--- a/code/utilities/orchestrator/LangChainAgent.py
+++ b/code/utilities/orchestrator/LangChainAgent.py
@@ -1,10 +1,10 @@
 from typing import List
-from langchain.agents import initialize_agent, Tool
+from langchain.agents import Tool
 from langchain.memory import ConversationBufferMemory
 from langchain.agents import ZeroShotAgent, AgentExecutor
 from langchain import LLMChain
 from langchain.callbacks import get_openai_callback
-        
+
 from .OrchestratorBase import OrchestratorBase
 from ..helpers.LLMHelper import LLMHelper
 from ..tools.PostPromptTool import PostPromptTool
@@ -14,9 +14,10 @@
 from ..parser.OutputParserTool import OutputParserTool
 from ..common.Answer import Answer
 
+
 class LangChainAgent(OrchestratorBase):
     def __init__(self) -> None:
-        super().__init__()   
+        super().__init__()
         self.content_safety_checker = ContentSafetyChecker()
         self.question_answer_tool = QuestionAnswerTool()
         self.text_processing_tool = TextProcessingTool()
@@ -30,31 +31,45 @@ def __init__(self) -> None:
             Tool(
                 name="Text Processing",
                 func=self.run_text_processing_tool,
-                description="""useful for when you need to process text like translate to Italian, summarize, make concise, in Spanish. 
+                description="""useful for when you need to process text like translate to Italian, summarize, make concise, in Spanish.
                 Always start the input with be a proper text operation with language if mentioned and then the full text to process.
                 e.g. translate to Spanish: <text to translate>""",
                 return_direct=True,
-            )
+            ),
         ]
 
     def run_tool(self, user_message):
-        answer = self.question_answer_tool.answer_question(user_message, chat_history=[])
+        answer = self.question_answer_tool.answer_question(
+            user_message, chat_history=[]
+        )
         return answer.to_json()
-    
+
     def run_text_processing_tool(self, user_message):
-        answer = self.text_processing_tool.answer_question(user_message, chat_history=[])
-        return answer.to_json()   
-    
-    def orchestrate(self, user_message: str, chat_history: List[dict], **kwargs: dict) -> dict:
+        answer = self.text_processing_tool.answer_question(
+            user_message, chat_history=[]
+        )
+        return answer.to_json()
+
+    def orchestrate(
+        self, user_message: str, chat_history: List[dict], **kwargs: dict
+    ) -> dict:
         output_formatter = OutputParserTool()
-        
+
         # Call Content Safety tool
         if self.config.prompts.enable_content_safety:
-            filtered_user_message = self.content_safety_checker.validate_input_and_replace_if_harmful(user_message)
+            filtered_user_message = (
+                self.content_safety_checker.validate_input_and_replace_if_harmful(
+                    user_message
+                )
+            )
             if user_message != filtered_user_message:
-                messages = output_formatter.parse(question=user_message, answer=filtered_user_message, source_documents=[])
+                messages = output_formatter.parse(
+                    question=user_message,
+                    answer=filtered_user_message,
+                    source_documents=[],
+                )
                 return messages
-        
+
         # Call function to determine route
         llm_helper = LLMHelper()
         prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
@@ -70,7 +85,9 @@ def orchestrate(self, user_message: str, chat_history: List[dict], **kwargs: dic
             input_variables=["input", "chat_history", "agent_scratchpad"],
         )
         # Create conversation memory
-        memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+        memory = ConversationBufferMemory(
+            memory_key="chat_history", return_messages=True
+        )
         for message in chat_history:
             memory.chat_memory.add_user_message(message[0])
             memory.chat_memory.add_ai_message(message[1])
@@ -84,27 +101,42 @@ def orchestrate(self, user_message: str, chat_history: List[dict], **kwargs: dic
         with get_openai_callback() as cb:
             try:
                 answer = agent_chain.run(user_message)
-                self.log_tokens(prompt_tokens=cb.prompt_tokens, completion_tokens=cb.completion_tokens)
+                self.log_tokens(
+                    prompt_tokens=cb.prompt_tokens,
+                    completion_tokens=cb.completion_tokens,
+                )
             except Exception as e:
                 answer = str(e)
         try:
             answer = Answer.from_json(answer)
-        except:
+        except Exception:
             answer = Answer(question=user_message, answer=answer)
-        
+
         if self.config.prompts.enable_post_answering_prompt:
             post_prompt_tool = PostPromptTool()
             answer = post_prompt_tool.validate_answer(answer)
-            self.log_tokens(prompt_tokens=answer.prompt_tokens, completion_tokens=answer.completion_tokens)                
+            self.log_tokens(
+                prompt_tokens=answer.prompt_tokens,
+                completion_tokens=answer.completion_tokens,
+            )
 
         # Call Content Safety tool
         if self.config.prompts.enable_content_safety:
-            filtered_answer = self.content_safety_checker.validate_output_and_replace_if_harmful(answer.answer)
+            filtered_answer = (
+                self.content_safety_checker.validate_output_and_replace_if_harmful(
+                    answer.answer
+                )
+            )
             if answer.answer != filtered_answer:
-                messages = output_formatter.parse(question=user_message, answer=filtered_answer, source_documents=[])
+                messages = output_formatter.parse(
+                    question=user_message, answer=filtered_answer, source_documents=[]
+                )
                 return messages
-        
-        # Format the output for the UI        
-        messages = output_formatter.parse(question=answer.question, answer=answer.answer, source_documents=answer.source_documents)
+
+        # Format the output for the UI
+        messages = output_formatter.parse(
+            question=answer.question,
+            answer=answer.answer,
+            source_documents=answer.source_documents,
+        )
         return messages
-    
\ No newline at end of file
diff --git a/code/utilities/orchestrator/OpenAIFunctions.py b/code/utilities/orchestrator/OpenAIFunctions.py
index d04d1a98e..c132f2ce0 100644
--- a/code/utilities/orchestrator/OpenAIFunctions.py
+++ b/code/utilities/orchestrator/OpenAIFunctions.py
@@ -1,9 +1,8 @@
-from typing import List, Optional
+from typing import List
 import json
 
 from .OrchestratorBase import OrchestratorBase
 from ..helpers.LLMHelper import LLMHelper
-from ..helpers.ConfigHelper import ConfigHelper
 from ..tools.PostPromptTool import PostPromptTool
 from ..tools.QuestionAnswerTool import QuestionAnswerTool
 from ..tools.TextProcessingTool import TextProcessingTool
@@ -11,9 +10,10 @@
 from ..parser.OutputParserTool import OutputParserTool
 from ..common.Answer import Answer
 
+
 class OpenAIFunctionsOrchestrator(OrchestratorBase):
     def __init__(self) -> None:
-        super().__init__()   
+        super().__init__()
         self.content_safety_checker = ContentSafetyChecker()
         self.functions = [
             {
@@ -47,19 +47,29 @@ def __init__(self) -> None:
                     },
                     "required": ["text", "operation"],
                 },
-            }
+            },
         ]
-        
-    def orchestrate(self, user_message: str, chat_history: List[dict], **kwargs: dict) -> dict:
+
+    def orchestrate(
+        self, user_message: str, chat_history: List[dict], **kwargs: dict
+    ) -> dict:
         output_formatter = OutputParserTool()
-        
+
         # Call Content Safety tool
         if self.config.prompts.enable_content_safety:
-            filtered_user_message = self.content_safety_checker.validate_input_and_replace_if_harmful(user_message)
+            filtered_user_message = (
+                self.content_safety_checker.validate_input_and_replace_if_harmful(
+                    user_message
+                )
+            )
             if user_message != filtered_user_message:
-                messages = output_formatter.parse(question=user_message, answer=filtered_user_message, source_documents=[])
+                messages = output_formatter.parse(
+                    question=user_message,
+                    answer=filtered_user_message,
+                    source_documents=[],
+                )
                 return messages
-        
+
         # Call function to determine route
         llm_helper = LLMHelper()
 
@@ -69,49 +79,82 @@ def orchestrate(self, user_message: str, chat_history: List[dict], **kwargs: dic
         When directly replying to the user, always reply in the language the user is speaking.
         """
         # Create conversation history
-        messages = [{"role": "system", "content": system_message}]        
+        messages = [{"role": "system", "content": system_message}]
         for message in chat_history:
             messages.append({"role": "user", "content": message[0]})
             messages.append({"role": "assistant", "content": message[1]})
         messages.append({"role": "user", "content": user_message})
-        
-        result = llm_helper.get_chat_completion_with_functions(messages, self.functions, function_call="auto")      
-        self.log_tokens(prompt_tokens=result['usage']['prompt_tokens'], completion_tokens=result['usage']['completion_tokens'])
-        
+
+        result = llm_helper.get_chat_completion_with_functions(
+            messages, self.functions, function_call="auto"
+        )
+        self.log_tokens(
+            prompt_tokens=result["usage"]["prompt_tokens"],
+            completion_tokens=result["usage"]["completion_tokens"],
+        )
+
         # TODO: call content safety if needed
-                        
-        if result['choices'][0]['finish_reason'] == "function_call":
-            if result['choices'][0]['message'].function_call.name == "search_documents":
-                question = json.loads(result['choices'][0]['message']['function_call']['arguments'])['question']
+
+        if result["choices"][0]["finish_reason"] == "function_call":
+            if result["choices"][0]["message"].function_call.name == "search_documents":
+                question = json.loads(
+                    result["choices"][0]["message"]["function_call"]["arguments"]
+                )["question"]
                 # run answering chain
                 answering_tool = QuestionAnswerTool()
                 answer = answering_tool.answer_question(question, chat_history)
 
-                self.log_tokens(prompt_tokens=answer.prompt_tokens, completion_tokens=answer.completion_tokens)
+                self.log_tokens(
+                    prompt_tokens=answer.prompt_tokens,
+                    completion_tokens=answer.completion_tokens,
+                )
 
                 # Run post prompt if needed
                 if self.config.prompts.enable_post_answering_prompt:
                     post_prompt_tool = PostPromptTool()
                     answer = post_prompt_tool.validate_answer(answer)
-                    self.log_tokens(prompt_tokens=answer.prompt_tokens, completion_tokens=answer.completion_tokens)                
-            elif result['choices'][0]['message'].function_call.name == "text_processing":
-                text = json.loads(result['choices'][0]['message']['function_call']['arguments'])['text']
-                operation = json.loads(result['choices'][0]['message']['function_call']['arguments'])['operation']
+                    self.log_tokens(
+                        prompt_tokens=answer.prompt_tokens,
+                        completion_tokens=answer.completion_tokens,
+                    )
+            elif (
+                result["choices"][0]["message"].function_call.name == "text_processing"
+            ):
+                text = json.loads(
+                    result["choices"][0]["message"]["function_call"]["arguments"]
+                )["text"]
+                operation = json.loads(
+                    result["choices"][0]["message"]["function_call"]["arguments"]
+                )["operation"]
                 text_processing_tool = TextProcessingTool()
-                answer = text_processing_tool.answer_question(user_message, chat_history, text=text, operation=operation)
-                self.log_tokens(prompt_tokens=answer.prompt_tokens, completion_tokens=answer.completion_tokens)
+                answer = text_processing_tool.answer_question(
+                    user_message, chat_history, text=text, operation=operation
+                )
+                self.log_tokens(
+                    prompt_tokens=answer.prompt_tokens,
+                    completion_tokens=answer.completion_tokens,
+                )
         else:
-            text = result['choices'][0]['message']['content']
+            text = result["choices"][0]["message"]["content"]
             answer = Answer(question=user_message, answer=text)
 
         # Call Content Safety tool
         if self.config.prompts.enable_content_safety:
-            filtered_answer = self.content_safety_checker.validate_output_and_replace_if_harmful(answer.answer)
+            filtered_answer = (
+                self.content_safety_checker.validate_output_and_replace_if_harmful(
+                    answer.answer
+                )
+            )
             if answer.answer != filtered_answer:
-                messages = output_formatter.parse(question=user_message, answer=filtered_answer, source_documents=[])
+                messages = output_formatter.parse(
+                    question=user_message, answer=filtered_answer, source_documents=[]
+                )
                 return messages
-        
-        # Format the output for the UI        
-        messages = output_formatter.parse(question=answer.question, answer=answer.answer, source_documents=answer.source_documents)
+
+        # Format the output for the UI
+        messages = output_formatter.parse(
+            question=answer.question,
+            answer=answer.answer,
+            source_documents=answer.source_documents,
+        )
         return messages
-        
\ No newline at end of file
diff --git a/code/utilities/orchestrator/OrchestratorBase.py b/code/utilities/orchestrator/OrchestratorBase.py
index 25758d523..b370ec38f 100644
--- a/code/utilities/orchestrator/OrchestratorBase.py
+++ b/code/utilities/orchestrator/OrchestratorBase.py
@@ -6,41 +6,54 @@
 from ..loggers.ConversationLogger import ConversationLogger
 from ..helpers.ConfigHelper import ConfigHelper
 
+
 class OrchestratorBase(ABC):
     def __init__(self) -> None:
         super().__init__()
         self.config = ConfigHelper.get_active_config_or_default()
         self.message_id = str(uuid4())
-        self.tokens = {
-            'prompt': 0,
-            'completion': 0,
-            'total': 0
-        }
+        self.tokens = {"prompt": 0, "completion": 0, "total": 0}
         print(f"New message id: {self.message_id} with tokens {self.tokens}")
-        self.token_logger : TokenLogger = TokenLogger()
-        self.conversation_logger : ConversationLogger = ConversationLogger()
-    
+        self.token_logger: TokenLogger = TokenLogger()
+        self.conversation_logger: ConversationLogger = ConversationLogger()
+
     def log_tokens(self, prompt_tokens, completion_tokens):
-        self.tokens['prompt'] += prompt_tokens
-        self.tokens['completion'] += completion_tokens
-        self.tokens['total'] += prompt_tokens + completion_tokens
-        
+        self.tokens["prompt"] += prompt_tokens
+        self.tokens["completion"] += completion_tokens
+        self.tokens["total"] += prompt_tokens + completion_tokens
+
     @abstractmethod
-    def orchestrate(self, user_message: str, chat_history: List[dict], **kwargs: dict) -> dict:
+    def orchestrate(
+        self, user_message: str, chat_history: List[dict], **kwargs: dict
+    ) -> dict:
         pass
-    
-    def handle_message(self, user_message: str, chat_history: List[dict], conversation_id: Optional[str], **kwargs: Optional[dict]) -> dict:
+
+    def handle_message(
+        self,
+        user_message: str,
+        chat_history: List[dict],
+        conversation_id: Optional[str],
+        **kwargs: Optional[dict],
+    ) -> dict:
         result = self.orchestrate(user_message, chat_history, **kwargs)
         if self.config.logging.log_tokens:
             custom_dimensions = {
                 "conversation_id": conversation_id,
                 "message_id": self.message_id,
-                "prompt_tokens": self.tokens['prompt'],
-                "completion_tokens": self.tokens['completion'],
-                "total_tokens": self.tokens['total']
+                "prompt_tokens": self.tokens["prompt"],
+                "completion_tokens": self.tokens["completion"],
+                "total_tokens": self.tokens["total"],
             }
             self.token_logger.log("Conversation", custom_dimensions=custom_dimensions)
-        if self.config.logging.log_user_interactions:  
-            self.conversation_logger.log(messages=[{"role": "user", "content": user_message, "conversation_id": conversation_id}] + result)          
+        if self.config.logging.log_user_interactions:
+            self.conversation_logger.log(
+                messages=[
+                    {
+                        "role": "user",
+                        "content": user_message,
+                        "conversation_id": conversation_id,
+                    }
+                ]
+                + result
+            )
         return result
-        
\ No newline at end of file
diff --git a/code/utilities/orchestrator/Strategies.py b/code/utilities/orchestrator/Strategies.py
index d91507ccf..f83480402 100644
--- a/code/utilities/orchestrator/Strategies.py
+++ b/code/utilities/orchestrator/Strategies.py
@@ -1,16 +1,19 @@
 from enum import Enum
 
+
 class OrchestrationStrategy(Enum):
-    OPENAI_FUNCTION = 'openai_function'
-    LANGCHAIN = 'langchain'
+    OPENAI_FUNCTION = "openai_function"
+    LANGCHAIN = "langchain"
+
 
 def get_orchestrator(orchestration_strategy: str):
     if orchestration_strategy == OrchestrationStrategy.OPENAI_FUNCTION.value:
         from .OpenAIFunctions import OpenAIFunctionsOrchestrator
+
         return OpenAIFunctionsOrchestrator()
     elif orchestration_strategy == OrchestrationStrategy.LANGCHAIN.value:
         from .LangChainAgent import LangChainAgent
+
         return LangChainAgent()
     else:
-        raise Exception(f"Unknown orchestration strategy: {orchestration_strategy}")    
-    
\ No newline at end of file
+        raise Exception(f"Unknown orchestration strategy: {orchestration_strategy}")
diff --git a/code/utilities/orchestrator/__init__.py b/code/utilities/orchestrator/__init__.py
index eb1be10a6..da087d844 100644
--- a/code/utilities/orchestrator/__init__.py
+++ b/code/utilities/orchestrator/__init__.py
@@ -1,15 +1,18 @@
 import os
 from typing import List
-import os.path, pkgutil
-from .Strategies import OrchestrationStrategy, get_orchestrator
-    
+import os.path
+import pkgutil
+from .Strategies import OrchestrationStrategy
+
+
 class OrchestrationSettings:
     def __init__(self, orchestration: dict):
-        self.strategy = OrchestrationStrategy(orchestration['strategy'])
+        self.strategy = OrchestrationStrategy(orchestration["strategy"])
+
 
 # Get a list of all the classes defined in the module
 def get_all_classes() -> List[str]:
     return [name for _, name, _ in pkgutil.iter_modules([os.path.dirname(__file__)])]
 
+
 __all__ = get_all_classes()
-    
\ No newline at end of file
diff --git a/code/utilities/parser/OutputParserTool.py b/code/utilities/parser/OutputParserTool.py
index e66bd337e..ac1ceb614 100644
--- a/code/utilities/parser/OutputParserTool.py
+++ b/code/utilities/parser/OutputParserTool.py
@@ -5,35 +5,41 @@
 from .ParserBase import ParserBase
 from ..common.SourceDocument import SourceDocument
 
+
 class OutputParserTool(ParserBase):
     def __init__(self) -> None:
         self.name = "OutputParser"
-    
+
     def _clean_up_answer(self, answer):
-        return answer.replace('  ', ' ')
-    
+        return answer.replace("  ", " ")
+
     def _get_source_docs_from_answer(self, answer):
         # extract all [docN] from answer and extract N, and just return the N's as a list of ints
-        results = re.findall(r'\[doc(\d+)\]', answer)
+        results = re.findall(r"\[doc(\d+)\]", answer)
         return [int(i) for i in results]
-       
+
     def _replace_last(self, text, old, new):
-        """Replaces the last occurence of a substring in a string 
-        
-        This is done by reversing the string using [::-1], replacing the first occurence of the reversed substring, and 
+        """Replaces the last occurence of a substring in a string
+
+        This is done by reversing the string using [::-1], replacing the first occurence of the reversed substring, and
         reversing the string again.
         """
-        return (text[::-1].replace(old[::-1],new[::-1], 1))[::-1]
-       
+        return (text[::-1].replace(old[::-1], new[::-1], 1))[::-1]
+
     def _make_doc_references_sequential(self, answer, doc_ids):
         for i, idx in enumerate(doc_ids):
-            answer = self._replace_last(answer, f'[doc{idx}]', f'[doc{i+1}]')
+            answer = self._replace_last(answer, f"[doc{idx}]", f"[doc{i+1}]")
         return answer
-    
-    def parse(self, question: str, answer: str, source_documents: List[SourceDocument], **kwargs: dict) -> List[dict]:     
-        
+
+    def parse(
+        self,
+        question: str,
+        answer: str,
+        source_documents: List[SourceDocument],
+        **kwargs: dict,
+    ) -> List[dict]:
         answer = self._clean_up_answer(answer)
-        doc_ids = self._get_source_docs_from_answer(answer)      
+        doc_ids = self._get_source_docs_from_answer(answer)
         answer = self._make_doc_references_sequential(answer, doc_ids)
 
         # create return message object
@@ -46,12 +52,12 @@ def parse(self, question: str, answer: str, source_documents: List[SourceDocumen
         ]
 
         for i in doc_ids:
-            idx = i-1
-            
+            idx = i - 1
+
             if idx >= len(source_documents):
                 logging.warning(f"Source document {i} not provided, skipping doc")
                 continue
-            
+
             doc = source_documents[idx]
             print(f"doc{idx}", doc)
 
@@ -69,15 +75,16 @@ def parse(self, question: str, answer: str, source_documents: List[SourceDocumen
                         "source": doc.source,
                         "markdown_url": doc.get_markdown_url(),
                         "title": doc.title,
-                        "original_url": doc.source, # TODO: do we need this?
+                        "original_url": doc.source,  # TODO: do we need this?
                         "chunk": doc.chunk,
                         "key": doc.id,
-                        "filename": doc.get_filename()
+                        "filename": doc.get_filename(),
                     },
-                })
+                }
+            )
         if messages[0]["content"]["citations"] == []:
-            answer = re.sub(r'\[doc\d+\]', '', answer)
+            answer = re.sub(r"\[doc\d+\]", "", answer)
         messages.append({"role": "assistant", "content": answer, "end_turn": True})
         # everything in content needs to be stringified to work with Azure BYOD frontend
         messages[0]["content"] = json.dumps(messages[0]["content"])
-        return messages
\ No newline at end of file
+        return messages
diff --git a/code/utilities/parser/ParserBase.py b/code/utilities/parser/ParserBase.py
index 3e487fd5e..1fb987d87 100644
--- a/code/utilities/parser/ParserBase.py
+++ b/code/utilities/parser/ParserBase.py
@@ -3,11 +3,17 @@
 from typing import List
 from ..common.SourceDocument import SourceDocument
 
+
 class ParserBase(ABC):
     def __init__(self) -> None:
         pass
-       
+
     @abstractmethod
-    def parse(self, question: str, answer: str, source_documents: List[SourceDocument], **kwargs: dict) -> List[dict]:        
+    def parse(
+        self,
+        question: str,
+        answer: str,
+        source_documents: List[SourceDocument],
+        **kwargs: dict
+    ) -> List[dict]:
         pass
-    
\ No newline at end of file
diff --git a/code/utilities/parser/__init__.py b/code/utilities/parser/__init__.py
index 1ea37fef0..05dd39f36 100644
--- a/code/utilities/parser/__init__.py
+++ b/code/utilities/parser/__init__.py
@@ -1,11 +1,11 @@
 # Create an abstract class for parser
 from abc import ABC, abstractmethod
 
+
 class ParserBase(ABC):
     def __init__(self) -> None:
         pass
-    
+
     @abstractmethod
-    def parse(self, input: dict, **kwargs: dict) -> dict:        
+    def parse(self, input: dict, **kwargs: dict) -> dict:
         pass
-    
\ No newline at end of file
diff --git a/code/utilities/tools/AnswerProcessingBase.py b/code/utilities/tools/AnswerProcessingBase.py
index 80ccaf822..040c00c4e 100644
--- a/code/utilities/tools/AnswerProcessingBase.py
+++ b/code/utilities/tools/AnswerProcessingBase.py
@@ -1,13 +1,12 @@
 # Create an abstract class for tool
 from abc import ABC, abstractmethod
-from typing import List
 from ..common.Answer import Answer
 
+
 class AnswerProcessingBase(ABC):
     def __init__(self) -> None:
         pass
-    
+
     @abstractmethod
-    def process_answer(self, answer: Answer,**kwargs: dict) -> Answer:        
+    def process_answer(self, answer: Answer, **kwargs: dict) -> Answer:
         pass
-    
\ No newline at end of file
diff --git a/code/utilities/tools/AnsweringToolBase.py b/code/utilities/tools/AnsweringToolBase.py
index d441a6d5e..3c1be2e32 100644
--- a/code/utilities/tools/AnsweringToolBase.py
+++ b/code/utilities/tools/AnsweringToolBase.py
@@ -3,10 +3,13 @@
 from typing import List
 from ..common.Answer import Answer
 
+
 class AnsweringToolBase(ABC):
     def __init__(self) -> None:
         pass
-    
+
     @abstractmethod
-    def answer_question(self, question: str, chat_history: List[dict], **kwargs: dict) -> Answer:
-        pass
\ No newline at end of file
+    def answer_question(
+        self, question: str, chat_history: List[dict], **kwargs: dict
+    ) -> Answer:
+        pass
diff --git a/code/utilities/tools/ContentSafetyChecker.py b/code/utilities/tools/ContentSafetyChecker.py
index 58005a6b6..da4f8963a 100644
--- a/code/utilities/tools/ContentSafetyChecker.py
+++ b/code/utilities/tools/ContentSafetyChecker.py
@@ -1,4 +1,3 @@
-from typing import List
 from azure.ai.contentsafety import ContentSafetyClient
 from azure.core.credentials import AzureKeyCredential
 from azure.core.exceptions import HttpResponseError
@@ -6,25 +5,35 @@
 from ..helpers.EnvHelper import EnvHelper
 from .AnswerProcessingBase import AnswerProcessingBase
 from ..common.Answer import Answer
- 
+
+
 class ContentSafetyChecker(AnswerProcessingBase):
     def __init__(self):
         env_helper = EnvHelper()
-        self.content_safety_client = ContentSafetyClient(env_helper.AZURE_CONTENT_SAFETY_ENDPOINT, AzureKeyCredential(env_helper.AZURE_CONTENT_SAFETY_KEY))
+        self.content_safety_client = ContentSafetyClient(
+            env_helper.AZURE_CONTENT_SAFETY_ENDPOINT,
+            AzureKeyCredential(env_helper.AZURE_CONTENT_SAFETY_KEY),
+        )
 
-    def process_answer(self, answer: Answer,**kwargs: dict) -> Answer:        
-        response_template = kwargs['response_template']
+    def process_answer(self, answer: Answer, **kwargs: dict) -> Answer:
+        response_template = kwargs["response_template"]
         answer.answer = self._filter_text_and_replace(answer.answer, response_template)
         return answer
 
     def validate_input_and_replace_if_harmful(self, text):
-        response_template = f"Unfortunately, I am not able to process your question, as I have detected sensitive content that I am not allowed to process. This might be a mistake, so please try rephrasing your question."
-        return self.process_answer(Answer(question="", answer=text, source_documents=[]), response_template=response_template).answer
-        
+        response_template = f'{"Unfortunately, I am not able to process your question, as I have detected sensitive content that I am not allowed to process. This might be a mistake, so please try rephrasing your question."}'
+        return self.process_answer(
+            Answer(question="", answer=text, source_documents=[]),
+            response_template=response_template,
+        ).answer
+
     def validate_output_and_replace_if_harmful(self, text):
-        response_template = f"Unfortunately, I have detected sensitive content in my answer, which I am not allowed to show you. This might be a mistake, so please try again and maybe rephrase your question."
-        return self.process_answer(Answer(question="", answer=text, source_documents=[]), response_template=response_template).answer
-    
+        response_template = f'{"Unfortunately, I have detected sensitive content in my answer, which I am not allowed to show you. This might be a mistake, so please try again and maybe rephrase your question."}'
+        return self.process_answer(
+            Answer(question="", answer=text, source_documents=[]),
+            response_template=response_template,
+        ).answer
+
     def _filter_text_and_replace(self, text, response_template):
         request = AnalyzeTextOptions(text=text)
         try:
@@ -39,9 +48,13 @@ def _filter_text_and_replace(self, text, response_template):
             raise
 
         filtered_text = text
-    
-        if response.hate_result.severity > 0 or response.self_harm_result.severity > 0 or response.sexual_result.severity > 0 or response.violence_result.severity > 0:
+
+        if (
+            response.hate_result.severity > 0
+            or response.self_harm_result.severity > 0
+            or response.sexual_result.severity > 0
+            or response.violence_result.severity > 0
+        ):
             filtered_text = response_template
-       
+
         return filtered_text
-    
\ No newline at end of file
diff --git a/code/utilities/tools/PostPromptTool.py b/code/utilities/tools/PostPromptTool.py
index 848bf1995..8f3ac7566 100644
--- a/code/utilities/tools/PostPromptTool.py
+++ b/code/utilities/tools/PostPromptTool.py
@@ -5,36 +5,62 @@
 from ..helpers.LLMHelper import LLMHelper
 from ..helpers.ConfigHelper import ConfigHelper
 
-class PostPromptTool():
+
+class PostPromptTool:
     def __init__(self) -> None:
         pass
-    
-    def validate_answer(self, answer: Answer) -> dict:        
+
+    def validate_answer(self, answer: Answer) -> dict:
         config = ConfigHelper.get_active_config_or_default()
         llm_helper = LLMHelper()
-        
+
         was_message_filtered = False
-        post_answering_prompt = PromptTemplate(template=config.prompts.post_answering_prompt, input_variables=["question", "answer", "sources"])
-        post_answering_chain = LLMChain(llm=llm_helper.get_llm(), prompt=post_answering_prompt, output_key="correct", verbose=True)
+        post_answering_prompt = PromptTemplate(
+            template=config.prompts.post_answering_prompt,
+            input_variables=["question", "answer", "sources"],
+        )
+        post_answering_chain = LLMChain(
+            llm=llm_helper.get_llm(),
+            prompt=post_answering_prompt,
+            output_key="correct",
+            verbose=True,
+        )
+
+        sources = "\n".join(
+            [
+                f"[doc{i+1}]: {source.content}"
+                for i, source in enumerate(answer.source_documents)
+            ]
+        )
 
-        sources = '\n'.join([f"[doc{i+1}]: {source.content}" for i, source in enumerate(answer.source_documents)])
-    
         with get_openai_callback() as cb:
-            post_result = post_answering_chain({"question": answer.question, "answer": answer.answer, "sources": sources})
-        
-        was_message_filtered = not (post_result['correct'].lower() == 'true' or post_result['correct'].lower() == 'yes')
+            post_result = post_answering_chain(
+                {
+                    "question": answer.question,
+                    "answer": answer.answer,
+                    "sources": sources,
+                }
+            )
+
+        was_message_filtered = not (
+            post_result["correct"].lower() == "true"
+            or post_result["correct"].lower() == "yes"
+        )
 
         # Return filtered answer or just the original one
         if was_message_filtered:
-            return Answer(question=answer.question, 
-                          answer=config.messages.post_answering_filter,
-                          source_documents=[],
-                          prompt_tokens=cb.prompt_tokens,
-                          completion_tokens=cb.completion_tokens)
+            return Answer(
+                question=answer.question,
+                answer=config.messages.post_answering_filter,
+                source_documents=[],
+                prompt_tokens=cb.prompt_tokens,
+                completion_tokens=cb.completion_tokens,
+            )
         else:
-            return Answer(question=answer.question, 
-                          answer=answer.answer,
-                          source_documents=answer.source_documents,
-                          prompt_tokens=cb.prompt_tokens,
-                          completion_tokens=cb.completion_tokens)
-    
\ No newline at end of file
+            return Answer(
+                question=answer.question,
+                answer=answer.answer,
+                source_documents=answer.source_documents,
+                prompt_tokens=cb.prompt_tokens,
+                completion_tokens=cb.completion_tokens,
+            )
diff --git a/code/utilities/tools/QuestionAnswerTool.py b/code/utilities/tools/QuestionAnswerTool.py
index 1792bd469..9e7590f3f 100644
--- a/code/utilities/tools/QuestionAnswerTool.py
+++ b/code/utilities/tools/QuestionAnswerTool.py
@@ -11,31 +11,41 @@
 from ..common.Answer import Answer
 from ..common.SourceDocument import SourceDocument
 
+
 class QuestionAnswerTool(AnsweringToolBase):
     def __init__(self) -> None:
         self.name = "QuestionAnswer"
         self.vector_store = AzureSearchHelper().get_vector_store()
         self.verbose = True
-    
+
     def answer_question(self, question: str, chat_history: List[dict], **kwargs: dict):
-        config = ConfigHelper.get_active_config_or_default()    
-        answering_prompt = PromptTemplate(template=config.prompts.answering_prompt, input_variables=["question", "sources"])
-        
+        config = ConfigHelper.get_active_config_or_default()
+        answering_prompt = PromptTemplate(
+            template=config.prompts.answering_prompt,
+            input_variables=["question", "sources"],
+        )
+
         llm_helper = LLMHelper()
-      
+
         # Retrieve documents as sources
-        sources = self.vector_store.similarity_search(query=question, k=4, search_type="hybrid")
-        
+        sources = self.vector_store.similarity_search(
+            query=question, k=4, search_type="hybrid"
+        )
+
         # Generate answer from sources
-        answer_generator = LLMChain(llm=llm_helper.get_llm(), prompt=answering_prompt, verbose=self.verbose)
-        sources_text = "\n\n".join([f"[doc{i+1}]: {source.page_content}" for i, source in enumerate(sources)])
-                
+        answer_generator = LLMChain(
+            llm=llm_helper.get_llm(), prompt=answering_prompt, verbose=self.verbose
+        )
+        sources_text = "\n\n".join(
+            [f"[doc{i+1}]: {source.page_content}" for i, source in enumerate(sources)]
+        )
+
         with get_openai_callback() as cb:
             result = answer_generator({"question": question, "sources": sources_text})
-            
+
         answer = result["text"]
         print(f"Answer: {answer}")
-                    
+
         # Generate Answer Object
         source_documents = []
         for source in sources:
@@ -49,11 +59,12 @@ def answer_question(self, question: str, chat_history: List[dict], **kwargs: dic
                 page_number=source.metadata["page_number"],
             )
             source_documents.append(source_document)
-        
-        clean_answer = Answer(question=question,
-                              answer=answer,
-                              source_documents=source_documents,
-                              prompt_tokens=cb.prompt_tokens,
-                              completion_tokens=cb.completion_tokens)
+
+        clean_answer = Answer(
+            question=question,
+            answer=answer,
+            source_documents=source_documents,
+            prompt_tokens=cb.prompt_tokens,
+            completion_tokens=cb.completion_tokens,
+        )
         return clean_answer
-    
\ No newline at end of file
diff --git a/code/utilities/tools/TextProcessingTool.py b/code/utilities/tools/TextProcessingTool.py
index 2140c677c..2da77ca2b 100644
--- a/code/utilities/tools/TextProcessingTool.py
+++ b/code/utilities/tools/TextProcessingTool.py
@@ -7,24 +7,29 @@
 class TextProcessingTool(AnsweringToolBase):
     def __init__(self) -> None:
         self.name = "TextProcessing"
-    
+
     def answer_question(self, question: str, chat_history: List[dict], **kwargs: dict):
-        
         llm_helper = LLMHelper()
-        text = kwargs.get('text')
-        operation = kwargs.get('operation')
-        user_content = f"{operation} the following TEXT: {text}" if question == "" else question
-        
+        text = kwargs.get("text")
+        operation = kwargs.get("operation")
+        user_content = (
+            f"{operation} the following TEXT: {text}" if question == "" else question
+        )
+
         system_message = """You are an AI assistant for the user."""
 
         result = llm_helper.get_chat_completion(
-                   [{"role": "system", "content": system_message}, 
-                    {"role": "user", "content": user_content},]
-                   )
-               
-        answer = Answer(question=question, 
-                        answer=result['choices'][0]['message']['content'], 
-                        source_documents=[],
-                        prompt_tokens=result['usage']['prompt_tokens'],
-                        completion_tokens=result['usage']['completion_tokens'])
-        return answer
\ No newline at end of file
+            [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": user_content},
+            ]
+        )
+
+        answer = Answer(
+            question=question,
+            answer=result["choices"][0]["message"]["content"],
+            source_documents=[],
+            prompt_tokens=result["usage"]["prompt_tokens"],
+            completion_tokens=result["usage"]["completion_tokens"],
+        )
+        return answer
diff --git a/extensions/backend/http_cwyod/__init__.py b/extensions/backend/http_cwyod/__init__.py
index 1dabae12b..083599461 100644
--- a/extensions/backend/http_cwyod/__init__.py
+++ b/extensions/backend/http_cwyod/__init__.py
@@ -2,41 +2,56 @@
 import logging
 import json
 import os
+import sys
 
 # Add the path to the code folder to the system path so that the code can be imported
-import sys
-sys.path.insert(0, '../../code')
+sys.path.insert(0, "../../code")
+
 
 def main(req: func.HttpRequest) -> func.HttpResponse:
-    logging.info('Python HTTP trigger function processed a request.')
+    logging.info("Python HTTP trigger function processed a request.")
 
     from utilities.helpers.OrchestratorHelper import Orchestrator
+
     message_orchestrator = Orchestrator()
-    
+
     try:
         req_body = req.get_json()
-        user_message = req_body["messages"][-1]['content']
+        user_message = req_body["messages"][-1]["content"]
         conversation_id = req_body["conversation_id"]
-        user_assistant_messages = list(filter(lambda x: x['role'] in ('user','assistant'), req_body["messages"][0:-1]))        
+        user_assistant_messages = list(
+            filter(
+                lambda x: x["role"] in ("user", "assistant"), req_body["messages"][0:-1]
+            )
+        )
         chat_history = []
-        for i,k in enumerate(user_assistant_messages):
+        for i, k in enumerate(user_assistant_messages):
             if i % 2 == 0:
-                chat_history.append((user_assistant_messages[i]['content'],user_assistant_messages[i+1]['content']))
+                chat_history.append(
+                    (
+                        user_assistant_messages[i]["content"],
+                        user_assistant_messages[i + 1]["content"],
+                    )
+                )
         from utilities.helpers.ConfigHelper import ConfigHelper
-        messages = message_orchestrator.handle_message(user_message=user_message, chat_history=chat_history, conversation_id=conversation_id, orchestrator=ConfigHelper.get_active_config_or_default().orchestrator)
+
+        messages = message_orchestrator.handle_message(
+            user_message=user_message,
+            chat_history=chat_history,
+            conversation_id=conversation_id,
+            orchestrator=ConfigHelper.get_active_config_or_default().orchestrator,
+        )
 
         response_obj = {
             "id": "response.id",
             "model": os.getenv("AZURE_OPENAI_MODEL"),
             "created": "response.created",
             "object": "response.object",
-            "choices": [{
-                "messages": messages
-            }]
+            "choices": [{"messages": messages}],
         }
 
         return func.HttpResponse(json.dumps(response_obj), status_code=200)
-    
+
     except Exception as e:
         logging.exception("Exception in /api/conversation/custom")
-        return func.HttpResponse(json.dumps({"error": str(e)}), status_code=500)
\ No newline at end of file
+        return func.HttpResponse(json.dumps({"error": str(e)}), status_code=500)
diff --git a/tests/test_AzureBlobStorage.py b/tests/test_AzureBlobStorage.py
index 33f192a0b..2743bb932 100644
--- a/tests/test_AzureBlobStorage.py
+++ b/tests/test_AzureBlobStorage.py
@@ -1,10 +1,12 @@
 import pytest
 from code.utilities.helpers.AzureBlobStorageHelper import AzureBlobStorageClient
 
+
 @pytest.fixture
 def blob_client():
     return AzureBlobStorageClient()
 
+
 @pytest.mark.azure("This test requires Azure Blob Storage")
 def test_upload_and_download_file(blob_client):
     # Upload a file
@@ -17,4 +19,3 @@ def test_upload_and_download_file(blob_client):
     assert downloaded_contents == file_contents
     # Delete the file
     blob_client.delete_file(file_name)
-    
\ No newline at end of file
diff --git a/tests/test_ContentSafetyChecker.py b/tests/test_ContentSafetyChecker.py
index a0978f95d..5bd68864a 100644
--- a/tests/test_ContentSafetyChecker.py
+++ b/tests/test_ContentSafetyChecker.py
@@ -1,14 +1,14 @@
 import pytest
 from code.utilities.tools.ContentSafetyChecker import ContentSafetyChecker
 
-@pytest.mark.azure("This test requires Azure Content Safety configured")   
+
+@pytest.mark.azure("This test requires Azure Content Safety configured")
 def test_document_chunking_layout():
-    
     cut = ContentSafetyChecker()
-    
+
     safe_input = "This is a test"
     unsafe_input = "I hate short people, they are dumb"
-    
+
     assert cut.validate_input_and_replace_if_harmful(safe_input) == safe_input
     assert cut.validate_output_and_replace_if_harmful(safe_input) == safe_input
     assert cut.validate_input_and_replace_if_harmful(unsafe_input) != unsafe_input
diff --git a/tests/test_DocumentChunking.py b/tests/test_DocumentChunking.py
index 9a9b4bbc4..45c841d08 100644
--- a/tests/test_DocumentChunking.py
+++ b/tests/test_DocumentChunking.py
@@ -1,7 +1,10 @@
 import pytest
-from typing import List
 from code.utilities.common.SourceDocument import SourceDocument
-from code.utilities.helpers.DocumentChunkingHelper import DocumentChunking, ChunkingSettings, ChunkingStrategy
+from code.utilities.helpers.DocumentChunkingHelper import (
+    DocumentChunking,
+    ChunkingSettings,
+    ChunkingStrategy,
+)
 
 # Create a sample document
 documents = [
@@ -16,20 +19,20 @@
         source="https://example.com/sample_document_1.pdf",
         offset=0,
         page_number=2,
-    )
+    ),
 ]
 
+
 @pytest.mark.unittest("DocumentChunking")
 def test_document_chunking_layout():
     # Test layout chunking strategy
-    chunking = ChunkingSettings({"strategy": ChunkingStrategy.LAYOUT, "size": 10, "overlap": 5})
+    chunking = ChunkingSettings(
+        {"strategy": ChunkingStrategy.LAYOUT, "size": 10, "overlap": 5}
+    )
     document_chunking = DocumentChunking()
     chunked_documents = document_chunking.chunk(documents, chunking)
     assert len(chunked_documents) == 8
-    assert (
-        chunked_documents[0].content
-        == "PAGE 1: This short sentence with 20 tokens"
-    )
+    assert chunked_documents[0].content == "PAGE 1: This short sentence with 20 tokens"
     assert (
         chunked_documents[1].content
         == "short sentence with 20 tokens shows how the different"
@@ -38,10 +41,7 @@ def test_document_chunking_layout():
         chunked_documents[2].content
         == "tokens shows how the different chunking strategies work"
     )
-    assert (
-        chunked_documents[3].content
-        == "different chunking strategies work now!PAGE"
-    )
+    assert chunked_documents[3].content == "different chunking strategies work now!PAGE"
     assert chunked_documents[4].content == "work now!PAGE 2: This short sentence"
     assert (
         chunked_documents[5].content
@@ -51,21 +51,18 @@ def test_document_chunking_layout():
         chunked_documents[6].content
         == "with 20 tokens shows how the different chunking strategies"
     )
-    assert (
-        chunked_documents[7].content
-        == "the different chunking strategies work now!"
-    )
+    assert chunked_documents[7].content == "the different chunking strategies work now!"
+
 
 def test_document_chunking_page():
     # Test page chunking strategy
-    chunking = ChunkingSettings({"strategy": ChunkingStrategy.PAGE, "size": 10, "overlap": 5})
+    chunking = ChunkingSettings(
+        {"strategy": ChunkingStrategy.PAGE, "size": 10, "overlap": 5}
+    )
     document_chunking = DocumentChunking()
     chunked_documents = document_chunking.chunk(documents, chunking)
     assert len(chunked_documents) == 8
-    assert (
-        chunked_documents[0].content
-        == "PAGE 1: This short sentence with 20 tokens"
-    )
+    assert chunked_documents[0].content == "PAGE 1: This short sentence with 20 tokens"
     assert (
         chunked_documents[1].content
         == "short sentence with 20 tokens shows how the different"
@@ -74,13 +71,8 @@ def test_document_chunking_page():
         chunked_documents[2].content
         == "tokens shows how the different chunking strategies work"
     )
-    assert (
-        chunked_documents[3].content == "different chunking strategies work now!"
-    )
-    assert (
-        chunked_documents[4].content
-        == "PAGE 2: This short sentence with 20 tokens"
-    )
+    assert chunked_documents[3].content == "different chunking strategies work now!"
+    assert chunked_documents[4].content == "PAGE 2: This short sentence with 20 tokens"
     assert (
         chunked_documents[5].content
         == "short sentence with 20 tokens shows how the different"
@@ -89,10 +81,9 @@ def test_document_chunking_page():
         chunked_documents[6].content
         == "tokens shows how the different chunking strategies work"
     )
-    assert (
-        chunked_documents[7].content == "different chunking strategies work now!"
-    )
-    
+    assert chunked_documents[7].content == "different chunking strategies work now!"
+
+
 def test_document_chunking_fixed_size_overlap():
     # Test fixed size overlap chunking strategy
     chunking = ChunkingSettings(
@@ -101,10 +92,7 @@ def test_document_chunking_fixed_size_overlap():
     document_chunking = DocumentChunking()
     chunked_documents = document_chunking.chunk(documents, chunking)
     assert len(chunked_documents) == 8
-    assert (
-        chunked_documents[0].content
-        == "PAGE 1: This short sentence with 20 tokens"
-    )
+    assert chunked_documents[0].content == "PAGE 1: This short sentence with 20 tokens"
     assert (
         chunked_documents[1].content
         == " short sentence with 20 tokens shows how the different chunk"
@@ -114,10 +102,7 @@ def test_document_chunking_fixed_size_overlap():
         == " shows how the different chunking strategies work now!"
     )
     assert chunked_documents[3].content == "ing strategies work now!PAGE 2: This"
-    assert (
-        chunked_documents[4].content
-        == "PAGE 2: This short sentence with 20 tokens"
-    )
+    assert chunked_documents[4].content == "PAGE 2: This short sentence with 20 tokens"
     assert (
         chunked_documents[5].content
         == " short sentence with 20 tokens shows how the different chunk"
diff --git a/tests/test_DocumentLoading.py b/tests/test_DocumentLoading.py
index 07bc02770..1c7a15004 100644
--- a/tests/test_DocumentLoading.py
+++ b/tests/test_DocumentLoading.py
@@ -1,13 +1,16 @@
 import pytest
-from typing import List
-from code.utilities.helpers.DocumentLoadingHelper import DocumentLoading, LoadingSettings
+from code.utilities.helpers.DocumentLoadingHelper import (
+    DocumentLoading,
+    LoadingSettings,
+)
+
 
 @pytest.mark.azure("This test requires Azure Document Intelligence configured")
 def test_document_loading_layout():
     # Azure Form Recognizer Layout
     document_loading = DocumentLoading()
     url = "https://csciblob.blob.core.windows.net/rag-sol-acc/cognitive-services.pdf"
-    data = document_loading.load(url, LoadingSettings({"strategy": "layout"}))    
+    data = document_loading.load(url, LoadingSettings({"strategy": "layout"}))
     assert len(data) == 5
     assert data[0].source == url
     assert data[0].page_number == 0
@@ -15,6 +18,7 @@ def test_document_loading_layout():
     assert data[4].page_number == 4
     assert data[4].source == url
 
+
 @pytest.mark.azure("This test requires Azure Document Intelligence configured")
 def test_document_loading_read():
     # Azure Form Recognizer Read
@@ -27,7 +31,8 @@ def test_document_loading_read():
     assert data[0].offset == 0
     assert data[4].page_number == 4
     assert data[4].source == url
-    
+
+
 def test_document_loading_web():
     # WebLoad
     document_loading = DocumentLoading()
@@ -36,6 +41,7 @@ def test_document_loading_web():
     assert len(data) == 1
     assert data[0].source == url
 
+
 @pytest.mark.azure("This test requires Azure Document Intelligence configured")
 def test_document_loading_docx():
     document_loading = DocumentLoading()
diff --git a/tests/test_DocumentProcessor.py b/tests/test_DocumentProcessor.py
index b2943e269..0393dc4a8 100644
--- a/tests/test_DocumentProcessor.py
+++ b/tests/test_DocumentProcessor.py
@@ -2,15 +2,23 @@
 from code.utilities.helpers.DocumentProcessorHelper import DocumentProcessor
 from code.utilities.helpers.ConfigHelper import ConfigHelper
 
-document_url = "https://csciblob.blob.core.windows.net/rag-sol-acc/cognitive-services.pdf"
+document_url = (
+    "https://csciblob.blob.core.windows.net/rag-sol-acc/cognitive-services.pdf"
+)
 url = "https://learn.microsoft.com/en-us/azure/search/search-what-is-azure-search"
 docx_url = "https://csciblob.blob.core.windows.net/rag-sol-acc/What is Azure OpenAI Service.docx"
 
+
 @pytest.mark.azure("This test requires Azure")
 def test_document_processor_layout():
     document_processor = DocumentProcessor()
-    processors = list(filter(lambda x : x.document_type == 'pdf', ConfigHelper.get_active_config_or_default().document_processors))
-    keys = document_processor.process(source_url= document_url, processors=processors)
+    processors = list(
+        filter(
+            lambda x: x.document_type == "pdf",
+            ConfigHelper.get_active_config_or_default().document_processors,
+        )
+    )
+    keys = document_processor.process(source_url=document_url, processors=processors)
     print(keys)
     assert len(keys) > 0
 
@@ -18,8 +26,13 @@ def test_document_processor_layout():
 @pytest.mark.azure("This test requires Azure")
 def test_document_processor_read():
     document_processor = DocumentProcessor()
-    processors = list(filter(lambda x : x.document_type == 'pdf', ConfigHelper.get_active_config_or_default().document_processors))
-    keys = document_processor.process(source_url= document_url, processors=processors)
+    processors = list(
+        filter(
+            lambda x: x.document_type == "pdf",
+            ConfigHelper.get_active_config_or_default().document_processors,
+        )
+    )
+    keys = document_processor.process(source_url=document_url, processors=processors)
     print(keys)
     assert len(keys) > 0
 
@@ -27,15 +40,26 @@ def test_document_processor_read():
 @pytest.mark.azure("This test requires Azure")
 def test_document_processor_web():
     document_processor = DocumentProcessor()
-    processors = list(filter(lambda x : x.document_type == 'url', ConfigHelper.get_active_config_or_default().document_processors))
-    keys = document_processor.process(source_url= url, processors=processors)    
+    processors = list(
+        filter(
+            lambda x: x.document_type == "url",
+            ConfigHelper.get_active_config_or_default().document_processors,
+        )
+    )
+    keys = document_processor.process(source_url=url, processors=processors)
     print(keys)
     assert len(keys) > 0
 
+
 @pytest.mark.azure("This test requires Azure")
 def test_document_processor_docx():
     document_processor = DocumentProcessor()
-    processors = list(filter(lambda x : x.document_type == 'docx', ConfigHelper.get_active_config_or_default().document_processors))
-    keys = document_processor.process(source_url= docx_url, processors=processors)    
+    processors = list(
+        filter(
+            lambda x: x.document_type == "docx",
+            ConfigHelper.get_active_config_or_default().document_processors,
+        )
+    )
+    keys = document_processor.process(source_url=docx_url, processors=processors)
     print(keys)
     assert len(keys) > 0
diff --git a/tests/test_Orchestrator.py b/tests/test_Orchestrator.py
index 21e208d30..b548ca3ad 100644
--- a/tests/test_Orchestrator.py
+++ b/tests/test_Orchestrator.py
@@ -1,19 +1,33 @@
 import pytest
-from code.utilities.helpers.OrchestratorHelper import Orchestrator, OrchestrationSettings
+from code.utilities.helpers.OrchestratorHelper import (
+    Orchestrator,
+    OrchestrationSettings,
+)
+
 
 @pytest.mark.azure("This test requires Azure Open AI configured")
 def test_orchestrator_openai_function():
     message_orchestrator = Orchestrator()
     strategy = "openai_function"
-    messages = message_orchestrator.handle_message(user_message="What's Azure AI Search?", chat_history=[], conversation_id="test_openai_function", orchestrator = OrchestrationSettings({"strategy" : strategy}))    
-    assert messages[-1]['role'] == 'assistant'
-    assert messages[-1]['content'] != ''
-    
+    messages = message_orchestrator.handle_message(
+        user_message="What's Azure AI Search?",
+        chat_history=[],
+        conversation_id="test_openai_function",
+        orchestrator=OrchestrationSettings({"strategy": strategy}),
+    )
+    assert messages[-1]["role"] == "assistant"
+    assert messages[-1]["content"] != ""
+
+
 @pytest.mark.azure("This test requires Azure Open AI configured")
 def test_orchestrator_langchain():
     message_orchestrator = Orchestrator()
     strategy = "langchain"
-    messages = message_orchestrator.handle_message(user_message="What's Azure AI Search?", chat_history=[], conversation_id="test_langchain", orchestrator = OrchestrationSettings({"strategy" : strategy}))    
-    assert messages[-1]['role'] == 'assistant'
-    assert messages[-1]['content'] != ''
-    
\ No newline at end of file
+    messages = message_orchestrator.handle_message(
+        user_message="What's Azure AI Search?",
+        chat_history=[],
+        conversation_id="test_langchain",
+        orchestrator=OrchestrationSettings({"strategy": strategy}),
+    )
+    assert messages[-1]["role"] == "assistant"
+    assert messages[-1]["content"] != ""
diff --git a/tests/test_OutputParserTool.py b/tests/test_OutputParserTool.py
index 03ba08ac5..6b2997556 100644
--- a/tests/test_OutputParserTool.py
+++ b/tests/test_OutputParserTool.py
@@ -1,5 +1,4 @@
 import json
-import pytest
 
 from typing import List
 
@@ -15,20 +14,18 @@ def test_returns_parsed_messages():
     source_documents = []
 
     # When
-    messages = output_parser.parse(question=question, answer=answer, source_documents=source_documents)
+    messages = output_parser.parse(
+        question=question, answer=answer, source_documents=source_documents
+    )
 
     # Then
     assert messages == [
         {
             "content": '{"citations": [], "intent": "A question?"}',
             "end_turn": False,
-            "role": "tool"
+            "role": "tool",
         },
-        {
-            "content": "An answer",
-            "end_turn": True,
-            "role": "assistant"
-        }
+        {"content": "An answer", "end_turn": True, "role": "assistant"},
     ]
 
 
@@ -40,20 +37,18 @@ def test_removes_double_spaces_from_answer():
     source_documents = []
 
     # When
-    messages = output_parser.parse(question=question, answer=answer, source_documents=source_documents)
+    messages = output_parser.parse(
+        question=question, answer=answer, source_documents=source_documents
+    )
 
     # Then
     assert messages == [
         {
             "content": '{"citations": [], "intent": "A question?"}',
             "end_turn": False,
-            "role": "tool"
+            "role": "tool",
         },
-        {
-            "content": "An answer",
-            "end_turn": True,
-            "role": "assistant"
-        }
+        {"content": "An answer", "end_turn": True, "role": "assistant"},
     ]
 
 
@@ -80,17 +75,21 @@ def test_returns_citations():
             chunk="Another chunk",
             offset="Another offset",
             page_number="",
-        )
+        ),
     ]
 
     # When
-    messages = output_parser.parse(question=question, answer=answer, source_documents=source_documents)
+    messages = output_parser.parse(
+        question=question, answer=answer, source_documents=source_documents
+    )
 
     # Then
-    expected_content = json.dumps(_convert_source_documents_to_content(question, source_documents))
+    expected_content = json.dumps(
+        _convert_source_documents_to_content(question, source_documents)
+    )
     assert messages[0]["content"] == expected_content
-    
-    
+
+
 def test_orders_citations_in_ascending_order():
     # Given
     output_parser = OutputParserTool()
@@ -127,12 +126,16 @@ def test_orders_citations_in_ascending_order():
     ]
 
     # When
-    messages = output_parser.parse(question=question, answer=answer, source_documents=source_documents)
+    messages = output_parser.parse(
+        question=question, answer=answer, source_documents=source_documents
+    )
 
     # Then
-    assert messages[1]["content"] == "An answer [doc1] [doc2] [doc3]. With some more text."
-        
-        
+    assert (
+        messages[1]["content"] == "An answer [doc1] [doc2] [doc3]. With some more text."
+    )
+
+
 def test_removes_doc_ids_from_answer_if_no_citations():
     # Given
     output_parser = OutputParserTool()
@@ -141,12 +144,14 @@ def test_removes_doc_ids_from_answer_if_no_citations():
     source_documents = []
 
     # When
-    messages = output_parser.parse(question=question, answer=answer, source_documents=source_documents)
+    messages = output_parser.parse(
+        question=question, answer=answer, source_documents=source_documents
+    )
 
     # Then
     assert messages[1]["content"] == "An answer  "
-    
-    
+
+
 def test_does_not_remove_doc_ids_from_answer_if_missing_citations():
     # Given
     output_parser = OutputParserTool()
@@ -164,36 +169,41 @@ def test_does_not_remove_doc_ids_from_answer_if_missing_citations():
         )
     ]
     # When
-    messages = output_parser.parse(question=question, answer=answer, source_documents=source_documents)
+    messages = output_parser.parse(
+        question=question, answer=answer, source_documents=source_documents
+    )
 
     # Then
     assert messages[1]["content"] == "An answer [doc1] [doc2]"
 
-    
-def _convert_source_documents_to_content(question: str, source_documents: List[SourceDocument]) -> dict:
-    content = {
-        "citations": [],
-        "intent": question
-    }
-    
+
+def _convert_source_documents_to_content(
+    question: str, source_documents: List[SourceDocument]
+) -> dict:
+    content = {"citations": [], "intent": question}
+
     for source_document in source_documents:
-        content["citations"].append({
-            "content": source_document.get_markdown_url() + "\n\n\n" + source_document.content,
-            "id": source_document.id,
-            "chunk_id": source_document.chunk,
-            "title": source_document.title,
-            "filepath": source_document.get_filename(include_path=True),
-            "url": source_document.get_markdown_url(),
-            "metadata": {
-                "offset": source_document.offset,
-                "source": source_document.source,
-                "markdown_url": source_document.get_markdown_url(),
+        content["citations"].append(
+            {
+                "content": source_document.get_markdown_url()
+                + "\n\n\n"
+                + source_document.content,
+                "id": source_document.id,
+                "chunk_id": source_document.chunk,
                 "title": source_document.title,
-                "original_url": source_document.source,
-                "chunk": source_document.chunk,
-                "key": source_document.id,
-                "filename": source_document.get_filename()
-            },
-        })
-            
+                "filepath": source_document.get_filename(include_path=True),
+                "url": source_document.get_markdown_url(),
+                "metadata": {
+                    "offset": source_document.offset,
+                    "source": source_document.source,
+                    "markdown_url": source_document.get_markdown_url(),
+                    "title": source_document.title,
+                    "original_url": source_document.source,
+                    "chunk": source_document.chunk,
+                    "key": source_document.id,
+                    "filename": source_document.get_filename(),
+                },
+            }
+        )
+
     return content