initial commit

.gitignore

@@ -0,0 +1,3 @@
+.env
+**/__pycache__
+awesumcare_data

app.py

@@ -0,0 +1,143 @@
+import re
+from typing import List
+import gradio as gr
+import openai
+import os
+from dotenv import load_dotenv
+import phoenix as px
+import llama_index
+from llama_index import OpenAIEmbedding, Prompt, ServiceContext, VectorStoreIndex, SimpleDirectoryReader
+from llama_index.chat_engine.types import ChatMode
+from llama_index.llms import ChatMessage, MessageRole, OpenAI
+from llama_index.vector_stores.qdrant import QdrantVectorStore
+from llama_index.text_splitter import SentenceSplitter
+from llama_index.extractors import TitleExtractor
+from llama_index.ingestion import IngestionPipeline
+from chat_template import CHAT_TEXT_QA_PROMPT
+from chatbot import Chatbot, ChatbotVersion
+from custom_io import UnstructuredReader, default_file_metadata_func
+from qdrant import client as qdrantClient
+
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+
+class AwesumCareChatbot(Chatbot):
+    DENIED_ANSWER_PROMPT = ""
+    SYSTEM_PROMPT = ""
+    CHAT_EXAMPLES = [
+        "什麼是安心三寶？",
+        "點樣立平安紙？"
+    ]
+
+    def _load_doucments(self):
+        dir_reader = SimpleDirectoryReader('./awesumcare_data', file_extractor={
+            ".pdf": UnstructuredReader(),
+            ".docx": UnstructuredReader(),
+            ".pptx": UnstructuredReader(),
+        },
+            recursive=True,
+            exclude=["*.png", "*.pptx"],
+            file_metadata=default_file_metadata_func)
+
+        self.documents = dir_reader.load_data()
+        super()._load_doucments()
+
+    def _setup_service_context(self):
+        self.service_context = ServiceContext.from_defaults(
+            chunk_size=self.chunk_size,
+            llm=self.llm,
+            embed_model=self.embed_model
+        )
+        super()._setup_service_context()
+
+    def _setup_vector_store(self):
+        self.vector_store = QdrantVectorStore(
+            client=qdrantClient, collection_name=self.vdb_collection_name)
+        super()._setup_vector_store()
+
+    def _setup_index(self):
+        if self.vdb_collection_name in [col.name for col in qdrantClient.get_collections().collections] and qdrantClient.get_collection(self.vdb_collection_name).vectors_count > 0:
+            self.index = VectorStoreIndex.from_vector_store(
+                self.vector_store, service_context=self.service_context)
+            print("set up index from vector store")
+            return
+        pipeline = IngestionPipeline(
+            transformations=[
+                SentenceSplitter(),
+                OpenAIEmbedding(),
+            ],
+            vector_store=self.vector_store,
+        )
+        pipeline.run(documents=self.documents)
+        self.index = VectorStoreIndex.from_vector_store(
+            self.vector_store, service_context=self.service_context)
+        super()._setup_index()
+
+    # def _setup_index(self):
+    #     self.index = VectorStoreIndex.from_documents(
+    #         self.documents,
+    #         service_context=self.service_context
+    #     )
+    #     super()._setup_index()
+
+    def _setup_chat_engine(self):
+        # testing #
+        from llama_index.agent import OpenAIAgent
+        from llama_index.tools.query_engine import QueryEngineTool
+
+        query_engine = self.index.as_query_engine(
+            text_qa_template=CHAT_TEXT_QA_PROMPT)
+        query_engine_tool = QueryEngineTool.from_defaults(
+            query_engine=query_engine)
+        self.chat_engine = OpenAIAgent.from_tools(
+            tools=[query_engine_tool],
+            llm=self.service_context.llm,
+            similarity_top_k=1,
+            verbose=True
+        )
+        print("set up agent as chat engine")
+        # testing #
+        # self.chat_engine = self.index.as_chat_engine(
+        #     chat_mode=ChatMode.BEST,
+        #     similarity_top_k=5,
+        #     text_qa_template=CHAT_TEXT_QA_PROMPT)
+        super()._setup_chat_engine()
+
+
+# gpt-3.5-turbo-1106, gpt-4-1106-preview
+awesum_chatbot = AwesumCareChatbot(ChatbotVersion.CHATGPT_35.value,
+                                   chunk_size=2048,
+                                   vdb_collection_name="v2")
+
+
+def vote(data: gr.LikeData):
+    if data.liked:
+        gr.Info("You up-voted this response: " + data.value)
+    else:
+        gr.Info("You down-voted this response: " + data.value)
+
+
+chatbot = gr.Chatbot()
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Awesum Care demo")
+
+    with gr.Tab("With awesum care data prepared"):
+        gr.ChatInterface(
+            awesum_chatbot.stream_chat,
+            chatbot=chatbot,
+            examples=awesum_chatbot.CHAT_EXAMPLES,
+        )
+        chatbot.like(vote, None, None)
+
+    with gr.Tab("With Initial System Prompt (a.k.a. prompt wrapper)"):
+        gr.ChatInterface(
+            awesum_chatbot.predict_with_prompt_wrapper, examples=awesum_chatbot.CHAT_EXAMPLES)
+
+    with gr.Tab("Vanilla ChatGPT without modification"):
+        gr.ChatInterface(awesum_chatbot.predict_vanilla_chatgpt,
+                         examples=awesum_chatbot.CHAT_EXAMPLES)
+
+demo.queue()
+demo.launch()

