4172637469634d6f6e6b6579733a33302e30372e3234

.gitignore

@@ -0,0 +1,2 @@
+**/__pycache__
+.history/

.streamlit/config.toml

@@ -1,2 +1,2 @@
 [theme]
-backgroundColor = "black"
+backgroundColor = "#363534"

app.py

@@ -1,59 +1,120 @@
-# version - ArcticMonkey:19.03.24:1743
+# version - ArcticMonkeys:30.07.24
 
 # python core libraries
-import os 
-
 import psutil
-
+# streamlit
+import streamlit as st
 # components from other authors
 from streamlit_mic_recorder import mic_recorder
-
 # core modules
 from audio_processing.A2T import A2T
 from audio_processing.T2A import T2A
-from command.utils import build_chain
-from llm.llm_factory import LLM_Factory
-
-
-# Можна редагувати аби не повтрювалось
-greeting_text = "Hi, my name is M8... oops, that's from my future, but right now I'm Chelsea, your personal voice assistant. Ask me anything you want and I'll try to help you."
-
-llm_model = LLM_Factory()
-
-def prepare_cor(input_text: str):
-    return build_chain.build_command_chain().handle_command(input_text)
-
-# Базово буде hf, а далі виходячи з завдання буде змінюватися.
-# Від можливості використовувати AI agent також буде залежати trigger, якщо використовується, то ліпше використовувати lc ніж hf.
-trigger = {"hf": "effective"}
-
+from llm.utils.chat import Conversation
+# utils modules
+from utils.keywords import keywords
+from utils.prompt_toggle import select_prompt, load_prompts
+from utils.documentation import Documentation
+
+# TODO: 
+#     * Зробити в utils можливість для використання різних промптів -> Done
+#     * Додати як робив на HF хто на  фото -> agent
+#     * Додати можливіть малюнками вирішувати мат проблеми -> agent
+#     * Додати моливість створювати/редагувати докменти(pdf, docx) -> agent 
+
+prompts = load_prompts()
+doc = Documentation()
+chat = Conversation()
 t2a = T2A()
 
 def main():
-    t2a.autoplay(greeting_text, just_once=True)
-    
-    mic = mic_recorder(start_prompt="Record", stop_prompt="Stop", just_once=True)
-
-    if mic is not None:
-        a2t = A2T(mic["bytes"])
-        text = a2t.predict()
-        print(text)
-
-        # Придумати як реалізувати команди
-        # prepare_cor(input_text=text)
-
-        # Треба для lc реалізувати буде виклик очишення
-        llm = llm_model.create_llm(prompt_entity=text, prompt_id=1, trigger=trigger)
-        response = llm.execution() if llm is not None else "Oops occurred some error. Please try again. Who is Jhon Galt!"
-
-        # Треба буде переписати клас, передавати текст не через __init__ а в autoplay.
-        t2a.autoplay(response)
-
+    try:
+        mic = mic_recorder(start_prompt="Record", stop_prompt="Stop", just_once=True, use_container_width=True)
+        if mic is not None:
+            a2t = A2T(mic["bytes"])
+            text = a2t.predict()
+            print(f"Text: {text}")
+
+            prompt = select_prompt(input_text=text, prompts=prompts, keywords=keywords)
+            print(f"Prompt:\n{prompt}")
+            response = chat.chatting(prompt=prompt if prompt is not None else text)
+            t2a.autoplay(response)
+
+            if response:
+                st.markdown(f"Your input: {prompt}")
+                st.markdown(f"Chelsea response: {response}")
+
+            prompt = None
+            response = None
+    except Exception as e:
+        print(f"An error occurred in main finction, reasone is: {e}")
+        doc.execution()
 
 if __name__ == "__main__":
     print(f"Total Memory: {psutil.virtual_memory().total / (1024**3):.2f} GB")
     print(f"Available Memory: {psutil.virtual_memory().available / (1024**3):.2f} GB")
     print(f"CPU Cores: {psutil.cpu_count()}")
     print(f"CPU Usage: {psutil.cpu_percent()}%")
-    
     main()
+    footer="""
+        <style>
+            /* Common styles for the footer */
+            .footer {
+                position: fixed;
+                left: 0;
+                bottom: 0;
+                width: 100%;
+                height: 60px; /* Set a fixed height for consistency */
+                font-size: 14px; /* Adjust font size for readability */
+                text-align: center;
+                padding: 15px 0; /* Reduced padding */
+                transition: color 0.3s, background-color 0.3s;
+            }
+        
+            .footer p {
+                margin: 0; /* Remove default margins */
+                font-size: 18px; /* Adjust font size as needed */
+            }
+        
+            a:link, a:visited {
+                text-decoration: dotted;
+                color: inherit; /* Use current text color */
+            }
+        
+            a:hover, a:active {
+                background: linear-gradient(to right, #ffe44d, #ffdd1a, #ffd700, #ffd900);
+                -webkit-text-fill-color: transparent;
+                -webkit-background-clip: text;
+            }
+        
+            .footer a:hover {
+                color: #ff4500; /* Different hover color */
+            }
+        
+            /* Light mode styles */
+            @media (prefers-color-scheme: light) { 
+                a:link, a:visited {
+                    color: #0056b3; /* Blue color for links */
+                }
+        
+                .footer a:hover {
+                    color: #ff4500; /* Hover color for light mode */
+                }
+            }
+        
+            /* Dark mode styles */
+            @media (prefers-color-scheme: dark) {        
+                a:link, a:visited {
+                    color: #ffd700; /* Gold color for links in dark mode */
+                }
+        
+                .footer a:hover {
+                    color: #ffa500; /* Hover color for dark mode */
+                }
+            }
+        </style>
+        
+        <div class="footer">
+            <p>Please support the project on <a href="https://buymeacoffee.com/cineai" target="_blank">Buy Me a Coffee</a></p>
+        </div>
+        """
+    st.markdown(footer,unsafe_allow_html=True)

audio_processing/A2T.py

@@ -1,6 +1,6 @@
-import numpy as np
-import librosa
 import io
+import librosa
+import numpy as np
 
 from typing import Optional
 
@@ -15,7 +15,7 @@ class A2T:
 
     def __generate_text(self, inputs, task: Optional[str] = None) -> str:
         if inputs is None:
-            raise Exception("Inputs is None")
+            raise ValueError(f"Input audio is None {inputs}, please provide audio")
 
         transcribed_text = pipe(inputs, batch_size=BATCH_SIZE, generate_kwargs={"task": task}, return_timestamps=True)["text"]
         return transcribed_text
@@ -34,7 +34,7 @@ class A2T:
             print(f"Sample rate : {sample_rate}")
             return audio
         except Exception as e:
-            print(f"Error loading audio: {e}")
+            print(f"Error loading audio in the preprocess function in the A2T class: {e}")
  
     def predict(self) -> str:
         try:
@@ -43,7 +43,7 @@ class A2T:
                 audio = self.__preprocess(raw=raw)
                 print(f"audio type : {type(audio)} \n shape : {audio.shape} \n audio max value : {np.max(audio)}")
             else:
-                raise Exception("please provide audio")
+                raise ValueError(f"Please provide audio your audio {self.mic}")
 
             if isinstance(audio, np.ndarray):
                 return self.__generate_text(inputs=audio, task=TASK)
@@ -51,4 +51,4 @@ class A2T:
                 raise ValueError("Audio is not np array")
                 
         except Exception as e:
-            print(f"Oops some kinda error : {e}")
+            print(f"An error occurred in the predict function in the A2T class: {e}")

audio_processing/T2A.py

@@ -3,27 +3,24 @@ from streamlit_TTS import auto_play, text_to_audio
 
 
 class T2A:
-    def autoplay(self, input_text: Optional[str] = None, lang: str = "en", just_once: bool = True) -> None:
+    def autoplay(self, input_text: Optional[str] = None, lang: str = "en") -> None:
         """
-        Plays audio once based on the provided input text.
+        Plays audio based on the provided input text.
     
         Args:
             input_text (Optional[str], optional): Text to convert to audio. Defaults to None.
             lang (str, optional): Language for text-to-speech conversion. Defaults to "en".
-            just_once (bool, optional): Flag to control whether audio plays only once. Defaults to False.
         """
         
-        if input_text is not None:
-            if isinstance(input_text, str):
-                audio = text_to_audio(input_text, language=lang)
-                if just_once:
-                    auto_play(audio)
-                    just_once = False
-            else: 
-                text = f"The text you provided is of data type {type(input_text)}, only string type is accepted"
-                audio = text_to_audio(text, language=lang)
-                auto_play(audio)
-        else:
+        if input_text is None:
             text = "Please check the input text you have provided, it has a value of None"
             audio = text_to_audio(text, language=lang)
             auto_play(audio)
+        
+        if not isinstance(input_text, str):
+            text = f"The text you provided is of data type {type(input_text)}, only string type is accepted"
+            audio = text_to_audio(text, language=lang)
+            auto_play(audio)
+
+        audio = text_to_audio(input_text, language=lang)
+        auto_play(audio)

audio_processing/config.py

@@ -2,10 +2,8 @@
 # https://magictool.ai/tool/text-to-hex-converter/ Here ArcticMonkey is name of version and rest of all is data and time
 
 import torch
-
 from transformers import pipeline
 
-
 device = 0 if torch.cuda.is_available() else "cpu"
 
 checkpoint_whisper = "openai/whisper-medium"
@@ -15,20 +13,4 @@ pipe = pipeline(
     model=checkpoint_whisper,
     device=device,
     chunk_length_s=30, 
-)
-
-# from parler_tts import ParlerTTSForConditionalGeneration
-# from transformers import AutoTokenizer, AutoFeatureExtractor
-
-# checkpoint_parler = "parler-tts/parler_tts_mini_v0.1"
-
-# model_parler = ParlerTTSForConditionalGeneration.from_pretrained(checkpoint_parler).to(device)
-# tokenizer = AutoTokenizer.from_pretrained(checkpoint_parler)
-# feature_extractor = AutoFeatureExtractor.from_pretrained(checkpoint_parler)
-
-# SAMPLE_RATE = feature_extractor.sampling_rate
-# SEED = 42
-
-# checkpoint_mms_tts_eng = "facebook/mms-tts-eng"
-
-# pipe_tts = pipeline("text-to-speech", model=checkpoint_mms_tts_eng)
+)

command/basic/basic_commands.py

@@ -1,37 +0,0 @@
-import os
-import logging
-
-import streamlit as st
-
-from typing import Optional, Dict, Any
-from ..command_interface import CommandInterface
-
-
-class Documentation(CommandInterface):
-    def __init__(self, 
-                 command_file: str, 
-                 commands: Optional[str], 
-                 llm: Any, 
-                 id: int):
-        
-        self.command_file = command_file
-
-        if commands is not None:
-            self.commands = commands
-        else:
-            self.commands = []
-
-        self.llm = llm
-        
-        self.id = id
-
-    def get_command() -> Dict[str, Dict[str, list]]:
-        
-        pass
-
-    def is_contains(commands: Optional[str], llm: Any, id: Any, command: Dict[str, Dict[str, list]]) -> bool:
-        
-        pass
-        
-    def execute() -> Any:
-        pass    

command/command_interface.py

