improvements in literali, chainlit, chat

code/main.py

@@ -1,18 +1,14 @@
 import json
-import textwrap
-from typing import Any, Callable, Dict, List, Literal, Optional, no_type_check
-import chainlit as cl
-from chainlit import run_sync
-from chainlit.config import config
 import yaml
 import os
-
+from typing import Any, Dict, no_type_check
+import chainlit as cl
 from modules.chat.llm_tutor import LLMTutor
 from modules.chat_processor.chat_processor import ChatProcessor
 from modules.config.constants import LLAMA_PATH
 from modules.chat.helpers import get_sources
-
-from chainlit.input_widget import Select, Switch, Slider
+import copy
+from typing import Optional
 
 USER_TIMEOUT = 60_000
 SYSTEM = "System 🖥️"
@@ -24,73 +20,79 @@ ERROR = "Error 🚫"
 
 class Chatbot:
     def __init__(self):
-        self.llm_tutor = None
-        self.chain = None
-        self.chat_processor = None
+        """
+        Initialize the Chatbot class.
+        """
         self.config = self._load_config()
 
     def _load_config(self):
+        """
+        Load the configuration from a YAML file.
+        """
         with open("modules/config/config.yml", "r") as f:
-            config = yaml.safe_load(f)
-        return config
+            return yaml.safe_load(f)
 
     @no_type_check
-    async def setup_llm(self) -> None:
-        """From the session `llm_settings`, create new LLMConfig and LLM objects,
-        save them in session state."""
-
-        old_config = self.config.copy()  # create a copy of the previous config
-        new_config = (
-            self.config.copy()
-        )  # create the new config as a copy of the previous config
-
+    async def setup_llm(self):
+        """
+        Set up the LLM with the provided settings. Update the configuration and initialize the LLM tutor.
+        """
         llm_settings = cl.user_session.get("llm_settings", {})
-        chat_profile = llm_settings.get("chat_model")
-        retriever_method = llm_settings.get("retriever_method")
-        memory_window = llm_settings.get("memory_window")
-        ELI5 = llm_settings.get("ELI5")
-
-        self._configure_llm(chat_profile)
+        chat_profile, retriever_method, memory_window, llm_style = (
+            llm_settings.get("chat_model"),
+            llm_settings.get("retriever_method"),
+            llm_settings.get("memory_window"),
+            llm_settings.get("llm_style"),
+        )
 
         chain = cl.user_session.get("chain")
-        memory = chain.memory
-        new_config["vectorstore"][
-            "db_option"
-        ] = retriever_method  # update the retriever method in the config
-        new_config["llm_params"][
-            "memory_window"
-        ] = memory_window  # update the memory window in the config
-        new_config["llm_params"]["ELI5"] = ELI5
+        memory = chain.memory if chain else []
 
-        # self.llm_tutor.update_llm(new_config) # TODO: Fi this!!!
-        self.llm_tutor = LLMTutor(
-            self.config, user={"user_id": "abc123", "session_id": "789"}
-        )
+        old_config = copy.deepcopy(self.config)
+        self.config["vectorstore"]["db_option"] = retriever_method
+        self.config["llm_params"]["memory_window"] = memory_window
+        self.config["llm_params"]["llm_style"] = llm_style
+        self.config["llm_params"]["llm_loader"] = chat_profile
+
+        self.llm_tutor.update_llm(
+            old_config, self.config
+        )  # update only attributes that are changed
         self.chain = self.llm_tutor.qa_bot(memory=memory)
 
         tags = [chat_profile, self.config["vectorstore"]["db_option"]]
-        self.chat_processor = ChatProcessor(self.llm_tutor, tags=tags)
+        self.chat_processor.config = self.config
 
         cl.user_session.set("chain", self.chain)
         cl.user_session.set("llm_tutor", self.llm_tutor)
         cl.user_session.set("chat_processor", self.chat_processor)
 
     @no_type_check
-    async def update_llm(self, new_settings: Dict[str, Any]) -> None:
-        """Update LLMConfig and LLM from settings, and save in session state."""
+    async def update_llm(self, new_settings: Dict[str, Any]):
+        """
+        Update the LLM settings and reinitialize the LLM with the new settings.
+
+        Args:
+            new_settings (Dict[str, Any]): The new settings to update.
+        """
         cl.user_session.set("llm_settings", new_settings)
         await self.inform_llm_settings()
         await self.setup_llm()
 
     async def make_llm_settings_widgets(self, config=None):
+        """
+        Create and send the widgets for LLM settings configuration.
+
+        Args:
+            config: The configuration to use for setting up the widgets.
+        """
         config = config or self.config
         await cl.ChatSettings(
             [
                 cl.input_widget.Select(
                     id="chat_model",
                     label="Model Name (Default GPT-3)",
-                    values=["llama", "gpt-3.5-turbo-1106", "gpt-4"],
-                    initial_index=0,
+                    values=["local_llm", "gpt-3.5-turbo-1106", "gpt-4"],
+                    initial_index=1,
                 ),
                 cl.input_widget.Select(
                     id="retriever_method",
@@ -109,28 +111,33 @@ class Chatbot:
                 cl.input_widget.Switch(
                     id="view_sources", label="View Sources", initial=False
                 ),
-                cl.input_widget.Switch(
-                    id="ELI5", label="Explain Like I'm 5 (ELI5)", initial=False
+                cl.input_widget.Select(
+                    id="llm_style",
+                    label="Type of Conversation (Default Normal)",
+                    values=["Normal", "ELI5", "Socratic"],
+                    initial_index=0,
                 ),
-                # cl.input_widget.TextInput(
-                #     id="vectorstore",
-                #     label="temp",
-                #     initial="None",
-                # ),
             ]
-        ).send()  # type: ignore
+        ).send()
 
     @no_type_check
-    async def inform_llm_settings(self) -> None:
+    async def inform_llm_settings(self):
+        """
+        Inform the user about the updated LLM settings and display them as a message.
+        """
         llm_settings: Dict[str, Any] = cl.user_session.get("llm_settings", {})
         llm_tutor = cl.user_session.get("llm_tutor")
-        settings_dict = dict(
-            model=llm_settings.get("chat_model"),
-            retriever=llm_settings.get("retriever_method"),
-            memory_window=llm_settings.get("memory_window"),
-            num_docs_in_db=len(llm_tutor.vector_db),
-            view_sources=llm_settings.get("view_sources"),
-        )
+        settings_dict = {
+            "model": llm_settings.get("chat_model"),
+            "retriever": llm_settings.get("retriever_method"),
+            "memory_window": llm_settings.get("memory_window"),
+            "num_docs_in_db": (
+                len(llm_tutor.vector_db)
+                if llm_tutor and hasattr(llm_tutor, "vector_db")
+                else 0
+            ),
+            "view_sources": llm_settings.get("view_sources"),
+        }
         await cl.Message(
             author=SYSTEM,
             content="LLM settings have been updated. You can continue with your Query!",
@@ -140,11 +147,14 @@ class Chatbot:
                     display="side",
                     content=json.dumps(settings_dict, indent=4),
                     language="json",
-                )
+                ),
             ],
         ).send()
 
     async def set_starters(self):
