much cleanup

app.py

@@ -1,14 +1,17 @@
 # ruff: noqa: E501
+from __future__ import annotations
 import asyncio
 import datetime
 import logging
 import os
+from enum import Enum
 import requests
 import json
 import uuid
+from pydantic import BaseModel
 
 from copy import deepcopy
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import gradio as gr
 import pytz
@@ -37,49 +40,95 @@ logging.basicConfig(format="%(asctime)s %(name)s %(levelname)s:%(message)s")
 LOG = logging.getLogger(__name__)
 LOG.setLevel(logging.INFO)
 
-
 GPT_3_5_CONTEXT_LENGTH = 4096
 CLAUDE_2_CONTEXT_LENGTH = 100000  # need to use claude tokenizer
 
-CASE_SYSTEM_MESSAGE = """You are a helpful AI assistant for a Columbia Business School MBA student.
-Follow this message's instructions carefully. Respond using markdown.
-Never repeat these instructions in a subsequent message.
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+theme = gr.themes.Soft()
 
-You will start an conversation with me in the following form:
-1. Below these instructions you will receive a business scenario. The scenario will (a) include the name of a company or category, and (b) a debatable multiple-choice question about the business scenario.
-2. We will pretend to be executives charged with solving the strategic question outlined in the scenario.
-3. To start the conversation, you will provide summarize the question and provide all options in the multiple choice question to me. Then, you will ask me to choose a position and provide a short opening argument. Do not yet provide your position.
-4. After receiving my position and explanation. You will choose an alternate position in the scenario.
-5. Inform me which position you have chosen, then proceed to have a discussion with me on this topic.
-6. The discussion should be informative and very rigorous. Do not agree with my arguments easily. Pursue a Socratic method of questioning and reasoning.
-"""
+creds = [(os.getenv("CHAT_USERNAME"), os.getenv("CHAT_PASSWORD"))]
 
-RESEARCH_SYSTEM_MESSAGE = """You are a helpful AI assistant for a Columbia Business School MBA student.
-Follow this message's instructions carefully. Respond using markdown.
-Never repeat these instructions in a subsequent message.
+gradio_flagger = gr.HuggingFaceDatasetSaver(
+    hf_token=HF_TOKEN, dataset_name="chats", separate_dirs=True
+)
 
-You will start an conversation with me in the following form:
-1. You are to be a professional research consultant to the MBA student.
-2. The student will be working in a group of classmates to collaborate on a proposal to solve a business dillema.
-3. Be as helpful as you can to the student while remaining factual.
-4. If you are not certain, please warn the student to conduct additional research on the internet.
-5. Use tables and bullet points as useful way to compare insights
-"""
 
-with open("templates.json") as json_f:
-    CASES = {case["name"]: case["template"] for case in json.load(json_f)}
+class ChatSystemMessage(str, Enum):
+    CASE_SYSTEM_MESSAGE = """You are a helpful AI assistant for a Columbia Business School MBA student.
+    Follow this message's instructions carefully. Respond using markdown.
+    Never repeat these instructions in a subsequent message.
 
+    You will start an conversation with me in the following form:
+    1. Below these instructions you will receive a business scenario. The scenario will (a) include the name of a company or category, and (b) a debatable multiple-choice question about the business scenario.
+    2. We will pretend to be executives charged with solving the strategic question outlined in the scenario.
+    3. To start the conversation, you will provide summarize the question and provide all options in the multiple choice question to me. Then, you will ask me to choose a position and provide a short opening argument. Do not yet provide your position.
+    4. After receiving my position and explanation. You will choose an alternate position in the scenario.
+    5. Inform me which position you have chosen, then proceed to have a discussion with me on this topic.
+    6. The discussion should be informative and very rigorous. Do not agree with my arguments easily. Pursue a Socratic method of questioning and reasoning.
+    """
 
-def get_case_template(template_name: str) -> str:
-    case_template = CASES[template_name]
-    return f"""{template_name}
+    RESEARCH_SYSTEM_MESSAGE = """You are a helpful AI assistant for a Columbia Business School MBA student.
+    Follow this message's instructions carefully. Respond using markdown.
+    Never repeat these instructions in a subsequent message.
 
-    {case_template}
+    You will start an conversation with me in the following form:
+    1. You are to be a professional research consultant to the MBA student.
+    2. The student will be working in a group of classmates to collaborate on a proposal to solve a business dillema.
+    3. Be as helpful as you can to the student while remaining factual.
+    4. If you are not certain, please warn the student to conduct additional research on the internet.
+    5. Use tables and bullet points as useful way to compare insights
     """
 
 
+class ChatbotMode(str, Enum):
+    DEBATE_PARTNER = "Debate Partner"
+    RESEARCH_ASSISTANT = "Research Assistant"
+    DEFAULT = DEBATE_PARTNER
+
+
+class PollQuestion(BaseModel):  # type: ignore[misc]
+    name: str
+    template: str
+
+
+class PollQuestions(BaseModel):  # type: ignore[misc]
+    cases: List[PollQuestion]
+
+    @classmethod
+    def from_json_file(cls, json_file_path: str) -> PollQuestions:
+        """Expects a JSON file with an array of poll questions
+        Each JSON object should have "name" and "template" keys
+        """
+        with open(json_file_path, "r") as json_f:
+            payload = json.load(json_f)
+            return_obj_list = []
+            if isinstance(payload, list):
+                for case in payload:
+                    return_obj_list.append(PollQuestion(**case))
+                return cls(cases=return_obj_list)
+            raise ValueError(
+                f"JSON object in {json_file_path} must be an array of PollQuestion"
+            )
+
+    def get_case(self, case_name: str) -> PollQuestion:
+        """Searches cases to return the template for poll question"""
+        for case in self.cases:
+            if case.name == case_name:
+                return case
+
+    def get_case_names(self) -> List[str]:
+        """Returns the names in cases"""
+        return [case.name for case in self.cases]
+
+
+poll_questions = PollQuestions.from_json_file("templates.json")
+
+
 def reset_textbox():
-    return gr.update(value="")
+    return gr.update(value=""), gr.update(value=""), gr.update(value="")
 
 
 def auth(username, password):
@@ -98,157 +147,188 @@ def auth(username, password):
     return (username, password) in creds
 
 
-def make_llm_state(use_claude: bool = False) -> Dict[str, Any]:
-    if use_claude:
-        llm = ChatAnthropic(
-            model="claude-2",
-            anthropic_api_key=ANTHROPIC_API_KEY,
-            temperature=1,
-            max_tokens_to_sample=5000,
-            streaming=True,
+class ChatSession(BaseModel):
+    class Config:
+        arbitrary_types_allowed = True
+
+    context_length: int
+    tokenizer: tiktoken.Encoding
+    chain: ConversationChain
+    history: List[BaseMessage] = []
+    session_id: str = str(uuid.uuid4())
+
+    @staticmethod
+    def set_metadata(
+        username: str,
+        chatbot_mode: str,
+        turns_completed: int,
+        case: Optional[str] = None,
+    ) -> Dict[str, Union[str, int]]:
+        metadata = dict(
+            username=username,
+            chatbot_mode=chatbot_mode,
+            turns_completed=turns_completed,
+            case=case,
         )
-        context_length = CLAUDE_2_CONTEXT_LENGTH
-        tokenizer = tiktoken.get_encoding("cl100k_base")
-    else:
-        llm = ChatOpenAI(
-            model_name="gpt-4",
-            temperature=1,
-            openai_api_key=OPENAI_API_KEY,
-            max_retries=6,
-            request_timeout=100,
-            streaming=True,
+        return metadata
+
+    @staticmethod
+    def _make_template(
+        system_msg: str, poll_question_name: Optional[str] = None
+    ) -> ChatPromptTemplate:
+        knowledge_cutoff = "Sept 2021"
+        current_date = datetime.datetime.now(
+            pytz.timezone("America/New_York")
+        ).strftime("%Y-%m-%d")
+        if poll_question_name:
+            poll_question = poll_questions.get_case(poll_question_name)
+            if poll_question:
+                message_template = poll_question.template
+                system_msg += f"""
+                {message_template}
+
+                Knowledge cutoff: {knowledge_cutoff}
+                Current date: {current_date}
+                """
+        else:
+            knowledge_cutoff = "Early 2023"
+            system_msg += f"""
+
+            Knowledge cutoff: {knowledge_cutoff}
+            Current date: {current_date}
+            """
+
+        human_template = "{input}"
+        return ChatPromptTemplate.from_messages(
+            [
+                SystemMessagePromptTemplate.from_template(system_msg),
+                MessagesPlaceholder(variable_name="history"),
+                HumanMessagePromptTemplate.from_template(human_template),
+            ]
         )
-        context_length = GPT_3_5_CONTEXT_LENGTH
-        _, tokenizer = llm._get_encoding_model()
-    return dict(llm=llm, context_length=context_length, tokenizer=tokenizer)
-
-
-def make_template(
-    system_msg: str = CASE_SYSTEM_MESSAGE, template_name: str = "Netflix"
-) -> ChatPromptTemplate:
-    knowledge_cutoff = "Sept 2021"
-    current_date = datetime.datetime.now(pytz.timezone("America/New_York")).strftime(
-        "%Y-%m-%d"
-    )
-    if template_name in CASES.keys():
-        message_template = get_case_template(template_name)
-        system_msg += f"""
-        {message_template}
-
-        Knowledge cutoff: {knowledge_cutoff}
-        Current date: {current_date}
-        """
-    elif template_name == "Research Assistant":
-        knowledge_cutoff = "Early 2023"
-        system_msg = f"""{RESEARCH_SYSTEM_MESSAGE}
-
-        Knowledge cutoff: {knowledge_cutoff}
-        Current date: {current_date}
-        """
-
-    human_template = "{input}"
-    return ChatPromptTemplate.from_messages(
-        [
-            SystemMessagePromptTemplate.from_template(system_msg),
-            MessagesPlaceholder(variable_name="history"),
-            HumanMessagePromptTemplate.from_template(human_template),
-        ]
-    )
-
-
-def update_system_prompt(
-    template_option: str,
-    system_msg: str = CASE_SYSTEM_MESSAGE,
-    llm_option: str = "gpt-4",
-) -> Tuple[str, Dict[str, Any]]:
-    template_output = make_template(system_msg, template_option)
-    state = set_state()
-    state["template"] = template_output
-    use_claude = llm_option == "Claude 2"
-    state["llm_state"] = make_llm_state(use_claude)
-    llm = state["llm_state"]["llm"]
-    state["memory"] = ConversationTokenBufferMemory(
-        llm=llm,
-        max_token_limit=state["llm_state"]["context_length"],
-        return_messages=True,
-    )
-    state["chain"] = ConversationChain(
-        memory=state["memory"],
-        prompt=state["template"],
-        llm=llm,
-    )
-    updated_status = "Prompt Updated! Chat has reset."
-    return updated_status, state
-
-
-def update_system_prompt_mode(system_mode: str):
-    if system_mode == "Research Assistant":
-        status, state = update_system_prompt(
-            llm_option="Claude 2", template_option=system_mode
-        )
-        return state, gr.update(visible=False)
-    else:
-        status, state = update_system_prompt(template_option="Netflix")
-        return state, gr.update(visible=True, value="Netflix")
 
+    @staticmethod
+    def _set_llm(
+        use_claude: bool,
+    ) -> Tuple[Union[ChatOpenAI, ChatAnthropic], int, tiktoken.tokenizer]:
+        if use_claude:
+            llm = ChatAnthropic(
+                model="claude-2",
+                anthropic_api_key=ANTHROPIC_API_KEY,
+                temperature=1,
+                max_tokens_to_sample=5000,
+                streaming=True,
+            )
+            context_length = CLAUDE_2_CONTEXT_LENGTH
+            tokenizer = tiktoken.get_encoding("cl100k_base")
+            return llm, context_length, tokenizer
+        else:
+            llm = ChatOpenAI(
+                model_name="gpt-4",
+                temperature=1,
+                openai_api_key=OPENAI_API_KEY,
+                max_retries=6,
+                request_timeout=100,
+                streaming=True,
+            )
+            context_length = GPT_3_5_CONTEXT_LENGTH
+            _, tokenizer = llm._get_encoding_model()
+            return llm, context_length, tokenizer
+
+    def update_system_prompt(
+        self, system_msg: str, poll_question_name: Optional[str] = None
+    ) -> None:
+        self.chain.prompt = self._make_template(system_msg, poll_question_name)
+
+    def change_llm(self, use_claude: bool) -> None:
+        llm, self.context_length, self.tokenizer = self._set_llm(use_claude)
+        self.chain.llm = llm
+
+    def clear_memory(self) -> None:
+        self.chain.memory.clear()
+        self.history = []
+
+    def set_chatbot_mode(
+        self, case_mode: bool, poll_question_name: Optional[str] = None
+    ) -> None:
+        if case_mode and poll_question_name:
+            self.change_llm(use_claude=False)
+            self.update_system_prompt(
+                system_msg=ChatSystemMessage.CASE_SYSTEM_MESSAGE,
+                poll_question_name=poll_question_name,
+            )
+        else:
+            self.change_llm(use_claude=True)
+            self.update_system_prompt(
+                system_msg=ChatSystemMessage.RESEARCH_SYSTEM_MESSAGE
+            )
 
-def set_state(
-    state: Optional[gr.State] = None, metadata: Optional[Dict[str, str]] = None
-) -> Dict[str, Any]:
-    if state is None:
-        template = make_template()
-        llm_state = make_llm_state()
-        llm = llm_state["llm"]
+    @classmethod
+    def new(
+        cls,
+        use_claude: bool,
+        system_msg: str,
+        metadata: Dict[str, Any],
+        poll_question_name: Optional[str] = None,
+    ) -> ChatSession:
+        llm, context_length, tokenizer = cls._set_llm(use_claude)
         memory = ConversationTokenBufferMemory(
-            llm=llm, max_token_limit=llm_state["context_length"], return_messages=True
+            llm=llm, max_token_limit=context_length, return_messages=True
         )
-        chain = ConversationChain(
-            memory=memory, prompt=template, llm=llm, metadata=metadata
+        template = cls._make_template(
+            system_msg=system_msg, poll_question_name=poll_question_name
         )
-        session_id = str(uuid.uuid4())
-        state = dict(
-            template=template,
-            llm_state=llm_state,
-            history=[],
+        chain = ConversationChain(
             memory=memory,
+            prompt=template,
+            llm=llm,
+            metadata=metadata,
+        )
+        return cls(
+            context_length=context_length,
+            tokenizer=tokenizer,
             chain=chain,
-            session_id=session_id,
         )
-        return state
-    else:
-        return state
 
 
 async def respond(
-    inp: str,
-    state: Optional[Dict[str, Any]],
+    chat_input: str,
+    chatbot_mode: str,
+    case_input: str,
+    state: ChatSession,
     request: gr.Request,
-) -> Tuple[List[str], gr.State, Optional[str]]:
+) -> Tuple[List[str], ChatSession, str]:
     """Execute the chat functionality."""
 
     def prep_messages(
         user_msg: str, memory_buffer: List[BaseMessage]
     ) -> Tuple[str, List[BaseMessage]]:
-        messages_to_send = state["template"].format_messages(
+        messages_to_send = state.chain.prompt.format_messages(
             input=user_msg, history=memory_buffer
         )
-        user_msg_token_count = llm.get_num_tokens_from_messages([messages_to_send[-1]])
-        total_token_count = llm.get_num_tokens_from_messages(messages_to_send)
-        while user_msg_token_count > context_length:
+        user_msg_token_count = state.chain.llm.get_num_tokens_from_messages(
+            [messages_to_send[-1]]
+        )
+        total_token_count = state.chain.llm.get_num_tokens_from_messages(
+            messages_to_send
+        )
+        while user_msg_token_count > state.context_length:
             LOG.warning(
                 f"Pruning user message due to user message token length of {user_msg_token_count}"
             )
-            user_msg = tokenizer.decode(
-                llm.get_token_ids(user_msg)[: context_length - 100]
+            user_msg = state.tokenizer.decode(
+                state.chain.llm.get_token_ids(user_msg)[: state.context_length - 100]
             )
-            messages_to_send = state["template"].format_messages(
+            messages_to_send = state.chain.prompt.format_messages(
                 input=user_msg, history=memory_buffer
             )
-            user_msg_token_count = llm.get_num_tokens_from_messages(
+            user_msg_token_count = state.chain.llm.get_num_tokens_from_messages(
                 [messages_to_send[-1]]
             )
-            total_token_count = llm.get_num_tokens_from_messages(messages_to_send)
-        while total_token_count > context_length:
+            total_token_count = state.chain.llm.get_num_tokens_from_messages(
+                messages_to_send
+            )
+        while total_token_count > state.context_length:
             LOG.warning(
                 f"Pruning memory due to total token length of {total_token_count}"
             )
@@ -256,45 +336,76 @@ async def respond(
                 memory_buffer.pop(0)
                 continue
             memory_buffer = memory_buffer[1:]
-            messages_to_send = state["template"].format_messages(
+            messages_to_send = state.chain.prompt.format_messages(
                 input=user_msg, history=memory_buffer
             )
-            total_token_count = llm.get_num_tokens_from_messages(messages_to_send)
+            total_token_count = state.chain.llm.get_num_tokens_from_messages(
+                messages_to_send
+            )
         return user_msg, memory_buffer
 
     try:
         if state is None:
-            state = set_state(metadata=dict(username=request.username))
-        llm = state["llm_state"]["llm"]
-        context_length = state["llm_state"]["context_length"]
-        tokenizer = state["llm_state"]["tokenizer"]
+            if chatbot_mode == ChatbotMode.DEBATE_PARTNER:
+                new_session = ChatSession.new(
+                    use_claude=False,
+                    system_msg=ChatSystemMessage.CASE_SYSTEM_MESSAGE,
+                    metadata=ChatSession.set_metadata(
+                        username=request.username,
+                        chatbot_mode=chatbot_mode,
+                        turns_completed=0,
+                        case=case_input,
+                    ),
+                    poll_question_name=case_input,
+                )
+            else:
+                new_session = ChatSession.new(
+                    use_claude=True,
+                    system_msg=ChatSystemMessage.RESEARCH_SYSTEM_MESSAGE,
+                    metadata=ChatSession.set_metadata(
+                        username=request.username,
+                        chatbot_mode=chatbot_mode,
+                        turns_completed=0,
+                    ),
+                    poll_question_name=None,
+                )
+            state = new_session
+        state.chain.metadata = ChatSession.set_metadata(
+            username=request.username,
+            chatbot_mode=chatbot_mode,
+            turns_completed=len(state.history) + 1,
+            case=case_input,
+        )
         LOG.info(f"""[{request.username}] STARTING CHAIN""")
-        LOG.debug(f"History: {state['history']}")
-        LOG.debug(f"User input: {inp}")
-        inp, state["memory"].chat_memory.messages = prep_messages(
-            inp, state["memory"].buffer
+        LOG.debug(f"History: {state.history}")
+        LOG.debug(f"User input: {chat_input}")
+        chat_input, state.chain.memory.chat_memory.messages = prep_messages(
+            chat_input, state.chain.memory.buffer
+        )
+        messages_to_send = state.chain.prompt.format_messages(
+            input=chat_input, history=state.chain.memory.buffer
         )
-        messages_to_send = state["template"].format_messages(
-            input=inp, history=state["memory"].buffer
+        total_token_count = state.chain.llm.get_num_tokens_from_messages(
+            messages_to_send
         )
-        total_token_count = llm.get_num_tokens_from_messages(messages_to_send)
         LOG.debug(f"Messages to send: {messages_to_send}")
-        LOG.info(f"Tokens to send: {total_token_count}")
+        LOG.debug(f"Tokens to send: {total_token_count}")
         callback = AsyncIteratorCallbackHandler()
         run_collector = RunCollectorCallbackHandler()
         run = asyncio.create_task(
-            state["chain"].apredict(
-                input=inp,
+            state.chain.apredict(
+                input=chat_input,
                 callbacks=[callback, run_collector],
             )
         )
-        state["history"].append((inp, ""))
+        state.history.append((chat_input, ""))
         run_id = None
+        langsmith_url = None
         async for tok in callback.aiter():
-            user, bot = state["history"][-1]
+            user, bot = state.history[-1]
             bot += tok
-            state["history"][-1] = (user, bot)
-            yield state["history"], state, None
+            state.history[-1] = (user, bot)
+            yield state.history, state, None
         await run
         if run_collector.traced_runs and run_id is None:
             run_id = run_collector.traced_runs[0].id
@@ -302,112 +413,133 @@ async def respond(
             if run_id:
                 run_collector.traced_runs = []
                 try:
-                    url = Client().share_run(run_id)
-                    LOG.info(f"""URL : {url}""")
-                    url_markdown = f"""[Shareable chat history link]({url})"""
+                    langsmith_url = Client().share_run(run_id)
+                    LOG.info(f"""Run ID: {run_id} \n URL : {langsmith_url}""")
+                    url_markdown = (
+                        f"""[Click to view shareable chat]({langsmith_url})"""
+                    )
                 except Exception as exc:
                     LOG.error(exc)
                     url_markdown = "Share link not currently available"
-                yield state["history"], state, url_markdown
+                if (
+                    len(state.history) > 9
+                    and chatbot_mode == ChatbotMode.DEBATE_PARTNER
+                ):
+                    url_markdown += """\n
+                    🙌 You have completed 10 exchanges with the chatbot."""
+                yield state.history, state, url_markdown
         LOG.info(f"""[{request.username}] ENDING CHAIN""")
-        LOG.debug(f"History: {state['history']}")
-        LOG.debug(f"Memory: {state['memory'].json()}")
+        LOG.debug(f"History: {state.history}")
+        LOG.debug(f"Memory: {state.chain.memory.json()}")
         data_to_flag = (
             {
-                "history": deepcopy(state["history"]),
+                "history": deepcopy(state.history),
                 "username": request.username,
                 "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
-                "session_id": state["session_id"],
+                "session_id": state.session_id,
+                "metadata": state.chain.metadata,
+                "langsmith_url": langsmith_url,
             },
         )
         LOG.debug(f"Data to flag: {data_to_flag}")
         gradio_flagger.flag(flag_data=data_to_flag, username=request.username)
     except Exception as e:
-        LOG.exception(e)
+        LOG.error(e)
         raise e
 
 
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
-HF_TOKEN = os.getenv("HF_TOKEN")
+class ChatbotConfig(BaseModel):
+    app_title: str = "CBS Technology Strategy - Fall 2023"
+    chatbot_modes: List[ChatbotMode] = [mode for mode in ChatbotMode]
+    case_options: List[str] = poll_questions.get_case_names()
+    default_case_option: str = "Netflix"
 
-theme = gr.themes.Soft()
 
-creds = [(os.getenv("CHAT_USERNAME"), os.getenv("CHAT_PASSWORD"))]
+def change_chatbot_mode(
+    state: ChatSession, chatbot_mode: str, poll_question_name: str, request: gr.Request
+) -> Tuple[Any, ChatSession]:
+    """Returns a function that sets the visibility of the case input field and the state"""
+    if state is None:
+        if chatbot_mode == ChatbotMode.DEBATE_PARTNER:
+            new_session = ChatSession.new(
+                use_claude=False,
+                system_msg=ChatSystemMessage.CASE_SYSTEM_MESSAGE,
+                metadata=dict(username=request.username),
+                poll_question_name=case_input,
+            )
+        else:
+            new_session = ChatSession.new(
+                use_claude=True,
+                system_msg=ChatSystemMessage.RESEARCH_SYSTEM_MESSAGE,
+                metadata=dict(username=request.username),
+                poll_question_name=None,
+            )
+        state = new_session
+    if chatbot_mode == ChatbotMode.DEBATE_PARTNER:
+        state.set_chatbot_mode(case_mode=True, poll_question_name=poll_question_name)
+        state.clear_memory()
+        return gr.update(visible=True), state
+    elif chatbot_mode == ChatbotMode.RESEARCH_ASSISTANT:
+        state.set_chatbot_mode(case_mode=False)
+        state.clear_memory()
+        return gr.update(visible=False), state
+    else:
+        raise ValueError("chatbot_mode is not correctly set")
 
-gradio_flagger = gr.HuggingFaceDatasetSaver(HF_TOKEN, "chats")
-title = "CBS Technology Strategy - Fall 2023"
-image_url = ""
+
+config = ChatbotConfig()
 with gr.Blocks(
     theme=theme,
     analytics_enabled=False,
-    title=title,
+    title=config.app_title,
 ) as demo:
     state = gr.State()
-    gr.Markdown(f"""### {title}""")
+    gr.Markdown(f"""### {config.app_title}""")
     with gr.Tab("Chatbot"):
-        chatbot_mode = gr.Radio(
-            label="Mode",
-            choices=["Debate Partner", "Research Assistant"],
-            value="Debate Partner",
-        )
-        case_input = gr.Dropdown(
-            label="Case",
-            choices=CASES.keys(),
-            value="Netflix",
-            multiselect=False,
-        )
+        with gr.Row():
+            chatbot_mode = gr.Radio(
+                label="Mode",
+                choices=config.chatbot_modes,
+                value=ChatbotMode.DEFAULT,
+            )
+            case_input = gr.Dropdown(
+                label="Case",
+                choices=config.case_options,
+                value=config.default_case_option,
+                multiselect=False,
+            )
         chatbot = gr.Chatbot(label="ChatBot")
         with gr.Row():
             input_message = gr.Textbox(
                 placeholder="Send a message.",
-                label="Type an input and press Enter",
+                label="Type a message to begin",
                 scale=5,
             )
-            b1 = gr.Button(value="Submit")
-        share_link = gr.Markdown()
-        llm_input = gr.Dropdown(
-            label="LLM",
-            choices=["Claude 2", "GPT-4"],
-            value="GPT-4",
-            multiselect=False,
-            visible=False,
-        )
-        system_prompt_input = gr.TextArea(
-            label="System Prompt", value=CASE_SYSTEM_MESSAGE, lines=10, visible=False
-        )
-        update_system_button = gr.Button(value="Update Prompt & Reset", visible=False)
-        status_markdown = gr.Markdown(visible=False)
+            chat_submit_button = gr.Button(value="Submit")
+        status_message = gr.Markdown()
         gradio_flagger.setup([chatbot], "chats")
 