@@ -1,20 +0,0 @@
-from typing import Optional, Dict, Any
-from abc import ABC, abstractmethod
-
-
-class CommandHandler(ABC):
-    # {"base": {"name": command}, "advance": {"name": command}}
-    @abstractmethod
-    def get_command() -> Dict[str, Dict[str, list]]:
-        "Method to get command from yaml file and return dictionary"
-        pass
-
-    @abstractmethod
-    def is_contains() -> bool:
-        """Method to check contains command in text or not"""
-        pass
-        
-    @abstractmethod
-    def execute() -> Any:
-        "Method to execute command"
-        pass

command/commands.yaml

@@ -1,25 +0,0 @@
-# This file is needed to check what the user wants to do when using Chelsea. The structure is similar to the prompts.
-# id: just a number between 1 and 100, an integer
-# command_dict: all options for how the user can pronounce the command, divided into two languages - English (en) and Ukrainian (ua)
-# description: a simple description of the command
-
-commands:
-  - id: 1
-    command_dict: {"en": ["Documentation"], "ua": ["Документація"]}
-    description: receive documentation 
-  - id: 2
-    command_dict: {"en": ["Buy Me A Coffee", "BMAC", "Coffee", "Pay the ghost"], "ua": ["Кава", "Заплати примарі"]}
-    description: support project on Buy Me A Coffee
-  - id: 3
-    command_dict: {"en": ["Translate"], "ua": ["Переклад"]}
-    description: translate
-  - id: 4
-    command_dict: {"en": ["Change model"], "ua": ["Змінити модель"]}
-    description: change model 
-  - id: 5
-    command_dict: {"en": ["Yes", "Yeah", "Yep"], "ua": ["Так", "Ага"]}
-    description: positive agreement
-  - id: 6
-    command_dict: {"en": ["No", "Nah"], "ua": ["Ні", "Ніт", "Ніц"]}
-    description: negative agreement
-   

command/utils/form_documentation.py

@@ -1,45 +0,0 @@
-import os
-import logging
-
-from typing import Optional
-
-TEMPLATE = """
-A complete list of commands that are designed to facilitate the use of the voice assistant Chelsea. 
-The complete list consists of no more than 100 commands written in a txt file. 
-The list of commands will be updated as the assistant is developed. 
-The first version of the programme (Arctic Monkeys) contains a total of 6 commands. 
-
-The list of commands and their use. 
-
-documentation command: first used to inform you how you able to interact with assistant. To call this command just say Documentation in english or 
-Документація in Ukrainian. Note you can use assistant without those commands, however for getting more advance expirience i strongly recommend use them.
-
-bmac command: Support author on Buy Me a Coffee. To activate this command you can spell in english Buy Me A Coffee, BMAC, Coffee, Pay the ghost and 
-in Ukrainian Кава, Заплати примарі.
-
-translate command: Use for translating speech in language which you choice. Commands to use it in english is Translate and in Ukrainian is Переклад.
-
-change model command: You able to choose model  using hugging face api (hf) or local model using Llama. List of models for hf are: Mistaril and Tinyllama and for lc: Phi 3 and TinyLlama either.
-To call command use in english Change model and in Ukrainian Змінити модель.
-
-yes command: Command to confirm your consent. To call command use in english Yes, Yeah, Yep and in Ukrainian Так, Ага.
-
-no command: Command to confirm your disagreement. To call command use in english No, Nah and in Ukrainian Ні, Ніт, Ніц.
-"""
-
-
-def generate_doc(path: Optional[str] = None) -> Optional[str]:
-    if path is not None:
-        file = os.path.join(path, NAME)
-    else:
-        current_dir = os.path.dirname(os.path.realpath(__file__))
-        file = os.path.join(current_dir, NAME)
-
-    logging.info(file)
-
-    try:
-        with open(file, 'w') as f:
-            f.write(TEMPLATE)
-        return file
-    except IOError as e:
-        logging.error(e)

command/utils/load_yaml.py

@@ -1,12 +0,0 @@
-import yaml
-from typing import Any
-
-
-def load_commands_from_yaml(file_path: str) -> Any:
-    try:
-        with open(file_path, 'r') as file:
-            commands_data = yaml.safe_load(file)
-            print(commands_data)
-            return commands_data.get('commands', [])
-    except IOError as e:
-        print(f"Error: {e}")

languages.txt

@@ -1,10 +1,111 @@
-'english', 'chinese', 'german', 'spanish', 'korean', 'french', 'japanese', 'portuguese', 'turkish', 'polish', 'catalan', 
-'dutch', 'arabic', 'swedish', 'italian', 'indonesian', 'hindi', 'finnish', 'vietnamese', 'hebrew', 'ukrainian', 'greek', 'malay', 'czech', 
-'romanian', 'danish', 'hungarian', 'tamil', 'norwegian', 'thai', 'urdu', 'croatian', 'bulgarian', 'lithuanian', 'latin', 'maori', 'malayalam', 
-'welsh', 'slovak', 'telugu', 'persian', 'latvian', 'bengali', 'serbian', 'azerbaijani', 'slovenian', 'kannada', 'estonian', 'macedonian', 
-'breton', 'basque', 'icelandic', 'armenian', 'nepali', 'mongolian', 'bosnian', 'kazakh', 'albanian', 'swahili', 'galician', 'marathi', 
-'punjabi', 'sinhala', 'khmer', 'shona', 'yoruba', 'somali', 'afrikaans', 'occitan', 'georgian', 'belarusian', 'tajik', 'sindhi', 'gujarati', 
-'amharic', 'yiddish', 'lao', 'uzbek', 'faroese', 'haitian creole', 'pashto', 'turkmen', 'nynorsk', 'maltese', 'sanskrit', 'luxembourgish', 
-'myanmar', 'tibetan', 'tagalog', 'malagasy', 'assamese', 'tatar', 'hawaiian', 'lingala', 'hausa', 'bashkir', 'javanese', 'sundanese', 
-'cantonese', 'burmese', 'valencian', 'flemish', 'haitian', 'letzeburgesch', 'pushto', 'panjabi', 'moldavian', 'moldovan', 'sinhalese', 
-'castilian', 'mandarin'
+'english', 
+'chinese', 
+'german', 
+'spanish', 
+'korean', 
+'french', 
+'japanese', 
+'portuguese', 
+'turkish', 
+'polish', 
+'catalan', 
+'dutch', 
+'arabic', 
+'swedish', 
+'italian', 
+'indonesian', 
+'hindi', 
+'finnish', 
+'vietnamese', 
+'hebrew', 
+'ukrainian', 
+'greek', 
+'malay', 
+'czech', 
+'romanian', 
+'danish', 
+'hungarian', 
+'tamil', 
+'norwegian', 
+'thai', 
+'urdu', 
+'croatian', 
+'bulgarian', 
+'lithuanian', 
+'latin', 
+'maori', 
+'malayalam', 
+'welsh', 
+'slovak', 
+'telugu', 
+'persian', 
+'latvian', 
+'bengali', 
+'serbian', 
+'azerbaijani', 
+'slovenian', 
+'kannada', 
+'estonian', 
+'macedonian', 
+'breton', 
+'basque', 
+'icelandic', 
+'armenian', 
+'nepali', 
+'mongolian', 
+'bosnian', 
+'kazakh', 
+'albanian', 
+'swahili', 
+'galician', 
+'marathi', 
+'punjabi', 
+'sinhala', 
+'khmer', 
+'shona', 
+'yoruba', 
+'somali', 
+'afrikaans', 
+'occitan', 
+'georgian', 
+'belarusian', 
+'tajik', 
+'sindhi', 
+'gujarati', 
+'amharic', 
+'yiddish', 
+'lao', 
+'uzbek', 
+'faroese', 
+'haitian creole', 
+'pashto', 
+'turkmen', 
+'nynorsk', 
+'maltese', 
+'sanskrit', 
+'luxembourgish', 
+'myanmar', 
+'tibetan', 
+'tagalog', 
+'malagasy', 
+'assamese', 
+'tatar', 
+'hawaiian', 
+'lingala', 
+'hausa', 
+'bashkir', 
+'javanese', 
+'sundanese', 
+'cantonese', 
+'burmese', 
+'valencian', 
+'flemish', 
+'haitian', 
+'letzeburgesch', 
+'pushto', 
+'panjabi', 
+'moldavian', 
+'moldovan', 
+'sinhalese', 
+'castilian', 
+'mandarin'

llm/apimodels/gemini_model.py

@@ -0,0 +1,110 @@
+
+import os
+import logging
+
+from llm.utils.hf_interface import HFInterface
+
+from langchain_google_genai import GoogleGenerativeAI
+from abc import ABC
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+file_handler = logging.FileHandler(
+    "logs/chelsea_llm_gemini.log")  # for all modules here template for logs file is "llm/logs/chelsea_{module_name}_{entity}.log"
+logger.setLevel(logging.INFO)  # informed
+
+formatted = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+file_handler.setFormatter(formatted)
+
+logger.addHandler(file_handler)
+logger.info("Getting information from apimodel module")
+
+
+# 429 - You've exceeded the rate limit.
+# 400 - The request body is malformed.
+# 403 - Your API key doesn't have the required permissions.
+# 404 - The requested resource wasn't found.
+# 500 - An unexpected error occurred on Google's side.
+# 503 - The service may be temporarily overloaded or down.
+
+# Якщо трапиться одна з цих помилок , то слід перемкнутися на HF , якщо якась модель занадто повільна 
+# перемкнутися на іншу після закінчення виконання текущої, якщо  трабли з HF перемкнутися на локальну, 
+# якщо ж у користувача відсутнє інтернет зʼєднання, то нічим не зарадиш, 
+# хіба що пропонувати скачати репозиторій.
+
+_api = os.environ.get("GEMINI_API_TOKEN")
+
+
+class Gemini(HFInterface, ABC):
+    """
+    This class represents a Gemini large language model interface.
+
+    It inherits from `HFInterface` (likely an interface from a Hugging Face library)
+    and `ABC` (for abstract base class) to enforce specific functionalities.
+    """
+
+    def __init__(self):
+        """
+        Initializer for the Gemini class.
+
+        - Raises a `ValueError` if the provided API key is None or an empty string.
+        - Creates an instance of `GoogleGenerativeAI` using the specified model name
+          ("gemini-1.5-flash") and the stored API key.
+        """
+
+        if not _api:
+            raise ValueError(f"Your api is None or empty string {_api}, please provide a Gemini API")
+
+        #{
+        #   'model': 'gemini-1.5-flash', 'temperature': 0.7, 'top_p': None, 
+        #   'top_k': None, 'max_output_tokens': None, 'candidate_count': 1
+        #}
+        self.llm = GoogleGenerativeAI(model="gemini-1.5-flash", google_api_key=_api)
+
+    def execution(self) -> GoogleGenerativeAI:
+        """
+        This method attempts to return the underlying `llm` (likely a language model object).
+
+        It wraps the retrieval in a `try-except` block to catch potential exceptions.
+        On success, it returns the `llm` object.
+        On failure, it logs an error message with the exception details using a logger
+        (assumed to be available elsewhere).
+        """
+        try:
+            return self.llm
+        except Exception as e:
+            logger.error("Something wrong with Gemini api", exc_info=e)
+            print(f"Something wrong with Gemini api: {e}")
+
+    def model_name(self):
+        """
+        Simple method that returns the hardcoded model name ("gemini-1.5-flash").
+
+        This can be useful for identifying the specific model being used.
+        """
+        return "gemini-1.5-flash"
+
+    def __str__(self):
+        """
+        Defines the string representation of the Gemini object for human readability.
+
+        It returns a string indicating that it's a "Gemini model" and appends the model name
+        obtained from the `model_name` method.
+        """
+        return f"Gemini model: {self.model_name()}"
+
+    def __repr__(self):
+        """
+        Defines the representation of the Gemini object for debugging purposes.
+
+        It uses `hasattr` to check if the `llm` attribute is set.
+        - If `llm` exists, it returns a string like `Gemini(llm=GoogleGenerativeAI(...))`,
+          showing the class name and the `llm` object information.
+        - If `llm` is not yet set (during initialization), it returns
+          `Gemini(llm=not initialized)`, indicating the state.
+        """
+        llm_info = f"llm={self.llm}" if hasattr(self, 'llm') else 'llm=not initialized'
+        return f"{self.__class__.__name__}({llm_info})"
+
+

