ENH: Update bot

.gitignore

@@ -1,3 +1,6 @@
 # ignore old_files folder
 old_files
-audio
+audio
+conversations
+# ignore pyc files
+*.pyc

app.py

@@ -1,16 +1,26 @@
+import json
+import os
+
+with open("env.json") as f:
+    env_vars = json.load(f)
+
+for k, v in env_vars.items():
+    os.environ[k] = v
+
 import os
 
 import openai
 
 from audio_utils import text_to_speech, text_to_speech_polly
+from openai_prompts import contextualize_question
 from openai_utils import get_embedding, whisper_transcription
 from vector_db import LanceVectorDb, QnA
 
 db = LanceVectorDb("qna_db")
-
 OPENAI_KEY = os.environ["OPENAI_KEY"]
 openai.api_key = OPENAI_KEY
 
+
 if len(db.table.to_pandas()) == 0:
     print("Empty db, trying to load qna's from json file")
     try:
@@ -19,6 +29,7 @@ if len(db.table.to_pandas()) == 0:
     except Exception as exception:
         raise Exception("Failed to initialize db from json file") from exception
 
+
 import os
 
 
@@ -29,53 +40,103 @@ def ensure_dir(directory):
 
 ensure_dir("audio")
 
+import random
+
 from langdetect import detect
 