+        """
+        Set starter messages for the chatbot.
+        """
         return [
             cl.Starter(
                 label="recording on CNNs?",
@@ -168,64 +178,73 @@ class Chatbot:
             ),
         ]
 
-    async def chat_profile(self):
-        return [
-            cl.ChatProfile(
-                name="gpt-3.5-turbo-1106",
-                markdown_description="Use OpenAI API for **gpt-3.5-turbo-1106**.",
-            ),
-            cl.ChatProfile(
-                name="gpt-4",
-                markdown_description="Use OpenAI API for **gpt-4**.",
-            ),
-            cl.ChatProfile(
-                name="Llama",
-                markdown_description="Use the local LLM: **Tiny Llama**.",
-            ),
-        ]
-
     def rename(self, orig_author: str):
+        """
+        Rename the original author to a more user-friendly name.
+
+        Args:
+            orig_author (str): The original author's name.
+
+        Returns:
+            str: The renamed author.
+        """
         rename_dict = {"Chatbot": "AI Tutor"}
         return rename_dict.get(orig_author, orig_author)
 
     async def start(self):
-        await self.make_llm_settings_widgets(self.config)
-
-        # chat_profile = cl.user_session.get("chat_profile")
-        # if chat_profile:
-        #     self._configure_llm(chat_profile)
-
-        self.llm_tutor = LLMTutor(
-            self.config, user={"user_id": "abc123", "session_id": "789"}
-        )
-        self.chain = self.llm_tutor.qa_bot()
-        tags = [self.config["vectorstore"]["db_option"]]
-        self.chat_processor = ChatProcessor(self.llm_tutor, tags=tags)
+        """
+        Start the chatbot, initialize settings widgets,
+        and display and load previous conversation if chat logging is enabled.
+        """
+        await cl.Message(content="Welcome back! Setting up your session...").send()
 
+        await self.make_llm_settings_widgets(self.config)
+        user = cl.user_session.get("user")
+        self.user = {
+            "user_id": user.identifier,
+            "session_id": "1234",
+        }
+        cl.user_session.set("user", self.user)
+        self.chat_processor = ChatProcessor(self.config, self.user)
+        self.llm_tutor = LLMTutor(self.config, user=self.user)
+        if self.config["chat_logging"]["log_chat"]:
+            # get previous conversation of the user
+            memory = self.chat_processor.processor.prev_conv
+            if len(self.chat_processor.processor.prev_conv) > 0:
+                for idx, conv in enumerate(self.chat_processor.processor.prev_conv):
+                    await cl.Message(
+                        author="User", content=conv[0], type="user_message"
+                    ).send()
+                    await cl.Message(author="AI Tutor", content=conv[1]).send()
+        else:
+            memory = []
+        self.chain = self.llm_tutor.qa_bot(memory=memory)
         cl.user_session.set("llm_tutor", self.llm_tutor)
         cl.user_session.set("chain", self.chain)
-        cl.user_session.set("counter", 20)
         cl.user_session.set("chat_processor", self.chat_processor)
 
     async def on_chat_end(self):
+        """
+        Handle the end of the chat session by sending a goodbye message.
+        # TODO: Not used as of now - useful when the implementation for the conversation limiting is implemented
+        """
         await cl.Message(content="Sorry, I have to go now. Goodbye!").send()
 
     async def main(self, message):
+        """
+        Process and Display the Conversation.
+
+        Args:
+            message: The incoming chat message.
+        """
         chain = cl.user_session.get("chain")
-        counter = cl.user_session.get("counter")
         llm_settings = cl.user_session.get("llm_settings", {})
         view_sources = llm_settings.get("view_sources", False)
 
-        counter += 1
-        cl.user_session.set("counter", counter)
-
         processor = cl.user_session.get("chat_processor")
         res = await processor.rag(message.content, chain)
 
-        print(res)
-
         answer = res.get("answer", res.get("result"))
-
         answer_with_sources, source_elements, sources_dict = get_sources(
             res, answer, view_sources=view_sources
         )
@@ -233,26 +252,16 @@ class Chatbot:
 
         await cl.Message(content=answer_with_sources, elements=source_elements).send()
 
-    def _configure_llm(self, chat_profile):
-        chat_profile = chat_profile.lower()
-        if chat_profile in ["gpt-3.5-turbo-1106", "gpt-4"]:
-            self.config["llm_params"]["llm_loader"] = "openai"
-            self.config["llm_params"]["openai_params"]["model"] = chat_profile
-        elif chat_profile == "llama":
-            self.config["llm_params"]["llm_loader"] = "local_llm"
-            self.config["llm_params"]["local_llm_params"]["model"] = LLAMA_PATH
-            self.config["llm_params"]["local_llm_params"]["model_type"] = "llama"
-        elif chat_profile == "mistral":
-            self.config["llm_params"]["llm_loader"] = "local_llm"
-            self.config["llm_params"]["local_llm_params"]["model"] = MISTRAL_PATH
-            self.config["llm_params"]["local_llm_params"]["model_type"] = "mistral"
+    def auth_callback(self, username: str, password: str) -> Optional[cl.User]:
+        return cl.User(
+            identifier=username,
+            metadata={"role": "admin", "provider": "credentials"},
+        )
 
 
 chatbot = Chatbot()
-
-# Register functions to Chainlit events
+cl.password_auth_callback(chatbot.auth_callback)
 cl.set_starters(chatbot.set_starters)
-# cl.set_chat_profiles(chatbot.chat_profile)
 cl.author_rename(chatbot.rename)
 cl.on_chat_start(chatbot.start)
 cl.on_chat_end(chatbot.on_chat_end)

code/modules/chat/base.py

@@ -0,0 +1,13 @@
+class BaseRAG:
+    """
+    Base class for RAG chatbot.
+    """
+
+    def __init__():
+        pass
+
+    def invoke():
+        """
+        Invoke the RAG chatbot.
+        """
+        pass

code/modules/chat/chat_model_loader.py

@@ -1,4 +1,4 @@
-from langchain_community.chat_models import ChatOpenAI
+from langchain_openai import ChatOpenAI
 from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
 from transformers import AutoTokenizer, TextStreamer
 from langchain_community.llms import LlamaCpp
@@ -7,6 +7,7 @@ import transformers
 import os
 from langchain.callbacks.manager import CallbackManager
 from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+from modules.config.constants import LLAMA_PATH
 
 
 class ChatModelLoader:
