- Adding multiple models from API and upgrading OpenAI

- Adding PromptEngine layer before each request
- Modifying system prompts and all prompts
- Modifying the protection layer
- Adding model selection to UI
- Adding open-sourced models

Config_files/message_system_config.json

@@ -21,7 +21,7 @@
   "AI_phrases_singeo": ["your voice deserves more"],
   "header_limit": 30,
   "message_limit": 110,
-  "LLM_models": ["4o-mini", "gpt-4o", "deepseek-r1:1.5b", "gemma3:4b"]
+  "LLM_models": ["4o-mini", "gpt-4o", "gpt-4.1-nano", "gpt-4.1-mini", "gpt-3.5-turbo", "o4-mini", "o1"]
 }
 
 

Messaging_system/LLM.py

@@ -21,6 +21,7 @@ class LLM:
         self.model_type = "openai" # valid values -> ["openai", "ollama"]
         self.client = None
         self.connect_to_llm()
+        self.reasoning = {}
 
 
     def get_response(self, prompt, instructions):
@@ -38,11 +39,14 @@ class LLM:
         connect to selected llm -> ollama or openai connection
         :return:
         """
-        openai_models = ["4o-mini", "gpt-4o", "gpt-4.1-nano"]
+        openai_models = ["4o-mini", "gpt-4o", "gpt-4.1-nano", "gpt-3.5-turbo", "gpt-4.1-mini"]
+        reasoning = ["o1", "o4-mini"]
         ollama_models = ["deepseek-r1:1.5b", "gemma3:4b", "deepseek-r1:7b", "gemma3:4b"]
 
         if self.Core.model in openai_models:
             self.model_type = "openai"
+            if self.Core.model in reasoning:
+                self.reasoning= {"effort": "medium"}
 
         if self.Core.model in ollama_models:
             self.model_type = "ollama"
@@ -51,27 +55,28 @@ class LLM:
         self.model = self.Core.model
 
 
-
     def get_message_openai(self, prompt, instructions, max_retries=4):
-        """
-        sending the prompt to openai LLM and get back the response
-        """
+
 
         openai.api_key = self.Core.api_key
         client = OpenAI(api_key=self.Core.api_key)
 
         for attempt in range(max_retries):
             try:
-                response = client.chat.completions.create(
+                response = client.responses.create(
                     model=self.Core.model,
-                    response_format={"type": "json_object"},
-                    messages=[
-                        {"role": "system", "content": instructions},
-                        {"role": "user", "content": prompt}
-                    ],
-                    max_tokens=500,
-                    n=1,
+                    input=[{"role": "system", "content": instructions},
+                            {"role": "user", "content": prompt}],
+                    text={
+                        "format": {
+                            "type": "json_object"
+                        }
+                    },
+                    reasoning=self.reasoning,
+                    max_output_tokens=500,
                     temperature=self.Core.temperature,
+                    top_p=1,
+                    tools=[],
                 )
 
                 tokens = {
@@ -120,6 +125,76 @@ class LLM:
         print("Max retries exceeded. Returning empty response.")
         return None
 
+
+
+    # def get_message_openai(self, prompt, instructions, max_retries=4):
+    #     """
+    #     sending the prompt to openai LLM and get back the response
+    #     """
+    #
+    #     openai.api_key = self.Core.api_key
+    #     client = OpenAI(api_key=self.Core.api_key)
+    #
+    #     for attempt in range(max_retries):
+    #         try:
+    #             response = client.chat.completions.create(
+    #                 model=self.Core.model,
+    #                 response_format={"type": "json_object"},
+    #                 messages=[
+    #                     {"role": "system", "content": instructions},
+    #                     {"role": "user", "content": prompt}
+    #                 ],
+    #                 max_tokens=500,
+    #                 n=1,
+    #                 temperature=self.Core.temperature,
+    #             )
+    #
+    #             tokens = {
+    #                 'prompt_tokens': response.usage.prompt_tokens,
+    #                 'completion_tokens': response.usage.completion_tokens,
+    #                 'total_tokens': response.usage.total_tokens
+    #             }
+    #
+    #             try:
+    #                 content = response.choices[0].message.content
+    #
+    #                 # Extract JSON code block
+    #
+    #                 output = json.loads(content)
+    #
+    #                 if 'message' not in output or 'header' not in output:
+    #                     print(f"'message' or 'header' is missing in response on attempt {attempt + 1}. Retrying...")
+    #                     continue  # Continue to next attempt
+    #
+    #                 else:
+    #                     if len(output["header"].strip()) > self.Core.config_file["header_limit"] or len(
+    #                             output["message"].strip()) > self.Core.config_file["message_limit"]:
+    #                         print(
+    #                             f"'header' or 'message' is more than specified characters in response on attempt {attempt + 1}. Retrying...")
+    #                         continue
+    #
+    #                 # validating the JSON
+    #                 self.Core.total_tokens['prompt_tokens'] += tokens['prompt_tokens']
+    #                 self.Core.total_tokens['completion_tokens'] += tokens['completion_tokens']
+    #                 self.Core.temp_token_counter += tokens['total_tokens']
+    #                 return output
+    #
+    #             except json.JSONDecodeError:
+    #                 print(f"Invalid JSON from LLM on attempt {attempt + 1}. Retrying...")
+    #
+    #         except openai.APIConnectionError as e:
+    #             print("The server could not be reached")
+    #             print(e.__cause__)  # an underlying Exception, likely raised within httpx.
+    #         except openai.RateLimitError as e:
+    #             print("A 429 status code was received; we should back off a bit.")
+    #         except openai.APIStatusError as e:
+    #             print("Another non-200-range status code was received")
+    #             print(e.status_code)
+    #             print(e.response)
+    #
+    #     print("Max retries exceeded. Returning empty response.")
+    #     return None
+
     # ======================================================================
 
     def get_message_ollama(self, prompt, instructions, max_retries=10):