-GENERAL_SYSTEM_PROMPT = (
+
+def red(text):
+    return f'\x1b[31m"{text}"\x1b[0m'
+
+
+def query_database(prompt: str):
+    print("Querying database for question:", prompt)
+    embedding = get_embedding(prompt)
+    qnas = db.get_qna(embedding, lang="en", limit=3)
+    print("Total_qnas:", len(qnas), [qna.score for qna in qnas])
+    qnas = [qna for qna in qnas if qna.score < 0.49]
+    print("Filtered_qnas:", len(qnas))
+    return qnas
+
+
+available_functions = {
+    "query_database": query_database,
+}
+
+conversation_folder = f"conversations/{random.randint(0, 10000)}"
+ensure_dir(conversation_folder)
+
+SYSTEM_PROMPT = (
     "You are a question answering assistant.\n"
-    "You answer questions from users based on information in our database provided as context.\n"
-    "You respond in one, maximum two sentences.\n"
-    "You use only the information in the context. If the information is not in the context, you tell the user that you don't know.\n"
+    "You answer questions from users delimited by tripple dashes --- based on information in our database provided as context.\n"
+    "The context informtion in delimited by tripple backticks ```\n"
+    "You try to be concise and offer the most relevant information.\n"
     "You answer in the language that the question was asked in.\n"
     "You speak german and english.\n"
 )
 
+step = 0
 
-def bot_respond(user_query, chat_messages: list):
-    embedding = get_embedding(user_query)
 
-    qnas = db.get_qna(embedding, lang="en", limit=3)
-    print("Total_qnas:", len(qnas), [qna.score for qna in qnas])
-    qnas = [qna for qna in qnas if qna.score < 0.45]
-    print("Filtered_qnas:", len(qnas))
-    context_prompt = f"The user said: {user_query}\n\n"
-
-    if len(qnas) > 0:
-        example_questions = ""
-        for qna in qnas:
-            example_questions += (
-                f"For question: '{qna.question}'\n" f"The answer is: '{qna.answer}'\n"
-            )
-
-        context_prompt += (
-            f"Context information from our database:\n{example_questions}"
-            "If the user hasn't provided some of the necessary information for answering the question, you can ask the user for it.\n"
-        )
+def context_format(qnas):
+    context = "Context:\n\n```"
+    for qna in qnas:
+        context += f"For question: {qna.question}\nThe answer is: {qna.answer}\n"
+    context += "```"
+    return context
+
+
+def bot_respond(user_query, history: list):
+    global step
+
+    chat_messages = history["chat_messages"]
+
+    user_query = contextualize_question(user_query, chat_messages)
+
+    path = os.path.join(conversation_folder, f"step_{step}_qna.json")
+
+    qnas = query_database(user_query)
+
+    prompt = f"The user said: ---{user_query}---\n\n"
 
-    print(context_prompt)
-    chat_messages.append({"role": "user", "content": context_prompt})
+    context = context_format(qnas)
+    prompt += context
+
+    qna_messages = [
+        {
+            "role": "assistant",
+            "content": SYSTEM_PROMPT,
+        },
+        {
+            "role": "user",
+            "content": prompt,
+        },
+    ]
 
     completion = openai.ChatCompletion.create(
-        model="gpt-3.5-turbo",
-        messages=chat_messages,
+        model="gpt-3.5-turbo", messages=qna_messages, temperature=0
     )
-    text = completion.choices[0].message.content
 
-    chat_messages.pop()
-    chat_messages.append({"role": "user", "content": user_query})
-    chat_messages.append({"role": "assistant", "content": text})
+    response_message = completion["choices"][0]["message"]
+    bot_response = response_message.content
+
+    path = os.path.join(conversation_folder, f"step_{step}_qna.json")
+
+    with open(path, "w") as f:
+        json.dump(
+            {
+                "chat_messages": chat_messages,
+                "response": response_message.content,
+            },
+            f,
+            indent=4,
+        )
+
+    chat_messages.append({"role": "assistant", "content": bot_response})
 
-    return text, context_prompt
+    step += 1
+
+    return bot_response, prompt
 
 
 import random
@@ -90,14 +151,17 @@ def display_history(conversation):
     return conversation_string
 
 
-def handle_audiofile(audio_filepath: str, chat_messages: list):
+def handle_audiofile(audio_filepath: str, history: list):
     user_question = whisper_transcription(audio_filepath)
     print("Transcription", user_question)
 
-    bot_response_text, context_prompt = bot_respond(user_question, chat_messages)
+    bot_response_text, context_prompt = bot_respond(user_question, history)
 
-    lang = detect(bot_response_text)
-    print("Detected language:", lang, "for text:", bot_response_text)
+    if bot_response_text:
+        lang = detect(bot_response_text)
+        print("Detected language:", lang, "for text:", bot_response_text)
+    else:
+        lang = "en"
 
     if lang not in ["en", "de"]:
         lang = "en"
@@ -111,9 +175,9 @@ def handle_audiofile(audio_filepath: str, chat_messages: list):
     return (
         user_question,
         bot_response_text,
-        chat_messages,
+        history,
         context_prompt,
-        display_history(chat_messages),
+        display_history(history["chat_messages"]),
         output_filepath,
     )
 
@@ -122,7 +186,11 @@ import gradio as gr
 
 with gr.Blocks() as demo:
     # initialize the state that will be used to store the chat messages
-    chat_messages = gr.State([{"role": "system", "content": GENERAL_SYSTEM_PROMPT}])
+    chat_messages = gr.State(
+        {
+            "chat_messages": [{"role": "system", "content": SYSTEM_PROMPT}],
+        }
+    )
 
     with gr.Row():
         audio_input = gr.Audio(source="microphone", type="filepath", format="mp3")
@@ -133,7 +201,9 @@ with gr.Blocks() as demo:
         assistant_answer = gr.Textbox(label="PhoneBot Answer")
 
     with gr.Row():
-        context_info = gr.Textbox(label="Provided context")
+        context_info = gr.Textbox(
+            label="Context provided to the bot + additional infos for debugging"
+        )
         conversation_history = gr.Textbox(label="Conversation history")
 
     # when the audio input is stopped, run the transcribe function

bot_gradio.ipynb

@@ -2,7 +2,22 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json, os\n",
+    "\n",
+    "with open(\"env.json\") as f:\n",
+    "    env_vars = json.load(f)\n",
+    "\n",
+    "for k, v in env_vars.items():\n",
+    "    os.environ[k] = v\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -10,16 +25,17 @@
     "from vector_db import LanceVectorDb, QnA\n",
     "from openai_utils import get_embedding, whisper_transcription\n",
     "from audio_utils import text_to_speech, text_to_speech_polly\n",
+    "from openai_prompts import contextualize_question\n",
     "import os\n",
     "\n",
     "db = LanceVectorDb(\"qna_db\")\n",
-    "OPENAI_KEY = os.environ.get[\"OPENAI_KEY\"]\n",
+    "OPENAI_KEY = os.environ[\"OPENAI_KEY\"]\n",
     "openai.api_key = OPENAI_KEY"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -34,96 +50,153 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
     "import os\n",
     "\n",
+    "\n",
     "def ensure_dir(directory):\n",
     "    if not os.path.exists(directory):\n",
     "        os.makedirs(directory)\n",
     "\n",
+    "\n",
     "ensure_dir(\"audio\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
     "from langdetect import detect\n",
+    "import random\n",
+    "\n",
+    "def red(text):\n",
+    "    return f'\\x1b[31m\"{text}\"\\x1b[0m'\n",
+    "\n",
     "\n",
-    "GENERAL_SYSTEM_PROMPT = (\n",
+    "def query_database(prompt: str):\n",
+    "    print(\"Querying database for question:\", prompt)\n",
+    "    embedding = get_embedding(prompt)\n",
+    "    qnas = db.get_qna(embedding, lang=\"en\", limit=3)\n",
+    "    print(\"Total_qnas:\", len(qnas), [qna.score for qna in qnas])\n",
+    "    qnas = [qna for qna in qnas if qna.score < 0.49]\n",
+    "    print(\"Filtered_qnas:\", len(qnas))\n",
+    "    return qnas\n",
+    "\n",
+    "\n",
+    "available_functions = {\n",
+    "    \"query_database\": query_database,\n",
+    "}\n",
+    "\n",
+    "conversation_folder = f\"conversations/{random.randint(0, 10000)}\"\n",
+    "ensure_dir(conversation_folder)\n",
+    "\n",
+    "SYSTEM_PROMPT = (\n",
     "    \"You are a question answering assistant.\\n\"\n",
-    "    \"You answer questions from users based on information in our database provided as context.\\n\"\n",
-    "    \"You respond in one, maximum two sentences.\\n\"\n",
-    "    \"You use only the information in the context. If the information is not in the context, you tell the user that you don't know.\\n\"\n",
+    "    \"You answer questions from users delimited by tripple dashes --- based on information in our database provided as context.\\n\"\n",
+    "    \"The context informtion in delimited by tripple backticks ```\\n\"\n",
+    "    \"You try to be concise and offer the most relevant information.\\n\"\n",
     "    \"You answer in the language that the question was asked in.\\n\"\n",
     "    \"You speak german and english.\\n\"\n",
     ")\n",
     "\n",
-    "def bot_respond(user_query, chat_messages: list):\n",
-    "    embedding = get_embedding(user_query)\n",
+    "step = 0\n",
     "\n",
-    "    qnas = db.get_qna(embedding, lang=\"en\", limit=3)\n",
-    "    print(\"Total_qnas:\", len(qnas), [qna.score for qna in qnas])\n",
-    "    qnas = [qna for qna in qnas if qna.score < 0.45]\n",
-    "    print(\"Filtered_qnas:\", len(qnas))\n",
-    "    context_prompt = f\"The user said: {user_query}\\n\\n\"\n",
-    "\n",
-    "    if len(qnas) > 0:\n",
-    "        example_questions = \"\"\n",
-    "        for qna in qnas:\n",
-    "            example_questions += (\n",
-    "                f\"For question: '{qna.question}'\\n\"\n",
-    "                f\"The answer is: '{qna.answer}'\\n\"\n",
-    "            )\n",
-    "\n",
-    "        context_prompt += (\n",
-    "            f\"Context information from our database:\\n{example_questions}\"\n",
-    "            \"If the user hasn't provided some of the necessary information for answering the question, you can ask the user for it.\\n\"\n",
-    "        )\n",
+    "def context_format(qnas):\n",
+    "    context = \"Context:\\n\\n```\"\n",
+    "    for qna in qnas:\n",
+    "        context += f\"For question: {qna.question}\\nThe answer is: {qna.answer}\\n\"\n",
+    "    context += \"```\"\n",
+    "    return context\n",
+    "\n",
+    "\n",
+    "def bot_respond(user_query, history: list):\n",
+    "    global step\n",
+    "\n",
+    "    chat_messages = history[\"chat_messages\"]\n",
+    "\n",
+    "    user_query = contextualize_question(user_query, chat_messages)\n",
+    "\n",
+    "    path = os.path.join(conversation_folder, f\"step_{step}_qna.json\")\n",
+    "\n",
+    "\n",
+    "    qnas = query_database(user_query)\n",
     "\n",
-    "    print(context_prompt)\n",
-    "    chat_messages.append({\"role\": \"user\", \"content\": context_prompt})\n",
+    "    prompt = f\"The user said: ---{user_query}---\\n\\n\"\n",
+    "\n",
+    "    context = context_format(qnas)\n",
+    "    prompt += context\n",
+    "\n",
+    "    qna_messages = [\n",
+    "        {\n",
+    "            \"role\": \"assistant\",\n",
+    "            \"content\": SYSTEM_PROMPT,\n",
+    "        },\n",
+    "        {\n",
+    "            \"role\": \"user\",\n",
+    "            \"content\": prompt,\n",
+    "        },\n",
+    "    ]\n",
     "\n",
     "    completion = openai.ChatCompletion.create(\n",
-    "        model=\"gpt-3.5-turbo\",\n",
-    "        messages=chat_messages,\n",
+    "        model=\"gpt-3.5-turbo\", messages=qna_messages, temperature=0\n",
     "    )\n",
-    "    text = completion.choices[0].message.content\n",
     "\n",
-    "    chat_messages.pop()\n",
-    "    chat_messages.append({\"role\": \"user\", \"content\": user_query})\n",
-    "    chat_messages.append({\"role\": \"system\", \"content\": text})\n",
+    "    response_message = completion[\"choices\"][0][\"message\"]\n",
+    "    bot_response = response_message.content\n",
+    "\n",
+    "    path = os.path.join(conversation_folder, f\"step_{step}_qna.json\")\n",
+    "\n",
+    "    with open(path, \"w\") as f:\n",
+    "        json.dump(\n",
+    "            {\n",
+    "                \"chat_messages\": chat_messages,\n",
+    "                \"response\": response_message.content,\n",
+    "            },\n",
+    "            f,\n",
+    "            indent=4,\n",
+    "        )\n",
     "\n",
-    "    return text, context_prompt\n"
+    "    chat_messages.append({\"role\": \"assistant\", \"content\": bot_response})\n",
+    "\n",
+    "    step += 1\n",
+    "\n",
+    "    return bot_response, prompt"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [],
    "source": [
     "import random\n",
     "\n",
+    "\n",
     "def display_history(conversation):\n",
     "    conversation_string = \"\"\n",
     "    for message in conversation:\n",
-    "        conversation_string += f\"<<{message['role']}>>:\\n{message['content']}\\n<<{message['role']}>>\\n\\n\"\n",
+    "        conversation_string += (\n",
+    "            f\"<<{message['role']}>>:\\n{message['content']}\\n<<{message['role']}>>\\n\\n\"\n",
+    "        )\n",
     "    return conversation_string\n",
     "\n",
-    "def handle_audiofile(audio_filepath: str, chat_messages: list):\n",
+    "\n",
+    "def handle_audiofile(audio_filepath: str, history: list):\n",
     "    user_question = whisper_transcription(audio_filepath)\n",
     "    print(\"Transcription\", user_question)\n",
     "\n",
-    "    bot_response_text, context_prompt = bot_respond(user_question, chat_messages)\n",
+    "    bot_response_text, context_prompt = bot_respond(user_question, history)\n",
     "\n",
-    "    lang = detect(bot_response_text)\n",
-    "    print(\"Detected language:\", lang, \"for text:\", bot_response_text)\n",
+    "    if bot_response_text:\n",
+    "        lang = detect(bot_response_text)\n",
+    "        print(\"Detected language:\", lang, \"for text:\", bot_response_text)\n",
+    "    else:\n",
+    "        lang = \"en\"\n",
     "\n",
     "    if lang not in [\"en\", \"de\"]:\n",
     "        lang = \"en\"\n",
@@ -134,41 +207,94 @@
     "    context_prompt += f\"<<tts language>> : {lang}\\n\"\n",
     "    context_prompt += f\"<<tts text>> : {bot_response_text}\\n\"\n",
     "\n",
-    "    return user_question, bot_response_text, chat_messages, context_prompt, display_history(chat_messages), output_filepath"
+    "    return (\n",
+    "        user_question,\n",
+    "        bot_response_text,\n",
+    "        history,\n",
+    "        context_prompt,\n",
+    "        display_history(history[\"chat_messages\"]),\n",
+    "        output_filepath,\n",
+    "    )"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 27,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7880\n",
+      "Running on public URL: https://80ddf0a828a1240987.gradio.live\n",
+      "\n",
+      "This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from Terminal to deploy to Spaces (https://huggingface.co/spaces)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Transcription What locations are available for measurement?\n",
+      "Querying database for question: What locations are available for measurement?\n",
+      "Total_qnas: 3 [0.43219417333602905, 0.43802204728126526, 0.4490761160850525]\n",
+      "Filtered_qnas: 3\n",
+      "Detected language: en for text: The available locations for measurement are Salzburg and Hallein. In Salzburg, there is an underground car park and individual parking spaces available. The Salzburg location is also easily accessible by O-Bus. In Hallein, there are plenty of parking spaces directly in front of the building.\n",
+      "Transcription How much time does the measurement take?\n",
+      "Querying database for question: How much time does the measurement at each location take?\n",
+      "Total_qnas: 3 [0.3830512762069702, 0.383282870054245, 0.38819530606269836]\n",
+      "Filtered_qnas: 3\n",
+      "Detected language: en for text: The measurement at each location takes about 5-15 minutes, depending on the question and number of examination areas.\n"
+     ]
+    }
+   ],
    "source": [
     "import gradio as gr\n",
     "\n",
     "\n",
     "with gr.Blocks() as demo:\n",
     "    # initialize the state that will be used to store the chat messages\n",
-    "    chat_messages = gr.State([{\"role\": \"system\", \"content\": GENERAL_SYSTEM_PROMPT}])\n",
+    "    chat_messages = gr.State(\n",
+    "        {\n",
+    "            \"chat_messages\": [{\"role\": \"system\", \"content\": SYSTEM_PROMPT}],\n",
+    "        }\n",
+    "    )\n",
     "\n",
     "    with gr.Row():\n",
     "        audio_input = gr.Audio(source=\"microphone\", type=\"filepath\", format=\"mp3\")\n",
     "        # autoplay=True => run the output audio file automatically\n",
-    "        output_audio = gr.Audio(\n",
-    "            label=\"PhoneBot Answer TTS\", autoplay=True\n",
-    "        )\n",
+    "        output_audio = gr.Audio(label=\"PhoneBot Answer TTS\", autoplay=True)\n",
     "    with gr.Row():\n",
     "        user_query_textbox = gr.Textbox(label=\"User Query\")\n",
     "        assistant_answer = gr.Textbox(label=\"PhoneBot Answer\")\n",
     "\n",
     "    with gr.Row():\n",
-    "        context_info = gr.Textbox(label=\"Context provided to the bot + additional infos for debugging\")\n",
+    "        context_info = gr.Textbox(\n",
+    "            label=\"Context provided to the bot + additional infos for debugging\"\n",
+    "        )\n",
     "        conversation_history = gr.Textbox(label=\"Conversation history\")\n",
     "\n",
     "    # when the audio input is stopped, run the transcribe function\n",
     "    audio_input.stop_recording(\n",
     "        handle_audiofile,\n",
     "        inputs=[audio_input, chat_messages],\n",
-    "        outputs=[user_query_textbox, assistant_answer, chat_messages, context_info, conversation_history, output_audio],\n",
+    "        outputs=[\n",
+    "            user_query_textbox,\n",
+    "            assistant_answer,\n",
+    "            chat_messages,\n",
+    "            context_info,\n",
+    "            conversation_history,\n",
+    "            output_audio,\n",
+    "        ],\n",
     "    )\n",
     "\n",
     "demo.launch(share=True, inbrowser=True, inline=False)"
@@ -176,34 +302,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 109,
    "metadata": {},
    "outputs": [],
    "source": [
     "import json\n",
+    "\n",
     "with open(\"all_questions.json\", encoding=\"utf-8\") as f:\n",
     "    all_questions = json.load(f)[\"qna\"]"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "all_questions = [{\"question\": qna[\"question\"], \"answer\": qna[\"answer\"]} for qna in all_questions]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open(\"test.json\", \"w\", encoding=\"utf-8\") as f:\n",
-    "    json.dump(all_questions, f, indent=4, ensure_ascii=False)"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -215,22 +323,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
-    "functions = [{\n",
-    "    \"name\": \"get_answer\",\n",
-    "    \"description\": \"Get answer from the bot\",\n",
-    "    \"parameters\": [\n",
-    "        \n",
-    "\n",
-    "}]\n",
-    "\n",
-    "openai.ChatCompletion.create(\n",
-    "    model=\"gpt-3.5-turbo\",\n",
-    "    functions=[\"get_answer\"],\n",
-    ")"
+    "from genson import SchemaBuilder\n",
+    "import json\n",
+    "\n",
+    "builder = SchemaBuilder()\n",
+    "obj = {\n",
+    "    \"response_type\": \"Which city do you want to book an appointment in?\",\n",
+    "    \"content\": \"The user wants to book an appointment\",\n",
+    "}\n",
+    "builder.add_object(obj)\n",
+    "\n",
+    "schema = builder.to_schema()\n",
+    "schema.pop(\"$schema\")\n",
+    "schema_str = json.dumps(schema, indent=4)"
    ]
   }
  ],

