Admin: Add package definition (__init__.py) and Continuous Integration (CI) pipeline.

.github/workflows/main_ci.yml

@@ -0,0 +1,36 @@
+name: Application CI/CD Pipeline
+
+on:
+  push:
+    branches:
+      - main
+      - develop
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build_and_test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository code
+        uses: actions/checkout@v4
+
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        # Install the dependencies needed for the application
+        run: pip install -r requirements.txt
+
+      - name: Run Smoke Test on Core Logic
+        # This checks if the core_logic file can run without errors
+        # Note: API call might fail if key is not available in CI, but file paths will be checked
+        run: |
+          # Create a dummy .env file for the CI runner to avoid errors
+          echo "OPENROUTER_API_KEY=dummy_key_for_ci_test" > .env
+          
+          # Run the test block inside core_logic.py
+          python app/core_logic.py

.github/workflows/scheduled_opt.yml

@@ -0,0 +1,38 @@
+name: Scheduled Prompt Optimization
+
+on:
+  # Run every day at midnight UTC
+  schedule:
+    - cron: '0 0 * * *'
+  # Allows manual triggering from the GitHub Actions tab
+  workflow_dispatch:
+
+jobs:
+  optimize_and_commit:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: pip install -r requirements.txt
+
+      - name: Run Prompt Optimization Script
+        env:
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+        run: python scripts/optimize_prompt.py
+
+      - name: Commit and Push changes
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: 'MLOps: Auto-updated master_prompt.json based on user feedback.'
+          file_pattern: |
+            data/master_prompt.json
+            data/feedback_log.json

.gitignore

@@ -0,0 +1,8 @@
+# Virtual Environment
+venv/
+# Secret Key
+.env
+# Python Caching
+__pycache__/
+# Gradio cache
+.gradio/

app/core_logic.py

