Update app.py

app.py

@@ -1,205 +1,137 @@
-import os
-import time
-import requests
-from flask import Flask, request, jsonify
+import os, re
+from flask import Flask, request, jsonify, make_response
 from flask_cors import CORS
-
-import openai
-import langchain
-import random
-from langchain_openai import ChatOpenAI
-from langchain_community.cache import InMemoryCache
-from langchain.prompts import PromptTemplate
-from langchain.chains import LLMChain
+from time import sleep
+from openai import OpenAI
 
 # Set environment variables and OpenAI configurations
-api_keys = os.environ
-openai.api_key = os.environ['OPENAI_API_KEY']
-print(os.environ['OPENAI_API_KEY'])
-langchain.llm_cache = InMemoryCache()
+print("OpenAI:\t\t"+os.environ['OPENAI_API_KEY'])
+# Connect to the assistant
+
+openai_client = OpenAI(api_key=os.environ['OPENAI_API_KEY'])
+openai_assistant = openai_client.beta.assistants.retrieve(assistant_id=os.environ['OPENAI_ASSISTANT_ID'])
+openai_assistant_id=openai_assistant.id
+openai_thread_id = ""
+openai_additional_instruction = os.environ['OPENAI_ADDITIONAL_INSTRUCTION']
+max_response_length = os.environ['MAX_RESPONSE_LENGTH']
 
 app = Flask(__name__)
 CORS(app)
 
-# This sends final LLM output to dynamically get tagged with UneeQ emotions and expressions
-def process_emotions(query):
-    try:
+# Function to create a thread
 
-        # URL of the FT LLM API endpoint (ECS)
-        url = "https://api-ft-inline-tags.caipinnovation.com/query"
+def create_thread():
 
-        # Payload to be sent in the POST request
-        payload = {"prompt": query}
+    openai_thread = openai_client.beta.threads.create()
+    return(openai_thread.id)
 
-        # Making the POST request
-        response = requests.post(url, json=payload)
+# Function to create a message in a given thread
 
-        # Checking if the request was successful
-        response.raise_for_status()
+def create_message(thread_id,user_message):
+    thread_message = openai_client.beta.threads.messages.create(
+    thread_id,
+    role='user',
+    content=user_message,
+    )
+    return thread_message
 
-        # Returning the 'answer' from the response
-        ft_answer = response.json().get("answer")
-        return ft_answer
+# Function to retrieve a message from a given thread
 
-    except Exception as e:
-        raise 
+def retrieve_message(thread_id,message_id):
+    message = openai_client.beta.threads.messages.retrieve(
+    message_id=message_id,
+    thread_id=thread_id,
+    )
+    return message
 
-#This handles general Q&A to the LLM
-def process_query(query, chat_history, systemMessage, emotions):
-    try:
+# Function to run the thread
 
-        print(f"calling fine_tuned_model") 
+def run_thread(thread_id,assistant_id):
+    run = openai_client.beta.threads.runs.create_and_poll(
+    thread_id=thread_id,
+    additional_instructions=openai_additional_instruction,
+    assistant_id=assistant_id,
+    )
 
-        #Get name of model from ENV
-        ft_model_name = os.environ.get("OPENAI_MODEL_NAME")
-        
-        #Model name from env will be used here:
-        fine_tuned_model = ChatOpenAI(
-            temperature=0, model_name=ft_model_name
-        )
-
-        prompt_template = """System: {systemMessage}.
-        User: The user is inquiring about cataracts or cataract surgery.  Answer their question: {query}"""
-        PROMPT = PromptTemplate(template=prompt_template,
-                                input_variables=["systemMessage", "query"])
-
-        chain = LLMChain(llm=fine_tuned_model, prompt=PROMPT, verbose=False)
-
-        input_prompt = [{"systemMessage": systemMessage, "query": query}]
-
-        generatedResponse = chain.apply(input_prompt)
-
-        #Replace/filter out any prepended strings from LLM response
-        #Sometimes we have issues that the LLM writes these following strings before answer. Use if needed.
-        llm_response = generatedResponse[0]["text"].replace("Answer:", "").replace("System:", "").lstrip()
-        print(llm_response)
-
-        #NOW SEND RESPONSE TO GET TAGGED w/ Emotions and Expressions
-        if emotions:
-            try:
-                llm_response_ft = process_emotions(llm_response)
-            except Exception as e:
-                # Log the error
-                print(f"Error processing emotions for query: {llm_response}. Error: {str(e)}")
-                # Return the error response
-                return {"error": "Error processing emotions", "query": llm_response}
-
-            return {
-                "answer": llm_response_ft,
-                "source_documents": ""
-            }
-        else:
-            return {
-                "answer": llm_response,
-                "source_documents": ""
-            }
-    except Exception as e:
-        print(f"Error processing query: {query}. Error: {str(e)}")
-        return {"error": "Error processing query"}
-    
-#This handles the chart functionality in HIMSS    
-def process_chart(query, s1 ,s2):
-    try:
-        print("calling fine_tuned_model")    
-        #Get name of model from ENV
-        ft_model_name = os.environ.get("OPENAI_MODEL_NAME")
-        
-        #Model name from env will be used here:
-        fine_tuned_model = ChatOpenAI(
-            temperature=0, model_name=ft_model_name
-        )
+    return run
 