openai_prompts/__init__.py

@@ -0,0 +1 @@
+from .contextualize import contextualize_question

openai_prompts/contextualize.py

@@ -0,0 +1,56 @@
+import json
+
+import openai
+
+functions = [
+    {
+        "name": "with_context",
+        "description": "Updates the question with context from the conversation to make it more clear, adds details, replaces general words like 'there', 'that', pronouns with the values mentioned in conversation.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "contextualized_question": {
+                    "type": "string",
+                    "description": "The contextualized question",
+                }
+            },
+            "required": ["contextualized_question"],
+        },
+    }
+]
+
+
+def contextualize_question(user_query: str, messages: list[str]):
+    prompt = (
+        f"The user said: {user_query}\n\n"
+        "If the user is asking a question, make sure you contextualize it using the replies exchanged before, add details to the question.\n"
+        "The previous messages are:\n"
+    )
+
+    messages_for_context = messages[1:]
+    for message in messages_for_context:
+        prompt += f"<<{message['role']}>>{message['content']}<<{message['role']}>>\n"
+
+    res = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {
+                "role": "system",
+                "content": "You are a helpful assistant adds context to vague questions.",
+            },
+            {"role": "user", "content": prompt},
+        ],
+        functions=functions,
+        function_call={"name": "with_context"},  # force the function to be called
+        temperature=0.2,
+    )
+
+    try:
+        arguments = res["choices"][0]["message"]["function_call"]["arguments"]
+
+        result_data = json.loads(arguments)
+
+        return result_data["contextualized_question"]
+    except Exception as error:
+        print(error)
+        return last_reply