@@ -0,0 +1,161 @@
+import os
+import json
+import datetime
+# Import Path for robust file handling
+from pathlib import Path 
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# --- Configuration & Initialization ---
+# Load environment variables from .env file
+load_dotenv()
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+
+# OpenRouter client setup
+client = OpenAI(
+    base_url="https://openrouter.ai/api/v1",
+    api_key=OPENROUTER_API_KEY,
+)
+
+# --- CORRECTED PATH HANDLING ---
+# The root of the project is two levels up from 'app/core_logic.py'
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+# Use Path objects for reliable access
+MASTER_PROMPT_PATH = PROJECT_ROOT / "data" / "master_prompt.json"
+FEEDBACK_LOG_PATH = PROJECT_ROOT / "data" / "feedback_log.json"
+
+# --- CORRECTED LLM Model IDs ---
+# Swapping to a confirmed free model ID on OpenRouter
+TASK_LLM_MODEL = "x-ai/grok-4-fast" 
+# Keeping the Meta-LLM for later use
+META_LLM_MODEL = "x-ai/grok-4-fast" 
+
+
+def load_master_prompt():
+    """Loads the current system message from the master configuration file."""
+    try:
+        # Using Path.read_text() is clean and safe
+        return json.loads(MASTER_PROMPT_PATH.read_text())
+    except FileNotFoundError:
+        # Create the file with initial data if it doesn't exist
+        initial_data = {
+            "system_message": "Error: Master prompt file not found.",
+            "model_name": TASK_LLM_MODEL,
+            "version": "0.0.0",
+            "last_updated": datetime.datetime.now().isoformat()
+        }
+        with open(MASTER_PROMPT_PATH, 'w') as f:
+             json.dump(initial_data, f, indent=4)
+        return initial_data
+    except Exception as e:
+        print(f"Error loading master prompt: {e}")
+        return {"system_message": f"CRITICAL ERROR: {e}"}
+
+
+def rewrite_and_generate(user_input: str) -> tuple[str, str]:
+    """
+    1. Loads the system prompt.
+    2. Sends the combined prompt to the Task-LLM via OpenRouter.
+    3. Returns the rewritten prompt (for user visibility) and the final response.
+    """
+    if not user_input:
+        return "Please enter a question.", "---"
+
+    config = load_master_prompt()
+    system_message = config.get("system_message", "")
+    
+    # The Meta-Prompt for the LLM to structure its own output
+    rewrite_instruction = (
+        "TASK: First, rewrite the following VAGUE_INPUT into a highly specific and professional instruction (the 'OPTIMIZED PROMPT'). "
+        "The optimized prompt MUST include a clear Persona, the desired Output Format, and clear Constraints. "
+        "Second, provide the final answer based on the OPTIMIZED PROMPT. "
+        "Format your output strictly as: \n\n<OPTIMIZED_PROMPT>\n\n<FINAL_RESPONSE>"
+    )
+
+    full_prompt = f"VAGUE_INPUT: {user_input}"
+
+    messages = [
+        {"role": "system", "content": system_message + " " + rewrite_instruction},
+        {"role": "user", "content": full_prompt}
+    ]
+
+    try:
+        response = client.chat.completions.create(
+            model=TASK_LLM_MODEL,
+            messages=messages,
+            temperature=0.7,
+            max_tokens=2048,
+        )
+        
+        raw_output = response.choices[0].message.content.strip()
+        
+        if "\n\n" in raw_output:
+            # We use .split("\n\n", 1) to ensure we only split on the first occurrence
+            optimized_prompt, final_response = raw_output.split("\n\n", 1)
+        else:
+            optimized_prompt = "--- (Parsing Error: Could not separate prompt and response. The LLM output might not follow the required format.)"
+            final_response = raw_output
+
+        return optimized_prompt.strip(), final_response.strip()
+
+    except Exception as e:
+        return (
+            f"ERROR: Failed to connect to OpenRouter API. Check key/internet. Details: {e}",
+            "---"
+        )
+
+
+def log_feedback(
+    original_prompt: str,
+    optimized_prompt: str,
+    final_response: str,
+    rating: int
+):
+    """Logs the interaction data and user feedback to the JSON log file."""
+    
+    new_entry = {
+        "timestamp": datetime.datetime.now().isoformat(),
+        "original_prompt": original_prompt,
+        "optimized_prompt": optimized_prompt,
+        "final_response": final_response,
+        "rating": rating
+    }
+
+    try:
+        # 1. Load existing data
+        if FEEDBACK_LOG_PATH.exists():
+            with open(FEEDBACK_LOG_PATH, 'r') as f:
+                # Handle case where file is empty (e.g., just '[]')
+                content = f.read().strip()
+                data = json.loads(content) if content else []
+        else:
+            data = []
+        
+        # 2. Append new entry and write back
+        data.append(new_entry)
+        
+        with open(FEEDBACK_LOG_PATH, 'w') as f:
+            json.dump(data, f, indent=4)
+        
+        return "Feedback Logged successfully! Thank you."
+    
+    except Exception as e:
+        return f"ERROR: Could not log feedback to JSON file. Details: {e}"
+
+# If you run this file directly, it runs a quick test:
+if __name__ == "__main__":
+    print("--- Testing Core Logic ---")
+    
+    # Check loading
+    config = load_master_prompt()
+    print(f"Current System Message: {config.get('system_message', 'N/A')}")
+    
+    # Test generation
+    opt_prompt, response = rewrite_and_generate("Tell me about the biggest planet in our solar system.")
+    print("\n[Optimized Prompt]:\n", opt_prompt)
+    print("\n[Final Response]:\n", response)
+
+    # Test logging
+    log_status = log_feedback("Vague Test", opt_prompt, response, 1)
+    print("\n[Log Status]:", log_status)

app/gradio_interface.py

