doc reference, multi language

app.py

@@ -27,20 +27,18 @@ makes = df["make"].unique().to_list()
 models = df["model"].unique().to_list()
 
 with open("sys_prompt.txt", "r") as f:
-    prompt = f.read()
-
-
-def embed(message):
-    return embedder.encode([message])[0]
+    sys_prompt = f.read()
 
+with open("translate_prompt.txt", "r") as f:
+    translate_prompt = f.read()
 
 # llm = AzureChatOpenAI(deployment_name="chatserver35turbo")
 embedder = SentenceTransformer("BAAI/bge-small-en")
-search = AzureSearch(
+vector_store = AzureSearch(
     azure_search_endpoint=vector_store_address,
     azure_search_key=vector_store_password,
     index_name=index_name,
-    embedding_function=embed,
+    embedding_function=lambda x: embedder.encode([x])[0],
 )
 
 
@@ -57,21 +55,39 @@ def filter_models(year, make):
     return gr.Dropdown.update(choices=choices, interactive=True)
 
 
-def search_db(query, year, make, model, k=5, s_type="similarity"):
-    filters = f"year eq {year} and make eq '{make}' and model eq '{model}'"
+def gpt(history, prompt, temp=0.0, stream=True):
+    hist = [{"role": "system", "content": prompt}]
+    for user, bot in history:
+        hist += [{"role": "user", "content": user}]
+        if bot:
+            hist += [{"role": "assistant", "content": bot}]
+    return openai.ChatCompletion.create(
+        deployment_id="chatserver35turbo16k",
+        messages=hist,
+        temperature=temp,
+        stream=stream,
+    )
+
+
+def user(message, history):
+    # Necessary to clear input and display message
+    return "", history + [[message, None]]
 
-    res = []
-    if search_type == "hybrid":
-        res = search.similarity_search(query, k, search_type=s_type, filters=filters)
-    else:
-        mult = 1
-        while len(res) < k or mult <= 16:
-            res = search.similarity_search(
-                query, 100 * mult, search_type=s_type, filters=filters
-            )
-            mult *= 2
-        res = res[:k]
 
+def search(history, results, year, make, model):
+    if results:
+        # If results already exist, don't search again
+        return history, results
+
+    query = gpt(history, translate_prompt, stream=False)["choices"][0]["message"][
+        "content"
+    ]
+    print(query)
+
+    filters = f"year eq {year} and make eq '{make}' and model eq '{model}'"
+    res = vector_store.similarity_search(
+        query, 5, search_type="hybrid", filters=filters
+    )
     results = []
     for r in res:
         results.append(
@@ -80,55 +96,53 @@ def search_db(query, year, make, model, k=5, s_type="similarity"):
                 "content": r.page_content,
             }
         )
-    return str(results)
-
+    return history, results
 
-def respond(message, history, year, make, model, search_type):
-    if not year or not make or not model:
-        msg = "Please select a year, make, and model."
-        # return msg
-        for i in range(len(msg)):
-            time.sleep(0.02)
-            yield msg[: i + 1]
-    else:
-        results = search_db(message, year, make, model, k=5, s_type=search_type)
 
-        hist = []
-        hist.append(
-            {
-                "role": "system",
-                "content": prompt + results,
-            }
-        )
-        hist.append(
-            {
-                "role": "user",
-                "content": f"Year: {year}\nMake: {make}\nModel: {model}\n\n{message}",
-            }
-        )
-        model = "chatserver35turbo16k"
-        res = openai.ChatCompletion.create(
-            deployment_id=model, messages=hist, temperature=0.0, stream=True
-        )
-        msg = ""
-        # return str(res["choices"][0]["message"]["content"])
-        for chunk in res:
-            if "content" in chunk["choices"][0]["delta"]:
-                msg = msg + chunk["choices"][0]["delta"]["content"]
-                yield msg
+def bot(history, results):
+    res = gpt(history, sys_prompt + str(results))
+    history[-1][1] = ""
+    for chunk in res:
+        if "content" in chunk["choices"][0]["delta"]:
+            history[-1][1] = history[-1][1] + chunk["choices"][0]["delta"]["content"]
+            yield history
 
 
 with gr.Blocks(
-    css="footer {visibility: hidden} #component-8 {height: 75vh !important} #component-9 {height: 70vh !important}"
+    css="footer {visibility: hidden} #docs {height: 600px; overflow: auto !important}"
 ) as app:
     with gr.Row():
         year = gr.Dropdown(years, label="Year")
         make = gr.Dropdown([], label="Make", interactive=False)
         model = gr.Dropdown([], label="Model", interactive=False)
-        types = ["similarity", "hybrid"]
-        search_type = gr.Dropdown(types, label="Search Type", value="hybrid")
         year.change(filter_makes, year, make)
         make.change(filter_models, [year, make], model)
-    row = [year, make, model, search_type]
-    gr.ChatInterface(respond, additional_inputs=row).queue()
+    with gr.Row():
+        with gr.Column(scale=0.3333):
+            results = []
+            text = gr.JSON(None, language="json", interactive=False, elem_id="docs")
+        with gr.Column(scale=0.6667):
+            chatbot = gr.Chatbot(height=462)
+            with gr.Row():
+                msg = gr.Textbox(show_label=False, scale=7)
+                msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+                    search,
+                    [chatbot, text, year, make, model],
+                    [chatbot, text],
+                    queue=False,
+                ).then(bot, [chatbot, text], chatbot)
+                btn = gr.Button("Send", variant="primary")
+                btn.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+                    search,
+                    [chatbot, text, year, make, model],
+                    [chatbot, text],
+                    queue=False,
+                ).then(bot, [chatbot, text], chatbot)
+            with gr.Row():
+                gr.Button("Clear").click(
+                    lambda x, y: ([], None), [chatbot, text], [chatbot, text]
+                )
+                gr.Button("Undo").click(lambda x: (x[:-1]), [chatbot], [chatbot])
+
     app.queue().launch(auth=("motor", "vectorsearch"))
+    # app.queue().launch()

sys_prompt.txt

@@ -4,6 +4,7 @@ You only and exclusively use the documents as a source of information.
 If the documents don't provide the answer or are empty, simply say so.
 Use only those documents that are strictly relevant to the query.
 Structure your answer step by step if it fits the query.
+Answer in the language the question or query is asked in.
 Include a list of relevant document titles in the end of your response.
 
 Documents:

translate_prompt.txt

@@ -0,0 +1,5 @@
+You are a professional translator.
+Any text that the user sends, you translate to English.
+If the text already is in English, just return the original text.
+Do not add remarks, comments, confirmations or acknoledgements.
+Simply return the English text.