Messaging_system/MultiMessage.py

@@ -1,6 +1,8 @@
 import json
 import time
 from openai import OpenAI
+
+from Messaging_system.PromptEng import PromptEngine
 from Messaging_system.protection_layer import ProtectionLayer
 import openai
 from Messaging_system.LLM import LLM
@@ -13,6 +15,7 @@ class MultiMessage:
         """
         self.Core = CoreConfig
         self.llm = LLM(CoreConfig)
+        self.engine = PromptEngine(self.Core)
 
     # --------------------------------------------------------------
     def generate_multi_messages(self, user):
@@ -107,8 +110,10 @@ class MultiMessage:
         # 1) Build a prompt that includes only those last two messages
         prompt = self.generate_prompt(context, step)
 
+        new_prompt = self.engine.prompt_engineering(prompt)
+
         # 2) Call our existing LLM routine
-        response_dict = self.llm.get_response(prompt=prompt, instructions=self.llm_instructions())
+        response_dict = self.llm.get_response(prompt=new_prompt, instructions=self.llm_instructions())
 
         return response_dict
 

Messaging_system/PromptEng.py

@@ -0,0 +1,86 @@
+"""
+This is the prompt engineering layer to modifty the prompt for better perfromance
+"""
+import openai
+from openai import OpenAI
+
+
+class PromptEngine:
+
+    def __init__(self, coreconfig):
+        self.Core=coreconfig
+
+    # =============================================================
+    def prompt_engineering(self, prompt):
+        """
+        prompt engineering layer to modify the prompt as needed
+        :param prompt:
+        :return:
+        """
+
+        new_prompt = self.get_llm_response(prompt)
+        return new_prompt
+
+    # ============================================================
+    def llm_instructions(self):
+
+        system_prompt = """
+        You are a prompt engineer. Rewrite the following prompt to be clearer, more specific, and likely to produce a better response from an LLM following best prompt engineering techniques and styles.
+        """
+
+        return system_prompt
+
+    # =============================================================
+
+    def get_llm_response(self, prompt, max_retries=4):
+        """
+        sending the prompt to openai LLM and get back the response
+        """
+
+        openai.api_key = self.Core.api_key
+        client = OpenAI(api_key=self.Core.api_key)
+
+        for attempt in range(max_retries):
+            try:
+                response = client.chat.completions.create(
+                    model=self.Core.model,
+                    response_format={"type": "text"},
+                    messages=[
+                        {"role": "system", "content": self.llm_instructions()},
+                        {"role": "user", "content": prompt}
+                    ],
+                    max_tokens=1000,
+                    n=1,
+                    temperature=self.Core.temperature,
+                )
+
+                tokens = {
+                    'prompt_tokens': response.usage.prompt_tokens,
+                    'completion_tokens': response.usage.completion_tokens,
+                    'total_tokens': response.usage.total_tokens
+                }
+
+
+                content = response.choices[0].message.content
+                output = str(content)
+
+                # validating the JSON
+                self.Core.total_tokens['prompt_tokens'] += tokens['prompt_tokens']
+                self.Core.total_tokens['completion_tokens'] += tokens['completion_tokens']
+                self.Core.temp_token_counter += tokens['total_tokens']
+                return output
+
+            except openai.APIConnectionError as e:
+                print("The server could not be reached")
+                print(e.__cause__)  # an underlying Exception, likely raised within httpx.
+            except openai.RateLimitError as e:
+                print("A 429 status code was received; we should back off a bit.")
+            except openai.APIStatusError as e:
+                print("Another non-200-range status code was received")
+                print(e.status_code)
+                print(e.response)
+
+        print("Max retries exceeded. Returning empty response.")
+        return prompt # returns original prompt if needed
+
+    # ==========================================================================

Messaging_system/PromptGenerator.py

@@ -3,6 +3,7 @@ THis class generate proper prompts for the messaging system
 """
 import pandas as pd
 from tqdm import tqdm
