Initial rewrite of LangChain functionality

app.py

@@ -5,43 +5,42 @@ from io import StringIO
 from threading import Thread
 from urllib import parse
 
+from tutor2 import load, chat, code, get_history
 
-from prompts import run_code_prompt, welcome_prompt
-from tutor import chat, create_llm_chain
-from gradio_callback import q, job_done
+#rom prompts import run_code_prompt, welcome_prompt
+#from tutor import chat, create_llm_chain
+#from gradio_callback import q, job_done
 
 
 def user(user_message, history):
     return "", history + [[user_message, None]]
 
 
-def code(editor, output, history):
-    json_template = {"editor": editor, "output": output}
-    print(json.dumps(json_template))
-    return "", history + [[json.dumps(json_template), None]]
+# def code(editor, output, history):
+#     json_template = {"editor": editor, "output": output}
+#     print(json.dumps(json_template))
+#     return "", history + [[json.dumps(json_template), None]]
 
 
-def bot(history):
-    user_message = history[-1][0]
-    try:  # Check to see if the user_message contains code
-        json_template = json.loads(user_message)
-        editor = json_template["editor"]
-        output = json_template["output"]
-        history[-1][0] = "Running your code..."
-        yield history
-        user_message = run_code_prompt(editor, output)
-    except:
-        pass
-    history[-1][1] = ""
-    thread = Thread(target=chat, kwargs={"user_message": user_message})
-    thread.start()
-    while True:
-        next_token = q.get(block=True)
-        if next_token is job_done:
-            break
-        history[-1][1] += next_token
-        yield history
-    thread.join()
+def submit_chat(tutor, message):
+    # user_message = history[-1][0]
+    # history[-1][1] = ""
+    # print(tutor)
+    tutor = chat(tutor, message)
+    return [get_history(tutor), None]
+    # thread = Thread(target=chat, kwargs={"user_message": user_message})
+    # thread.start()
+    # while True:
+    #     next_token = q.get(block=True)
+    #     if next_token is job_done:
+    #         break
+    #     history[-1][1] += next_token
+    #     yield history
+    # thread.join()
+
+def submit_code(tutor, editor, output):
+    tutor = code(tutor, editor, output)
+    return get_history(tutor)
 
 
 def run_code(code):
@@ -72,15 +71,16 @@ def load_level(request: gr.Request):
 
 
 with gr.Blocks() as demo:
+    tutor = gr.State()
     with gr.Row():
         instruction_panel = gr.Markdown()
     with gr.Row():
         with gr.Column(scale=1):