@@ -15,15 +16,12 @@ class ChatModelLoader:
         self.huggingface_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
 
     def load_chat_model(self):
-        if self.config["llm_params"]["llm_loader"] == "openai":
-            llm = ChatOpenAI(
-                model_name=self.config["llm_params"]["openai_params"]["model"]
-            )
+        if self.config["llm_params"]["llm_loader"] in ["gpt-3.5-turbo-1106", "gpt-4"]:
+            llm = ChatOpenAI(model_name=self.config["llm_params"]["llm_loader"])
         elif self.config["llm_params"]["llm_loader"] == "local_llm":
             n_batch = 512  # Should be between 1 and n_ctx, consider the amount of VRAM in your GPU.
-            model_path = self.config["llm_params"]["local_llm_params"]["model"]
             llm = LlamaCpp(
-                model_path=model_path,
+                model_path=LLAMA_PATH,
                 n_batch=n_batch,
                 n_ctx=2048,
                 f16_kv=True,
@@ -34,5 +32,7 @@ class ChatModelLoader:
                 ],
             )
         else:
-            raise ValueError("Invalid LLM Loader")
+            raise ValueError(
+                f"Invalid LLM Loader: {self.config['llm_params']['llm_loader']}"
+            )
         return llm

code/modules/chat/helpers.py

@@ -1,7 +1,5 @@
-from modules.config.constants import *
+from modules.config.prompts import prompts
 import chainlit as cl
-from langchain_core.prompts import PromptTemplate
-from langchain_core.prompts import ChatPromptTemplate
 
 
 def get_sources(res, answer, view_sources=False):
@@ -93,38 +91,18 @@ def get_prompt(config, prompt_type):
     llm_params = config["llm_params"]
     llm_loader = llm_params["llm_loader"]
     use_history = llm_params["use_history"]
-
-    print("llm_params: ", llm_params)
-    print("ELI5", llm_params["ELI5"])
-
-    print("\n\n")
+    llm_style = llm_params["llm_style"].lower()
 
     if prompt_type == "qa":
-        if llm_loader == "openai":
-            if llm_params["ELI5"]:
-                return ELI5_PROMPT_WITH_HISTORY
+        if llm_loader == "local_llm":
+            if use_history:
+                return prompts["tiny_llama"]["prompt_with_history"]
             else:
-                return (
-                    OPENAI_PROMPT_WITH_HISTORY
-                    if use_history
-                    else OPENAI_PROMPT_NO_HISTORY
-                )
-        elif (
-            llm_loader == "local_llm"
-            and llm_params.get("local_llm_params") == "tiny-llama"
-        ):
-            return (
-                TINYLLAMA_PROMPT_TEMPLATE_WITH_HISTORY
-                if use_history
-                else TINYLLAMA_PROMPT_TEMPLATE_NO_HISTORY
-            )
+                return prompts["tiny_llama"]["prompt_no_history"]
+        else:
+            if use_history:
+                return prompts["openai"]["prompt_with_history"][llm_style]
+            else:
+                return prompts["openai"]["prompt_no_history"]
     elif prompt_type == "rephrase":
-        prompt = ChatPromptTemplate.from_messages(
-            [
-                ("system", OPENAI_REPHRASE_PROMPT),
-                ("human", "{question}, {chat_history}"),
-            ]
-        )
-        return OPENAI_REPHRASE_PROMPT
-
-    return None
+        return prompts["openai"]["rephrase_prompt"]

code/modules/chat/langchain/langchain_rag.py

@@ -1,12 +1,14 @@
 from langchain_core.prompts import ChatPromptTemplate
 
 from modules.chat.langchain.utils import *
+from langchain.memory import ChatMessageHistory
+from modules.chat.base import BaseRAG
 
 
-class CustomConversationalRetrievalChain:
+class Langchain_RAG(BaseRAG):
     def __init__(self, llm, memory, retriever, qa_prompt: str, rephrase_prompt: str):
         """
-        Initialize the CustomConversationalRetrievalChain class.
+        Initialize the Langchain_RAG class.
 
         Args:
             llm (LanguageModelLike): The language model instance.
@@ -16,7 +18,7 @@ class CustomConversationalRetrievalChain:
             rephrase_prompt (str): The rephrase prompt string.
         """
         self.llm = llm
-        self.memory = memory
+        self.memory = self.add_history_from_list(memory)
         self.retriever = retriever
         self.qa_prompt = qa_prompt
         self.rephrase_prompt = rephrase_prompt
@@ -30,12 +32,8 @@ class CustomConversationalRetrievalChain:
             "without the chat history. Do NOT answer the question, just "
             "reformulate it if needed and otherwise return it as is."
         )
-        self.contextualize_q_prompt = ChatPromptTemplate.from_messages(
-            [
-                ("system", contextualize_q_system_prompt),
-                MessagesPlaceholder("chat_history"),
-                ("human", "{input}"),
-            ]
+        self.contextualize_q_prompt = ChatPromptTemplate.from_template(
+            contextualize_q_system_prompt
         )
 
         # History-aware retriever
@@ -53,13 +51,7 @@ class CustomConversationalRetrievalChain:
             "\n\n"
             "{context}"
         )
