First version

.env

@@ -0,0 +1,13 @@
+OPENAI_API_KEY=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
+PINECONE_API_KEY=416ba549-14f7-4770-abcc-bb054451dcd3
+PINECONE_REGION=us-east4-gcp
+PINECONE_INDEX=game-instructions
+EMBEDDING_ENGINE=text-embedding-ada-002
+CONVO_LENGTH_TO_FETCH=1000
+LLM_MODEL=gpt-4
+DEBUG=True
+GAME_DOCS_FOLDER="game_docs"
+GAME_DOCS_FILE="Sim_AI_Superprompt.docx"
+GAME_ID_INDEX="game_index.json"
+HOST=127.0.0.1
+PORT=5000

app.py

@@ -1,18 +1,47 @@
-import gradio
+from flask import Flask, jsonify, request
+from gameload import upload_game_docs
+import chat
+import os
+import dotenv
+import os
 
-def my_inference_function(name):
-  return "Hello " + name + "!"
+app = Flask(__name__)
+dotenv.load_dotenv('.env')
+host = os.getenv('HOST')
+port = os.getenv('PORT')
 
-gradio_interface = gradio.Interface(
-  fn=my_inference_function,
-  inputs="text",
-  outputs="text",
-  examples=[
-    ["Jill"],
-    ["Sam"]
-  ],
-  title="REST API with Gradio and Huggingface Spaces",
-  description="This is a demo of how to build an AI powered REST API with Gradio and Huggingface Spaces – for free! Based on [this article](https://www.tomsoderlund.com/ai/building-ai-powered-rest-api). See the **Use via API** link at the bottom of this page.",
-  article="© Tom Söderlund 2022"
-)
-gradio_interface.launch()
+@app.route('/initialize_game', methods=['GET'])
+def initialize_game():
+    inputs = request.args.to_dict()
+    user_id = inputs['user_id']
+    game_id = inputs['game_id']  
+    result = chat.initialize_game(user_id, game_id)
+    response = {'role': 'assistant', 'content': result}
+    return jsonify(response)
+
+@app.route('/start_game', methods=['GET'])
+def start_game():
+    inputs = request.args.to_dict()
+    user_id = inputs['user_id']
+    game_id = inputs['game_id']  
+    user_input = inputs['user_input']
+    gpt_output = chat.start_game(game_id, user_id, user_input)
+    response = {'role': 'assistant', 'content': gpt_output}
+    return jsonify(response)
+
+@app.route('/health_check', methods=['GET'])
+def health_check():
+    response = {'message': 'Site is healthy'}
+    return jsonify(response)
+
+@app.route('/load_game', methods=['GET'])
+def load_game():
+    upload_game_docs()
+    response = {'message': 'Game loaded'}
+    return jsonify(response)
+
+if __name__ == '__main__':
+    host = '0.0.0.0'  # Replace with your desired host IP
+    port = 8080  # Replace with your desired port number
+
+    app.run(host=host, port=port)

chat.py