llm/apimodels/hf_model.py

@@ -0,0 +1,186 @@
+import os
+import logging
+
+from abc import ABC
+from typing import Any
+
+from llm.utils.hf_interface import HFInterface
+from llm.utils.config import config
+
+from langchain_community.llms import HuggingFaceEndpoint
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)  # because if something went wrong in execution, application can't be work anyway
+
+file_handler = logging.FileHandler(
+    "logs/chelsea_llm_huggingfacehub.log")  # for all modules here template for logs file is "llm/logs/chelsea_{module_name}_{dir_name}.log"
+logger.setLevel(logging.INFO)  # informed
+
+formatted = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+file_handler.setFormatter(formatted)
+
+logger.addHandler(file_handler)
+logger.info("Getting information from apimodel module")
+
+_api = os.environ.get("HUGGINGFACEHUB_API_TOKEN")
+
+class HF_Mistaril(HFInterface, ABC):
+    """
+    This class represents an interface for the Mistaril large language model from Hugging Face.
+
+    It inherits from `HFInterface` (likely an interface from a Hugging Face library)
+    and `ABC` (for abstract base class) to enforce specific functionalities.
+    """
+
+    def __init__(self):
+        """
+        Initializer for the `HF_Mistaril` class.
+
+        - Retrieves configuration values for the Mistaril model from a `config` dictionary:
+            - `repo_id`: The ID of the repository containing the Mistaril model on Hugging Face.
+            - `max_length`: Maximum length of the generated text.
+            - `temperature`: Controls randomness in the generation process.
+            - `top_k`: Restricts the vocabulary used for generation.
+        - Raises a `ValueError` if the `api` key (presumably stored elsewhere) is missing.
+        - Creates an instance of `HuggingFaceEndpoint` using the retrieved configuration
+          and the `api` key.
+        """
+
+        repo_id = config["HF_Mistrail"]["model"]
+        max_length = config["HF_Mistrail"]["max_new_tokens"]
+        temperature = config["HF_Mistrail"]["temperature"]
+        top_k = config["HF_Mistrail"]["top_k"]
+
+        if not _api:
+            raise ValueError(f"API key not provided {_api}")
+
+        self.llm = HuggingFaceEndpoint(
+            repo_id=repo_id, max_length=max_length, temperature=temperature, top_k=top_k, token=_api
+        )
+
+    def execution(self) -> Any:
+        """
+        This method attempts to return the underlying `llm` (likely a language model object).
+
+        It wraps the retrieval in a `try-except` block to catch potential exceptions.
+        On success, it returns the `llm` object.
+        On failure, it logs an error message with the exception details using a logger
+        (assumed to be available elsewhere).
+        """
+        try:
+            return self.llm  # `invoke()`
+        except Exception as e:
+            logger.error("Something wrong with API or HuggingFaceEndpoint", exc_info=e)
+            print(f"Something wrong with API or HuggingFaceEndpoint: {e}")
+
+    def model_name(self):
+        """
+        Simple method that returns the Mistaril model name from the configuration.
+
+        This can be useful for identifying the specific model being used.
+        """
+        return config["HF_Mistrail"]["model"]
+
+    def __str__(self):
+        """
+        Defines the string representation of the `HF_Mistaril` object for human readability.
+
+        It combines the class name and the model name retrieved from the `model_name` method
+        with an underscore separator.
+        """
+        return f"{self.__class__.__name__}_{self.model_name()}"
+
+    def __repr__(self):
+        """
+        Defines the representation of the `HF_Mistaril` object for debugging purposes.
+
+        It uses `hasattr` to check if the `llm` attribute is set.
+        - If `llm` exists, it returns a string like `HF_Mistaril(llm=HuggingFaceEndpoint(...))`,
+          showing the class name and the `llm` object information.
+        - If `llm` is not yet set (during initialization), it returns
+          `HF_Mistaril(llm=not initialized)`, indicating the state.
+        """
+        llm_info = f"llm={self.llm}" if hasattr(self, 'llm') else 'llm=not initialized'
+        return f"{self.__class__.__name__}({llm_info})"
+
+
+
+class HF_TinyLlama(HFInterface, ABC):
+    """
+    This class represents an interface for the TinyLlama large language model from Hugging Face.
+
+    It inherits from `HFInterface` (likely an interface from a Hugging Face library)
+    and `ABC` (for abstract base class) to enforce specific functionalities.
+    """
+        
+    def __init__(self):
+        """
+        Initializer for the `HF_TinyLlama` class.
+
+        - Retrieves configuration values for the Mistaril model from a `config` dictionary:
+            - `repo_id`: The ID of the repository containing the TinyLlama model on Hugging Face.
+            - `max_length`: Maximum length of the generated text.
+            - `temperature`: Controls randomness in the generation process.
+            - `top_k`: Restricts the vocabulary used for generation.
+        - Raises a `ValueError` if the `api` key (presumably stored elsewhere) is missing.
+        - Creates an instance of `HuggingFaceEndpoint` using the retrieved configuration
+          and the `api` key.
+        """
+
+        repo_id = config["HF_TinyLlama"]["model"]
+        max_length = config["HF_TinyLlama"]["max_new_tokens"]
+        temperature = config["HF_TinyLlama"]["temperature"]
+        top_k = config["HF_TinyLlama"]["top_k"]
+
+        if not _api:
+            raise ValueError(f"API key not provided {_api}")
+
+        self.llm = HuggingFaceEndpoint(
+            repo_id=repo_id, max_length=max_length, temperature=temperature, top_k=top_k, token=_api
+        )
+
+    def execution(self) -> Any:
+        """
+        This method attempts to return the underlying `llm` (likely a language model object).
+
+        It wraps the retrieval in a `try-except` block to catch potential exceptions.
+        On success, it returns the `llm` object.
+        On failure, it logs an error message with the exception details using a logger
+        (assumed to be available elsewhere).
+        """
+        try:
+            return self.llm
+        except Exception as e:
+            logger.error("Something wrong with API or HuggingFaceEndpoint", exc_info=e)
+            print(f"Something wrong with API or HuggingFaceEndpoint: {e}")
+        
+    def model_name(self):
+        """
+        Simple method that returns the TinyLlama model name from the configuration.
+
+        This can be useful for identifying the specific model being used.
+        """
+        return config["HF_TinyLlama"]["model"]
+        
+    def __str__(self):
+        """
+        Defines the string representation of the `HF_TinyLlama` object for human readability.
+
+        It combines the class name and the model name retrieved from the `model_name` method
+        with an underscore separator.
+        """
+        return f"{self.__class__.__name__}_{self.model_name()}"
+
+    def __repr__(self):
+        """
+        Defines the representation of the `HF_TinyLlama` object for debugging purposes.
+
+        It uses `hasattr` to check if the `llm` attribute is set.
+        - If `llm` exists, it returns a string like `HF_TinyLlama(llm=HuggingFaceEndpoint(...))`,
+          showing the class name and the `llm` object information.
+        - If `llm` is not yet set (during initialization), it returns
+          `HF_TinyLlama(llm=not initialized)`, indicating the state.
+        """
+        llm_info = f"llm={self.llm}" if hasattr(self, 'llm') else 'llm=not initialized'
+        return f"{self.__class__.__name__}({llm_info})"

llm/huggingfacehub/hf_model.py

@@ -1,140 +0,0 @@
-import os
-import yaml
-import logging
-
-from abc import ABC
-
-from llm.hf_interface import HFInterface
-from llm.config import config
-
-from langchain.prompts import PromptTemplate
-from langchain.chains import LLMChain
-from langchain.llms import HuggingFaceHub
-
-logger = logging.getLogger(__name__)
-
-logger.setLevel(logging.CRITICAL)  # because if something went wrong in execution, application can't be work anyway
-
-file_handler = logging.FileHandler(
-    "logs/chelsea_llm_huggingfacehub.log")  # for all modules here template for logs file is "llm/logs/chelsea_{module_name}_{dir_name}.log"
-logger.setLevel(logging.INFO)  # informed
-
-formatted = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-file_handler.setFormatter(formatted)
-
-logger.addHandler(file_handler)
-
-logger.info("Getting information from hf_model module")
-
-llm_dir = '/home/user/app/llm/'
-
-path_to_yaml = os.path.join(os.getcwd(), "llm/prompts.yaml")
-
-print("Path to prompts : ", path_to_yaml)
-
-
-class HF_Mistaril(HFInterface, ABC):
-    def __init__(self, prompt_entity: str, prompt_id: int = 0):
-        self.prompt_entity = prompt_entity
-        self.prompt_id = prompt_id
-
-        self.model_config = config["HF_Mistrail"]
-
-        # Додати repetition_penalty, task?, top_p, stop_sequences
-        self.llm = HuggingFaceHub(
-            repo_id=self.model_config["model"],
-            # temperature=self.model_config["temperature"],
-            # max_new_tokens=self.model_config["max_new_tokens"],
-            # top_k=self.model_config["top_k"],
-            model_kwargs={"load_in_8bit": self.model_config["load_in_8bit"], 
-                          "temperature": self.model_config["temperature"],
-                          "max_new_tokens": self.model_config["max_new_tokens"],
-                          "top_k": self.model_config["top_k"],
-                         },
-            huggingfacehub_api_token=os.environ.get("HUGGINGFACEHUB_API_TOKEN")
-        )
-
-    @staticmethod
-    def __read_yaml():
-        try:
-            yaml_file = os.path.join(llm_dir, 'prompts.yaml')
-            with open(yaml_file, 'r') as f:
-                data = yaml.safe_load(f)
-            f.close()
-            return data
-        except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.error(msg="Execution filed", exc_info=e)
-
-    def execution(self):
-        try:
-            data = self.__read_yaml()
-            prompts = data["prompts"][
-                self.prompt_id]  #get second prompt from yaml, need change id parameter to get other prompt
-            template = prompts["prompt_template"]
-            prompt = PromptTemplate(template=template, input_variables=["entity"])
-            llm_chain = LLMChain(prompt=prompt, llm=self.llm, verbose=True)
-            output = llm_chain.invoke(self.prompt_entity)
-            return output["text"]
-        except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.critical(msg="Execution filed", exc_info=e)
-
-    def __str__(self):
-        return f"prompt_entity={self.prompt_entity}, prompt_id={self.prompt_id}"
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}(prompt_entity: {type(self.prompt_entity)} = {self.prompt_entity}, prompt_id: {type(self.prompt_id)} = {self.prompt_id})"
-
-
-class HF_TinyLlama(HFInterface, ABC):
-    def __init__(self, prompt_entity: str, prompt_id: int = 0):
-        self.prompt_entity = prompt_entity
-        self.prompt_id = prompt_id
-
-        self.model_config = config["HF_TinyLlama"]
-
-        self.llm = HuggingFaceHub(
-            repo_id=self.model_config["model"],
-            # temperature=self.model_config["temperature"],
-            # max_new_tokens=self.model_config["max_new_tokens"],
-            # top_k=self.model_config["top_k"],
-            model_kwargs={"load_in_8bit": self.model_config["load_in_8bit"], 
-                          "temperature": self.model_config["temperature"],
-                          "max_new_tokens": self.model_config["max_new_tokens"],
-                          "top_k": self.model_config["top_k"],
-                         },
-            huggingfacehub_api_token=os.environ.get("HUGGINGFACEHUB_API_TOKEN")
-        )
-
-    @staticmethod
-    def __read_yaml():
-        try:
-            yaml_file = os.path.join(llm_dir, 'prompts.yaml')
-            with open(yaml_file, 'r') as f:
-                data = yaml.safe_load(f)
-            f.close()
-            return data
-        except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.error(msg="Execution filed", exc_info=e)
-
-    def execution(self):
-        try:
-            data = self.__read_yaml()
-            prompts = data["prompts"][
-                self.prompt_id]  #get second prompt from yaml, need change id parameter to get other prompt
-            template = prompts["prompt_template"]
-            prompt = PromptTemplate(template=template, input_variables=["entity"])
-            llm_chain = LLMChain(prompt=prompt, llm=self.llm, verbose=True)
-            output = llm_chain.invoke(self.prompt_entity)
-            return output["text"]
-        except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.critical(msg="Execution filed", exc_info=e)
-
-    def __str__(self):
-        return f"prompt_entity={self.prompt_entity}, prompt_id={self.prompt_id}"
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}(prompt_entity: {type(self.prompt_entity)} = {self.prompt_entity}, prompt_id: {type(self.prompt_id)} = {self.prompt_id})"

llm/llamacpp/lc_model.py

@@ -3,20 +3,14 @@ import logging
 from abc import ABC
 
 import requests
-import yaml
-from langchain.prompts import PromptTemplate
-from langchain_community.llms import LlamaCpp
-
-from llm.config import config
-from llm.lc_interface import LCInterface
 
-# print(os.getcwd())
+from langchain_community.llms import LlamaCpp
 
-print("Current path : ", os.path.dirname(os.path.realpath(__file__)))
+from llm.utils.config import config
+from llm.utils.lc_interface import LCInterface
 
 logger = logging.getLogger(__name__)
-
-logger.setLevel(logging.CRITICAL)  # because if something went wrong in execution application can't be work anymore
+logger.setLevel(logging.ERROR)  # because if something went wrong in execution application can't be work anymore
 
 file_handler = logging.FileHandler(
     "logs/chelsea_llm_llamacpp.log")  # for all modules template for logs file is "logs/chelsea_{module_name}_{dir_name}.log"
@@ -24,27 +18,16 @@ logger.setLevel(logging.INFO)  # informed
 
 formatted = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
 file_handler.setFormatter(formatted)
-
 logger.addHandler(file_handler)
 
-try:
-   os.chdir('/home/user/app/llm/')
-except FileNotFoundError:
-   print("Error: Could not move up. You might be at the root directory.")
-
 work_dir = os.getcwd()
-
-models_dir = os.path.join(work_dir, "models")
+models_dir = os.path.join(work_dir, "llm/models")
     
 
 class LC_TinyLlama(LCInterface, ABC):
-    def __init__(self, prompt_entity: str, prompt_id: int = 0):
-        self.prompt_entity = prompt_entity
-        self.prompt_id = prompt_id
-
+    def __init__(self):
         self.model_config = config["LC_TinyLlama-1.1B-Chat-v1.0-GGUF"]
         
-
         try:
             get_file = requests.get(self.model_config["model_url"])
             if get_file.status_code == 200:
@@ -60,43 +43,23 @@ class LC_TinyLlama(LCInterface, ABC):
             print(f"Error while writing a file to directory : {e}")
             logger.error(msg="Error while write a file to directory", exc_info=e)
 
-    @staticmethod
-    def __read_yaml():
-        try:
-            yaml_file = os.path.join(work_dir, 'prompts.yaml')
-            with open(yaml_file, 'r') as file:
-                data = yaml.safe_load(file)
-            return data
-        except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.error(msg="Execution filed", exc_info=e)
+        self.llm = LlamaCpp(
+            model_path=os.path.join(models_dir, self.model_config["model_name"]),
+            temperature=self.model_config["temperature"],
+            max_tokens=self.model_config["max_tokens"],
+            top_p=self.model_config["top_p"],
+            top_k=self.model_config["top_k"],
+            # callback_manager=callback_manager,
+            verbose=True,  # Verbose is required to pass to the callback manager
+        )
 
     def execution(self):
         try:
-            data = self.__read_yaml()
-            prompts = data["prompts"][
-                self.prompt_id]  # to get second prompt from yaml, need change id parameter to get other prompt
-            template = prompts["prompt_template"]
-            prompt = PromptTemplate(template=template, input_variables=["entity"])
-
-            llm = LlamaCpp(
-                model_path=os.path.join(models_dir, self.model_config["model_name"]),
-                temperature=self.model_config["temperature"],
-                max_tokens=self.model_config["max_tokens"],
-                top_p=self.model_config["top_p"],
-                top_k=self.model_config["top_k"],
-                # callback_manager=callback_manager,
-                verbose=True,  # Verbose is required to pass to the callback manager
-            )
-
-            logger.info(f"Check llm : {llm}")
-
-            llm_chain = prompt | llm
-            output = llm_chain.invoke({"question": self.prompt_entity})
-            return output
+            return self.llm
         except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.critical(msg="Execution filed", exc_info=e)
+            print(f"Execution filed in LC_TinyLlama execution function: {e}")
+            logger.critical(msg="Execution filed in LC_TinyLlama execution function", exc_info=e)
+            return None
 
     def clear_llm(self, unused_model_dict, current_lc):
         # If unused_model_dict is not empty
@@ -108,8 +71,10 @@ class LC_TinyLlama(LCInterface, ABC):
                     # delete files from models directory except of current_lc
                     os.remove(value)
                     logger.info(f"Successfully deleted file {value}")
+                    print(f"Successfully deleted file {value}")
         else:
             logger.info(f"Unfortunately dictionary empty or None")
+            print(f"Unfortunately dictionary {unused_model_dict} empty or None")
 
     def get_unused(self, current_lc):
 
@@ -121,21 +86,22 @@ class LC_TinyLlama(LCInterface, ABC):
                     return {item: unused_model_file}
         else:
             return None
+    
+    def model_name(self):
+        return self.model_config["model_name"]
 
     def __str__(self):
-        return f"prompt_entity={self.prompt_entity}, prompt_id={self.prompt_id}"
+        return f"{self.__class__.__name__}_{self.model_name()}"
 
     def __repr__(self):
-        return f"{self.__class__.__name__}(prompt_entity: {type(self.prompt_entity)} = {self.prompt_entity}, prompt_id: {type(self.prompt_id)} = {self.prompt_id})"
-
+        llm_info = f"llm={self.llm}" if hasattr(self, 'llm') else 'llm=not initialized'
+        return f"{self.__class__.__name__}({llm_info})"
+    
 
 class LC_Phi3(LCInterface, ABC):
-    def __init__(self, prompt_entity: str, prompt_id: int = 0):
-        self.prompt_entity = prompt_entity
-        self.prompt_id = prompt_id
-
+    def __init__(self):
         self.model_config = config["LC_Phi-3-mini-4k-instruct-gguf"]
-
+        
         try:
             get_file = requests.get(self.model_config["model_url"])
             if get_file.status_code == 200:
@@ -143,50 +109,33 @@ class LC_Phi3(LCInterface, ABC):
                 with open(path_to_model, "wb") as f:
                     f.write(get_file.content)
                     logger.info("Model file successfully recorded")
+                    print("Model file successfully recorded")
                 f.close()
         except FileExistsError:
+            print(f"Model file {path_to_model} already exists. Skipping download.")
             logger.info(f"Model file {path_to_model} already exists. Skipping download.")
         except OSError as e:
             print(f"Error while writing a file to directory : {e}")
             logger.error(msg="Error while write a file to directory", exc_info=e)
 
-    @staticmethod
-    def __read_yaml():
-        try:
-            yaml_file = os.path.join(work_dir, 'prompts.yaml')
-            with open(yaml_file, 'r') as file:
-                data = yaml.safe_load(file)
-            return data
-        except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.error(msg="Execution filed", exc_info=e)
+        self.llm = LlamaCpp(
+            model_path=os.path.join(models_dir, self.model_config["model_name"]),
+            temperature=self.model_config["temperature"],
+            max_tokens=self.model_config["max_tokens"],
+            top_p=self.model_config["top_p"],
+            top_k=self.model_config["top_k"],
+            # callback_manager=callback_manager,
+            verbose=True,  # Verbose is required to pass to the callback manager
+        )
+
 
     def execution(self):
         try:
-            data = self.__read_yaml()
-            prompts = data["prompts"][
-                self.prompt_id]  # get second prompt from yaml, need change id parameter to get other prompt
-            template = prompts["prompt_template"]
-            prompt = PromptTemplate(template=template, input_variables=["entity"])
-
-            llm = LlamaCpp(
-                model_path=os.path.join(models_dir, self.model_config["model_name"]),
-                temperature=self.model_config["temperature"],
-                max_tokens=self.model_config["max_tokens"],
-                top_p=self.model_config["top_p"],
-                top_k=self.model_config["top_k"],
-                # callback_manager=callback_manager,
-                verbose=True,  # Verbose is required to pass to the callback manager
-            )
-
-            logger.info(f"Check llm : {llm}")
-
-            llm_chain = prompt | llm
-            output = llm_chain.invoke({"question": self.prompt_entity})
-            return output
+            return self.llm
         except Exception as e:
-            print(f"Execution filed : {e}")
-            logger.critical(msg="Execution filed", exc_info=e)
+            print(f"Execution filed in LC_Phi3 execution function: {e}")
+            logger.critical(msg="Execution filed in LC_Phi3 execution function:", exc_info=e)
+            return None
 
     def clear_llm(self, unused_model_dict, current_lc):
         # If unused_model_dict is not empty
@@ -198,8 +147,10 @@ class LC_Phi3(LCInterface, ABC):
                     # delete files from models directory except of current_lc
                     os.remove(value)
                     logger.info(f"Successfully deleted file {value}")
+                    print(f"Successfully deleted file {value}")
         else:
             logger.info(f"Unfortunately dictionary empty or None")
+            print(f"Unfortunately dictionary {unused_model_dict} empty or None")
 
     def get_unused(self, current_lc):
 
@@ -211,9 +162,13 @@ class LC_Phi3(LCInterface, ABC):
                     return {item: unused_model_file}
         else:
             return None
+    
+    def model_name(self):
+        return self.model_config["model_name"]
 
     def __str__(self):
-        return f"prompt_entity={self.prompt_entity}, prompt_id={self.prompt_id}"
+        return f"{self.__class__.__name__}_{self.model_name()}"
 
     def __repr__(self):
-        return f"{self.__class__.__name__}(prompt_entity: {type(self.prompt_entity)} = {self.prompt_entity}, prompt_id: {type(self.prompt_id)} = {self.prompt_id})"
+        llm_info = f"llm={self.llm}" if hasattr(self, 'llm') else 'llm=not initialized'
+        return f"{self.__class__.__name__}({llm_info})"

llm/llm_factory.py

@@ -1,27 +0,0 @@
-from typing import Dict
-
-from .huggingfacehub.hf_model import HF_Mistaril, HF_TinyLlama
-from .llamacpp.lc_model import LC_TinyLlama, LC_Phi3
-
-
-class LLM_Factory:
-
-    # trigger = {"model_type": "execution_type"} -> {"hf": "small"}
-    @staticmethod
-    def create_llm(prompt_entity: str, prompt_id: int, trigger: Dict[str, str]):
-
-        print(trigger)
-
-        for key, value in trigger.items():
-            if key == "hf" and value == "effective":
-                model = HF_Mistaril(prompt_entity=prompt_entity, prompt_id=prompt_id)
-            elif key == "hf" and value == "small":
-                model = HF_TinyLlama(prompt_entity=prompt_entity, prompt_id=prompt_id)
-            elif key == "lc" and value == "effective":
-                model = LC_Phi3(prompt_entity=prompt_entity, prompt_id=prompt_id)
-            elif key == "lc" and value == "small":
-                model = LC_TinyLlama(prompt_entity=prompt_entity, prompt_id=prompt_id)
-            else:
-                model = None
-
-        return model

llm/models/tinyllama-1.1b-chat-v1.0.Q8_0.gguf.bin

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a4c9bb1dbaa372f6381a035fa5c02ef087aaa1ff1f843a56a22328114f03fc59
-size 1170781568

llm/prompts.yaml

@@ -1,76 +0,0 @@
-# https://www.promptingguide.ai/techniques/
-
-# Add more examples of the template here, id should be an interval from 1 to 100_000 
-# The description provides a basic overview of the template, the description should include the level of difficulty, 
-# the name of the prompting method and end with the word "prompt", e.g. "simple short prompt" or "simple zero-shot thought chain prompt
-# The prompt is rated from 0 to 10
-
-prompts:
-  - id: 1
-    prompt_template: |
-        Question: {question}
-        Answer: 
-    description: simple question without a prompt
-    rate: 1
-
-  - id: 2
-    prompt_template: |
-        Question: {question}
-        Answer: Write a concise answer on the question with one example if it's possible. CONCISE ANSWER.
-    description: simple concise prompt
-    rate: 3
-
-# useful for solving simple math task 
-  - id: 3
-    prompt_template: |
-        Let's think step by step.
-        Question: {question}
-        Answer: 
-    description: simple zero-shot chain-of-thoughts prompt
-    rate: 5
-
-# another one example for solving simple math task 
-  - id: 4
-    prompt_template: |
-        Q: Roger has 5 tennis balls. He buys 2 more cans of tennis balls.
-           Each can has 3 tennis balls. How many tennis balls does he have now?
-        A: Roger started with 5 balls. 2 cans of 3 tennis balls each is 6 tennis balls. 5 + 6 = 11. The answer is 11.
-        Question: {question}
-        Answer: 
-    description: simple few-shot chain-of-thoughts prompt
-    rate: 5
-    
-  - id: 5
-    prompt_template: |
-        Q: There are 15 trees in the grove. Grove workers will plant trees in the grove today. After they are done,
-           there will be 21 trees. How many trees did the grove workers plant today?
-        A: We start with 15 trees. Later we have 21 trees. The difference must be the number of trees they planted.
-           So, they must have planted 21 - 15 = 6 trees. The answer is 6.
-        Q: If there are 3 cars in the parking lot and 2 more cars arrive, how many cars are in the parking lot?
-        A: There are 3 cars in the parking lot already. 2 more arrive. Now there are 3 + 2 = 5 cars. The answer is 5.
-        Q: Leah had 32 chocolates and her sister had 42. If they ate 35, how many pieces do they have left in total?
-        A: Leah had 32 chocolates and Leah’s sister had 42. That means there were originally 32 + 42 = 74
-           chocolates. 35 have been eaten. So in total they still have 74 - 35 = 39 chocolates. The answer is 39.
-        Q: Jason had 20 lollipops. He gave Denny some lollipops. Now Jason has 12 lollipops. How many lollipops
-           did Jason give to Denny?
-        A: Jason had 20 lollipops. Since he only has 12 now, he must have given the rest to Denny. The number of
-           lollipops he has given to Denny must have been 20 - 12 = 8 lollipops. The answer is 8.
-        Q: Shawn has five toys. For Christmas, he got two toys each from his mom and dad. How many toys does
-           he have now?
-        A: He has 5 toys. He got 2 from mom, so after that he has 5 + 2 = 7 toys. Then he got 2 more from dad, so
-           in total he has 7 + 2 = 9 toys. The answer is 9.
-        Q: There were nine computers in the server room. Five more computers were installed each day, from
-           monday to thursday. How many computers are now in the server room?
-        A: There are 4 days from monday to thursday. 5 computers were added each day. That means in total 4 * 5 =
-           20 computers were added. There were 9 computers in the beginning, so now there are 9 + 20 = 29 computers.
-           The answer is 29.
-        Q: Michael had 58 golf balls. On tuesday, he lost 23 golf balls. On wednesday, he lost 2 more. How many
-           golf balls did he have at the end of wednesday?
-        A: Michael initially had 58 balls. He lost 23 on Tuesday, so after that he has 58 - 23 = 35 balls. On
-           Wednesday he lost 2 more so now he has 35 - 2 = 33 balls. The answer is 33.
-        Q: Olivia has $23. She bought five bagels for $3 each. How much money does she have left?
-        A: She bought 5 bagels for $3 each. This means she spent $15. She has $8 left.
-        Question: {question}
-        Answer: 
-    description: simple self-consistency prompt
-    rate: 6

llm/utils/chat.py

@@ -0,0 +1,149 @@
+import time
+import logging
+
+from llm.apimodels.gemini_model import Gemini
+from llm.apimodels.hf_model import HF_Mistaril, HF_TinyLlama
+from llm.llamacpp.lc_model import LC_Phi3, LC_TinyLlama
+
+from typing import Optional, Any
+
+from langchain.chains.conversation.memory import ConversationBufferWindowMemory
+from langchain.chains import ConversationChain
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.WARNING)
+
+file_handler = logging.FileHandler(
+    "logs/chelsea_llm_chat.log")  # for all modules here template for logs file is "llm/logs/chelsea_{module_name}_{entity}.log"
+logger.setLevel(logging.INFO)  # informed
+
+formatted = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+file_handler.setFormatter(formatted)
+
+logger.addHandler(file_handler)
+logger.info("Getting information from chat module")
+
+def prettify(raw_text: str) -> str:        
+    pretty = raw_text.replace("**", "")
+    return pretty.strip()
+
+# option + command + F -> replace
+
+memory: ConversationBufferWindowMemory = ConversationBufferWindowMemory(k=3, ai_prefix="Chelsea")
+
+DELAY: int = 300  # 5 minutes
+
+def has_failed(conversation, prompt) -> Optional[str]:
+    """
+    Checks if the LLM conversation prediction fails and returns None if so.
+
+    Args:
+        conversation: The LLM conversation object used for prediction.
+        prompt: The prompt to be used for prediction.
+
+    Returns:
+        None, otherwise the prettified response.
+    """
+
+    try:
+        response = conversation.predict(input=prompt)
+        print(f"response: {response}")
+        result = prettify(raw_text=response)
+        return result
+    except Exception as e:
+        logger.error(msg="Error during prediction with conversation in has_failed function", exc_info=e)
+        print(f"Error during prediction with conversation in has_failed function: {e}")
+        return None
+
+
+def has_delay(conversation, prompt) -> Optional[str]:
+    """
+    Checks if the LLM conversation prediction takes longer than a set delay.
+
+    Args:
+        conversation: The LLM conversation object used for prediction.
+        prompt: The prompt to be used for prediction.
+
+    Returns:
+        None if the execution time exceeds the delay,
+        otherwise, the prettified response from the conversation object.
+    """
+
+    start_time = time.perf_counter()  # Start timer before prediction
+    try:
+        response = conversation.predict(input=prompt)
+        execution_time = time.perf_counter() - start_time  # Calculate execution time
+
+        if execution_time > DELAY: 
+            return None  # Return None if delayed
+        
+        result = prettify(raw_text=response)  # Prettify the response
+        return result  # Return the prettified response
+
+    except Exception as e:
+        logger.error(msg="Error during prediction with conversation in has_delay function", exc_info=e)
+        print(f"Error during prediction with conversation in has_delay function: {e}")
+
+
+class Conversation:
+    def __init__(self):
+        """
+        Initializes the Conversation class with a prompt and a list of LLM model classes.
+
+        Args:
+            model_classes (list, optional): A list of LLM model classes to try in sequence.
+                Defaults to [Gemini, HF_Mistaril, HF_TinyLlama, LC_Phi3, LC_TinyLlama].
+        """
+
+        self.model_classes = [Gemini, HF_Mistaril, HF_TinyLlama, LC_Phi3, LC_TinyLlama]
+        self.current_model_index = 0
+
+    def _get_conversation(self) -> Any:
+        """
+        Creates a ConversationChain object using the current model class.
+        """
+        try:
+            current_model_class = self.model_classes[self.current_model_index]
+            print("current model class is: ", current_model_class)
+            return ConversationChain(llm=current_model_class().execution(), memory=memory, return_final_only=True)
+        except Exception as e:
+            logger.error(msg="Error during conversation chain in get_conversation function", exc_info=e)
+            print(f"Error during conversation chain in get_conversation function: {e}")
+
+    def chatting(self, prompt: str) -> str:
+        """
+        Carries out the conversation with the user, handling errors and delays.
+
+        Args: 
+            prompt(str): The prompt to be used for prediction.
+
+        Returns:
+            Optional[str]: The final conversation response or None if all models fail.
+        """
+
+        if prompt is None or prompt == "":
+            raise Exception(f"Prompt must be string not None or empty string: {prompt}")
+
+        while self.current_model_index < len(self.model_classes):
+            conversation = self._get_conversation()
+
+            result = has_failed(conversation=conversation, prompt=prompt)
+            if result is not None:
+                return result
+            print(f"chat - chatting result : {result}")
+
+            result = has_delay(conversation=conversation, prompt=prompt)
+            if result is None:
+                self.current_model_index += 1  # Switch to next model after delay
+                continue
+
+            return result
+
+        return "All models failed conversation. Please, try again"
+    
+    def __str__(self) -> str:
+        return f"prompt: {type(self.prompt)}"
+    
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(prompt: {type(self.prompt)})"
+    

llm/{config.py → utils/config.py}