@@ -0,0 +1,144 @@
+import gradio as gr
+from app.core_logic import rewrite_and_generate, log_feedback
+
+# --- State Variables ---
+# Gradio needs a way to temporarily store the original prompt and response 
+# to be used by the separate feedback button.
+
+# These will hold the current interaction data
+current_original_prompt = gr.State("")
+current_optimized_prompt = gr.State("")
+current_final_response = gr.State("")
+
+
+# --- Helper Functions for Gradio UI ---
+
+def process_submission(user_input):
+    """Handles the full workflow: calling the LLM and storing results."""
+    
+    # 1. Call the core logic function
+    optimized_prompt, final_response = rewrite_and_generate(user_input)
+    
+    # 2. Return new UI values and update internal state variables
+    # The return order must match the output components in the 'Submit' button click event.
+    return (
+        optimized_prompt, 
+        final_response, 
+        user_input,          # New state for original_prompt
+        optimized_prompt,    # New state for optimized_prompt
+        final_response       # New state for final_response
+    )
+
+def handle_feedback(rating_value, orig_prompt, opt_prompt, final_resp):
+    """Handles the user clicking the feedback button."""
+    if not orig_prompt:
+        return "Error: Please run a query first before providing feedback."
+    
+    # 1. Map the string rating to an integer (1 for thumbs up, 0 for thumbs down)
+    rating_int = 1 if rating_value == "👍 Excellent" else 0
+    
+    # 2. Call the core logic function to log data
+    log_message = log_feedback(orig_prompt, opt_prompt, final_resp, rating_int)
+    
+    # 3. Clear the state variables after successful logging
+    return log_message, "", "", ""
+
+
+# --- Gradio Interface Layout ---
+
+with gr.Blocks(title="IPO-Meta: Prompt Optimizer") as demo:
+    gr.Markdown("# ✨ IPO-Meta: Intelligent Prompt Optimizer")
+    gr.Markdown(
+        "Enter a question, and our system will automatically rewrite it into a **high-quality, structured prompt** (powered by LLMs) "
+        "before generating the final answer. Provide feedback to improve the system's core instruction over time! (The MLOps loop)"
+    )
+
+    # --- INPUT SECTION ---
+    with gr.Row():
+        user_input = gr.Textbox(
+            label="1. Your Vague Question/Input:",
+            placeholder="e.g., Tell me about quantum computing.",
+            lines=3
+        )
+        
+    # --- SUBMIT BUTTON ---
+    submit_btn = gr.Button("🚀 Optimize Prompt & Generate Response")
+
+    # --- OUTPUT SECTION ---
+    with gr.Row():
+        optimized_output = gr.Textbox(
+            label="2. Optimized Prompt (The System's Suggestion):",
+            lines=4,
+            interactive=False,
+            elem_id="optimized_prompt"
+        )
+    
+    final_response_output = gr.Markdown(
+        "**3. Final AI Response:**\n\n---",
+        elem_id="final_response_area"
+    )
+
+    # --- FEEDBACK SECTION ---
+    gr.Markdown("---")
+    gr.Markdown("### 4. Continuous Improvement Feedback (The MLOps Data)")
+    
+    with gr.Row():
+        feedback_status = gr.Textbox(
+            label="Feedback Status", 
+            value="Waiting for feedback...", 
+            interactive=False,
+            scale=2
+        )
+        
+        # Radio buttons for clear feedback
+        feedback_radio = gr.Radio(
+            ["👍 Excellent", "👎 Needs Work"],
+            label="Did the Optimized Prompt result in a good response?",
+            value=None, # No default selection
+            scale=1
+        )
+        
+        feedback_btn = gr.Button("💾 Log Feedback")
+
+    # --- STATE MANAGEMENT (Hidden) ---
+    # These hidden components store the data needed by the feedback handler
+    current_original_prompt.render()
+    current_optimized_prompt.render()
+    current_final_response.render()
+
+    # --- Event Handling ---
+    
+    # When 'Submit' is clicked:
+    submit_btn.click(
+        fn=process_submission,
+        inputs=[user_input],
+        outputs=[
+            optimized_output,
+            final_response_output,
+            current_original_prompt,
+            current_optimized_prompt,
+            current_final_response
+        ]
+    )
+    
+    # When 'Log Feedback' is clicked:
+    feedback_btn.click(
+        fn=handle_feedback,
+        inputs=[
+            feedback_radio,
+            current_original_prompt,
+            current_optimized_prompt,
+            current_final_response
+        ],
+        outputs=[
+            feedback_status, 
+            current_original_prompt, # Clear state on successful log
+            current_optimized_prompt, # Clear state on successful log
+            current_final_response # Clear state on successful log
+        ]
+    )
+    
+# Launch the Gradio app
+if __name__ == "__main__":
+    # Note: To run locally, your OpenRouter API key must be set in the .env file.
+    demo.launch()