+from Messaging_system.PromptEng import PromptEngine
 
 
 class PromptGenerator:
@@ -18,16 +19,19 @@ class PromptGenerator:
         :return:
         """
 
+        engine = PromptEngine(self.Core)
+
         # if we have personalized information about them, we generate a personalized prompt
         for idx, row in tqdm(self.Core.users_df.iterrows(), desc="generating prompts"):
             # check if we have enough information to generate a personalized message
             prompt = self.generate_personalized_prompt(user=row)
-            # message = self.call_llm(prompt)
-            self.Core.users_df.at[idx, "prompt"] = prompt
+            new_prompt = engine.prompt_engineering(prompt)
+            self.Core.users_df.at[idx, "prompt"] = new_prompt
             self.Core.users_df.at[idx, "source"] = "AI-generated"
 
         return self.Core
 
+
     # --------------------------------------------------------------
     def safe_get(self, value):
         return str(value) if pd.notna(value) else "Not available"

Messaging_system/protection_layer.py

@@ -2,11 +2,6 @@
 protection layer on top of the messaging system to make sure the messages are as expected.
 """
 
-import json
-import os
-import openai
-from openai import OpenAI
-from dotenv import load_dotenv
 from Messaging_system.LLM import LLM
 
 
@@ -29,125 +24,106 @@ class ProtectionLayer:
         }
 
     # --------------------------------------------------------------
-    def llm_instructions(self):
+    # ----------------------------------------------------------------------
+    def llm_instructions(self) -> str:
         """
-        Setting instructions for the LLM for the second pass.
+        System-level directions for the *second-pass* LLM that either approves
+        or fixes a push-notification draft produced earlier.
         """
 
         jargon_list = "\n".join(f"- {word}" for word in self.Core.config_file["AI_Jargon"])
 
-        instructions = f"""
-
-        You are friendly copywriter. Your job is to *either* approve the candidate message or return a corrected version that obeys the style guide.
-        the 'header' and a 'message' as a push notification should sounds like everyday speech—friendly, short, no jargon, following the instructions.
-        
-        ABSOLUTE RULE – OVERRIDES EVERYTHING ELSE: 
-        Always Capitalize the first word of 'header' and 'message'
-        The message should sounds like a normal person, something that people normally say in daily conversations. This is the most important part of the message, the message should sounds like a normal and casual conversation. 
-        If the header or message contains any banned word or phrases, you must rewrite the offending sentence so that **none** of those words or phrases(case-insensitive; singular, plural, verb forms, or their derivatives)
-        remain. If no banned words or phrases are present, leave the text unchanged. Return only valid JSON.
-        
-        Banned word:
-        {jargon_list}
-        
-        Banned phrases:
-        Voice is NOT an instrument, so avoid below phrases and similar ones like below:
-        - Your voice is waiting
-        - Your voice awaits
-        - Your voice needs you
-        - Your voice is calling
-        - Your voice deserves more
-        - ...
-        
-        """
-        return instructions
+        return f"""
+    You are a friendly copy-writer. **Approve the candidate JSON as-is, or
+    return a corrected version that obeys every rule below.**
+
+    ABSOLUTE RULES (override everything else)
+    • Output **only** valid JSON with exactly two keys: "header" and "message".
+    • Capitalize the **first** word in each value.
+    • Keep the original if it already passes every rule.
+
+    STYLE
+    • Sound like everyday speech: casual, friendly, concise.
+    • No greetings or sign-offs.
+
+    JARGON / BANNED CONTENT
+    • Never use any of these words (case-insensitive, all forms):
+    {jargon_list}
+
+    • Never use or paraphrase the following phrases (Voice ≠ instrument):
+      - Your voice is waiting
+      - Your voice awaits
+      - Your voice needs you
+      - Your voice is calling
+      - Your voice deserves more
+      - Hit the high notes
+    """
 