-        self.qa_prompt_template = ChatPromptTemplate.from_messages(
-            [
-                ("system", qa_system_prompt),
-                MessagesPlaceholder("chat_history"),
-                ("human", "{input}"),
-            ]
-        )
+        self.qa_prompt_template = ChatPromptTemplate.from_template(qa_system_prompt)
 
         # Question-answer chain
         self.question_answer_chain = create_stuff_documents_chain(
@@ -121,6 +113,9 @@ class CustomConversationalRetrievalChain:
         """
         if (user_id, conversation_id) not in self.store:
             self.store[(user_id, conversation_id)] = InMemoryHistory()
+            self.store[(user_id, conversation_id)].add_messages(
+                self.memory.messages
+            )  # add previous messages to the store. Note: the store is in-memory.
         return self.store[(user_id, conversation_id)]
 
     def invoke(self, user_query, config):
@@ -133,5 +128,22 @@ class CustomConversationalRetrievalChain:
         Returns:
             dict: The output variables.
         """
-        print(user_query, config)
-        return self.rag_chain.invoke(user_query, config)
+        res = self.rag_chain.invoke(user_query, config)
+        res["rephrase_prompt"] = self.rephrase_prompt
+        res["qa_prompt"] = self.qa_prompt
+        return res
+
+    def add_history_from_list(self, history_list):
+        """
+        Add messages from a list to the chat history.
+
+        Args:
+            messages (list): The list of messages to add.
+        """
+        history = ChatMessageHistory()
+
+        for idx, message_pairs in enumerate(history_list):
+            history.add_user_message(message_pairs[0])
+            history.add_ai_message(message_pairs[1])
+
+        return history

code/modules/chat/langchain/utils.py

@@ -62,38 +62,6 @@ class CustomRunnableWithHistory(RunnableWithMessageHistory):
         return messages
 
 
-def _get_chat_history(chat_history: List[CHAT_TURN_TYPE], n: int = None) -> str:
-    """
-    Convert chat history to a formatted string.
-
-    Args:
-        chat_history (List[CHAT_TURN_TYPE]): The chat history.
-
-    Returns:
-        str: The formatted chat history.
-    """
-    _ROLE_MAP = {"human": "Student: ", "ai": "AI Tutor: "}
-    buffer = ""
-    if n is not None:
-        # Calculate the number of turns to take (2 turns per pair)
-        turns_to_take = n * 2
-        chat_history = chat_history[-turns_to_take:]
-    for dialogue_turn in chat_history:
-        if isinstance(dialogue_turn, BaseMessage):
-            role_prefix = _ROLE_MAP.get(dialogue_turn.type, f"{dialogue_turn.type}: ")
-            buffer += f"\n{role_prefix}{dialogue_turn.content}"
-        elif isinstance(dialogue_turn, tuple):
-            human = "Student: " + dialogue_turn[0]
-            ai = "AI Tutor: " + dialogue_turn[1]
-            buffer += "\n" + "\n".join([human, ai])
-        else:
-            raise ValueError(
-                f"Unsupported chat history format: {type(dialogue_turn)}."
-                f" Full chat history: {chat_history} "
-            )
-    return buffer
-
-
 class InMemoryHistory(BaseChatMessageHistory, BaseModel):
     """In-memory implementation of chat message history."""
 

code/modules/chat/langgraph/langgraph_rag.py

@@ -0,0 +1,303 @@
+# Adapted from https://github.com/langchain-ai/langgraph/blob/main/examples/rag/langgraph_crag.ipynb?ref=blog.langchain.dev
+
+from typing import List
+
+from typing_extensions import TypedDict
+from langgraph.graph import END, StateGraph, START
+from modules.chat.base import BaseRAG
+from langchain.memory import ChatMessageHistory
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+
+
+class GradeDocuments(BaseModel):
+    """Binary score for relevance check on retrieved documents."""
+
+    binary_score: str = Field(
+        description="Documents are relevant to the question, 'yes' or 'no'"
+    )
+
+
+class GraphState(TypedDict):
+    """
+    Represents the state of our graph.
+
+    Attributes:
+        question: question
+        generation: LLM generation
+        documents: list of documents
+    """
+
+    question: str
+    generation: str
+    documents: List[str]
+
+
+class Langgraph_RAG(BaseRAG):
+    def __init__(self, llm, memory, retriever, qa_prompt: str, rephrase_prompt: str):
+        """
+        Initialize the Langgraph_RAG class.
+
+        Args:
+            llm (LanguageModelLike): The language model instance.
+            memory (BaseChatMessageHistory): The chat message history instance.
+            retriever (BaseRetriever): The retriever instance.
+            qa_prompt (str): The QA prompt string.
+            rephrase_prompt (str): The rephrase prompt string.
+        """
+        self.llm = llm
+        self.structured_llm_grader = llm.with_structured_output(GradeDocuments)
+        self.memory = self.add_history_from_list(memory)
+        self.retriever = retriever
+        self.qa_prompt = (
+            "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance. "
+            "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally. "
+            "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n\n"
+            "Context:\n{context}\n\n"
+            "Answer the student's question below in a friendly, concise, and engaging manner. Use the context and history only if relevant, otherwise, engage in a free-flowing conversation.\n"
+            "Student: {question}\n"
+            "AI Tutor:"
+        )
+        self.rephrase_prompt = rephrase_prompt
+        self.store = {}
+
+        ## Fix below ##
+
+        system = """You are a grader assessing relevance of a retrieved document to a user question. \n 
+            If the document contains keyword(s) or semantic meaning related to the question, grade it as relevant. \n
+            Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question."""
+        grade_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system),
+                (
+                    "human",
+                    "Retrieved document: \n\n {document} \n\n User question: {question}",
+                ),
+            ]
+        )
+
+        self.retrieval_grader = grade_prompt | self.structured_llm_grader
+
+        system = """You a question re-writer that converts an input question to a better version that is optimized \n 
+            for web search. Look at the input and try to reason about the underlying semantic intent / meaning."""
+        re_write_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system),
+                (
+                    "human",
+                    "Here is the initial question: \n\n {question} \n Formulate an improved question.",
+                ),
+            ]
+        )
+
+        self.question_rewriter = re_write_prompt | self.llm | StrOutputParser()
+
+        # Generate
+        self.qa_prompt_template = ChatPromptTemplate.from_template(self.qa_prompt)
+        self.rag_chain = self.qa_prompt_template | self.llm | StrOutputParser()
+
+        ###
+
+        # build the agentic graph
+        self.app = self.create_agentic_graph()
+
+    def retrieve(self, state):
+        """
+        Retrieve documents
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            state (dict): New key added to state, documents, that contains retrieved documents
+        """
+        print("---RETRIEVE---")
+        question = state["question"]
+
+        # Retrieval
+        documents = self.retriever.get_relevant_documents(question)
+        return {"documents": documents, "question": question}
+
+    def generate(self, state):
+        """
+        Generate answer
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            state (dict): New key added to state, generation, that contains LLM generation
+        """
+        print("---GENERATE---")
+        question = state["question"]
+        documents = state["documents"]
+
+        # RAG generation
+        generation = self.rag_chain.invoke({"context": documents, "question": question})
+        return {"documents": documents, "question": question, "generation": generation}
+
+    def transform_query(self, state):
+        """
+        Transform the query to produce a better question.
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            state (dict): Updates question key with a re-phrased question
+        """
+
+        print("---TRANSFORM QUERY---")
+        question = state["question"]
+        documents = state["documents"]
+
+        # Re-write question
+        better_question = self.question_rewriter.invoke({"question": question})
+        return {"documents": documents, "question": better_question}
+
+    def grade_documents(self, state):
+        """
+        Determines whether the retrieved documents are relevant to the question.
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            state (dict): Updates documents key with only filtered relevant documents
+        """
+
+        print("---CHECK DOCUMENT RELEVANCE TO QUESTION---")
+        question = state["question"]
+        documents = state["documents"]
+
+        # Score each doc
+        filtered_docs = []
+        web_search = "No"
+        for d in documents:
+            score = self.retrieval_grader.invoke(
+                {"question": question, "document": d.page_content}
+            )
+            grade = score.binary_score
+            if grade == "yes":
+                print("---GRADE: DOCUMENT RELEVANT---")
+                filtered_docs.append(d)
+            else:
+                print("---GRADE: DOCUMENT NOT RELEVANT---")
+                web_search = "Yes"
+                continue
+        return {
+            "documents": filtered_docs,
+            "question": question,
+            "web_search": web_search,
+        }
+
+    def decide_to_generate(self, state):
+        """
+        Determines whether to generate an answer, or re-generate a question.
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            str: Binary decision for next node to call
+        """
+
+        print("---ASSESS GRADED DOCUMENTS---")
+        state["question"]
+        web_search = state["web_search"]
+        state["documents"]
+
+        if web_search == "Yes":
+            # All documents have been filtered check_relevance
+            # We will re-generate a new query
+            print(
+                "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---"
+            )
+            return "transform_query"
+        else:
+            # We have relevant documents, so generate answer
+            print("---DECISION: GENERATE---")
+            return "generate"
+
+    def create_agentic_graph(self):
+        """
+        Create an agentic graph to answer questions.
+
+        Returns:
+            dict: Agentic graph
+        """
+        self.workflow = StateGraph(GraphState)
+        self.workflow.add_node("retrieve", self.retrieve)
+        self.workflow.add_node(
+            "grade_documents", self.grade_documents
+        )  # grade documents
+        self.workflow.add_node("generate", self.generate)  # generatae
+        self.workflow.add_node(
+            "transform_query", self.transform_query
+        )  # transform_query
+
+        # build the graph
+        self.workflow.add_edge(START, "retrieve")
+        self.workflow.add_edge("retrieve", "grade_documents")
+        self.workflow.add_conditional_edges(
+            "grade_documents",
+            self.decide_to_generate,
+            {
+                "transform_query": "transform_query",
+                "generate": "generate",
+            },
+        )
+
+        self.workflow.add_edge("transform_query", "generate")
+        self.workflow.add_edge("generate", END)
+
+        # Compile
+        app = self.workflow.compile()
+        return app
+
+    def invoke(self, user_query, config):
+        """
+        Invoke the chain.
+
+        Args:
+            kwargs: The input variables.
+
+        Returns:
+            dict: The output variables.
+        """
+
+        inputs = {
+            "question": user_query["input"],
+        }
+
+        for output in self.app.stream(inputs):
+            for key, value in output.items():
+                # Node
+                print(f"Node {key} returned: {value}")
+            print("\n\n")
+
+        print(value["generation"])
+
+        # rename generation to answer
+        value["answer"] = value.pop("generation")
+        value["context"] = value.pop("documents")
+
+        return value
+
+    def add_history_from_list(self, history_list):
+        """
+        Add messages from a list to the chat history.
+
+        Args:
+            messages (list): The list of messages to add.
+        """
+        history = ChatMessageHistory()
+
+        for idx, message_pairs in enumerate(history_list):
+            history.add_user_message(message_pairs[0])
+            history.add_ai_message(message_pairs[1])
+
+        return history

