Initial Commit

app.py

@@ -0,0 +1,60 @@
+import chat
+import gradio
+
+def initialize_game(game_id, user_id, user_input):
+    result = chat.initialize_game(game_id, user_id, user_input)
+    return result
+
+def play_game(game_id, user_id, user_input):
+    result = chat.start_game(game_id, user_id, user_input)
+    return result
+
+def health_check(name):
+    result = {"role": "assistant", "content": "Hello " + name + "! The site is up"}
+    return result
+
+def generate_image_prompt(game_id, user_id, user_input):
+    result = chat.generate_image_prompt(game_id, user_id, user_input)
+    return result
+
+   
+# @app.route('/load_game', methods=['GET'])
+# def load_game():
+#     upload_game_docs()
+#     response = {'message': 'Game loaded'}
+#     return jsonify(response)
+
+health_check_gr = gradio.Interface(
+  fn=health_check,
+  inputs="text",
+  outputs="text",
+  title="DEVELOPERS ONLY - Health Check for Genesis APIs",
+  description="An API to check if the API is working"
+)
+
+initialize_game_gr = gradio.Interface(
+  fn=initialize_game,
+  inputs=["text","text", "text"],
+  outputs="text",
+  title="Initialize Game",
+  description="An API to initialize the game. This is executed ONLY when a user starts a game"
+)
+
+play_game_gr = gradio.Interface(
+  fn=play_game,
+  inputs=["text","text", "text"],
+  outputs="text",
+  title="Play Game",
+  description="An API for the user to interact with the LLM"
+)
+
+generate_image_prompt_gr = gradio.Interface(
+  fn=generate_image_prompt,
+  inputs=["text","text", "text"],
+  outputs="text",
+  title="Generate prompt for image",
+  description="An API for the user to generate a prompt to input to Leo"
+)
+
+genesis_app = gradio.TabbedInterface([health_check_gr, initialize_game_gr, play_game_gr, generate_image_prompt_gr], ["Developers - Health Check", "Initialize game", "Play Game", "Generate Prompt for Leo"])
+genesis_app.launch()

chat.py

@@ -0,0 +1,181 @@
+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, read_word_document
+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')
+debug=False
+if os.getenv('DEBUG') == 'True':
+    debug=True
+
+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)
+file_path = os.getenv('GAME_DOCS_FOLDER')
+file_name = os.getenv('GAME_DOCS_FILE')
+game_index = os.getenv('GAME_ID_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 get_game_details(game_id):
+    file_data = open_file(f"{file_path}/{game_index}")
+    tmp_json = json.loads(file_data)
+    for json_item in tmp_json["game_details"]:
+        if json_item["game_id"] == game_id:
+            return json_item
+    return "Not Found"
+
+def populate_prompt(game_id, splits):
+    prompt_text = list()
+    idlist = []
+    for j in range(int(splits)):
+       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(game_id, user_id, user_input):
+    game_details = get_game_details(game_id)
+    whole_prompt = populate_prompt(game_id, game_details["splits"])
+    if debug:
+        print(whole_prompt[:1000])
+    whole_prompt = whole_prompt.replace("<<USER_INPUT_MSG>>", user_input)
+    if debug:
+        print(whole_prompt[:1000])
+    
+    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"]
+
+
+def generate_image_prompt(game_id, user_id, user_input):
+    if 'You have a manual' in user_input:
+        user_input = user_input.replace('You have a manual of this newly created simulation in your mind. Now what is the first thing you will do in this world?', '')
+    payload = list()
+    file_data = open_file(f"{file_path}/image_prompt_leo.txt").replace("<<PROMPT_FOR_IMG>>", user_input)
+    leo_input_msg = call_gpt(file_data)
+    leo_input = leo_input_msg.choices[0].message.content
+    timestamp_op = time()
+    timestring_op = timestamp_to_datetime(timestamp_op) 
+    vector_op = perform_embedding(leo_input)
+    unique_id_op = str(uuid4)
+    metadata_op = {'speaker': 'BOT4LEO', 'user_id': user_id, 'game_id': game_id, 'timestring': timestring_op, 'text': leo_input}
+    payload.append((unique_id_op, vector_op, metadata_op))
+
+    return leo_input
+
+if __name__ == '__main__':
+    print("main")

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,23 @@
+import json
+from docx import Document
+
+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)
+
+def read_word_document(filepath):
+    try:
+        doc = Document(filepath)
+        paragraphs = [p.text for p in doc.paragraphs]
+        return paragraphs
+    except Exception as e:
+        print(f"Error reading the Word document: {e}")
+        return []

prompt_response.txt

@@ -0,0 +1,13 @@
+<<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 on behalf of the person who answers:
+
+GENESIS:

requirements.txt

@@ -0,0 +1,77 @@
+aiofiles==23.1.0
+aiohttp==3.8.4
+aiosignal==1.3.1
+altair==5.0.1
+anyio==3.7.0
+async-timeout==4.0.2
+attrs==23.1.0
+certifi==2023.5.7
+charset-normalizer==3.1.0
+click==8.1.3
+colorama==0.4.6
+contourpy==1.0.7
+cycler==0.11.0
+elevenlabs==0.2.18
+exceptiongroup==1.1.1
+fastapi==0.95.2
+ffmpy==0.3.0
+filelock==3.12.0
+fonttools==4.39.4
+frozenlist==1.3.3
+fsspec==2023.5.0
+gradio==3.32.0
+gradio-client==0.2.5
+h11==0.14.0
+httpcore==0.17.2
+httpx==0.24.1
+huggingface-hub==0.14.1
+idna==3.4
+importlib-resources==5.12.0
+Jinja2==3.1.2
+jsonschema==4.17.3
+kiwisolver==1.4.4
+linkify-it-py==2.0.2
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+matplotlib==3.7.1
+mdit-py-plugins==0.3.3
+mdurl==0.1.2
+multidict==6.0.4
+numpy==1.24.3
+orjson==3.8.14
+packaging==23.1
+pandas==2.0.2
+Pillow==9.5.0
+pkgutil-resolve-name==1.3.10
+pydantic==1.10.8
+pydub==0.25.1
+Pygments==2.15.1
+pyparsing==3.0.9
+pyrsistent==0.19.3
+python-dateutil==2.8.2
+python-docx==0.8.11
+python-multipart==0.0.6
+pytz==2023.3
+PyYAML==6.0
+requests==2.31.0
+semantic-version==2.10.0
+six==1.16.0
+sniffio==1.3.0
+starlette==0.27.0
+toolz==0.12.0
+tqdm==4.65.0
+typing-extensions==4.6.2
+tzdata==2023.3
+uc-micro-py==1.0.2
+urllib3==2.0.2
+uvicorn==0.22.0
+websockets==11.0.3
+yarl==1.9.2
+zipp==3.15.0
+flask
+python-dotenv
+langchain
+openai
+pinecone-client
+tiktoken
+docx2txt