-        # --------------------------------------------------------------
-    def get_general_rules(self):
+    # ----------------------------------------------------------------------
+    def get_general_rules(self) -> str:
         """
-        Core rules to apply when checking or modifying the message.
+        Validation rules applied to both 'header' and 'message'.
         """
 
-
-        return f"""
-    - No two consecutive sentences should end with exclamation points, change one of them to dot. 
-    - Header and message should Start directly with the message content without greetings or closing phrases (every word counts).
-    - First word of the 'header' and 'message' as well as names or any proper nouns **MUST** be Capitalized.
-    - If there is any grammar error in the message, you must fix it.
-    - Do not include any words that explicitly or implicitly reference a time-related concept (e.g., “new,” “recent,” “latest,” “upcoming,” etc.). 
-    - Preserve the original JSON structure: {{"header": "...", "message": "..."}}; The output must be strictly a valid JSON with no extra commentary or text.
-    - Would a normal freind text this to a friend? If not, modify it as needed.
-    - If no rule is violated, return the exact same JSON unchanged.
+        return """
+    - No two consecutive sentences may both end with '!'. Change one to '.'.
+    - Begin directly with content—no greetings or closings.
+    - Capitalize the first word and any proper noun.
+    - Fix any grammar or spelling errors.
+    - Remove words that imply recency (e.g. “new”, “latest”, “upcoming”).
+    - Would a friendly musician casually say such message? If not, rewrite.
+    - Preserve the exact JSON structure: {"header":"...", "message":"..."}.
+    - If no rule is violated, return the JSON unchanged.
     """
 
-    # --------------------------------------------------------------
-    def output_instruction(self):
+    # ----------------------------------------------------------------------
+    def output_instruction(self) -> str:
         """
-        :return: output instructions as a string
+        Explicit output contract (shown last so it’s freshest in token memory).
         """
-        instructions = f"""
-        **You must output only valid JSON in the form:**
-        
-        {{
-          "header": "Original header or modified version",
-          "message": "Original header or modified version"
-        }}
-        
-
-        **Constraints:**
-            - The "header" must be less than 30 character. 
-            - The "message" must be less than 100 character.
-            - No text is allowed outside this JSON structure.\n"
-        """
-
-        return instructions
+        return """
+    **Return ONLY JSON, nothing else**
+
+    {
+      "header": "Header text here",
+      "message": "Message text here"
+    }
+
+    Constraints
+    - "header" ≤ 30 characters (including spaces & punctuation)
+    - "message" ≤ 100 characters
+    - Do NOT add, remove, or rename keys.
+    """
 
-    # --------------------------------------------------------------
-    # --------------------------------------------------------------
-    def get_context(self):
+    # ----------------------------------------------------------------------
+    def get_context(self) -> str:
         """
-        context for the LLM
-        :return: the context string
+        High-level context for the LLM.
         """
-        context = (
-            "We created a personalized message for a user "
-            "considering the provided information. Your task is to double-check "
-            "the message and correct or improve the output, according to instructions."
+        return (
+            "We generated a personalized push-notification. "
+            "Please check it against the rules and fix only what is necessary."
         )
-        return context
 
-    # --------------------------------------------------------------
-    def generate_prompt(self, message, user):
+    # ----------------------------------------------------------------------
+    def generate_prompt(self, message: str, user: dict) -> str:
         """
-        generating the prompt for criticizing
-        :param query: input query
-        :param message: llm response
-        :return: new prompt
+        Combine all pieces into the final prompt sent to the validator LLM.
         """
-        # recommended_content = ""
-        # if self.Core.messaging_mode == "recsys_result":
-        #     recommended_content = f"""
-        # ### ** Recommended Content **
-        # {user['recommendation_info']}
-        #     """
 
         prompt = f"""
-        
-        ### Context:
-        We created a personalized push notification message based on available information. 
-        Your job is to check the message and correct only if it violates rules. Otherwise, leave it unchanged.
- 
+    ### Context
+    {self.get_context()}
 
-        ### Original JSON Message:
-        {message}
+    ### Original JSON
+    {message}
 
-        ### Rules:
-        {self.get_general_rules()}
-
-        ### Output Requirements:
-        {self.output_instruction()}
-        """
+    ### Rules
+    {self.get_general_rules()}
 
+    ### Output Contract
+    {self.output_instruction()}
+    """
         return prompt
 
     # --------------------------------------------------------------