@@ -0,0 +1,152 @@
+from time import time, sleep
+import datetime
+import dotenv
+import os
+import openai
+import json
+import pinecone
+from uuid import uuid4
+from helper import open_file, save_file
+import re
+from langchain.memory import VectorStoreRetrieverMemory
+
+## Read the environment variables
+dotenv.load_dotenv('.env')
+openai.api_key = os.getenv('OPENAI_API_KEY')
+embedding_model = os.getenv('EMBEDDING_ENGINE')
+convo_length = int(os.getenv('CONVO_LENGTH_TO_FETCH'))
+llm_model = os.getenv('LLM_MODEL')
+
+pinecone_api_key = os.getenv('PINECONE_API_KEY')
+pinecone_env = os.getenv('PINECONE_REGION')
+pinecone_index = os.getenv('PINECONE_INDEX')
+pinecone.init(
+    api_key=pinecone_api_key,  
+    environment=pinecone_env 
+)
+vector_db = pinecone.Index(pinecone_index)
+
+def timestamp_to_datetime(unix_time):
+    return datetime.datetime.fromtimestamp(unix_time).strftime("%A, %B %d, %Y at %I:%M%p %Z")
+
+
+def perform_embedding(content):
+    content = content.encode(encoding='ASCII',errors='ignore').decode()
+    response = openai.Embedding.create(model=embedding_model, input=content)
+    vector = response['data'][0]['embedding']
+    return vector
+
+def load_conversation(results):
+    result = list()
+    for m in results['matches']:
+        result.append({'time1': m['metadata']['timestring'], 'text': m['metadata']['text']})
+    ordered = sorted(result, key=lambda d: d['time1'], reverse = False)
+    messages = [i['text'] for i in ordered]
+    message_block = '\n'.join(messages).strip()
+    return message_block
+ 
+
+def call_gpt(prompt):
+    max_retry = 5
+    retry = 0
+    prompt = prompt.encode(encoding='ASCII',errors='ignore').decode()
+    while True:
+        try:
+            response = openai.ChatCompletion.create(
+                    model=llm_model,
+                    temperature=0.9,
+               messages=[
+                {"role": "user", "content": prompt}
+              ]
+            )
+            
+            text = response.choices[0].message.content
+            text = re.sub('[\r\n]+', '\n', text)
+            text = re.sub('[\t ]+', ' ', text)
+            filename = '%s_gpt3.txt' % time()
+            if not os.path.exists('gpt3_logs'):
+                os.makedirs('gpt3_logs')
+            save_file('gpt3_logs/%s' % filename, prompt + '\n\n==========\n\n' + text)
+            response.choices[0].message.content = text
+            return response
+        except Exception as oops:
+            retry += 1
+            if retry >= max_retry:
+                return "GPT3 error: %s" % oops
+            print('Error communicating with OpenAI:', oops)
+            sleep(1)
+
+
+def start_game(game_id, user_id, user_input):
+    payload = list()
+
+    # Get user input, save it, vectorize it and save to pinecone
+    timestamp = time()
+    timestring = timestamp_to_datetime(timestamp)   
+    unique_id = str(uuid4())
+    vector = perform_embedding(user_input)
+    metadata = {'speaker': 'USER', 'user_id': user_id, 'game_id': game_id, 'timestring': timestring, 'text': user_input}
+    payload.append((unique_id, vector, metadata))
+       
+    
+    # Search for relevant messages and return a response
+    results=vector_db.query(vector=vector, top_k=convo_length, include_metadata=True, 
+                            filter={
+                                    "$and": [{ "user_id": { "$eq": user_id } }, { "game_id": { "$eq": game_id } }]
+                             }
+                          )
+    conversation = load_conversation(results)
+                                           
+
+    # Populate prompt
+    prompt_text = open_file(f"prompt_{game_id}_{user_id}.txt")
+    prompt = open_file('prompt_response.txt').replace('<<PROMPT_VALUE>>', prompt_text).replace('<<CONVERSATION>>', conversation).replace('<<USER_MSG>>', user_input).replace('<<USER_VAL>>', user_id)
+
+    # Generate response, vectorize
+    llm_output_msg = call_gpt(prompt)
+    llm_output = llm_output_msg.choices[0].message.content
+    timestamp_op = time()
+    timestring_op = timestamp_to_datetime(timestamp) 
+    vector_op = perform_embedding(llm_output)
+    unique_id_op = str(uuid4)
+    metadata_op = {'speaker': 'BOT', 'user_id': user_id, 'game_id': game_id, 'timestring': timestring, 'text': llm_output}
+    payload.append((unique_id_op, vector_op, metadata_op))
+
+    # Upsert into the vector database
+    vector_db.upsert(payload)
+       
+    return(llm_output)
+
+def populate_prompt(game_id):
+    prompt_text = list()
+    idlist = []
+    for j in range(21):
+       idlist.append(game_id + "-" + str(j))
+  
+
+    results=vector_db.fetch(ids=idlist)
+  
+    for ids in idlist:
+        prompt_text.append(results['vectors'][ids]["metadata"]["text"])
+
+    whole_prompt = ' '.join(prompt_text).strip()
+    return whole_prompt
+    
+
+def initialize_game(user_id, game_id):
+    whole_prompt = populate_prompt(game_id)
+    llm_prompt_op = call_gpt(whole_prompt)
+    #print(llm_prompt_op.choices[0]["message"]["content"])
+    fname="prompt_" + game_id + "_" + user_id + ".txt"
+    save_file(fname, llm_prompt_op.choices[0]["message"]["content"])
+    return llm_prompt_op.choices[0]["message"]["content"]
+
+if __name__ == '__main__':
+    user_id='user_1'
+    game_id = '536e6bc89df5'
+    output = initialize_game(user_id, game_id)
+    print('\n\nGENESIS: %s' % output)
+    while True:
+        a = input('\n\n%s: ' % user_id)
+        output = start_game(game_id, user_id, user_input=a)
+        print('\n\nGENESIS: %s' % output)

