OpenAI chatbot

app.py

@@ -1,16 +0,0 @@
-from openai import OpenAI
-
-client = OpenAI()
-
-if __name__ == '__main__':
-    completion = client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=[
-            {"role": "system",
-             "content":
-                 "You are a stoic assistant, skilled answers every question with a flare of philosophy on life and death."},
-            {"role": "user", "content": "What is python and what it is used for?"}
-        ]
-    )
-
-    print(completion.choices[0].message)

bot.py

@@ -0,0 +1,24 @@
+import os.path
+import pathlib
+from pathlib import Path
+
+from openai import OpenAI
+
+from scripts.components import OpenAIBot
+from scripts.io.terminal import TerminalIO
+
+exit_codes = ["done", "quit", "exit"]
+
+client = OpenAI()
+prompt = pathlib.Path(__file__).parent.resolve() / "system_prompts" / "financial_bot.txt"
+input_output = TerminalIO("User: ", "Agent: ")
+
+openai_bot = OpenAIBot(client, "gpt-4o-mini", prompt, 10, input_output,
+                       exit_codes=exit_codes)
+
+if __name__ == '__main__':
+    openai_bot.start()
+    while openai_bot.interact():
+        pass
+
+

commons/utils.py

@@ -0,0 +1,5 @@
+
+
+def getdefault(data: dict, key, default):
+    return default if not data.__contains__(key) else data[key]
+

scripts/components.py

@@ -0,0 +1,100 @@
+from enum import Enum
+from os import PathLike
+
+from openai import OpenAI
+
+from commons.utils import getdefault
+from scripts.io import InputOutput
+
+
+DEFAULT_WELCOME_MESSAGE = "How can I assist you ..."
+DEFAULT_USER_PROMPT = "User: "
+DEFAULT_AGENT_PROMPT = "Agent: "
+DEFAULT_EXIT_MESSAGE = "Have a nice day!"
+
+
+class Role(Enum):
+    SYSTEM = "system"
+    USER = "user"
+    ASSISTANT = "assistant"
+
+
+class ChatHistory:
+    def __init__(self, context_span: int, initial_context: list[dict[str, str]]):
+        self.__context_span = context_span
+        self.__context = list()
+        for context in initial_context:
+            self.__add_context(context)
+
+    def __ensure_max_size(self):
+        while len(self.__context) > self.__context_span:
+            self.__context.pop(1)
+        return self
+
+    def __add_context(self, context: dict[str, str]) -> "ChatHistory":
+        self.__context.append(context)
+        return self.__ensure_max_size()
+
+    def add_message(self, role: Role, content: str) -> "ChatHistory":
+        return self.__add_context({"role": role.value, "content": content})
+
+    def get_whole_context(self) -> list[dict[str, str]]:
+        return self.__ensure_max_size().__context.copy()
+
+    def get_chat_history(self) -> list[dict[str, str]]:
+        return self.get_whole_context()[0:]
+
+    def get_context_size(self) -> int:
+        return len(self.__ensure_max_size().__context)
+
+    def last_in_history(self):
+        return self.__context[-1]
+
+    def reset(self) -> "ChatHistory":
+        self.__context.clear()
+        return self
+
+
+class OpenAIBot:
+    def __init__(self, bot: OpenAI, model: str, prompt: PathLike | str, context_span: int, io: InputOutput, **args):
+        self.__bot = bot
+        self.__model = model
+        final_prompt = prompt
+        if isinstance(prompt, PathLike):
+            with open(prompt, "r") as pf:
+                final_prompt = pf.read()
+        self.__history = ChatHistory(context_span=context_span,
+                                     initial_context=[{"role": Role.SYSTEM.value, "content": final_prompt}])
+        self.io = io
+
+        self.__welcome_message: str = getdefault(args, "welcome_message", DEFAULT_WELCOME_MESSAGE)
+        self.__exit_codes: list = getdefault(args, "exit_codes", list())
+        self.__exit_message: str = getdefault(args, "exit_message", DEFAULT_EXIT_MESSAGE)
+
+    def __is_exit(self, message: str) -> bool:
+        return message.lower() in self.__exit_codes
+
+    def start(self):
+        self.io.output(self.__welcome_message)
+
+    def interact(self) -> bool:
+        user_input = self.io.input()
+
+        if self.__is_exit(user_input):
+            self.io.output(self.__exit_message)
+            return False
+
+        if user_input:
+            messages = self.__history.add_message(Role.USER, user_input).get_whole_context()
+
+            chat = self.__bot.chat.completions.create(model=self.__model, messages=messages)
+            print(f"Tokens count, prompts: {chat.usage.prompt_tokens}, completion: {chat.usage.completion_tokens}, "
+                  f"total: {chat.usage.total_tokens}")
+            # del messages
+
+            reply = chat.choices[0].message.content
+            self.io.output(reply)
+            self.__history.add_message(Role.ASSISTANT, reply)
+
+        return True
+

scripts/io/__init__.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+
+class InputOutput(ABC):
+
+    @abstractmethod
+    def input(self) -> str:
+        ...
+
+    @abstractmethod
+    def output(self, message: str):
+        ...

scripts/io/terminal.py

@@ -0,0 +1,15 @@
+from scripts.io import InputOutput
+
+
+class TerminalIO(InputOutput):
+
+    def __init__(self, input_prompt: str, output_prompt: str):
+        self.__input_prompt = input_prompt
+        self.__output_prompt = output_prompt
+
+    def input(self) -> str:
+        return input(self.__input_prompt)
+
+    def output(self, message: str):
+        print(f"{self.__output_prompt} {message}")
+

system_prompts/financial_bot.txt

@@ -0,0 +1,12 @@
+You are a professional financial advisor agent who helps people with financial questions. Although your scope of knowledge is vast,
+you are allowed to answer questions only related to money, market, how money flows, related terminologies and info that can help someone in this sector. That is only topic you can talk about and discuss, nothing more.
+Keep in mind if someone asks anything other than above-mentioned topics you can entertain for sort time, but try to remain inside you scope of topics mentioned above. To get back to the scope of your above-mentioned knowledge, convey that your objective is to help in the above-mentioned fields. Make sure that conversation should not derail from the above-mentioned topics for too long.
+Few of the responses in case user's question are diverting from the above-mentioned topics are:
+1. I would not be the right bot to help you with this. Can I help you with any question related to money?
+2. I'm not the best source for that topic, but I'm here to help with anything related to finance or money. How can I assist you in that area?
+3. It sounds interesting, but my expertise is in money and markets. Do you have any financial questions I can help with?
+4. I’m better suited for finance and money matters. Can I answer something related to that for you?
+5. That's a fascinating topic, but my knowledge revolves around the flow of money and markets. How can I help you in that space?
+6. Unfortunately, that's beyond my scope. I'd be happy to assist with anything related to finance. Any money-related questions?
+Your tone should be professional, calm and of a person with a kind demeanour. Your answers should be to-the-point and simple in language so that even a high school user can understand what you are saying. As a rule of thumb wordcount of your answer should not exceed a soft limit of 100 and hard limit of 200.
+In short, you act as a call center personnel who is professional, to the point, has all-rounder knowledge in above-mentioned topics, but is also kind and empathetic.