chat_template.py

@@ -0,0 +1,32 @@
+from llama_index.llms.base import ChatMessage, MessageRole
+from llama_index.prompts.base import ChatPromptTemplate
+
+# text qa prompt
+TEXT_QA_SYSTEM_PROMPT = ChatMessage(
+    content=(
+        "You are '安心三寶', a specialized chatbot for elderly users, trusted for providing "
+        "detailed information on legal and medical documents like '平安紙', '持久授權書', and '預設醫療指示'.\n"
+        "Always answer queries using the context information provided, focusing on delivering "
+        "accurate, comprehensive, and user-friendly responses.\n"
+    ),
+    role=MessageRole.SYSTEM,
+)
+
+TEXT_QA_PROMPT_TMPL_MSGS = [
+    TEXT_QA_SYSTEM_PROMPT,
+    ChatMessage(
+        content=(
+            "Context information is below.\n"
+            "---------------------\n"
+            "{context_str}\n"
+            "---------------------\n"
+            "Given the context information and not prior knowledge, "
+            "answer the query in a warm, approachable manner, ensuring clarity and precision.\n"
+            "Query: {query_str}\n"
+            "Answer: "
+        ),
+        role=MessageRole.USER,
+    ),
+]
+
+CHAT_TEXT_QA_PROMPT = ChatPromptTemplate(message_templates=TEXT_QA_PROMPT_TMPL_MSGS)

chatbot.py

@@ -0,0 +1,151 @@
+from enum import Enum
+from typing import List
+import os
+import re
+from typing import List
+from dotenv import load_dotenv
+from openai import OpenAI
+import phoenix as px
+import llama_index
+from llama_index import OpenAIEmbedding
+from llama_index.llms import ChatMessage, MessageRole, OpenAI
+
+load_dotenv()
+
+
+class Chatbot:
+    SYSTEM_PROMPT = ""
+    DENIED_ANSWER_PROMPT = ""
+    CHAT_EXAMPLES = []
+
+    def __init__(self, model_name, chunk_size, vdb_collection_name="test_store"):
+        self.model_name = model_name
+        self.llm = OpenAI(model=self.model_name)
+        self.embed_model = OpenAIEmbedding()
+        self.chunk_size = chunk_size
+
+        self.documents = None
+        self.index = None
+        self.chat_engine = None
+        self.service_context = None
+        self.vector_store = None
+        self.vdb_collection_name = vdb_collection_name
+
+        self._setup_chatbot()
+
+    def _setup_chatbot(self):
+        self._setup_observer()
+        self._setup_service_context()
+        self._setup_vector_store()
+        self._load_doucments()
+        self._setup_index()
+        self._setup_chat_engine()
+
+    def _setup_observer(self):
+        px.launch_app()
+        llama_index.set_global_handler("arize_phoenix")
+
+    def _load_doucments(self):
+        pass
+        print(f"Loaded {len(self.documents)} docs")
+
+    def _setup_service_context(self):
+        pass
+        print("Setup service context...")
+
+    def _setup_vector_store(self):
+        pass
+        print("Setup vector store...")
+
+    def _setup_index(self):
+        if self.documents is None:
+            raise ValueError("No documents loaded")
+        pass
+        print("Built index...")
+
+    def _setup_chat_engine(self):
+        if self.index is None:
+            raise ValueError("No index built")
+        pass
+        print("Setup chat engine...")
+
+    def stream_chat(self, message, history):
+        print(history)
+        print(self.convert_to_chat_messages(history))
+        response = self.chat_engine.stream_chat(
+            message, chat_history=self.convert_to_chat_messages(history)
+        )
+        # Stream tokens as they are generated
+        partial_message = ""
+        for token in response.response_gen:
+            partial_message += token
+            yield partial_message
+
+        urls = [source.node.metadata.get(
+            "file_name") for source in response.source_nodes if source.score >= 0.78 and source.node.metadata.get("file_name")]
+        if urls:
+            urls = list(set(urls))
+            url_section = "\n \n\n---\n\n參考: \n" + \
+                "\n".join(f"- {url}" for url in urls)
+            partial_message += url_section
+            yield partial_message
+
+    def convert_to_chat_messages(self, history: List[List[str]]) -> List[ChatMessage]:
+        chat_messages = [ChatMessage(
+            role=MessageRole.SYSTEM, content=self.SYSTEM_PROMPT)]
+        for conversation in history[-3:]:
+            for index, message in enumerate(conversation):
+                role = MessageRole.USER if index % 2 == 0 else MessageRole.ASSISTANT
+                clean_message = re.sub(
+                    r"\n \n\n---\n\n參考: \n.*$", "", message, flags=re.DOTALL)
+                chat_messages.append(ChatMessage(
+                    role=role, content=clean_message.strip()))
+        return chat_messages
+
+    def predict_with_rag(self, message, history):
+        return self.stream_chat(message, history)
+
+    # barebone chatgpt methods, shared across all chatbot instance
+    def _invoke_chatgpt(self, history, message, is_include_system_prompt=False):
+        openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        history_openai_format = []
+        if is_include_system_prompt:
+            history_openai_format.append(
+                {"role": "system", "content": self.SYSTEM_PROMPT})
+        for human, assistant in history:
+            history_openai_format.append({"role": "user", "content": human})
+            history_openai_format.append(
+                {"role": "assistant", "content": assistant})
+        history_openai_format.append({"role": "user", "content": message})
+
+        import openai
+        print(openai.__version__)
+        stream = openai_client.chat.completions.create(
+            model=self.model_name,
+            messages=history_openai_format,
+            temperature=1.0,
+            stream=True)
+        for part in stream:
+            yield part.choices[0].delta.content or ""
+        # partial_message = ""
+        # for chunk in response:
+        #     if len(chunk["choices"][0]["delta"]) != 0:
+        #         partial_message = partial_message + \
+        #             chunk["choices"][0]["delta"]["content"]
+        #         yield partial_message
+
+    # For 'With Prompt Wrapper' - Add system prompt, no Pinecone
+    def predict_with_prompt_wrapper(self, message, history):
+        yield from self._invoke_chatgpt(history, message, is_include_system_prompt=True)
+
+    # For 'Vanilla ChatGPT' - No system prompt
+    def predict_vanilla_chatgpt(self, message, history):
+        yield from self._invoke_chatgpt(history, message)
+
+
+# make a enum of chatbot type and string
+
+
+class ChatbotVersion(str, Enum):
+    CHATGPT_35 = "gpt-3.5-turbo-1106"
+    CHATGPT_4 = "gpt-4-1106-preview"