gameload.py

@@ -0,0 +1,72 @@
+import os
+import dotenv
+import openai
+import pinecone
+from langchain.document_loaders import Docx2txtLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import hashlib
+from time import sleep
+from helper import append_file
+import json
+
+## Read the environment variables
+dotenv.load_dotenv('.env')
+openai.api_key = os.getenv('OPENAI_API_KEY')
+embedding_model = os.getenv('EMBEDDING_ENGINE')
+debug_mode = os.getenv('DEBUG')
+file_path = os.getenv('GAME_DOCS_FOLDER')
+file_name = os.getenv('GAME_DOCS_FILE')
+game_index = os.getenv('GAME_ID_INDEX')
+
+pinecone_api_key = os.getenv('PINECONE_API_KEY')
+pinecone_env = os.getenv('PINECONE_REGION')
+pinecone_index = os.getenv('PINECONE_INDEX')
+pinecone.init(
+    api_key=pinecone_api_key,  
+    environment=pinecone_env 
+)
+# check if index_name' index already exists (only create index if not)
+if pinecone_index not in pinecone.list_indexes():
+    pinecone.create_index(pinecone_index, dimension=1536, metric="cosine", pods=1, pod_type="p1.x1")
+    sleep(3)
+
+vector_db = pinecone.Index(pinecone_index)
+
+
+def perform_embedding(doclist):
+    payload=list()
+    m = hashlib.md5()  
+    # convert file_name to unique ID
+    m.update(file_name.encode('utf-8'))
+    game_id = m.hexdigest()[:12]
+    json_val = {"game_id":game_id, "game_file":file_name}
+    append_file(f"{file_path}/{game_index}",json.dumps(json_val))
+
+    for i in range(len(doclist)):
+        unique_id = game_id + "-" + str(i)
+        content = doclist[i].page_content
+        content = content.encode(encoding='ASCII',errors='ignore').decode()
+        response = openai.Embedding.create(model=embedding_model, input=content)
+        metadata = {'game_id': game_id, 'split_count': i, 'text': content}
+        vector = response['data'][0]['embedding']
+        payload.append((unique_id, vector, metadata))
+
+    return payload
+
+
+def load_split_document():
+    loader = Docx2txtLoader(file_path + "/" + file_name)
+    word_doc_data = loader.load()    
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+    docs = text_splitter.split_documents(word_doc_data)
+    if debug_mode == 'True':
+        print("Total count of splits created: " + str(len(docs)))
+    return docs
+
+def upload_game_docs():
+    docs = load_split_document()
+    payload = perform_embedding(docs)
+    vector_db.upsert(payload)
+
+if __name__ == '__main__':
+    upload_game_docs()

helper.py

@@ -0,0 +1,13 @@
+import json
+
+def open_file(filepath):
+    with open(filepath, 'r', encoding='utf-8') as infile:
+        return infile.read()
+
+def save_file(filepath, content):
+    with open(filepath, 'w', encoding='utf-8') as outfile:
+        outfile.write(content)
+
+def append_file(filepath, content):
+     with open(filepath, 'w', encoding='utf-8') as outfile:
+        outfile.write(content)

prompt_response.txt

@@ -0,0 +1,12 @@
+<<PROMPT_VALUE>>
+
+
+The following are the most relevant messages in the conversation:
+<<CONVERSATION>>
+
+<<USER_VAL>>:
+<<USER_MSG>>
+
+
+You will now provide a response, followed by a question:
+GENESIS: