Duplicate from johnnyclee/chatgpt_clone

Co-authored-by: Johnny Lee <[email protected]>

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+chats/*

.pre-commit-config.yaml

@@ -0,0 +1,34 @@
+default_language_version:
+  node: system
+  python: python3.8
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: debug-statements
+      - id: end-of-file-fixer
+        exclude: "^.*.crt|^.*.json|^.*.svg|^.*.txt"
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace
+      # - id: pretty-format-json
+      #   args: [--autofix]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.0.282
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+
+  - repo: https://github.com/psf/black
+    rev: 23.7.0
+    # TODO: ensure that the black version is aligned, with another hook?
+    hooks:
+      - id: black
+        language: python
+        types: [python]
+
+  - repo: meta
+    hooks:
+      - id: check-useless-excludes
+      - id: check-hooks-apply

.python-version

@@ -0,0 +1 @@
+chatgpt-clone

README.md

@@ -0,0 +1,11 @@
+---
+title: Chatgpt Clone
+emoji: 🏆
+colorFrom: gray
+colorTo: yellow
+sdk: gradio
+app_file: app.py
+pinned: false
+license: cc
+duplicated_from: johnnyclee/chatgpt_clone
+---

app.py

@@ -0,0 +1,598 @@
+# ruff: noqa: E501
+from __future__ import annotations
+import asyncio
+import datetime
+import pytz
+import logging
+import os
+from enum import Enum
+import json
+import uuid
+from pydantic import BaseModel
+import gspread
+
+from copy import deepcopy
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import gradio as gr
+import tiktoken
+
+# from dotenv import load_dotenv
+
+# load_dotenv()
+
+from langchain.callbacks.streaming_aiter import AsyncIteratorCallbackHandler
+from langchain.callbacks.tracers.run_collector import RunCollectorCallbackHandler
+from langchain.chains import ConversationChain
+from langsmith import Client
+from langchain.chat_models import ChatAnthropic, ChatOpenAI
+from langchain.memory import ConversationTokenBufferMemory
+from langchain.prompts.chat import (
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    MessagesPlaceholder,
+    SystemMessagePromptTemplate,
+)
+from langchain.schema import BaseMessage
+
+
+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
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+HF_TOKEN = os.getenv("HF_TOKEN")
+GS_CREDS = json.loads(rf"""{os.getenv("GSPREAD_SERVICE")}""")
+GSHEET_ID = os.getenv("GSHEET_ID")
+AUTH_GSHEET_NAME = os.getenv("AUTH_GSHEET_NAME")
+TURNS_GSHEET_NAME = os.getenv("TURNS_GSHEET_NAME")
+
+theme = gr.themes.Soft()
+
+creds = [(os.getenv("CHAT_USERNAME"), os.getenv("CHAT_PASSWORD"))]
+
+gradio_flagger = gr.HuggingFaceDatasetSaver(
+    hf_token=HF_TOKEN, dataset_name="chats", separate_dirs=True
+)
+
+
+def get_gsheet_rows(
+    sheet_id: str, sheet_name: str, creds: Dict[str, str]
+) -> List[Dict[str, str]]:
+    gc = gspread.service_account_from_dict(creds)
+    worksheet = gc.open_by_key(sheet_id).worksheet(sheet_name)
+    rows = worksheet.get_all_records()
+    return rows
+
+
+def append_gsheet_rows(
+    sheet_id: str,
+    rows: List[List[str]],
+    sheet_name: str,
+    creds: Dict[str, str],
+) -> None:
+    gc = gspread.service_account_from_dict(creds)
+    worksheet = gc.open_by_key(sheet_id).worksheet(sheet_name)
+    worksheet.append_rows(values=rows, insert_data_option="INSERT_ROWS")
+
+
+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.
+    """
+
+    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.
+
+    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=""), gr.update(value=""), gr.update(value="")
+
+
+def auth(username, password):
+    try:
+        auth_records = get_gsheet_rows(
+            sheet_id=GSHEET_ID, sheet_name=AUTH_GSHEET_NAME, creds=GS_CREDS
+        )
+        auth_dict = {user["username"]: user["password"] for user in auth_records}
+        search_auth_user = auth_dict.get(username)
+        if search_auth_user:
+            autheticated = search_auth_user == password
+            if autheticated:
+                LOG.info(f"{username} successfully logged in.")
+                return autheticated
+        else:
+            LOG.info(f"{username} failed to login.")
+            return False
+
+    except Exception as exc:
+        LOG.info(f"{username} failed to login")
+        LOG.error(exc)
+    return (username, password) in creds
+
+
+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,
+        )
+        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),
+            ]
+        )
+
+    @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
+            )
+
+    @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=context_length, return_messages=True
+        )
+        template = cls._make_template(
+            system_msg=system_msg, poll_question_name=poll_question_name
+        )
+        chain = ConversationChain(
+            memory=memory,
+            prompt=template,
+            llm=llm,
+            metadata=metadata,
+        )
+        return cls(
+            context_length=context_length,
+            tokenizer=tokenizer,
+            chain=chain,
+        )
+
+
+async def respond(
+    chat_input: str,
+    chatbot_mode: str,
+    case_input: str,
+    state: ChatSession,
+    request: gr.Request,
+) -> 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.chain.prompt.format_messages(
+            input=user_msg, history=memory_buffer
+        )
+        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 = state.tokenizer.decode(
+                state.chain.llm.get_token_ids(user_msg)[: state.context_length - 100]
+            )
+            messages_to_send = state.chain.prompt.format_messages(
+                input=user_msg, history=memory_buffer
+            )
+            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 total_token_count > state.context_length:
+            LOG.warning(
+                f"Pruning memory due to total token length of {total_token_count}"
+            )
+            if len(memory_buffer) == 1:
+                memory_buffer.pop(0)
+                continue
+            memory_buffer = memory_buffer[1:]
+            messages_to_send = state.chain.prompt.format_messages(
+                input=user_msg, history=memory_buffer
+            )
+            total_token_count = state.chain.llm.get_num_tokens_from_messages(
+                messages_to_send
+            )
+        return user_msg, memory_buffer
+
+    try:
+        if state is None:
+            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: {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
+        )
+        total_token_count = state.chain.llm.get_num_tokens_from_messages(
+            messages_to_send
+        )
+        LOG.debug(f"Messages to send: {messages_to_send}")
+        LOG.debug(f"Tokens to send: {total_token_count}")
+        callback = AsyncIteratorCallbackHandler()
+        run_collector = RunCollectorCallbackHandler()
+        run = asyncio.create_task(
+            state.chain.apredict(
+                input=chat_input,
+                callbacks=[callback, run_collector],
+            )
+        )
+        state.history.append((chat_input, ""))
+        run_id = None
+        langsmith_url = None
+        async for tok in callback.aiter():
+            user, bot = state.history[-1]
+            bot += tok
+            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
+            LOG.info(f"RUNID: {run_id}")
+            if run_id:
+                run_collector.traced_runs = []
+                try:
+                    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"
+                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.chain.memory.json()}")
+        current_timestamp = datetime.datetime.now(pytz.timezone("US/Eastern")).replace(
+            tzinfo=None
+        )
+        timestamp_string = current_timestamp.strftime("%Y-%m-%d %H:%M:%S")
+        data_to_flag = (
+            {
+                "history": deepcopy(state.history),
+                "username": request.username,
+                "timestamp": timestamp_string,
+                "session_id": state.session_id,
+                "metadata": state.chain.metadata,
+                "langsmith_url": langsmith_url,
+            },
+        )
+        gradio_flagger.flag(flag_data=data_to_flag, username=request.username)
+        (flagged_data,) = data_to_flag
+        metadata_to_gsheet = flagged_data.get("metadata").values()
+        gsheet_row = [[timestamp_string, *metadata_to_gsheet, langsmith_url]]
+        LOG.info(f"Data to GSHEET: {gsheet_row}")
+        append_gsheet_rows(
+            sheet_id=GSHEET_ID,
+            sheet_name=TURNS_GSHEET_NAME,
+            rows=gsheet_row,
+            creds=GS_CREDS,
+        )
+    except Exception as e:
+        LOG.error(e)
+        raise e
+
+
+class ChatbotConfig(BaseModel):
+    app_title: str = "CBS Technology Strategy - Fall 2023"
+    chatbot_modes: List[ChatbotMode] = [mode.value for mode in ChatbotMode]
+    case_options: List[str] = poll_questions.get_case_names()
+    default_case_option: str = "Netflix"
+
+
+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=ChatSession.set_metadata(
+                    username=request.username,
+                    chatbot_mode=chatbot_mode,
+                    turns_completed=0,
+                    case=poll_question_name,
+                ),
+                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
+    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")
+
+
+config = ChatbotConfig()
+with gr.Blocks(
+    theme=theme,
+    analytics_enabled=False,
+    title=config.app_title,
+) as demo:
+    state = gr.State()
+    gr.Markdown(f"""### {config.app_title}""")
+    with gr.Tab("Chatbot"):
+        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", show_share_button=False)
+        with gr.Row():
+            input_message = gr.Textbox(
+                placeholder="Send a message.",
+                label="Type a message to begin",
+                scale=5,
+            )
+            chat_submit_button = gr.Button(value="Submit")
+        status_message = gr.Markdown()
+        gradio_flagger.setup([chatbot], "chats")
+
+    chatbot_submit_params = dict(
+        fn=respond,
+        inputs=[input_message, chatbot_mode, case_input, state],
+        outputs=[chatbot, state, status_message],
+    )
+    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],
+    )
+    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(**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
+)

requirements.txt

@@ -0,0 +1,7 @@
+anthropic==0.3.7
+gradio==3.39.0
+gspread==5.10.0
+langchain==0.0.265
+openai==0.27.8
+pytz==2023.3
+tiktoken==0.4.0

templates.json

@@ -0,0 +1,62 @@
+[
+    {
+        "name": "Rivian",
+        "template": "Rivian secure supply for their EV batteries primarily through which of the following options?\n1. Buying from multiple battery suppliers\n2. Partnering with a battery supplier (Joint Venture, for example)\n3. Developing in-house manufacturing capabilities"
+    },
+    {
+        "name": "LEGO",
+        "template": "How should LEGO protect its plastic molding manufacturing platform?\n1. Patent\n2. Trade Secret\n3. Publish"
+    },
+    {
+        "name": "Netflix",
+        "template": "Going forward, what should Netflix prioritize in its content strategy?\n1. Invest more in original content than third-party licensing\n2. Balance between original content and third-party licensing\n3. Invest more in third-party licensing than original content"
+    },
+    {
+        "name": "LinkedIn",
+        "template": "Is it wise for LinkedIn to invest more in developing its LinkedIn Learning platform?\n1. Yes, definitely\n2. Yes, but it should not be core to LinkedIn\n3. No, but I wouldn't kill it\n4. No, I would either stop investing or outsource/partner"
+    },
+    {
+        "name": "Uber",
+        "template": "Are there reasonable platform synergies between Uber's ridesharing business (e.g., UberX and UberX Share) and food/grocery delivery business (e.g., Uber Eats)?\n1. Yes, definitely\n2. Yes, but mainly because the success of one side can subsidize the other\n3. Somewhat, because there is a limit\n4. Probably not"
+    },
+    {
+        "name": "DigitalOcean",
+        "template": "Should Digital Ocean dedicate resources towards 1) gaining more market share among small businesses, or 2) getting existing customers to spend more?\n1. Market share\n2. Higher spend"
+    },
+    {
+        "name": "Alphabet",
+        "template": "Given competition from Amazon, TikTok, and new technologies like Generative AI, how important will search be as a core part of Google's platform business going forward?\n1. Still very important\n2. Gradually become less important\n3. Quickly become less important"
+    },
+    {
+        "name": "Twitch",
+        "template": "Currently, Twitch uses a mix of admins (Twitch employees and contractors) and volunteer moderators who are also members of specific Twitch channel communities to address content moderation. Which side should get priority in evaluating instances of content policy violations if their recommendations are in conflict?\n1. Twitch admins\n2. Channel volunteer moderators\n3. It depends\n4. I have a different idea"
+    },
+    {
+        "name": "Kakao",
+        "template": "How do you think Kakao should approach the expansion of its platform?\n1. Prioritize expanding into other culturally similar Asian markets\n2. Prioritize expanding into new verticals within Korea (such as enterprise software)\n3. Prioritize testing markets beyond Asia\n4. I have another idea"
+    },
+    {
+        "name": "StitchFix",
+        "template": "Is Generative AI (i.e., AI tools like ChatGPT that can develop novel insights and ideas rather than simply engaging in pattern recognition) more of a threat, a complement, or neither with respect to Stitch Fix's core business operations?\n1. More of a Threat\n2. More of a Complement\n3. Neither"
+    },
+    {
+        "name": "Hubspot",
+        "template": "In which phases of the sales funnel would chatbots do better than human representatives?\n1. Top of Funnel\n2. Middle of the Funnel\n3. Bottom of the Funnel\nIn implementing a chatbot, should it disclose to a customer that they are chatting with a bot?\n1. Yes, almost always\n2. It depends on the circumstances\n3. No, almost never"
+    },
+    {
+        "name": "Mastercard",
+        "template": "To effectively build an 'AI Powerhouse', would you recommend MasterCard creating a central AI team (Centralized AI), or staff AI experts within each business unit (Decentralized AI)?\n1. Centralized AI\n2. Decentralized AI\n3. I have a different idea"
+    },
+    {
+        "name": "Autonomous Vehicles",
+        "template": "Suppose you are a general partner of a VC/PE firm that has a fund set aside for futurist and frontier technologies. Within the autonomous vehicles space, which of the following rivals discussed in the case would you invest in?\n1. Tesla\n2. GM and Cruise\n3. Waymo\n4. Motional\nWhen it comes to programming decision rules for ethical dilemmas that Autonomous Vehicles will encounter (like the Trolley Problem described in the case), which stakeholder's opinion should matter the most?\n1. Social Scientists (e.g., professors of philosophy, sociology, etc.)\n2. Technology Specialists (e.g., engineers)\n3. Policy-makers and regulators (e.g., government agencies)\n4. The general public (e.g., by popular vote)\n5. The owner (e.g., shareholders) and managers of AV car companies"
+    },
+    {
+        "name": "Apple Privacy",
+        "template": "Apple claims that its vertical integration and emphasis on privacy raises WTP for consumers which makes up for the potential revenues it could earn by making its data on users available to partners, such as app-makers. Do you think Apple should maintain its strict data privacy policy and strategy?\n1. Yes, unconditionally.\n2. It depends on the partner and case.\n3. No, Apple should be more open to sharing user data."
+    },
+    {
+        "name": "Meta",
+        "template": "Does Meta have a responsibility to inform their users when conducting experiments or A/B tests on Facebook, Instagram, or any of its other platforms in a more explicit way? (i.e., other than offering a blanket statement in the user agreement during registration)\n1. Yes.\n2. No.\n3. It depends."
+    }
+]