custom_io.py

@@ -0,0 +1,73 @@
+"""Unstructured file reader.
+
+A parser for unstructured text files using Unstructured.io.
+Supports .txt, .docx, .pptx, .jpg, .png, .eml, .html, and .pdf documents.
+
+"""
+from datetime import datetime
+import mimetypes
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from llama_index.readers.base import BaseReader
+from llama_index.readers.schema.base import Document
+
+
+class UnstructuredReader(BaseReader):
+    """General unstructured text reader for a variety of files."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Init params."""
+        super().__init__(*args, **kwargs)
+
+        # Prerequisite for Unstructured.io to work
+        import nltk
+
+        nltk.download("punkt")
+        nltk.download("averaged_perceptron_tagger")
+
+    def load_data(
+        self,
+        file: Path,
+        extra_info: Optional[Dict] = None,
+        split_documents: Optional[bool] = True,
+    ) -> List[Document]:
+        """Parse file."""
+        from unstructured.partition.auto import partition
+
+        elements = partition(str(file))
+        text_chunks = [" ".join(str(el).split()) for el in elements]
+
+        if split_documents:
+            return [
+                Document(text=chunk, extra_info=extra_info or {})
+                for chunk in text_chunks
+            ]
+        else:
+            return [
+                Document(text="\n\n".join(text_chunks), extra_info=extra_info or {})
+            ]
+
+
+def default_file_metadata_func(file_path: str) -> Dict:
+    """Get some handy metadate from filesystem.
+
+    Args:
+        file_path: str: file path in str
+    """
+    return {
+        "file_path": file_path,
+        "file_name": os.path.basename(file_path),
+        "file_type": mimetypes.guess_type(file_path)[0],
+        "file_size": os.path.getsize(file_path),
+        "creation_date": datetime.fromtimestamp(
+            Path(file_path).stat().st_ctime
+        ).strftime("%Y-%m-%d"),
+        "last_modified_date": datetime.fromtimestamp(
+            Path(file_path).stat().st_mtime
+        ).strftime("%Y-%m-%d"),
+        "last_accessed_date": datetime.fromtimestamp(
+            Path(file_path).stat().st_atime
+        ).strftime("%Y-%m-%d"),
+    }

qdrant.py

@@ -0,0 +1,5 @@
+
+import qdrant_client
+
+
+client = qdrant_client.QdrantClient(path="/tmp/total_qdrant/")

requirements.txt

@@ -0,0 +1,7 @@
+numpy
+openai
+llama_index
+arize-phoenix[experimental]
+pypdf
+gradio
+# unstructure io