Initial

app.py

@@ -0,0 +1,120 @@
+import os
+import time
+import openai
+import gradio as gr
+
+# Embeddings
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+
+# Chat Q&A
+from langchain.chat_models import ChatOpenAI
+from langchain.schema import AIMessage, HumanMessage, SystemMessage
+
+# This sets up OpenAI embeddings model
+embeddings = OpenAIEmbeddings()
+
+# Loads database from persisted directory
+db_directory = "chroma_db"
+db = Chroma(persist_directory=db_directory, embedding_function=embeddings)
+
+# This is code that retrieves relevant documents based on a similarity search (in this case, it grabs the top 2 relevant documents or chunks)
+retriever = db.as_retriever(search_type='similarity', search_kwargs={"k":2})
+
+with open('system_prompt.txt', 'r') as file:
+    ORIG_SYSTEM_MESSAGE_PROMPT = file.read()
+
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+#chat = ChatOpenAI(model_name="gpt-3.5-turbo",temperature=0) # Faster for experiments
+chat = ChatOpenAI(model_name="gpt-4",temperature=0)
+
+# Make sure we don't exceed estimation of token limit:
+TOKEN_LIMIT = 4096  # GPT-3.5 Turbo token limit
+BUFFER = 100  # Extra tokens to consider for incoming messages
+
+def estimate_tokens(texts):
+    return sum([len(t.split()) for t in texts])
+
+def truncate_history(history):
+    tokens = estimate_tokens([msg.content for msg in history])
+    while tokens + BUFFER > TOKEN_LIMIT and len(history) > 3:
+        history = history[0:1] + history[3:]
+        tokens = estimate_tokens([msg.content for msg in history])
+    return history
+
+# Here is the langchain
+def predict(history, input):
+    context = retriever.get_relevant_documents(input)
+    print(context) #For debugging
+    history_langchain_format = []
+    history_langchain_format.append(SystemMessage(content=f"{ORIG_SYSTEM_MESSAGE_PROMPT}"))
+    for human, ai in history:
+        history_langchain_format.append(HumanMessage(content=human))
+        history_langchain_format.append(AIMessage(content=ai))
+    history_langchain_format.append(HumanMessage(content=input))
+    history_langchain_format.append(SystemMessage(content=f"If you need to answer a question based on the previous message, here is some info: {context}"))
+    
+    # Truncate if history is too long
+    history_langchain_format = truncate_history(history_langchain_format)
+    
+    gpt_response = chat(history_langchain_format)
+    
+    # Extract pairs of HumanMessage and AIMessage
+    pairs = []
+    for i in range(len(history_langchain_format)):
+        if isinstance(history_langchain_format[i], HumanMessage) and (i+1 < len(history_langchain_format)) and isinstance(history_langchain_format[i+1], AIMessage):
+            pairs.append((history_langchain_format[i].content, history_langchain_format[i+1].content))
+    
+    # Add the new AI response to the pairs for subsequent interactions
+    pairs.append((input, gpt_response.content))
+    
+    return pairs
+
+# Function to handle user message (this clears the interface)
+def user(user_message, chatbot_history):
+    return "", chatbot_history + [[user_message, ""]]
+
+# Function to handle AI's response
+def bot(chatbot_history):
+    user_message = chatbot_history[-1][0] #This line is because we cleared the user_message previously in the user function above
+    # Call the predict function to get the AI's response
+    pairs = predict(chatbot_history, user_message)
+    _, ai_response = pairs[-1]  # Get the latest response
+
+    response_in_progress = ""
+    for character in ai_response:
+        response_in_progress += character
+        chatbot_history[-1][1] = response_in_progress
+        time.sleep(0.05)
+        yield chatbot_history
+
+# This is a function to do something with the voted information (TODO: Save this info somewhere?)
+def vote(data: gr.LikeData):
+    if data.liked:
+        print("You upvoted this response: " + data.value)
+    else:
+        print("You downvoted this response: " + data.value)
+        with open("logs.txt", "a") as text_file:
+          print(f"Disliked content: {data.value}", file=text_file)
+
+# The Gradio App interface
+with gr.Blocks() as demo:
+    gr.Markdown("""<h1><center>DylanAI by CIONIC</center></h1>""")
+    gr.Markdown("""<p><center>For best results, please ask DylanAI one question at a time. Unlike Human Dylan, DylanAI cannot multitask.</center></p>""")
+    chatbot = gr.Chatbot()
+    textbox = gr.Textbox()
+    clear = gr.Button("Clear")
+    
+    # Chain user and bot functions with `.then()`
+    textbox.submit(user, [textbox, chatbot], [textbox, chatbot], queue=False).then(
+        bot, chatbot, chatbot,
+    )
+    clear.click(lambda: None, None, chatbot, queue=False)
+    chatbot.like(vote, None, None)
+
+# Enable queuing
+demo.queue()
+demo.launch(debug=True)
+
+

requirements.txt

@@ -0,0 +1,4 @@
+openai == 0.28.1
+langchain == 0.0.308
+chromadb == 0.4.13
+tiktoken == 0.5.1

system_prompt.txt

@@ -0,0 +1,27 @@
+You are DylanAI, a very friendly customer service agent who answers questions \
+from prospective customers about Cionic as a company and the Cionic Neural Sleeve \
+as a product. 
+
+Rules (you must follow all the rules):
+* If you cannot answer using the sources and logical deduction, say you don't know.
+* Make things easy to understand, explain all jargon and acronyms, and explain uncommon words.
+* Be concise
+* You should only answer questions that are about Cionic and the Cionic Neural Sleeve.
+
+If answer is not in context, say you don't know and refer them to support-team@cionic.com.
+If you are asked a question that is not about Cionic or the Cionic Neural Sleeve, you should redirect the conversation back to Cionic.
+Do not make reference to the data or sources available to you. 
+Ask questions of the user if you need clarification.
+
+If users ask whether they are eligible for the Cionic Neural Sleeve or whether it will work for them, you should ask the following questions:
+How old are you?
+Do you reside in the US?
+Tell us about your diagnosis?
+Tell us about your walking?
+
+You can determine if they are eligible by matching their answers to this eligibility criteria:
+* Must be 22 years old or older to be eligible.
+* Must reside inside of the United States to be eligible.
+* Must be able to walk to be eligible.
+* They cannot be implanted with a demand-type cardiac pacemaker or defibrillator.  
+* Must have one of the supported diagnoses, which include: Multiple Sclerosis, Stroke, Cerebral Palsy, Traumatic Brain Injury, and Spinal Cord Injury.