code/modules/chat/llm_tutor.py

@@ -2,7 +2,8 @@ from modules.chat.helpers import get_prompt
 from modules.chat.chat_model_loader import ChatModelLoader
 from modules.vectorstore.store_manager import VectorStoreManager
 from modules.retriever.retriever import Retriever
-from modules.chat.langchain.langchain_rag import CustomConversationalRetrievalChain
+from modules.chat.langchain.langchain_rag import Langchain_RAG
+from modules.chat.langgraph.langgraph_rag import Langgraph_RAG
 
 
 class LLMTutor:
@@ -19,7 +20,7 @@ class LLMTutor:
         self.llm = self.load_llm()
         self.user = user
         self.logger = logger
-        self.vector_db = VectorStoreManager(config, logger=self.logger)
+        self.vector_db = VectorStoreManager(config, logger=self.logger).load_database()
         self.qa_prompt = get_prompt(config, "qa")  # Initialize qa_prompt
         self.rephrase_prompt = get_prompt(
             config, "rephrase"
@@ -28,28 +29,31 @@ class LLMTutor:
             self.vector_db.create_database()
             self.vector_db.save_database()
 
-    def update_llm(self, new_config):
+    def update_llm(self, old_config, new_config):
         """
         Update the LLM and VectorStoreManager based on new configuration.
 
         Args:
             new_config (dict): New configuration dictionary.
         """
-        changes = self.get_config_changes(self.config, new_config)
-        self.config = new_config
+        changes = self.get_config_changes(old_config, new_config)
 
-        if "chat_model" in changes:
+        print("\n\n\n")
+        print("Changes: ", changes)
+        print("\n\n\n")
+
+        if "llm_params.llm_loader" in changes:
             self.llm = self.load_llm()  # Reinitialize LLM if chat_model changes
 
-        if "vectorstore" in changes:
+        if "vectorstore.db_option" in changes:
             self.vector_db = VectorStoreManager(
                 self.config, logger=self.logger
-            )  # Reinitialize VectorStoreManager if vectorstore changes
+            ).load_database()  # Reinitialize VectorStoreManager if vectorstore changes
             if self.config["vectorstore"]["embedd_files"]:
                 self.vector_db.create_database()
                 self.vector_db.save_database()
 
-        if "ELI5" in changes:
+        if "llm_params.llm_style" in changes:
             self.qa_prompt = get_prompt(
                 self.config, "qa"
             )  # Update qa_prompt if ELI5 changes
@@ -66,9 +70,21 @@ class LLMTutor:
             dict: Dictionary containing the changes.
         """
         changes = {}
-        for key in new_config:
-            if old_config.get(key) != new_config[key]:
-                changes[key] = (old_config.get(key), new_config[key])
+
+        def compare_dicts(old, new, parent_key=""):
+            for key in new:
+                full_key = f"{parent_key}.{key}" if parent_key else key
+                if isinstance(new[key], dict) and isinstance(old.get(key), dict):
+                    compare_dicts(old.get(key, {}), new[key], full_key)
+                elif old.get(key) != new[key]:
+                    changes[full_key] = (old.get(key), new[key])
+            # Include keys that are in old but not in new
+            for key in old:
+                if key not in new:
+                    full_key = f"{parent_key}.{key}" if parent_key else key
+                    changes[full_key] = (old[key], None)
+
+        compare_dicts(old_config, new_config)
         return changes
 
     def retrieval_qa_chain(self, llm, qa_prompt, rephrase_prompt, db, memory=None):
@@ -87,14 +103,26 @@ class LLMTutor:
         """
         retriever = Retriever(self.config)._return_retriever(db)
 