data/feedback_log.json

@@ -0,0 +1,23 @@
+[
+    {
+        "timestamp": "2025-09-28T16:15:04.042900",
+        "original_prompt": "Vague Test",
+        "optimized_prompt": "ERROR: Failed to connect to OpenRouter API. Check key/internet. Details: Error code: 400 - {'error': {'message': 'deepseek/deepseek-v3-0324:free is not a valid model ID', 'code': 400}, 'user_id': 'user_32wobDRyaUhuLgKrre5COzxeNDH'}",
+        "final_response": "---",
+        "rating": 1
+    },
+    {
+        "timestamp": "2025-09-28T16:16:27.080462",
+        "original_prompt": "Vague Test",
+        "optimized_prompt": "<OPTIMIZED_PROMPT>\nYou are an expert astronomer and science communicator with a passion for making complex topics accessible to everyone. Your role is to educate users on celestial bodies in an engaging, accurate, and straightforward manner.",
+        "final_response": "Task: Provide a comprehensive yet concise overview of the largest planet in our solar system, including its key characteristics, size comparison to other planets, and notable features.\n\nOutput Format: Start with a brief introductory paragraph explaining what the planet is and why it's the largest. Follow with 5-7 bullet points highlighting essential facts such as diameter, mass, composition, moons, and exploration history. End with a short concluding sentence on its significance.\n\nConstraints: Base all information on verified astronomical data from sources like NASA. Keep the language simple, engaging, and suitable for a general audience (ages 12+). Limit the total response to under 300 words. Do not include unrelated topics or speculation; focus solely on factual details. Ensure the response is positive and inspiring about space exploration.\n</OPTIMIZED_PROMPT>\n\n<FINAL_RESPONSE>\nJupiter is the largest planet in our solar system, a gas giant that dwarfs all others in size and mass, making it a fascinating subject for astronomers and space enthusiasts alike.\n\n- **Size and Scale**: Jupiter has a diameter of about 88,846 miles (142,984 kilometers) at its equator, roughly 11 times that of Earth\u2014over 1,300 Earths could fit inside it.\n- **Mass**: It is more than twice as massive as all the other planets combined, with a mass of 1.898 \u00d7 10^27 kilograms, contributing significantly to the solar system's overall gravity.\n- **Composition**: Primarily made of hydrogen (90%) and helium (10%), similar to the Sun, with swirling clouds of ammonia and water vapor creating its colorful bands.\n- **Great Red Spot**: This iconic storm, larger than Earth, has raged for at least 400 years and is a hallmark of Jupiter's turbulent atmosphere.\n- **Moons**: Jupiter boasts 95 known moons, including the four large Galilean moons\u2014Io, Europa, Ganymede, and Callisto\u2014discovered by Galileo in 1610.\n- **Rings**: It has a faint ring system made of dust particles, discovered by Voyager 1 in 1979.\n- **Exploration**: Pioneered by missions like Pioneer 10 (1973), Voyager (1979), and Juno (2016-present), which revealed its magnetic field and interior structure.\n\nJupiter's immense presence not only shapes our solar system but also inspires ongoing quests to uncover its secrets through future missions.\n</FINAL_RESPONSE>",
+        "rating": 1
+    },
+    {
+        "timestamp": "2025-09-28T16:24:58.358824",
+        "original_prompt": "Vague Test",
+        "optimized_prompt": "<OPTIMIZED_PROMPT>\nYou are an expert astronomer with a passion for making complex space topics accessible to everyone. Respond to the query about the largest planet in our solar system by providing an informative overview that includes its name, size compared to Earth, key physical characteristics, notable features like atmosphere and moons, and its role in the solar system. Structure the output as a concise paragraph (under 150 words) followed by 3-5 bullet points highlighting fun facts. Use simple, engaging language suitable for a general audience, ensuring all information is accurate and based on established astronomical knowledge. Do not include unrelated topics or speculation.\n</OPTIMIZED_PROMPT>",
+        "final_response": "<FINAL_RESPONSE>\nJupiter is the largest planet in our solar system, a gas giant that's about 11 times wider than Earth and has a mass more than twice that of all other planets combined. It's mostly made of hydrogen and helium, with swirling clouds of ammonia and water ice creating its famous colorful bands and massive storms, including the Great Red Spot\u2014a storm bigger than Earth that's raged for centuries. Jupiter orbits the Sun every 12 Earth years and plays a key role in protecting inner planets by gravitationally pulling in asteroids and comets.\n\n- Jupiter has at least 95 moons, with the four largest (Io, Europa, Ganymede, and Callisto) discovered by Galileo in 1610.\n- Its strong magnetic field creates auroras and intense radiation belts.\n- The planet's diameter is about 88,850 miles (143,000 km), making it visible to the naked eye from Earth.\n- NASA's Juno mission is currently studying Jupiter's atmosphere and interior up close.\n</FINAL_RESPONSE>",
+        "rating": 1
+    }
+]