-            chatbot = gr.Chatbot(label="AI Tutor", value=[[None, welcome_prompt()]])
+            chatbot = gr.Chatbot(label="AI Tutor", value=[])
             msg = gr.Textbox(show_label=False, placeholder="Type your message here...")
             msg.submit(
-                user, [msg, chatbot], [msg, chatbot], queue=False, scroll_to_output=True
-            ).then(bot, chatbot, chatbot)
+                submit_chat, [tutor, msg], [chatbot, msg]
+            )
         with gr.Column(scale=2):
             editor = gr.Code(
                 value="Loading...",
@@ -102,12 +102,12 @@ with gr.Blocks() as demo:
                 run.click(
                     run_code, editor, output, queue=False, scroll_to_output=True
                 ).then(
-                    code, [editor, output, chatbot], [msg, chatbot], queue=False
-                ).then(
-                    bot, chatbot, chatbot
+                    submit_code, [tutor, editor, output], chatbot
                 )
     demo.load(load_level, None, [instruction_panel, editor], queue=False).then(
-        create_llm_chain, [instruction_panel, editor]
+        load, [instruction_panel, editor], tutor
+    ).then(
+        get_history, tutor, chatbot
     )
 
 demo.queue()

prompts.py

@@ -1,6 +1,3 @@
-from langchain import PromptTemplate
-
-
 def system_prompt(instructions, starter_code):
     template = f"""
 You are a computer science teacher helping a student learn computer science. You are friendly and want your students to succeed.
@@ -17,16 +14,12 @@ They will ask you for help. You may help them, but you must not give them the an
 
 Do not let the student deviate from the task at hand. If they ask you a question that is not related to the task at hand, you must redirect them to the task at hand.
 
-{{chat_history}}
-Student: {{student_input}}
-Teacher:"""
-    return PromptTemplate(
-        input_variables=["chat_history", "student_input"], template=template
-    )
+"""
+    return template
 
+CODE_HEADER = "I've written this code:"
 def run_code_prompt(editor, output):
-    return f"""
-I've written this code:
+    return f"""{CODE_HEADER}
 ```
 {editor}
 ```
@@ -36,5 +29,9 @@ And it produces this output:
 ```
 """
 
+def is_code_prompt(prompt):
+    if (prompt.startswith(CODE_HEADER)):
+        return True
+
 def welcome_prompt():
     return "Hi! I'm your AI-powered computer science tutor. Feel free to ask me any questions as you work on this level. I'll also try and provide help when you run your code."

test.py

@@ -0,0 +1,9 @@
+from tutor2 import Tutor, STUDENT, TEACHER
+
+tutor = Tutor("instructions", "print('hello world')")
+#tutor.chat("hello")
+#tutor.chat("How does a for loop work in Python?")
+# tutor.chat("hi", role=TEACHER)
+tutor.code("print('hello world')", "hello world")
+# tutor.chat("not working", role=TEACHER)
+print(tutor._memory_as_history())

tutor2.py

@@ -0,0 +1,117 @@
+import openai
+import os
+from prompts import system_prompt, welcome_prompt, run_code_prompt, is_code_prompt
+
+SYSTEM = "system"
+TEACHER = "assistant"
+STUDENT = "user"
+
+def load(instructions, starter_code):
+    print("Loading tutor...")
+    return Tutor(instructions, starter_code).serialize()
+
+def chat(serialized_tutor, message):
+    print("Chatting...")
+    tutor = Tutor()
+    tutor.deserialize(serialized_tutor)
+    tutor.chat(message)
+    return tutor.serialize()
+
+def code(serialized_tutor, editor, output):
+    print("Submitting code...")
+    tutor = Tutor()
+    tutor.deserialize(serialized_tutor)
+    tutor.code(editor, output)
+    return tutor.serialize()
+
+def get_history(serialized_tutor):
+    print("Getting history...")
+    tutor = Tutor()
+    tutor.deserialize(serialized_tutor)
+    return tutor._memory_as_history()
+
+
+class Tutor:
+    def __init__(self, instructions="", starter_code="", debug=False):
+        self.memory = []
+        self.system_prompt = system_prompt(instructions, starter_code)
+        self.memory.append({SYSTEM: self.system_prompt})
+        self.memory.append({TEACHER: welcome_prompt()})
+        self.model = "gpt-4"
+        self.temperature = 0.0
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        self.debug = debug
+    
+    def serialize(self):
+        # Return memory as a dictionary
+        return {"memory": self.memory}
+
+    def deserialize(self, data):
+        # Make sure incoming data is a dictionary containing "memory"
+        if isinstance(data, dict) and "memory" in data:
+            self.memory = data["memory"]
+        else:
+            raise ValueError("Input must be a dictionary containing 'memory'")
+
+    def chat(self, message, role=STUDENT, request=True):
+        # Append incoming role and message to memory as a dictionary
+        self.memory.append({role: message})
+        # Make the call to OpenAI and append the response to memory
+        if request:
+            response = openai.ChatCompletion.create(
+                model=self.model,
+                api_key=self.api_key,
+                temperature=self.temperature,
+                messages=self._memory_as_openai_messages(),
+            )
+            self.memory.append({TEACHER: response.choices[0].message.content})
+
+    def code(self, editor, output, request=True):
+        # Run the code and append the output to memory
+        self.memory.append({STUDENT: run_code_prompt(editor, output)})
+        # Make the call to OpenAI and append the response to memory
+        if request:
+            response = openai.ChatCompletion.create(
+                model=self.model,
+                api_key=self.api_key,
+                temperature=self.temperature,
+                messages=self._memory_as_openai_messages(),
+            )
+            self.memory.append({TEACHER: response.choices[0].message.content})
+
+    def _memory_as_string(self):
+        # Convert memory to a formatted string
+        memory_string = ""
+        for entry in self.memory:
+            for role, message in entry.items():
+                memory_string += f"{role}: {message}\n"
+        return memory_string
+
+    def _memory_as_history(self):
+        # Convert memory to a list of message pairs
+        history = []
+        for i in range(0, len(self.memory), 2):  # Step by 2, as we need pairs
+            # Get messages, ignoring role
+            if (i == 0):
+              message1 = None # Skip the system prompt
+            else:
+              message1 = list(self.memory[i].values())[0]
+            if message1 is not None and is_code_prompt(message1):
+              message1 = "Running your code..."
+            # If there's a next message, get it, else use an empty string
+            message2 = (
+                list(self.memory[i + 1].values())[0] if i + 1 < len(self.memory) else None
+            )
+            if message2 is not None and is_code_prompt(message2):
+                message2 = "Running your code..."
+            history.append([message1, message2])
+        return history
+
+    def _memory_as_openai_messages(self):
+        # Convert memory to a list of OpenAI style messages
+        messages = []
+        messages.append({"role": SYSTEM, "content": self.system_prompt})
+        for entry in self.memory:
+            for role, message in entry.items():
+                messages.append({"role": role, "content": message})
+        return messages