feat: :sparkles: qa gradio ui and coding problem chain (#11)

README.md

@@ -18,9 +18,12 @@
 | AZURE_OPENAI_API_BASE         | No  |                | azure openai api base                        |
 | AZURE_OPENAI_DEPLOYMENT_ID    | No  |                | azure openai deployment id for gpt 3.5       |
 | AZURE_OPENAI_EMBEDDING_DEP_ID | No  |                | azure openai deployment id for embedding     |
+| QDRANT_API                    | No  |                | use qdrant api if not blank                  |
+| QDRANT_API_KEY                | No  |                | qdrant api key                               |
+| QDRANT_API_BASE               | No  |                | qdrant api base                              |
 
 ## setup
 
 - install python 3.10+
 - install poetry 1.5.1+
-- run: `poetry install`
+- run: `poetry install --with dev`

edu_assistant/learning_tasks/qa.py

@@ -19,11 +19,29 @@ The ai act following below instructions:
 {instruction}
 ---
 
+
 Current conversation:
-{{history}}
+{{chat_history}}
 Human: {{input}}
 AI:"""
 
+TEMPLATE_CHAT_CONTEXT = """The following is a friendly conversation between a human and an ai.
+The ai is talkative and provides lots of specific details from its context.
+If the ai does not know the answer to a question, it truthfully says it does not know.
+The ai act following below instructions:
+---
+{instruction}
+---
+Useful context for you to answer the question:
+---
+{{context}}
+---
+
+Current conversation:
+{{chat_history}}
+Human: {{question}}
+AI:"""
+
 TEMPLATE_ONCE = """The following is a friendly conversation between a human and an ai.
 The ai is talkative and provides lots of specific details from its context.
 If the ai does not know the answer to a question, it truthfully says it does not know.
@@ -35,12 +53,29 @@ The ai act following below instructions:
 {{input}}
 """
 
+TEMPLATE_ONCE_CONTEXT = """The following is a friendly conversation between a human and an ai.
+The ai is talkative and provides lots of specific details from its context.
+If the ai does not know the answer to a question, it truthfully says it does not know.
+The ai act following below instructions:
+---
+{instruction}
+---
+Useful context for you to answer the question:
+---
+{{context}}
+---
+
+{{input}}
+"""
+
 
 class QaTask(BaseTask):
     _session_store: dict
     _knowledge: BaseRetriever | None
     _qa_once: Chain
 
+    HISTORY_KEY = "chat_history"
+
     def __init__(self, instruction: str = "", knowledge: BaseRetriever = None):
         """Create a new QaTask service.
 
@@ -53,8 +88,16 @@ class QaTask(BaseTask):
                 If not set, will use internal memory to store chat history. Which will be lost after restart and might
                 cost huge memory.
         """
-        self._chat_prompt = PromptTemplate.from_template(TEMPLATE_CHAT.format(instruction=instruction))
-        self._once_prompt = PromptTemplate.from_template(TEMPLATE_ONCE.format(instruction=instruction))
+        if knowledge:
+            self._chat_prompt = PromptTemplate.from_template(TEMPLATE_CHAT_CONTEXT.format(instruction=instruction))
+            self._once_prompt = PromptTemplate.from_template(TEMPLATE_ONCE_CONTEXT.format(instruction=instruction))
+            self._input_key = "question"
+            self._output_key = "answer"
+        else:
+            self._chat_prompt = PromptTemplate.from_template(TEMPLATE_CHAT.format(instruction=instruction))
+            self._once_prompt = PromptTemplate.from_template(TEMPLATE_ONCE.format(instruction=instruction))
+            self._input_key = "input"
+            self._output_key = "response"
 
         self._session_store = {}
         self._knowledge = knowledge
@@ -66,7 +109,6 @@ class QaTask(BaseTask):
             return LLMChain(
                 llm=load_llm(),
                 prompt=self._once_prompt,
-                memory=ConversationBufferMemory(),
             )
         else:
             return RetrievalQA.from_llm(
@@ -80,7 +122,7 @@ class QaTask(BaseTask):
         if not self._knowledge:
             return ConversationChain(
                 llm=load_llm(),
-                memory=ConversationBufferMemory(),
+                memory=ConversationBufferMemory(memory_key=QaTask.HISTORY_KEY, output_key=self._output_key),
                 prompt=self._chat_prompt,
             )
         else:
@@ -89,8 +131,8 @@ class QaTask(BaseTask):
                 retriever=self._knowledge,
                 condense_question_llm=load_llm(),
                 return_source_documents=True,
-                combine_docs_chain_kwargs={"prompt": PromptTemplate.from_template(self._chat_prompt)},
-                memory=ConversationBufferMemory(),
+                combine_docs_chain_kwargs={"prompt": self._chat_prompt},
+                memory=ConversationBufferMemory(memory_key=QaTask.HISTORY_KEY, output_key=self._output_key),
             )
 
     def ask(
@@ -117,14 +159,14 @@ class QaTask(BaseTask):
         """
 
         if session:
-            args = {"input": question}
+            args = {self._input_key: question}
             if session_id and session_id in self._session_store:
                 chain = self._session_store[session_id]
             else:
                 session_id = self._create_session_id()
                 chain = self._create_session_chain(session_id)
         else:
-            args = {"input": question, "history": ""}
+            args = {self._input_key: question, QaTask.HISTORY_KEY: ""}
             chain = self._qa_once
 
         if session_mem:

edu_assistant/utils/langchain_utils.py

@@ -3,7 +3,10 @@ from functools import lru_cache
 
 from langchain.chat_models import AzureChatOpenAI, ChatOpenAI
 from langchain.chat_models.base import BaseChatModel
-from langchain.memory.chat_memory import BaseChatMemory
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import Qdrant, VectorStore
+
+from edu_assistant.utils.qdrant_utils import load_qdrant_client
 
 
 @lru_cache(maxsize=1)
@@ -28,6 +31,7 @@ def load_llm() -> BaseChatModel:
     return llm
 
 
+@lru_cache(maxsize=1)
 def load_gpt4_llm() -> BaseChatModel:
     llm = ChatOpenAI(
         openai_api_key=os.environ.get("OPENAI_API_KEY"),
@@ -38,13 +42,32 @@ def load_gpt4_llm() -> BaseChatModel:
     return llm
 
 
-def update_chat_memory(memory: BaseChatMemory, user_text: str, ai_text: str):
-    """update langchain memory
+@lru_cache(maxsize=1)
+def load_embeddings():
+    if os.environ.get("AZURE_OPENAI"):
+        embeddings = OpenAIEmbeddings(
+            openai_api_type="azure",
+            openai_api_key=os.environ.get("AZURE_OPENAI_API_KEY"),
+            openai_api_base=os.environ.get("AZURE_OPENAI_API_BASE"),
+            openai_api_version="2023-05-15",
+            deployment=os.environ.get("AZURE_OPENAI_EMBEDDING_DEP_ID", ""),
+        )
+    else:
+        embeddings = OpenAIEmbeddings(
+            openai_api_key=os.environ.get("OPENAI_API_KEY"),
+            openai_proxy=os.environ.get("OPENAI_PROXY", ""),
+        )
+
+    return embeddings
+
+
+@lru_cache(maxsize=10)
+def load_vectorstore(collection_name: str = "default") -> VectorStore:
+    if os.environ.get("QDRANT_API"):
+        client = load_qdrant_client()
+        embeddings = load_embeddings()
+        doc_store = Qdrant(client=client, collection_name=collection_name, embeddings=embeddings)
+
+        return doc_store
 
-    Args:
-        memory (BaseChatMemory): chat history memory
-        question (str): qa question str
-        result (str): chain answer result
-    """
-    memory.chat_memory.add_user_message(user_text)
-    memory.chat_memory.add_ai_message(ai_text)
+    return None

edu_assistant/utils/qdrant_utils.py

@@ -0,0 +1,13 @@
+import os
+from functools import lru_cache
+
+from qdrant_client import QdrantClient
+
+
+@lru_cache(maxsize=1)
+def load_qdrant_client():
+    qdrant_url = os.environ.get("QDRANT_API_BASE", "")
+    qdrant_apikey = os.environ.get("QDRANT_API_KEY", "")
+    client = QdrantClient(url=qdrant_url, api_key=qdrant_apikey)
+
+    return client

examples/docs/1. cpp_intro.txt

@@ -0,0 +1,26 @@
+What is C++?
+C++ is a cross-platform language that can be used to create high-performance applications.
+
+C++ was developed by Bjarne Stroustrup, as an extension to the C language.
+
+C++ gives programmers a high level of control over system resources and memory.
+
+The language was updated 4 major times in 2011, 2014, 2017, and 2020 to C++11, C++14, C++17, C++20.
+
+Why Use C++
+C++ is one of the world's most popular programming languages.
+
+C++ can be found in today's operating systems, Graphical User Interfaces, and embedded systems.
+
+C++ is an object-oriented programming language which gives a clear structure to programs and allows code to be reused, lowering development costs.
+
+C++ is portable and can be used to develop applications that can be adapted to multiple platforms.
+
+C++ is fun and easy to learn!
+
+As C++ is close to C, C# and Java, it makes it easy for programmers to switch to C++ or vice versa.
+
+Difference between C and C++
+C++ was developed as an extension of C, and both languages have almost the same syntax.
+
+The main difference between C and C++ is that C++ support classes and objects, while C does not.

examples/docs/2. cpp_getting_started.txt

@@ -0,0 +1,61 @@
+C++ Get Started
+To start using C++, you need two things:
+
+A text editor, like Notepad, to write C++ code
+A compiler, like GCC, to translate the C++ code into a language that the computer will understand
+There are many text editors and compilers to choose from. In this tutorial, we will use an IDE (see below).
+
+C++ Install IDE
+An IDE (Integrated Development Environment) is used to edit AND compile the code.
+
+Popular IDE's include Code::Blocks, Eclipse, and Visual Studio. These are all free, and they can be used to both edit and debug C++ code.
+
+Note: Web-based IDE's can work as well, but functionality is limited.
+
+We will use Code::Blocks in our tutorial, which we believe is a good place to start.
+
+You can find the latest version of Codeblocks at http://www.codeblocks.org/. Download the mingw-setup.exe file, which will install the text editor with a compiler.
+
+C++ Quickstart
+Let's create our first C++ file.
+
+Open Codeblocks and go to File > New > Empty File.
+
+Write the following C++ code and save the file as myfirstprogram.cpp (File > Save File as):
+
+myfirstprogram.cpp
+#include <iostream>
+using namespace std;
+
+int main() {
+  cout << "Hello World!";
+  return 0;
+}
+Don't worry if you don't understand the code above - we will discuss it in detail in later chapters. For now, focus on how to run the code.
+
+In Codeblocks, it should look like this:
+
+
+Then, go to Build > Build and Run to run (execute) the program. The result will look something to this:
+
+Hello World!
+Process returned 0 (0x0) execution time : 0.011 s
+Press any key to continue.
+Congratulations! You have now written and executed your first C++ program.
+
+Learning C++ At W3Schools
+When learning C++ at W3Schools.com, you can use our "Try it Yourself" tool, which shows both the code and the result. This will make it easier for you to understand every part as we move forward:
+
+myfirstprogram.cpp
+Code:
+
+#include <iostream>
+using namespace std;
+
+int main() {
+  cout << "Hello World!";
+  return 0;
+}
+Result:
+
+Hello World!

examples/qa.py

@@ -1,9 +1,10 @@
 import json
+import logging
 
 from edu_assistant.learning_tasks import QaTask
 from edu_assistant.utils.common_utils import init_local_logging
 
-init_local_logging()
+init_local_logging(logging.DEBUG)
 
 
 instruction = """

examples/qdrant_vs.py

@@ -0,0 +1,61 @@
+import json
+import logging
+
+from fastapi.encoders import jsonable_encoder
+from langchain.chains import RetrievalQA
+from langchain.document_loaders import DirectoryLoader, TextLoader
+from langchain.text_splitter import CharacterTextSplitter
+from qdrant_client.http.models import Distance, VectorParams
+
+from edu_assistant.utils.common_utils import init_local_logging
+from edu_assistant.utils.langchain_utils import load_llm, load_vectorstore
+from edu_assistant.utils.qdrant_utils import load_qdrant_client
+
+init_local_logging(logging.DEBUG)
+
+
+def create_collection(collection_name: str):
+    client = load_qdrant_client()
+    client.recreate_collection(
+        collection_name=collection_name,
+        vectors_config=VectorParams(size=1536, distance=Distance.DOT),
+    )
+    collection_info = client.get_collection(collection_name=collection_name)
+    print(collection_info)
+
+
+def delete_collection(collection_name: str):
+    client = load_qdrant_client()
+    client.delete_collection(collection_name=collection_name)
+
+
+def add_docs(path: str, collection_name: str):
+    vs = load_vectorstore(collection_name=collection_name)
+    loader = DirectoryLoader(path=path, glob="*.txt", loader_cls=TextLoader)
+    documents = loader.load()
+    text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)
+    docs = text_splitter.split_documents(documents)
+
+    for doc in docs:
+        vs.add_documents([doc])
+
+
+def qa(collection_name: str, question: str):
+    chain = RetrievalQA.from_llm(
+        llm=load_llm(),
+        retriever=load_vectorstore(collection_name=collection_name).as_retriever(),
+        return_source_documents=True,
+    )
+    result = chain(question)
+    print(json.dumps(jsonable_encoder(result), ensure_ascii=False, indent=4))
+
+
+if __name__ == "__main__":
+    name = "example"
+    path = "examples/docs"
+    question = "C和C++的区别是什么？"
+
+    create_collection(name)
+    add_docs(path, name)
+    qa(name, question)
+    delete_collection(name)

pyproject.toml

@@ -8,13 +8,16 @@ readme = "README.md"
 packages = [{include = "edu_assistant"}]
 
 [tool.poetry.dependencies]
-python = "^3.10"
+python = "^3.10 <3.12"
 fastapi = "^0.95.1"
 langchain = "^0.0.234"
 openai = "^0.27.4"
 pydantic = "^1.10.7"
 tenacity = "^8.2.2"
 uvicorn = "^0.21.1"
+qdrant-client = "^1.3.1"
+tiktoken = "^0.4.0"
+gradio = "^3.37.0"
 
 [tool.poetry.group.dev]
 optional = true

webui/coding_problem.py

@@ -0,0 +1,4 @@
+import gradio as gr
+
+with gr.Blocks() as coding_problem_ui:
+    pass

webui/qa.py

@@ -0,0 +1,63 @@
+import gradio as gr
+from fastapi.encoders import jsonable_encoder
+from langchain.callbacks import get_openai_callback
+
+from edu_assistant.learning_tasks.qa import QaTask
+from edu_assistant.utils.langchain_utils import load_vectorstore
+
+DEFAULT_INSTRUCTION = """Act as a c++ professional to answer student aged 5-10 questions. Answer properly and politely.
+Don't extend conversation multiple times. Only add one time saying."""
+
+
+task = QaTask(
+    instruction=DEFAULT_INSTRUCTION,
+    knowledge=load_vectorstore("example").as_retriever(),
+)
+
+
+def respond(message, chat_history, session_id):
+    with get_openai_callback() as cb:
+        if session_id:
+            result = task.ask(message, session_id=session_id)
+        else:
+            result = task.ask(message)
+
+        session_id = result["session_id"]
+        docs = jsonable_encoder(result.get("source_documents", []))
+
+        bot_message = result["answer"]
+        chat_history.append((message, bot_message))
+
+        status = {"tokens": cb.total_tokens, "cost": f"${cb.total_cost:.4f}"}
+    return "", chat_history, session_id, status, docs
+
+
+def recreate(instruction):
+    global task
+    task = QaTask(instruction=instruction, knowledge=load_vectorstore("example").as_retriever())
+
+
+with gr.Blocks() as qa_ui:
+    with gr.Row():
+        with gr.Column(scale=6):
+            with gr.Row():
+                chatbot = gr.Chatbot(height=800)
+            with gr.Row():
+                msg = gr.Textbox()
+        with gr.Column(scale=1):
+            with gr.Row():
+                session_id = gr.Textbox(label="Session", interactive=False, value="")
+            with gr.Row():
+                telemetry = gr.JSON(value="""{"tokens":0}""", label="Telemetry")
+            with gr.Row():
+                docs = gr.JSON(value="""["docs"]""", label="Docs")
+            with gr.Row():
+                clear = gr.ClearButton([msg, chatbot, session_id, telemetry, docs])
+    with gr.Row():
+        with gr.Column(scale=6):
+            instruction = gr.Textbox(label="Instruction", value=DEFAULT_INSTRUCTION, interactive=False)
+        with gr.Column(scale=1):
+            apply = gr.Button(value="更换Prompt")
+
+    msg.submit(respond, [msg, chatbot, session_id], [msg, chatbot, session_id, telemetry])
+    apply.click(recreate, [instruction], [])

webui/ui.py

@@ -0,0 +1,18 @@
+import gradio as gr
+from coding_problem import coding_problem_ui
+from qa import qa_ui
+
+from edu_assistant import version
+
+with gr.Blocks() as ui:
+    with gr.Row():
+        gr.Markdown(f" v{version}")
+
+    with gr.Tab(label="答疑"):
+        qa_ui.render()
+
+    with gr.Tab(label="编程题"):
+        coding_problem_ui.render()
+
+if __name__ == "__main__":
+    ui.launch()