-        prompt_template = """System: {systemMessage}.
-        User: {query}"""
-        PROMPT = PromptTemplate(template=prompt_template,
-                                input_variables=["systemMessage", "query"])
+# Function to check the status of the run
 
-        chain = LLMChain(llm=fine_tuned_model, prompt=PROMPT, verbose=False)
+def run_status(run):
+    return run.status
 
-        # Get systemMessage from env file:
-        systemMessage = os.environ.get("SYSTEM_MESSAGE")
+# Function to clear a thread
 
-        input_prompt = [{"systemMessage": systemMessage, "query": query}]
+def delete_thread(thread_id):
+    return openai_client.beta.threads.delete(thread_id)
 
-        generatedResponse = chain.apply(input_prompt)
-        print("after ", generatedResponse[0]["text"])
+def delete_message(message_id,thread_id):
+    deleted_message = openai_client.beta.threads.messages.delete(
+    message_id=message_id,
+    thread_id=thread_id,
+    )
+    return deleted_message.id
 
-        #Replace/filter out any prepended strings from LLM response
-        #Sometimes we have issues that the LLM writes these following strings before answer. Use if needed.
-        generatedResponse_filtered = generatedResponse[0]["text"].replace("Answer:", "").replace("System:", "").lstrip()
+#This handles general Q&A to the LLM
+def process_query(query,thread_id):
 
-        stripped_answer = f"I see you have {s1} and {s2}. {generatedResponse_filtered}"
+    retval = {"answer":""}
+    
+    new_message = create_message(thread_id,query)
+    run =run_thread(thread_id,openai_assistant_id)
 
-        return {
-            "answer": stripped_answer,
-            "source_documents": ""
-        }
-    except Exception as e:
-        print(f"Error processing query: {query}. Error: {str(e)}")
-        return {"error": "Error processing query"}
+    messages = openai_client.beta.threads.messages.list(thread_id=thread_id)
+    for message in messages:
+        
+        if message.run_id == run.id:
+            if message.role=='assistant':
+                # gets the answer from the assistant
+                answer = str(message.content[0].text.value)
+                # kills the source reference in the response, if there
+                regex_pattern = r"【.*?】"
+                scrubbed_answer = re.sub(regex_pattern, '', answer)
+                scrubbed_answer = scrubbed_answer.replace('Mater','Matter')
+                retval = {"answer":scrubbed_answer}
+
+    return retval
 
 #POST request to this service
 @app.route('/query', methods=['POST'])
 def handle_query():
-
+    print(request)
+    print(request.json)
     data = request.json
     query=data['prompt']
-    chatHistory=""
-    systemMessage=os.environ['SYSTEM_MESSAGE']
+    openai_thread_id=data['thread']
+    print("Assistant:\t\t "+openai_assistant.id)
+    print("Thread:\t\t"+openai_thread_id)
     answer = ''
-    emotions = ''
 
-    result = process_query(query, chatHistory, systemMessage, emotions)
-    answer = result['answer']
+    # need to grab a thread id or create a new thread
 
-    serialized_result = {
-        "answer": answer,
-        "matchedContext": "",
-        "conversationPayload": ""
-    }
+    if openai_thread_id == "":
+        print("Creating a new thread ")
+        # create the thread
+        openai_thread_id=create_thread()
 
-    print(serialized_result)
-    
-    return jsonify(serialized_result), 200
+        print("New thread:\t"+openai_thread_id)
 
-# Helper Functions
-def pick_random_issues(issues):     
-    # Randomly select two strings from the list
-    random_strings = random.sample(issues, 2)
-    return random_strings
-
-def generate_description():
-    issues = ["Anterior Uveitis", "Corneal Guttata", "Diabetes", "Diabetes Mellitus", "Glaucoma", "Retinal Detachment", "Corticosteroids", "Phenothiazine", "Chlorpromazine", "Ultraviolet Radiation Exposure", "Smoking", "High Alcohol Consumption", "Poor Nutrition"]
-    random_strings = pick_random_issues(issues)
-    random_string_1, random_string_2 = random_strings
-    description = f"Describe any issues I may encounter due to {random_string_1} and {random_string_2} relative to my upcoming cataract surgery?"
-    return description, random_string_1, random_string_2
-
-#GET request to chart feature
-@app.route('/chart', methods=['GET'])
-def handle_chart():
-    description, random_string_1, random_string_2 = generate_description()
-    query = description
-    if not query:
-        return jsonify({"error": "No query provided"}), 400
-    result = process_chart(query, random_string_1, random_string_2)
-    if "error" in result:
-        return jsonify(result), 500
+    result = process_query(query,openai_thread_id)
+    answer = result['answer']
 
     serialized_result = {
-        "query": query,
-        "answer": result["answer"],
-        "source_documents": ""
+        "answer": answer,
+        "matchedContext": "",
+        "conversationPayload": "",
+        "thread": openai_thread_id
     }
-    
+    print(serialized_result['answer'])
     return jsonify(serialized_result), 200
 
-
 @app.route('/')
 def hello():
     version = os.environ.get("CODE_VERSION")
     return jsonify({"status": "Healthy", "version": version}), 200
 
-
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    app.run(host="0.0.0.0", port=15002)