Completed conversation from LangChain

app.py

@@ -2,22 +2,21 @@ import gradio as gr
 import sys
 import json
 from io import StringIO
-from threading import Thread
 from urllib import parse
 
-from tutor2 import Tutor
+from tutor import Tutor
 
 
 def submit_chat(tutor_ctx, message):
     tutor = Tutor(context=tutor_ctx)
-    tutor.chat(message)
-    return [tutor.serialize(), tutor._memory_as_history(), None]
-
+    for history in tutor.chat(message):
+        yield [tutor.serialize(), history, None]
+    
 
 def submit_code(tutor_ctx, editor, output):
     tutor = Tutor(context=tutor_ctx)
-    tutor.code(editor, output)
-    return [tutor.serialize(), tutor._memory_as_history()]
+    for history in tutor.code(editor, output):
+        yield [tutor.serialize(), history, None]    
 
 
 def init_tutor(instructions, starter_code):

gradio_callback.py

@@ -1,36 +0,0 @@
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain.schema import LLMResult
-from typing import Any, Union, Dict, List
-
-from queue import Empty, SimpleQueue
-q = SimpleQueue()
-
-job_done = object()
-
-class StreamingGradioCallbackHandler(BaseCallbackHandler):
-    def __init__(self, q: SimpleQueue):
-        self.q = q
-
-    def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
-    ) -> None:
-        """Run when LLM starts running. Clean the queue."""
-        while not self.q.empty():
-            try:
-                self.q.get(block=False)
-            except Empty:
-                continue
-
-    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        """Run on new LLM token. Only available when streaming is enabled."""
-        self.q.put(token)
-
-    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
-        """Run when LLM ends running."""
-        self.q.put(job_done)
-
-    def on_llm_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> None:
-        """Run when LLM errors."""
-        self.q.put(job_done)

requirements.txt

@@ -1,3 +1 @@
 openai==0.27.8
-langchain==0.0.225
-langchainplus-sdk==0.0.20

test.py

@@ -1,9 +0,0 @@
-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())

tutor.py

@@ -1,32 +1,123 @@
+import openai
 import os
+from prompts import system_prompt, welcome_prompt, run_code_prompt, is_code_prompt
 
-from langchain.memory import ConversationBufferMemory
-from langchain import LLMChain
-from langchain.chat_models import ChatOpenAI
+SYSTEM = "system"
+TEACHER = "assistant"
+STUDENT = "user"
 
-from gradio_callback import StreamingGradioCallbackHandler, q
-from prompts import system_prompt
 
-llm = ChatOpenAI(
-    streaming=True,
-    callbacks=[StreamingGradioCallbackHandler(q)],
-    temperature=0.0,
-    model="gpt-4",
-    openai_api_key=os.getenv("OPENAI_API_KEY"),
-)
+class Tutor:
+    def __init__(self, instructions="", starter_code="", context=None, debug=False):
+        self.model = "gpt-4"
+        self.temperature = 0.0
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        self.debug = debug
 
-memory = ConversationBufferMemory(memory_key="chat_history")
+        if context is not None:
+            self.deserialize(context)
+        else:
+            self.memory = []
+            # self.system_prompt = system_prompt(instructions, starter_code)
+            self.instructions = instructions
+            self.starter_code = starter_code
+            self.memory.append(
+                {SYSTEM: system_prompt(self.instructions, self.starter_code)}
+            )
+            self.memory.append({TEACHER: welcome_prompt()})
 
-llm_chain = None
+    def serialize(self):
+        # Return memory as a dictionary
+        return {
+            "instructions": self.instructions,
+            "starter_code": self.starter_code,
+            "memory": self.memory,
+        }
 
-def chat(user_message):
-    return llm_chain.predict(student_input=user_message)
+    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"]
+            self.instructions = data["instructions"]
+            self.starter_code = data["starter_code"]
+        else:
+            raise ValueError("Input must be a dictionary containing 'memory'")
 
-def create_llm_chain(instructions, starter_code):
-    global llm_chain
-    llm_chain = LLMChain(
-        llm=llm,
-        prompt=system_prompt(instructions, starter_code),
-        verbose=True,
-        memory=memory,
-    )
+    def _gpt(self):
+        return openai.ChatCompletion.create(
+            model=self.model,
+            api_key=self.api_key,
+            temperature=self.temperature,
+            messages=self._memory_as_openai_messages(),
+            stream=True,
+        )
+
+    def chat(self, message, role=STUDENT, request=True):
+        self.memory.append({role: message})
+        yield self._memory_as_history()
+        # Pre-append an empty teacher messages so that we can stream the result
+        self.memory.append({TEACHER: ""})
+        if request:
+            for token in self._gpt():
+                if token.choices[0].finish_reason != "stop":
+                    self.memory[-1][TEACHER] = (
+                        self.memory[-1][TEACHER] + token.choices[0].delta.content
+                    )
+                    yield self._memory_as_history()
+
+    def code(self, editor, output, request=True):
+        self.memory.append({STUDENT: run_code_prompt(editor, output)})
+        yield self._memory_as_history()
+        # Pre-append an empty teacher messages so that we can stream the result
+        self.memory.append({TEACHER: ""})
+        if request:
+            for token in self._gpt():
+                if token.choices[0].finish_reason != "stop":
+                    self.memory[-1][TEACHER] = (
+                        self.memory[-1][TEACHER] + token.choices[0].delta.content
+                    )
+                    yield self._memory_as_history()
+
+    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": system_prompt(self.instructions, self.starter_code),
+            }
+        )
+        for entry in self.memory:
+            for role, message in entry.items():
+                messages.append({"role": role, "content": message})
+        return messages

tutor2.py

@@ -1,114 +0,0 @@
-import openai
-import os
-from prompts import system_prompt, welcome_prompt, run_code_prompt, is_code_prompt
-
-SYSTEM = "system"
-TEACHER = "assistant"
-STUDENT = "user"
-
-
-class Tutor:
-    def __init__(self, instructions="", starter_code="", context=None, debug=False):
-        self.model = "gpt-4"
-        self.temperature = 0.0
-        self.api_key = os.getenv("OPENAI_API_KEY")
-        self.debug = debug
-
-        if context is not None:
-            self.deserialize(context)
-        else:
-            self.memory = []
-            # self.system_prompt = system_prompt(instructions, starter_code)
-            self.instructions = instructions
-            self.starter_code = starter_code
-            self.memory.append(
-                {SYSTEM: system_prompt(self.instructions, self.starter_code)}
-            )
-            self.memory.append({TEACHER: welcome_prompt()})
-
-    def serialize(self):
-        # Return memory as a dictionary
-        return {
-            "instructions": self.instructions,
-            "starter_code": self.starter_code,
-            "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"]
-            self.instructions = data["instructions"]
-            self.starter_code = data["starter_code"]
-        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": system_prompt(self.instructions, self.starter_code),
-            }
-        )
-        for entry in self.memory:
-            for role, message in entry.items():
-                messages.append({"role": role, "content": message})
-        return messages