data/master_prompt.json

@@ -0,0 +1,6 @@
+{
+  "system_message": "You are a friendly, helpful content assistant. Your task is to briefly answer the user's question, keeping the response concise and easy to understand for a general audience.",
+  "model_name": "google/gemma-7b-it:free",
+  "version": "1.0.0",
+  "last_updated": "2025-09-28T16:00:00Z"
+}

requirements.txt

@@ -0,0 +1,4 @@
+# Core application dependencies
+gradio
+openai          # Used to communicate with OpenRouter API
+python-dotenv   # Used to load API key from .env file

scripts/optimize_prompt.py

@@ -0,0 +1,157 @@
+import os
+import json
+import datetime
+from pathlib import Path
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# --- Configuration & Initialization ---
+load_dotenv()
+
+# The script runs from the 'scripts/' directory, so its root is one level up.
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+# File Paths
+MASTER_PROMPT_PATH = PROJECT_ROOT / "data" / "master_prompt.json"
+FEEDBACK_LOG_PATH = PROJECT_ROOT / "data" / "feedback_log.json"
+
+# LLM Model ID for Rewriting (Meta-LLM)
+META_LLM_MODEL = "x-ai/grok-4-fast" 
+# The minimum number of negative feedback entries required to trigger an update
+MIN_NEGATIVE_FEEDBACK = 3 
+
+
+def load_data(path: Path):
+    """Safely loads JSON data, handling empty file content."""
+    try:
+        if path.exists():
+            content = path.read_text().strip()
+            return json.loads(content) if content else []
+        return []
+    except Exception as e:
+        print(f"Error loading {path}: {e}")
+        return []
+
+def aggregate_negative_feedback(feedback_data: list) -> str:
+    """
+    Analyzes the feedback log to summarize only the negative (rating=0) feedback.
+    """
+    negative_feedback = [entry for entry in feedback_data if entry.get("rating") == 0]
+    
+    if len(negative_feedback) < MIN_NEGATIVE_FEEDBACK:
+        print(f"INFO: Only {len(negative_feedback)} negative entries found. Skipping optimization.")
+        return None
+
+    # Summarize the negative prompts that led to user dislike
+    summary = []
+    for entry in negative_feedback:
+        summary.append(
+            f"User disliked the response (Rating 0) after input: '{entry['original_prompt']}' "
+            f"The resulting OPTIMIZED PROMPT was: '{entry['optimized_prompt']}'"
+        )
+    
+    print(f"INFO: Aggregated {len(negative_feedback)} negative feedback entries.")
+    return "\n---\n".join(summary)
+
+
+def optimize_system_prompt(current_system_message: str, feedback_summary: str) -> str:
+    """
+    Calls the Meta-LLM to rewrite the system message based on negative feedback.
+    """
+    
+    # We define a strict Meta-Prompt for the Grok model to follow
+    meta_prompt = (
+        "You are the **System Prompt Optimizing Agent**. Your goal is to analyze the 'FAILED FEEDBACK' and rewrite the 'CURRENT SYSTEM MESSAGE' "
+        "to address the problems identified. The new system message must aim to improve the quality of future responses, making them more accurate, "
+        "detailed, or strictly adherent to formatting rules, based on the failure patterns. "
+        "You must output **ONLY** the new system message text, nothing else."
+    )
+
+    # The user message feeds the prompt and the negative data to the agent
+    user_message = f"""
+    CURRENT SYSTEM MESSAGE:
+    ---
+    {current_system_message}
+    ---
+    
+    FAILED FEEDBACK (You must incorporate lessons from this data):
+    ---
+    {feedback_summary}
+    ---
+    
+    Based ONLY on the above, rewrite the CURRENT SYSTEM MESSAGE to improve it.
+    New System Message:
+    """
+    
+    try:
+        # Call OpenRouter API with the Meta-LLM
+        client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=os.getenv("OPENROUTER_API_KEY"),
+        )
+
+        response = client.chat.completions.create(
+            model=META_LLM_MODEL,
+            messages=[
+                {"role": "system", "content": meta_prompt},
+                {"role": "user", "content": user_message}
+            ],
+            temperature=0.1, # Low temperature for reliable instruction following
+            max_tokens=512,
+        )
+        
+        new_prompt = response.choices[0].message.content.strip()
+        print("SUCCESS: New System Prompt generated by Meta-LLM.")
+        return new_prompt
+
+    except Exception as e:
+        print(f"CRITICAL ERROR: Meta-LLM API call failed: {e}")
+        return current_system_message # Return original prompt on failure
+
+
+def run_optimization():
+    """Main function for the MLOps pipeline script."""
+    print(f"--- Running Prompt Optimization Pipeline at {datetime.datetime.now()} ---")
+    
+    # 1. Load Data
+    current_config = load_data(MASTER_PROMPT_PATH)
+    feedback_data = load_data(FEEDBACK_LOG_PATH)
+    current_system_message = current_config.get("system_message", "")
+    
+    if not feedback_data:
+        print("INFO: Feedback log is empty. Exiting optimization.")
+        return
+
+    # 2. Aggregate Feedback
+    feedback_summary = aggregate_negative_feedback(feedback_data)
+    
+    if feedback_summary is None:
+        return
+
+    # 3. Optimize Prompt
+    new_system_message = optimize_system_prompt(current_system_message, feedback_summary)
+    
+    # 4. Check if prompt actually changed before committing
+    if new_system_message != current_system_message:
+        print("\n*** PROMPT UPDATED ***")
+        
+        # 5. Update Master Prompt File
+        current_config["system_message"] = new_system_message
+        current_config["version"] = str(round(float(current_config.get("version", 1.0)) + 0.01, 2))
+        current_config["last_updated"] = datetime.datetime.now().isoformat()
+        
+        with open(MASTER_PROMPT_PATH, 'w') as f:
+            json.dump(current_config, f, indent=4)
+        print(f"Successfully wrote new prompt version {current_config['version']} to master_prompt.json")
+
+        # 6. Clear Feedback Log (Ready for next cycle)
+        with open(FEEDBACK_LOG_PATH, 'w') as f:
+            json.dump([], f)
+        print("Feedback log cleared.")
+    
+    else:
+        print("\nINFO: No significant change or API error. Master prompt remains the same.")
+
+
+if __name__ == "__main__":
+    run_optimization()