@@ -1,14 +1,14 @@
 config = {
     "HF_Mistrail": {
         "model": "mistralai/Mistral-7B-Instruct-v0.2",
-        "temperature": 0.1,
+        "temperature": 0.5,
         "max_new_tokens": 1024,
         "top_k": 5,
         "load_in_8bit": True
     },
     "HF_TinyLlama": {
         "model": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
-        "temperature": 0.1,
+        "temperature": 0.5,
         "max_new_tokens": 1024,
         "top_k": 5,
         "top_p":0.95,
@@ -18,7 +18,7 @@ config = {
     "LC_TinyLlama-1.1B-Chat-v1.0-GGUF": {
         "model_url": "https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/tinyllama-1.1b-chat-v1.0.Q8_0.gguf",
         "model_name": "tinyllama-1.1b-chat-v1.0.Q8_0.gguf.bin",
-        "temperature": 0.4,
+        "temperature": 0.5,
         "max_tokens": 868,
         "top_p": 0.8,
         "top_k": 5,
@@ -26,7 +26,7 @@ config = {
     "LC_Phi-3-mini-4k-instruct-gguf": {
         "model_url": "https://huggingface.co/microsoft/Phi-3-mini-4k-instruct-gguf/resolve/main/Phi-3-mini-4k-instruct-q4.gguf",
         "model_name": "Phi-3-mini-4k-instruct-gguf.bin",
-        "temperature": 0.4,
+        "temperature": 0.5,
         "max_tokens": 868,
         "top_p": 0.8,
         "top_k": 5,

llm/{hf_interface.py → utils/hf_interface.py}

@@ -1,8 +1,8 @@
 from abc import ABC, abstractmethod
-
+from typing import Any, Optional
 
 class HFInterface(ABC):
     @abstractmethod
-    def execution(self):
-        """Method execution LLM model based on HuggingFace or Langchain"""
+    def execution(self) -> Optional[Any]:
+        """Method execution LLM model based on HuggingFace or others"""
         pass

logs/chelsea_llm_chat.log

@@ -0,0 +1 @@
+2024-07-30 19:01:46,091 - INFO - Getting information from chat module

logs/chelsea_llm_gemini.log

@@ -0,0 +1 @@
+2024-07-30 19:01:45,915 - INFO - Getting information from apimodel module

logs/chelsea_llm_huggingfacehub.log

@@ -0,0 +1,2 @@
+
+2024-07-30 19:01:45,937 - INFO - Getting information from apimodel module

logs/chelsea_llm_llamacpp.log

@@ -0,0 +1 @@
+

requirements.txt

@@ -15,19 +15,23 @@ openai
 ffprobe
 
 # related to huggingface
-torch~=2.2.2
+torch~=2.2.0
 transformers~=4.40.1
 accelerate
 sentence-transformers
 bitsandbytes
 einops
 
+#gemini-langchain
+langchain_google_genai
+
 # related to langchain
 langchain~=0.1.17
+langchain-community
 pypdf
 chromadb
 
 # related to audio
 librosa==0.10.1
 soundfile~=0.12.1
-numpy~=1.26.4
+numpy~=1.24.4

todo.txt

@@ -1,7 +0,0 @@
-ToDo
-
-- Переписати модуль команди оновивши патеерн на Factory, додати інші команди. Придумати як з ними взаємодіяти
-- Додати очищення для lc
-- Додати ще моделі до hf та зробити пенальті
-- Оновити промпти
-- Придумати можливість зміни моделі 

utils/documentation.py

@@ -0,0 +1,14 @@
+import streamlit as st
+
+TEMPLATE = """
+    A complete list of commands that are designed to facilitate the use of the voice assistant Chelsea. 
+    The complete list consists of no more than 100 commands written in a txt file. 
+    The list of commands will be updated as the assistant is developed. 
+    The first version of the program (Arctic Monkeys) contains a total of 2 commands. 
+
+    The list of commands and their use. 
+"""
+
+class Documentation():
+    def execution(self):
+        st.write(f"Documentation:\n\n{TEMPLATE}")

utils/keywords.py

@@ -0,0 +1,286 @@
+from typing import Dict, List
+
+keywords: Dict[str, List[str]] = {
+    "math": [
+        "math", "mathematica", "algebra", "geometry", "calculus", "trigonometry", "arithmetic", 
+        "statistics", "probability", "equation", "theorem", "proof", 
+        "function", "integral", "derivative", "matrix", "vector", 
+        "series", "sequence", "logarithm", "exponent", "ratio", 
+        "proportion", "mean", "median", "mode", "variance", 
+        "standard deviation", "normal distribution", "binomial distribution", "polynomial", "quadratic", 
+        "linear", "nonlinear", "differential equation", "graph", "plot", 
+        "coordinate", "axis", "slope", "intercept", "angle", 
+        "sin", "cos", "tan", "cot", "sec", "sine", "cosine", "tangent", "cotangent", "secant", "cosecant",
+        "csc", "hypotenuse", "adjacent", "opposite", "prime number", 
+        "composite number", "factor", "multiple", "divisor", "fraction", 
+        "decimal", "percent", "permutation", "combination", "set", 
+        "subset", "union", "intersection", "probability distribution", "random variable",
+        "symmetric", "asymmetric", "function", "domain", "range",
+        "parabola", "hyperbola", "ellipse", "conic sections", "scalar",
+        "dot product", "cross product", "eigenvalue", "eigenvector", "identity matrix",
+        "determinant", "transpose", "inverse matrix", "system of equations", "linear transformation",
+        "orthogonal", "projection", "angle bisector", "midpoint", "distance formula",
+        "circumference", "area", "volume", "surface area", "unit circle",
+        "radian", "degree", "sector", "arc", "chord",
+        "geometric sequence", "arithmetic sequence", "infinity", "limit", "continuity",
+        "convergence", "divergence", "power series", "taylor series", "maclaurin series",
+        "partial fraction", "improper integral", "line integral", "surface integral", "triple integral"
+    ],
+    "physics": [
+        "physics", "quantum mechanics", "relativity", "thermodynamics", "electromagnetism", "classical mechanics", 
+        "particle physics", "nuclear physics", "optics", "wave", "particle", 
+        "energy", "force", "motion", "velocity", "acceleration", 
+        "mass", "weight", "gravity", "magnetism", "electricity", 
+        "current", "voltage", "resistance", "circuit", "magnetic field", 
+        "electric field", "photon", "electron", "proton", "neutron", 
+        "atom", "molecule", "nucleus", "radioactivity", "fission", 
+        "fusion", "black hole", "big bang", "entropy", "enthalpy", 
+        "conduction", "convection", "radiation", "wave-particle duality", "superposition", 
+        "entanglement", "heisenberg uncertainty principle", "schrodinger's cat", "string theory", "standard model", 
+        "higgs boson", "dark matter", "dark energy", "gravitational waves", "relativistic effects", 
+        "time dilation", "length contraction", "inertia", "momentum", "angular momentum", 
+        "torque", "centripetal force", "centrifugal force", "kinetic energy", "potential energy", 
+        "work", "power", "conservation laws", "frame of reference", "wave function", 
+        "quantum state", "wave equation", "phase", "frequency", "wavelength", 
+        "amplitude", "interference", "diffraction", "polarization", "reflection", 
+        "refraction",
+        "plasma", "boson", "fermion", "lepton", "quark",
+        "gluons", "neutrino", "antimatter", "tachyon", "string",
+        "brane", "multiverse", "spacetime", "singularity", "event horizon",
+        "hawking radiation", "cosmology", "cosmic microwave background", "redshift", "blueshift",
+        "doppler effect", "hubble's law", "expansion of the universe", "cosmic inflation", "dark flow",
+        "supernova", "neutron star", "pulsar", "quasar", "gamma-ray burst",
+        "solar wind", "magnetosphere", "aurora", "flux", "field lines",
+        "ampere's law", "faraday's law", "gauss's law", "lorentz force", "coulomb's law",
+        "kepler's laws", "newton's laws", "planck's constant", "speed of light", "universal constant",
+        "atomic mass", "atomic number", "isotope", "half-life", "binding energy",
+        "solid state physics", "semiconductor", "superconductor", "hall effect", "ferromagnetism"
+    ],
+    "history": [
+        "history", "revolution", "war", "empire", "kingdom", "dynasty", 
+        "monarchy", "republic", "democracy", "constitution", "treaty", 
+        "colonization", "independence", "civilization", "ancient", "medieval", 
+        "modern", "industrialization", "renaissance", "enlightenment", "feudalism", 
+        "imperialism", "nationalism", "communism", "socialism", "capitalism", 
+        "fascism", "dictatorship", "cold war", "world war", "reformation", 
+        "crusades", "expedition", "exploration", "discovery", "trade", 
+        "silk road", "spice trade", "slavery", "abolition", "emancipation", 
+        "civil rights", "suffrage", "holocaust", "genocide", "revolutionary war", 
+        "civil war", "world war i", "world war ii", "great depression", "cold war", 
+        "cold war era", "space race", "arms race", "nuclear proliferation", "decolonization", 
+        "indian independence", "american revolution", "french revolution", "russian revolution", "chinese revolution", 
+        "cuban revolution", "vietnam war", "korean war", "gulf war", "iraq war", 
+        "afghanistan war", "middle ages", "renaissance period", "industrial revolution", "scientific revolution", 
+        "age of exploration", "age of enlightenment", "victorian era", "edwardian era", "progressive era", 
+        "roaring twenties", "great depression era", "post-war era", "cold war period", "digital age", 
+        "information age", "modern era",
+        "ancient egypt", "ancient greece", "roman empire", "byzantine empire", "ottoman empire",
+        "ming dynasty", "qing dynasty", "han dynasty", "gupta empire", "mauryan empire",
+        "aztec empire", "inca empire", "maya civilization", "mesopotamia", "babylon",
+        "persian empire", "carthage", "vikings", "mongol empire", "medieval europe",
+        "feudal japan", "samurai", "shogunate", "mughal empire", "age of reason",
+        "scientific enlightenment", "american civil rights movement", "women's suffrage", "the great migration", "civil disobedience",
+        "nonviolent resistance", "apartheid", "mandela", "gandhi", "martin luther king jr.",
+        "malcolm x", "che guevara", "mao zedong", "stalin", "hitler",
+        "churchill", "fdr", "truman", "kennedy", "roosevelt",
+        "cold war espionage", "berlin wall", "iron curtain", "nato", "warsaw pact",
+        "marshall plan", "watergate", "cuban missile crisis", "yugoslav wars", "bosnian genocide",
+        "rwanda genocide", "darfur conflict", "arab spring", "syrian civil war", "russo-ukrainian war",
+        "brexit", "european union", "united nations", "nato", "world trade organization",
+        "nafta", "trans-pacific partnership", "climate change", "global warming", "paris agreement"
+    ],
+    "technology": [
+        "artificial intelligence", "software", "hardware", "programming", "coding", "algorithm", 
+        "machine learning", "artificial intelligence", "ai", "neural networks", "deep learning", 
+        "data science", "big data", "cloud computing", "internet of things", "iot", 
+        "cybersecurity", "encryption", "blockchain", "cryptocurrency", "bitcoin", 
+        "ethereum", "smart contract", "virtual reality", "vr", "augmented reality", 
+        "ar", "robotics", "automation", "3d printing", "biotechnology", 
+        "genetic engineering", "nanotechnology", "quantum computing", "quantum technology", "5g", 
+        "wireless communication", "network", "database", "sql", "nosql", 
+        "web development", "frontend", "backend", "full stack", "html", 
+        "css", "javascript", "react", "angular", "vue", 
+        "node.js", "python", "java", "c++", "c#", 
+        "ruby", "swift", "kotlin", "mobile development", "ios", 
+        "android", "app development", "user interface", "ui", "user experience", 
+        "ux", "responsive design", "devops", "agile", "scrum", 
+        "kanban", "version control", "git", "github", "continuous integration", 
+        "ci", "continuous deployment", "cd", "containerization", "docker", 
+        "kubernetes", "microservices", "serverless", "cloud infrastructure", "aws", 
+        "azure", "google cloud", "gcp", "digital transformation", "edge computing", 
+        "fog computing", "smart home", "smart devices", "wearables", "fitness trackers", 
+        "health tech", "medtech", "fintech", "edtech", "proptech",
+        "natural language processing", "nlp", "speech recognition", "chatbots", "virtual assistants",
+        "augmented reality", "mixed reality", "extended reality", "er", "haptic technology",
+        "3d modeling", "computer graphics", "game development", "simulation", "digital twins",
+        "smart cities", "connected vehicles", "autonomous vehicles", "self-driving cars", "electric vehicles",
+        "ev", "renewable energy", "solar power", "wind power", "hydroelectric power",
+        "smart grid", "energy storage", "battery technology", "wearable tech", "smartwatch",
+        "fitness tracker", "smart glasses", "e-learning", "online education", "moocs",
+        "massive open online courses", "online collaboration", "telemedicine", "remote work", "digital workspace",
+        "cryptography", "secure communications", "quantum encryption", "privacy", "data protection",
+        "regtech", "insurtech", "agritech", "contech", "govtech",
+        "martech", "hrtech", "legaltech", "real estate technology", "property management systems",
+        "virtual real estate", "3d printing construction", "sustainable technology", "cleantech", "green technology",
+        "environmental technology", "recycling technology", "waste management technology", "water purification technology", "air purification technology",
+        "carbon capture", "carbon footprint reduction", "renewable materials", "biodegradable materials", "smart packaging",
+        "advanced manufacturing", "industry 4.0", "internet of behaviors", "behavioral data", "personalization",
+        "customer experience", "cx", "user journey", "touchpoints", "interaction design",
+        "service design", "design thinking", "innovation management", "creative technology", "disruptive technology"
+    ],
+    "life": [
+        "health", "wellness", "fitness", "nutrition", "diet", 
+        "exercise", "mental health", "stress", "anxiety", "depression", 
+        "mindfulness", "meditation", "yoga", "self-care", "hygiene", 
+        "lifestyle", "work-life balance", "relationships", "friendship", "family", 
+        "parenting", "education", "career", "job", "profession", 
+        "hobbies", "interests", "travel", "adventure", "vacation", 
+        "culture", "arts", "music", "film", "literature", 
+        "reading", "writing", "creativity", "crafts", "diy", 
+        "cooking", "recipes", "baking", "gardening", "sustainability", 
+        "environment", "eco-friendly", "green living", "minimalism", "decluttering", 
+        "finance", "budgeting", "saving", "investing", "retirement", 
+        "insurance", "real estate", "housing", "mortgage", "renting", 
+        "transportation", "driving", "public transit", "biking", "walking", 
+        "pets", "animals", "dog", "cat", "pet care", 
+        "community", "volunteering", "charity", "philanthropy", "social issues", 
+        "politics", "government", "laws", "rights", "justice", 
+        "equality", "diversity", "inclusion", "personal development", "self-improvement", 
+        "goal setting", "productivity", "time management", "motivation", "inspiration", 
+        "spirituality", "religion", "faith", "beliefs", "values", 
+        "ethics", "morality", "philosophy", "wisdom", "knowledge", 
+        "learning", "education system", "school", "college", "university",
+        "workplace", "entrepreneurship", "startups", "leadership", "management",
+        "mentorship", "networking", "communication skills", "public speaking", "negotiation",
+        "conflict resolution", "teamwork", "collaboration", "project management", "organizational skills",
+        "problem-solving", "critical thinking", "decision making", "emotional intelligence", "self-awareness",
+        "resilience", "adaptability", "creativity", "innovation", "lifelong learning",
+        "personal growth", "mindset", "habits", "routine", "discipline",
+        "focus", "concentration", "clarity", "vision", "values",
+        "purpose", "fulfillment", "happiness", "gratitude", "optimism",
+        "positive thinking", "self-esteem", "self-confidence", "body image", "self-acceptance",
+        "stress management", "relaxation", "rest", "sleep", "dreams",
+        "lucid dreaming", "mental clarity", "cognitive function", "memory", "learning styles",
+        "study techniques", "academic success", "career planning", "professional development", "workplace culture",
+        "employee engagement", "job satisfaction", "work environment", "remote work", "telecommuting",
+        "flexible work", "gig economy", "side hustle", "financial independence", "early retirement",
+        "fire movement", "minimalism", "simple living", "downshifting", "voluntary simplicity",
+        "sustainable living", "zero waste", "plastic-free", "veganism", "vegetarianism",
+        "plant-based diet", "organic food", "local food", "farm-to-table", "slow food",
+        "mindful eating", "intuitive eating", "diet culture", "body positivity", "weight management",
+        "fitness goals", "workout routines", "exercise science", "sports nutrition", "athletic performance",
+        "injury prevention", "rehabilitation", "physiotherapy", "chiropractic care", "alternative medicine",
+        "holistic health", "integrative medicine", "traditional medicine", "herbal medicine", "acupuncture",
+        "massage therapy", "aromatherapy", "sound therapy", "energy healing", "reiki",
+        "chakra balancing", "spiritual healing", "faith healing", "meditative practices", "breathwork",
+        "pranayama", "tai chi", "qigong", "martial arts", "self-defense",
+        "dance", "movement therapy", "art therapy", "music therapy", "drama therapy",
+        "play therapy", "animal-assisted therapy", "equine therapy", "nature therapy", "ecotherapy",
+        "forest bathing", "wild swimming", "outdoor activities", "hiking", "camping",
+        "backpacking", "mountaineering", "rock climbing", "bouldering", "caving",
+        "kayaking", "canoeing", "rafting", "sailing", "boating",
+        "fishing", "birdwatching", "wildlife photography", "stargazing", "astronomy",
+        "geocaching", "orienteering", "survival skills", "bushcraft", "foraging",
+        "homesteading", "permaculture", "urban gardening", "community gardening", "allotment gardening",
+        "container gardening", "vertical gardening", "indoor gardening", "houseplants", "succulents",
+        "bonsai", "orchids", "roses", "tulips", "wildflowers",
+        "herbs", "vegetables", "fruits", "berries", "nut trees",
+        "shade gardening", "water gardening", "xeriscaping", "landscape design", "garden design",
+        "garden maintenance", "pruning", "composting", "soil health", "organic gardening",
+        "pest control", "natural fertilizers", "greenhouse gardening", "aquaponics", "hydroponics",
+        "aquaculture", "sustainable agriculture", "regenerative agriculture", "carbon farming", "climate-smart agriculture",
+        "urban farming", "city farming", "vertical farming", "rooftop farming", "indoor farming",
+        "community supported agriculture", "csa", "farmers markets", "local food systems", "food sovereignty",
+        "food security", "food justice", "food deserts", "food waste", "food recovery",
+        "gleaning", "food rescue", "food banks", "food pantries", "community kitchens",
+        "soup kitchens", "meal programs", "nutrition education", "food policy", "agricultural policy",
+        "food industry", "food science", "food technology", "food safety", "food regulation",
+        "dietary guidelines", "nutrition research", "public health", "global health", "health equity",
+        "social determinants of health", "healthcare access", "universal healthcare", "healthcare policy", "health insurance",
+        "primary care", "preventive care", "chronic disease management", "mental health care", "substance abuse treatment",
+        "addiction recovery", "rehabilitation services", "disability services", "elder care", "geriatric care",
+        "end-of-life care", "palliative care", "hospice care", "patient advocacy", "health literacy",
+        "patient empowerment", "shared decision making", "informed consent", "medical ethics", "bioethics",
+        "genetic counseling", "reproductive health", "maternal health", "child health", "adolescent health",
+        "men's health", "women's health", "lgbtq+ health", "sexual health", "sex education",
+        "family planning", "birth control", "fertility", "infertility", "adoption",
+        "surrogacy", "pregnancy", "prenatal care", "postpartum care", "breastfeeding",
+        "newborn care", "pediatric care", "immunizations", "vaccinations", "infectious diseases",
+        "pandemics", "epidemics", "public health response", "emergency preparedness", "disaster response",
+        "humanitarian aid", "global development", "international relations", "diplomacy", "peacekeeping",
+        "conflict resolution", "human rights", "civil liberties", "social justice", "advocacy",
+        "activism", "community organizing", "grassroots movements", "social movements", "political activism",
+        "environmental activism", "climate activism", "sustainable development", "social entrepreneurship", "impact investing",
+        "corporate social responsibility", "csr", "ethical business", "fair trade", "sustainable fashion",
+        "slow fashion", "circular economy", "zero waste lifestyle", "plastic-free living", "minimal waste",
+        "eco-friendly products", "green products", "sustainable brands", "ethical consumerism", "conscious consumerism",
+        "mindful living", "simple living", "voluntary simplicity", "intentional living", "purpose-driven life",
+        "values-driven life", "authenticity", "integrity", "vulnerability", "empathy",
+        "compassion", "kindness", "gratitude", "generosity", "service",
+        "community service", "volunteerism", "philanthropy", "charitable giving", "social impact",
+        "civic engagement", "democratic participation", "voting", "elections", "campaigns",
+        "political engagement", "policy advocacy", "government accountability", "transparency", "good governance",
+        "public accountability", "citizen oversight", "public participation", "community involvement", "collective action",
+        "solidarity", "social cohesion", "community resilience", "disaster resilience", "climate resilience",
+        "ecosystem resilience", "environmental stewardship", "conservation", "biodiversity", "wildlife protection",
+        "habitat restoration", "ecosystem services", "natural resources", "sustainable resource management", "renewable resources",
+        "non-renewable resources", "energy conservation", "water conservation", "soil conservation", "forest conservation",
+        "marine conservation", "sustainable fisheries", "sustainable forestry", "sustainable agriculture", "sustainable tourism",
+        "eco-tourism", "nature-based tourism", "cultural tourism", "heritage tourism", "community-based tourism",
+        "responsible tourism", "ethical tourism", "regenerative tourism", "adventure tourism", "wildlife tourism",
+        "urban tourism", "rural tourism", "agritourism", "gastrotourism", "culinary tourism",
+        "food tourism", "wine tourism", "beer tourism", "coffee tourism", "chocolate tourism",
+        "craft tourism", "artisan tourism", "handicraft tourism", "souvenir tourism", "local tourism",
+        "staycations", "domestic tourism", "short-term rentals", "vacation rentals", "holiday homes",
+        "vacation homes", "second homes", "vacation planning", "travel planning", "itinerary planning",
+        "travel tips", "packing tips", "travel hacks", "budget travel", "luxury travel",
+        "solo travel", "group travel", "family travel", "pet-friendly travel", "accessible travel",
+        "sustainable travel", "green travel", "slow travel", "responsible travel", "ethical travel",
+        "off-the-beaten-path travel", "hidden gems", "bucket list", "once-in-a-lifetime trips", "once-in-a-lifetime experiences",
+        "adventure travel", "extreme travel", "extreme sports", "extreme adventures", "thrill-seeking",
+        "adrenaline junkie", "challenge", "personal challenge", "physical challenge", "mental challenge",
+        "growth mindset", "fixed mindset", "open-mindedness", "curiosity", "exploration",
+        "discovery", "innovation", "creativity", "invention", "problem-solving",
+        "critical thinking", "strategic thinking", "analytical thinking", "logical thinking", "scientific thinking",
+        "philosophical thinking", "ethical thinking", "creative thinking", "design thinking", "systems thinking",
+        "complexity", "ambiguity", "uncertainty", "paradox", "dilemma",
+        "contradiction", "tension", "balance", "harmony", "equilibrium",
+        "equanimity", "tranquility", "serenity", "calm", "peace",
+        "inner peace", "outer peace", "global peace", "world peace", "peacebuilding",
+        "conflict prevention", "conflict resolution", "mediation", "negotiation", "dialogue",
+        "understanding", "tolerance", "acceptance", "inclusion", "diversity",
+        "multiculturalism", "pluralism", "intercultural dialogue", "interfaith dialogue", "cross-cultural communication",
+        "cross-cultural understanding", "interpersonal communication", "interpersonal skills", "relationship building", "relationship management",
+        "relationship maintenance", "relationship development", "relationship repair", "relationship enhancement", "relationship success",
+        "relationship satisfaction", "relationship happiness", "relationship fulfillment", "relationship growth", "relationship dynamics",
+        "family dynamics", "family relationships", "parent-child relationships", "sibling relationships", "extended family",
+        "family systems", "family therapy", "family counseling", "marriage", "marriage counseling",
+        "divorce", "separation", "co-parenting", "blended families", "stepfamilies",
+        "adoption", "foster care", "child welfare", "child protection", "child development",
+        "childhood", "adolescence", "adolescent development", "youth development", "youth programs",
+        "youth leadership", "youth empowerment", "youth engagement", "youth advocacy", "youth participation",
+        "youth voice", "youth rights", "youth justice", "youth crime", "youth violence",
+        "youth gangs", "youth homelessness", "youth mental health", "youth substance abuse", "youth addiction",
+        "youth education", "youth employment", "youth entrepreneurship", "youth innovation", "youth creativity",
+        "youth sports", "youth arts", "youth culture", "youth identity", "youth diversity",
+        "youth inclusion", "youth equity", "youth social justice", "youth environmental justice", "youth climate action",
+        "youth activism", "youth advocacy", "youth leadership", "youth participation", "youth empowerment",
+        "youth engagement", "youth organizing", "youth mobilization", "youth networks", "youth movements",
+        "youth campaigns", "youth initiatives", "youth projects", "youth programs", "youth services",
+        "youth organizations", "youth groups", "youth clubs", "youth associations", "youth councils",
+        "youth committees", "youth forums", "youth dialogues", "youth workshops", "youth conferences",
+        "youth summits", "youth assemblies", "youth festivals", "youth events", "youth activities",
+        "youth education", "youth training", "youth development", "youth mentoring", "youth coaching",
+        "youth support", "youth advocacy", "youth empowerment", "youth engagement", "youth participation",
+        "youth leadership", "youth entrepreneurship", "youth innovation", "youth creativity", "youth development",
+        "youth programs", "youth services", "youth organizations", "youth groups", "youth clubs",
+        "youth associations", "youth councils", "youth committees", "youth forums", "youth dialogues",
+        "youth workshops", "youth conferences"
+    ],
+    "riddles": [
+        "riddle", "puzzle", "brain teaser", "what am I", "guess", 
+        "mystery", "conundrum", "enigma", "paradox", "trick question", 
+        "wordplay", "challenge", "logic puzzle", "mind bender", 
+        "cryptic", "clue", "riddle me this", "solve", "answer", "question"
+    ]
+}

utils/prompt_toggle.py

@@ -0,0 +1,59 @@
+import os
+import re
+import yaml
+
+from typing import Any, Dict, List
+from langchain.prompts import PromptTemplate
+
+cwd: str = os.getcwd()
+propmt_file_path: str = os.path.join(cwd, "utils/prompts.yaml")
+
+# Load prompts from yaml
+def load_prompts():
+    try:
+        with open(propmt_file_path, "r") as f:
+            return yaml.safe_load(f)['prompts']
+    except Exception as e:
+        print(f"Reading prompts file has failed {e}")
+
+# Preprocess text and keywords
+def __preprocess_text(text: str) -> List[Any]:
+    return re.findall(r'\b\w+\b', text.lower())
+
+def __preprocess_keywords(keywords: Dict[str, List[str]]) -> Dict[str, List[str]]:
+    preprocessed_keywords = {}
+    for category, kw_list in keywords.items():
+        preprocessed_keywords[category] = set(kw.lower() for kw in kw_list)
+    return preprocessed_keywords
+
+# Check for keywords in input text
+def __check_for_keywords(text: str, keywords: Dict[str, List[str]]) -> Dict[str, List[str]]:
+    preprocessed_keywords = __preprocess_keywords(keywords)
+    matched_keywords = {category: [] for category in keywords}
+    words = __preprocess_text(text)
+    
+    for word in words:
+        for category, kw_set in preprocessed_keywords.items():
+            if word in kw_set:
+                matched_keywords[category].append(word)
+    
+    matched_keywords = {category: list(set(matches)) for category, matches in matched_keywords.items() if matches}
+    
+    return matched_keywords
+
+# Select the most appropriate prompt based on matched keywords
+def select_prompt(input_text: str, prompts: Any, keywords: Dict[str, List[str]]) -> str:
+    matched_keywords = __check_for_keywords(input_text, keywords)
+    matched_categories = list(matched_keywords.keys())
+    
+    # Default to the highest rated common prompt if no specific category is matched
+    selected_prompt = max((p for p in prompts if 'common' in p['purpose']), key=lambda p: p['rate'], default=None)
+    
+    for category in matched_categories:
+        category_prompts = [p for p in prompts if category in p['purpose']]
+        if category_prompts:
+            selected_prompt = max(category_prompts, key=lambda p: p['rate'], default=selected_prompt)
+
+    prompt_template = PromptTemplate(template=selected_prompt['prompt_template'], input_variables=['entity'])
+    prompt = prompt_template.format(entity=input_text)
+    return prompt

utils/prompts.yaml

@@ -0,0 +1,95 @@
+# https://www.promptingguide.ai/techniques/
+
+# Add more examples of the template here, id should be an interval from 0 to 99_999 
+# The description provides a basic overview of the template, the description should include the level of difficulty, 
+# the name of the prompting method and end with the word "prompt", e.g. "short prompt" or "zero-shot thought chain prompt
+# The prompt is rated from 0 to 10
+# common purpose means that the prompt fits for all situations
+
+prompts:
+  - id: 0
+    prompt_template: |
+        Instruction: You are a voice assistant who enjoys to help people called Chelsea
+        Question: {entity}
+        Answer:
+    description: main prompt
+    rate: 8
+    purpose: ['common']
+
+  - id: 1
+    prompt_template: |
+        Instruction: just give a response
+        Question: {entity}
+        Answer: 
+    description: a simple prompt
+    rate: 1
+    purpose: ['common']
+
+  - id: 2
+    prompt_template: |
+        Instruction: Write a concise answer on the question with one example if it's possible. CONCISE ANSWER.
+        Question: {entity}
+        Answer: 
+    description: concise prompt
+    rate: 3
+    purpose: ['common']
+
+# useful for solving simple math task 
+  - id: 3
+    prompt_template: |
+        Instruction: Let's think step by step.
+        Question: {entity}
+        Answer: 
+    description: zero-shot chain-of-thoughts prompt
+    rate: 4
+    purpose: ['math', 'physics', 'technology']
+
+# another one example for solving simple math task 
+  - id: 4
+    prompt_template: |
+        Instruction:       
+            Q: Roger has 5 tennis balls. He buys 2 more cans of tennis balls.
+               Each can has 3 tennis balls. How many tennis balls does he have now?
+            A: Roger started with 5 balls. 2 cans of 3 tennis balls each is 6 tennis balls. 5 + 6 = 11. The answer is 11.
+        Question: {entity}
+        Answer:
+    description: few-shot chain-of-thoughts prompt
+    rate: 4
+    purpose: ['riddles']
+    
+  - id: 5
+    prompt_template: |
+        Instruction: 
+            Q: There are 15 trees in the grove. Grove workers will plant trees in the grove today. After they are done,
+               there will be 21 trees. How many trees did the grove workers plant today?
+            A: We start with 15 trees. Later we have 21 trees. The difference must be the number of trees they planted.
+               So, they must have planted 21 - 15 = 6 trees. The answer is 6.
+            Q: If there are 3 cars in the parking lot and 2 more cars arrive, how many cars are in the parking lot?
+            A: There are 3 cars in the parking lot already. 2 more arrive. Now there are 3 + 2 = 5 cars. The answer is 5.
+            Q: Leah had 32 chocolates and her sister had 42. If they ate 35, how many pieces do they have left in total?
+            A: Leah had 32 chocolates and Leah`s sister had 42. That means there were originally 32 + 42 = 74
+               chocolates. 35 have been eaten. So in total they still have 74 - 35 = 39 chocolates. The answer is 39.
+            Q: Jason had 20 lollipops. He gave Denny some lollipops. Now Jason has 12 lollipops. How many lollipops
+               did Jason give to Denny?
+            A: Jason had 20 lollipops. Since he only has 12 now, he must have given the rest to Denny. The number of
+               lollipops he has given to Denny must have been 20 - 12 = 8 lollipops. The answer is 8.
+            Q: Shawn has five toys. For Christmas, he got two toys each from his mom and dad. How many toys does
+               he have now?
+            A: He has 5 toys. He got 2 from mom, so after that he has 5 + 2 = 7 toys. Then he got 2 more from dad, so
+               in total he has 7 + 2 = 9 toys. The answer is 9.
+            Q: There were nine computers in the server room. Five more computers were installed each day, from
+               monday to thursday. How many computers are now in the server room?
+            A: There are 4 days from monday to thursday. 5 computers were added each day. That means in total 4 * 5 =
+               20 computers were added. There were 9 computers in the beginning, so now there are 9 + 20 = 29 computers.
+               The answer is 29.
+            Q: Michael had 58 golf balls. On tuesday, he lost 23 golf balls. On wednesday, he lost 2 more. How many
+               golf balls did he have at the end of wednesday?
+            A: Michael initially had 58 balls. He lost 23 on Tuesday, so after that he has 58 - 23 = 35 balls. On
+               Wednesday he lost 2 more so now he has 35 - 2 = 33 balls. The answer is 33.
+            Q: Olivia has $23. She bought five bagels for $3 each. How much money does she have left?
+            A: She bought 5 bagels for $3 each. This means she spent $15. She has $8 left.
+        Question: {entity}
+        Answer: 
+    description: self-consistency prompt
+    rate: 6
+    purpose: ['riddles']