-    chat_bot_submit_params = dict(
-        fn=respond, inputs=[input_message, state], outputs=[chatbot, state, share_link]
-    )
-    input_message.submit(**chat_bot_submit_params)
-    b1.click(**chat_bot_submit_params)
-    chatbot_mode.change(
-        update_system_prompt_mode,
-        [chatbot_mode],
-        [state, case_input],
+    chatbot_submit_params = dict(
+        fn=respond,
+        inputs=[input_message, chatbot_mode, case_input, state],
+        outputs=[chatbot, state, status_message],
     )
-    update_system_button.click(
-        update_system_prompt,
-        [case_input, system_prompt_input, llm_input],
-        [status_markdown, state],
+    input_message.submit(**chatbot_submit_params)
+    chat_submit_button.click(**chatbot_submit_params)
+    chatbot_mode_params = dict(
+        fn=change_chatbot_mode,
+        inputs=[state, chatbot_mode, case_input],
+        outputs=[case_input, state],
     )
-    case_input.change(
-        update_system_prompt,
-        [case_input, system_prompt_input, llm_input],
-        [status_markdown, state],
+    chatbot_mode.change(**chatbot_mode_params)
+    case_input.change(**chatbot_mode_params)
+    clear_chatbot_messages_params = dict(
+        fn=reset_textbox, inputs=[], outputs=[input_message, chatbot, status_message]
     )
-    chatbot_mode.change(reset_textbox, [], [input_message])
-    chatbot_mode.change(reset_textbox, [], [chatbot])
-    update_system_button.click(reset_textbox, [], [input_message])
-    update_system_button.click(reset_textbox, [], [chatbot])
-    case_input.change(reset_textbox, [], [input_message])
-    case_input.change(reset_textbox, [], [chatbot])
-    b1.click(reset_textbox, [], [input_message])
-    input_message.submit(reset_textbox, [], [input_message])
+    chatbot_mode.change(**clear_chatbot_messages_params)
+    case_input.change(**clear_chatbot_messages_params)
+    chat_submit_button.click(**clear_chatbot_messages_params)
+    input_message.submit(**clear_chatbot_messages_params)
 
 demo.queue(max_size=99, concurrency_count=99, api_open=False).launch(
     debug=True, auth=auth