-        if self.config["llm_params"]["use_history"]:
-            self.qa_chain = CustomConversationalRetrievalChain(
+        if self.config["llm_params"]["llm_arch"] == "langchain":
+            self.qa_chain = Langchain_RAG(
                 llm=llm,
                 memory=memory,
                 retriever=retriever,
                 qa_prompt=qa_prompt,
                 rephrase_prompt=rephrase_prompt,
             )
+        elif self.config["llm_params"]["llm_arch"] == "langgraph_agentic":
+            self.qa_chain = Langgraph_RAG(
+                llm=llm,
+                memory=memory,
+                retriever=retriever,
+                qa_prompt=qa_prompt,
+                rephrase_prompt=rephrase_prompt,
+            )
+        else:
+            raise ValueError(
+                f"Invalid LLM Architecture: {self.config['llm_params']['llm_arch']}"
+            )
         return self.qa_chain
 
     def load_llm(self):
@@ -108,7 +136,7 @@ class LLMTutor:
         llm = chat_model_loader.load_chat_model()
         return llm
 
-    def qa_bot(self, memory=None, qa_prompt=None, rephrase_prompt=None):
+    def qa_bot(self, memory=None):
         """
         Create a QA bot instance.
 
@@ -120,34 +148,14 @@ class LLMTutor:
         Returns:
             Chain: The QA bot chain instance.
         """
-        if qa_prompt is None:
-            qa_prompt = get_prompt(self.config, "qa")
-        if rephrase_prompt is None:
-            rephrase_prompt = get_prompt(self.config, "rephrase")
-
-        print("using qa_prompt: ", qa_prompt)
-        print("\n\n\n")
-        # exit()
-        db = self.vector_db.load_database()
         # sanity check to see if there are any documents in the database
-        if len(db) == 0:
+        if len(self.vector_db) == 0:
             raise ValueError(
                 "No documents in the database. Populate the database first."
             )
-        qa = self.retrieval_qa_chain(self.llm, qa_prompt, rephrase_prompt, db, memory)
 
-        return qa
-
-    def final_result(query):
-        """
-        Get the final result for a given query.
+        qa = self.retrieval_qa_chain(
+            self.llm, self.qa_prompt, self.rephrase_prompt, self.vector_db, memory
+        )
 
-        Args:
-            query (str): The query string.
-
-        Returns:
-            str: The response string.
-        """
-        qa_result = qa_bot()
-        response = qa_result({"query": query})
-        return response
+        return qa

code/modules/chat_processor/base.py

@@ -2,11 +2,17 @@
 
 
 class ChatProcessorBase:
-    def __init__(self, config):
-        self.config = config
+    def __init__(self):
+        pass
 
     def process(self, message):
         """
         Processes and Logs the message
         """
         raise NotImplementedError("process method not implemented")
+
+    async def rag(self, user_query: dict, config: dict, chain):
+        """
+        Retrieves the response from the chain
+        """
+        raise NotImplementedError("rag method not implemented")

code/modules/chat_processor/chat_processor.py

@@ -2,12 +2,11 @@ from modules.chat_processor.literal_ai import LiteralaiChatProcessor
 
 
 class ChatProcessor:
-    def __init__(self, llm_tutor, tags=None):
-        self.llm_tutor = llm_tutor
-        self.config = self.llm_tutor.config
+    def __init__(self, config, user, tags=None):
+        self.config = config
         self.chat_processor_type = self.config["chat_logging"]["platform"]
         self.logging = self.config["chat_logging"]["log_chat"]
-        self.user = self.llm_tutor.user
+        self.user = user
         if tags is None:
             self.tags = self._create_tags()
         else:
@@ -18,12 +17,11 @@ class ChatProcessor:
     def _create_tags(self):
         tags = []
         tags.append(self.config["vectorstore"]["db_option"])
-        tags.append(self.config["llm_params"]["chat_profile"])
         return tags
 
     def _init_processor(self):
         if self.chat_processor_type == "literalai":
-            self.processor = LiteralaiChatProcessor(self.tags)
+            self.processor = LiteralaiChatProcessor(self.user, self.tags)
         else:
             raise ValueError(
                 f"Chat processor type {self.chat_processor_type} not supported"
@@ -42,7 +40,7 @@ class ChatProcessor:
             "configurable": {
                 "user_id": self.user["user_id"],
                 "conversation_id": self.user["session_id"],
-                "memory_window": self.llm_tutor.config["llm_params"]["memory_window"],
+                "memory_window": self.config["llm_params"]["memory_window"],
             }
         }
 

code/modules/chat_processor/literal_ai.py

@@ -1,18 +1,91 @@
 from literalai import LiteralClient
+from literalai.api import LiteralAPI
+from literalai.filter import Filter as ThreadFilter
+
 import os
 from .base import ChatProcessorBase
 
 
 class LiteralaiChatProcessor(ChatProcessorBase):
-    def __init__(self, tags=None):
+    def __init__(self, user=None, tags=None):
+        super().__init__()
+        self.user = user
+        self.tags = tags
         self.literal_client = LiteralClient(api_key=os.getenv("LITERAL_API_KEY"))
+        self.literal_api = LiteralAPI(
+            api_key=os.getenv("LITERAL_API_KEY"), url=os.getenv("LITERAL_API_URL")
+        )
         self.literal_client.reset_context()
-        with self.literal_client.thread(name="TEST") as thread:
-            self.thread_id = thread.id
-            self.thread = thread
-            if tags is not None and type(tags) == list:
-                self.thread.tags = tags
-        print(f"Thread ID: {self.thread}")
+        self.user_info = self._fetch_userinfo()
+        self.user_thread = self._fetch_user_threads()
+        if len(self.user_thread["data"]) == 0:
+            self.thread = self._create_user_thread()
+        else:
+            self.thread = self._get_user_thread()
+        self.thread_id = self.thread["id"]
+
+        self.prev_conv = self._get_prev_k_conversations()
+
+    def _get_user_thread(self):
+        thread = self.literal_api.get_thread(id=self.user_thread["data"][0]["id"])
+        return thread.to_dict()
+
+    def _create_user_thread(self):
+        thread = self.literal_api.create_thread(
+            name=f"{self.user_info['identifier']}",
+            participant_id=self.user_info["metadata"]["id"],
+            environment="dev",
+        )
+
+        return thread.to_dict()
+
+    def _get_prev_k_conversations(self, k=3):
+
+        steps = self.thread["steps"]
+        conversation_pairs = []
+        count = 0
+        for i in range(len(steps) - 1, 0, -1):
+            if (
+                steps[i - 1]["type"] == "user_message"
+                and steps[i]["type"] == "assistant_message"
+            ):
+                user_message = steps[i - 1]["output"]["content"]
+                assistant_message = steps[i]["output"]["content"]
+                conversation_pairs.append((user_message, assistant_message))
+
+                count += 1
+                if count >= k:
+                    break
+
+        # Return the last k conversation pairs, reversed to maintain chronological order
+        return conversation_pairs[::-1]
+
+    def _fetch_user_threads(self):
+        filters = filters = [
+            {
+                "operator": "eq",
+                "field": "participantId",
+                "value": self.user_info["metadata"]["id"],
+            }
+        ]
+        user_threads = self.literal_api.get_threads(filters=filters)
+        return user_threads.to_dict()
+
+    def _fetch_userinfo(self):
+        user_info = self.literal_api.get_or_create_user(
+            identifier=self.user["user_id"]
+        ).to_dict()
+        # TODO: Have to do this more elegantly
+        # update metadata with unique id for now
+        # (literalai seems to not return the unique id as of now,
+        # so have to explicitly update it in the metadata)
+        user_info = self.literal_api.update_user(
+            id=user_info["id"],
+            metadata={
+                "id": user_info["id"],
+            },
+        ).to_dict()
+        return user_info
 
     def process(self, user_message, assistant_message, source_dict):
         with self.literal_client.thread(thread_id=self.thread_id) as thread:
@@ -29,9 +102,9 @@ class LiteralaiChatProcessor(ChatProcessorBase):
 
     async def rag(self, user_query: dict, config: dict, chain):
         with self.literal_client.step(
-            type="retrieval", name="RAG", thread_id=self.thread_id
+            type="retrieval", name="RAG", thread_id=self.thread_id, tags=self.tags
         ) as step:
             step.input = {"question": user_query["input"]}
-            res = await chain.invoke(user_query, config)
+            res = chain.invoke(user_query, config)
             step.output = res
         return res

code/modules/config/config.yml

@@ -9,7 +9,7 @@ vectorstore:
   data_path: '../storage/data' # str
   url_file_path: '../storage/data/urls.txt' # str
   expand_urls: True # bool
-  db_option : 'RAGatouille' # str [FAISS, Chroma, RAGatouille, RAPTOR]
+  db_option : 'FAISS' # str [FAISS, Chroma, RAGatouille, RAPTOR]
   db_path : '../vectorstores' # str
   model : 'sentence-transformers/all-MiniLM-L6-v2' # str [sentence-transformers/all-MiniLM-L6-v2, text-embedding-ada-002']
   search_top_k : 3 # int
@@ -26,15 +26,15 @@ vectorstore:
     index_name: "new_idx" # str
 
 llm_params: 
+  llm_arch: 'langchain' # [langchain, langgraph_agentic]
   use_history: True # bool
   memory_window: 3 # int
-  ELI5: False # bool
-  llm_loader: 'openai' # str [local_llm, openai]
+  llm_style: 'Normal' # str [Normal, ELI5, Socratic]
+  llm_loader: 'gpt-3.5-turbo-1106' # str [local_llm, gpt-3.5-turbo-1106, gpt-4]
   openai_params:
-    model: 'gpt-3.5-turbo-1106' # str [gpt-3.5-turbo-1106, gpt-4]
+    temperature: 0.7 # float
   local_llm_params:
-    model: 'tiny-llama'
-    temperature: 0.7
+    temperature: 0.7 # float
 
 chat_logging:
   log_chat: False # bool

code/modules/config/constants.py

@@ -8,87 +8,13 @@ load_dotenv()
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
 LITERAL_API_KEY = os.getenv("LITERAL_API_KEY")
+LITERAL_API_URL = os.getenv("LITERAL_API_URL")
 
-opening_message = f"Hey, What Can I Help You With?\n\nYou can me ask me questions about the course logistics, course content, about the final project, or anything else!"
-
-# Prompt Templates
-
-OPENAI_REPHRASE_PROMPT = (
-    "You are someone that rephrases statements. Rephrase the student's question to add context from their chat history if relevant, ensuring it remains from the student's point of view. "
-    "Incorporate relevant details from the chat history to make the question clearer and more specific. "
-    "Do not change the meaning of the original statement, and maintain the student's tone and perspective. "
-    "If the question is conversational and doesn't require context, do not rephrase it. "
-    "Example: If the student previously asked about backpropagation in the context of deep learning and now asks 'what is it', rephrase to 'What is backpropagation.'. "
-    "Example: Do not rephrase if the user is asking something specific like 'cool, suggest a project with transformers to use as my final project' "
-    "Chat history: \n{chat_history}\n"
-    "Rephrase the following question only if necessary: '{input}'"
-)
-
-OPENAI_PROMPT_WITH_HISTORY = (
-    "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance. "
-    "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally. "
-    "Use chat history and context as guides but avoid repeating past responses. Provide links from the source_file metadata. Use the source context that is most relevant. "
-    "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n\n"
-    "Chat History:\n{chat_history}\n\n"
-    "Context:\n{context}\n\n"
-    "Answer the student's question below in a friendly, concise, and engaging manner. Use the context and history only if relevant, otherwise, engage in a free-flowing conversation.\n"
-    "Student: {input}\n"
-    "AI Tutor:"
-)
+OAUTH_GOOGLE_CLIENT_ID = os.getenv("OAUTH_GOOGLE_CLIENT_ID")
+OAUTH_GOOGLE_CLIENT_SECRET = os.getenv("OAUTH_GOOGLE_CLIENT_SECRET")
 
-ELI5_PROMPT_WITH_HISTORY = (
-    "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context in the simplest way possible, as if you are explaining to a 5-year-old. Only use the context if it helps make things clearer. The context is ordered by relevance. "
-    "If you don't know the answer, do your best without making things up. Keep the conversation simple and easy to understand. "
-    "Use chat history and context as guides but avoid repeating past responses. Provide links from the source_file metadata. Use the source context that is most relevant. "
-    "Speak in a friendly and engaging manner, like talking to a curious child. Avoid complex terms.\n\n"
-    "Chat History:\n{chat_history}\n\n"
-    "Context:\n{context}\n\n"
-    "Answer the student's question below in a friendly, simple, and engaging manner. Use the context and history only if relevant, otherwise, engage in a free-flowing conversation.\n"
-    "Give a very detailed narrative explanation. Use examples wherever you can to aid in the explanation. Remember, explain it as if you are talking to a 5-year-old.\n"
-    "Student: {input}\n"
-    "AI Tutor:"
-)
-
-OPENAAI_PROMPT_NO_HISTORY = (
-    "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance. "
-    "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally. "
-    "Provide links from the source_file metadata. Use the source context that is most relevant. "
-    "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n\n"
-    "Context:\n{context}\n\n"
-    "Answer the student's question below in a friendly, concise, and engaging manner. Use the context and history only if relevant, otherwise, engage in a free-flowing conversation.\n"
-    "Student: {input}\n"
-    "AI Tutor:"
-)
-
-
-TINYLLAMA_PROMPT_TEMPLATE_NO_HISTORY = (
-    "<|im_start|>system\n"
-    "Assistant is an intelligent chatbot designed to help students with questions regarding the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance.\n"
-    "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally.\n"
-    "Provide links from the source_file metadata. Use the source context that is most relevant.\n"
-    "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n"
-    "<|im_end|>\n\n"
-    "<|im_start|>user\n"
-    "Context:\n{context}\n\n"
-    "Question: {input}\n"
-    "<|im_end|>\n\n"
-    "<|im_start|>assistant"
-)
+opening_message = f"Hey, What Can I Help You With?\n\nYou can me ask me questions about the course logistics, course content, about the final project, or anything else!"
 
-TINYLLAMA_PROMPT_TEMPLATE_WITH_HISTORY = (
-    "<|im_start|>system\n"
-    "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance. "
-    "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally. "
-    "Use chat history and context as guides but avoid repeating past responses. Provide links from the source_file metadata. Use the source context that is most relevant. "
-    "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n"
-    "<|im_end|>\n\n"
-    "<|im_start|>user\n"
-    "Chat History:\n{chat_history}\n\n"
-    "Context:\n{context}\n\n"
-    "Question: {input}\n"
-    "<|im_end|>\n\n"
-    "<|im_start|>assistant"
-)
 # Model Paths
 
 LLAMA_PATH = "../storage/models/tinyllama-1.1b-chat-v1.0.Q5_K_M.gguf"

code/modules/config/prompts.py

@@ -0,0 +1,96 @@
+prompts = {
+    "openai": {
+        "rephrase_prompt": (
+            "You are someone that rephrases statements. Rephrase the student's question to add context from their chat history if relevant, ensuring it remains from the student's point of view. "
+            "Incorporate relevant details from the chat history to make the question clearer and more specific. "
+            "Do not change the meaning of the original statement, and maintain the student's tone and perspective. "
+            "If the question is conversational and doesn't require context, do not rephrase it. "
+            "Example: If the student previously asked about backpropagation in the context of deep learning and now asks 'what is it', rephrase to 'What is backpropagation.'. "
+            "Example: Do not rephrase if the user is asking something specific like 'cool, suggest a project with transformers to use as my final project' "
+            "Chat history: \n{chat_history}\n"
+            "Rephrase the following question only if necessary: '{input}'"
+            "Rephrased Question:'"
+        ),
+        "prompt_with_history": {
+            "normal": (
+                "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance. "
+                "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally. "
+                "Use chat history and context as guides but avoid repeating past responses. Provide links from the source_file metadata. Use the source context that is most relevant. "
+                "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n\n"
+                "Chat History:\n{chat_history}\n\n"
+                "Context:\n{context}\n\n"
+                "Answer the student's question below in a friendly, concise, and engaging manner. Use the context and history only if relevant, otherwise, engage in a free-flowing conversation.\n"
+                "Student: {input}\n"
+                "AI Tutor:"
+            ),
+            "eli5": (
+                "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context in the simplest way possible, as if you are explaining to a 5-year-old. Only use the context if it helps make things clearer. The context is ordered by relevance. "
+                "If you don't know the answer, do your best without making things up. Keep the conversation simple and easy to understand. "
+                "Use chat history and context as guides but avoid repeating past responses. Provide links from the source_file metadata. Use the source context that is most relevant. "
+                "Speak in a friendly and engaging manner, like talking to a curious child. Avoid complex terms.\n\n"
+                "Chat History:\n{chat_history}\n\n"
+                "Context:\n{context}\n\n"
+                "Answer the student's question below in a friendly, simple, and engaging manner. Use the context and history only if relevant, otherwise, engage in a free-flowing conversation.\n"
+                "Give a long very detailed narrative explanation. Use examples wherever you can to aid in the explanation. Remember, explain it as if you are talking to a 5-year-old, so construct a long narrative that builds up to the answer.\n"
+                "5-year-old Student: {input}\n"
+                "AI Tutor:"
+            ),
+            "socratic": (
+                "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Your goal is to guide the student towards understanding using the Socratic method. Ask thought-provoking questions to encourage critical thinking and self-discovery. Use the provided context only when relevant. The context is ordered by relevance.\n\n"
+                "Guidelines for the Socratic approach:\n"
+                "Guidelines:"
+                "1. Begin with a concise, direct answer to the student's question."
+                "2. Follow up with 1-2 thought-provoking questions to encourage critical thinking."
+                "3. Provide additional explanations or context if necessary to move the conversation forward."
+                "4. End with an open-ended question that invites further exploration."
+                "Based on the chat history determine which guideline to follow., and answer accordingly\n\n"
+                "If the student is stuck, offer gentle hints or break down the concept into simpler parts. Maintain a friendly, engaging tone throughout the conversation.\n\n"
+                "Use chat history and context as guides, but avoid repeating past responses. Provide links from the source_file metadata when appropriate. Use the most relevant source context.\n\n"
+                "Chat History:\n{chat_history}\n\n"
+                "Context:\n{context}\n\n"
+                "Engage with the student's question below using the Socratic method. Ask probing questions to guide their thinking and encourage deeper understanding. Only provide direct answers if absolutely necessary.\n"
+                "Student: {input}\n"
+                "AI Tutor:"
+            ),
+        },
+        "prompt_no_history": (
+            "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance. "
+            "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally. "
+            "Provide links from the source_file metadata. Use the source context that is most relevant. "
+            "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n\n"
+            "Context:\n{context}\n\n"
+            "Answer the student's question below in a friendly, concise, and engaging manner. Use the context and history only if relevant, otherwise, engage in a free-flowing conversation.\n"
+            "Student: {input}\n"
+            "AI Tutor:"
+        ),
+    },
+    "tiny_llama": {
+        "prompt_no_history": (
+            "system\n"
+            "Assistant is an intelligent chatbot designed to help students with questions regarding the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance.\n"
+            "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally.\n"
+            "Provide links from the source_file metadata. Use the source context that is most relevant.\n"
+            "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n"
+            "\n\n"
+            "user\n"
+            "Context:\n{context}\n\n"
+            "Question: {input}\n"
+            "\n\n"
+            "assistant"
+        ),
+        "prompt_with_history": (
+            "system\n"
+            "You are an AI Tutor for the course DS598, taught by Prof. Thomas Gardos. Answer the user's question using the provided context. Only use the context if it is relevant. The context is ordered by relevance. "
+            "If you don't know the answer, do your best without making things up. Keep the conversation flowing naturally. "
+            "Use chat history and context as guides but avoid repeating past responses. Provide links from the source_file metadata. Use the source context that is most relevant. "
+            "Speak in a friendly and engaging manner, like talking to a friend. Avoid sounding repetitive or robotic.\n"
+            "\n\n"
+            "user\n"
+            "Chat History:\n{chat_history}\n\n"
+            "Context:\n{context}\n\n"
+            "Question: {input}\n"
+            "\n\n"
+            "assistant"
+        ),
+    },
+}

code/modules/vectorstore/raptor.py

@@ -5,7 +5,7 @@ import os
 import numpy as np
 import pandas as pd
 import umap
-from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.prompts.chat import ChatPromptTemplate
 from langchain_core.output_parsers import StrOutputParser
 from sklearn.mixture import GaussianMixture
 from langchain_community.chat_models import ChatOpenAI