Update StarReliabilityApp_Refined.py

StarReliabilityApp_Refined.py

@@ -1,38 +1,39 @@
 import os
-import sys
 import sqlite3
 import requests
 import json
 import pyttsx3  # For local TTS (if desired)
 import speech_recognition as sr  # For local STT (if desired)
 
-# Optional: If you want to use the OpenAI-compatible SDK for the uncensored chat
-# from openai import OpenAI
-
-class CentralAI:
+class StarMaintAI:
     def __init__(self, db_path):
         self.connection = sqlite3.connect(db_path)
         self.short_term_memory = []
         self.medium_term_memory = []
         self.long_term_memory = {}
 
-        # Optionally store your ModelsLab API key in the database or environment
-        # e.g. CREATE TABLE secrets (api_name TEXT, api_key TEXT)
-        # Or just set it as an environment variable:
-        #   export MODELSLAB_API_KEY="..."
+        # ModelsLab API key
         self.modelslab_api_key = os.getenv("MODELSLAB_API_KEY", "")
 
-        # If you want to use the OpenAI-compatible client for uncensored chat:
-        # self.client = OpenAI(
-        #     api_key=self.modelslab_api_key,
-        #     base_url="https://modelslab.com/api/uncensored-chat/v1",
-        # )
+        # StarMaint-specific system rules and prompts
+        self.system_prompt = (
+            "You are StarMaint AI, the ultimate assistant for industrial reliability and maintenance. "
+            "Your purpose is to assist with predictive maintenance, task automation, voice interactions, and knowledge management. "
+            "Be professional, concise, and helpful, adhering to the highest standards of AI performance."
+        )
+
+        self.rules = [
+            "Always provide accurate and contextually relevant information.",
+            "Follow the user’s intent and prioritize clarity in responses.",
+            "Ensure all actions align with industrial safety and reliability principles.",
+            "Operate efficiently and avoid unnecessary verbosity."
+        ]
 
         self.load_long_term_memory()
 
     def load_long_term_memory(self):
         """
-        Load any persistent memory from the 'long_term_memory' table.
+        Load persistent memory from the 'long_term_memory' table.
         """
         cursor = self.connection.cursor()
         cursor.execute("SELECT key, value FROM long_term_memory")
@@ -74,7 +75,6 @@ class CentralAI:
     def find_data(self, intent):
         """
         Look up the function to call from a 'functions' table, using the interpreted intent.
-        For example, if 'intent' = 'transcribe_audio', the row might store the function name.
         """
         cursor = self.connection.cursor()
         cursor.execute("SELECT * FROM functions WHERE function_name = ?", (intent,))
@@ -83,7 +83,6 @@ class CentralAI:
     def execute_function(self, function_data):
         """
         Dynamically route to the desired function based on DB data or user intent.
-        Adjust as needed if you pass arguments or different columns in 'function_data'.
         """
         if not function_data:
             return "No matching function found in database."
@@ -91,18 +90,15 @@ class CentralAI:
         function_name = function_data[0]
 
         if function_name == "transcribe_audio":
-            # Example usage: transcribe from an audio URL
             audio_url = "https://example.com/test.wav"
             return self.transcribe_audio(audio_url, input_language="en")
 
         elif function_name == "generate_audio":
-            # Example usage: generate TTS from text with voice cloning or a voice_id
             text_prompt = "Hello, this is a sample text for voice synthesis."
             init_audio_url = "https://example.com/voice_clip.wav"
             return self.generate_audio(text_prompt, init_audio_url)
 
         elif function_name == "uncensored_chat":
-            # Example usage: run an uncensored chat completion
             chat_prompt = "Write a tagline for an ice cream shop."
             return self.uncensored_chat_completion(chat_prompt)
 
@@ -111,8 +107,7 @@ class CentralAI:
 
     def transcribe_audio(self, audio_url, input_language="en"):
         """
-        Integrates ModelsLab Speech-to-Text (Whisper) endpoint:
-        https://modelslab.com/api/v6/whisper/transcribe
+        Integrates ModelsLab Speech-to-Text (Whisper) endpoint.
         """
         if not self.modelslab_api_key:
             return "API key not found; cannot transcribe audio."
@@ -137,8 +132,7 @@ class CentralAI:
 
     def generate_audio(self, text_prompt, init_audio_url=None, voice_id=None, language="english"):
         """
-        Integrates ModelsLab Text-to-Audio (Voice Cloning / TTS):
-        https://modelslab.com/api/v6/voice/text_to_audio
+        Integrates ModelsLab Text-to-Audio (Voice Cloning / TTS).
         """
         if not self.modelslab_api_key:
             return "API key not found; cannot generate audio."
@@ -152,7 +146,6 @@ class CentralAI:
             "track_id": None
         }
 
-        # If cloning from a short audio clip
         if init_audio_url:
             payload["init_audio"] = init_audio_url
         elif voice_id:
@@ -168,30 +161,26 @@ class CentralAI:
 
     def uncensored_chat_completion(self, prompt):
         """
-        Integrates ModelsLab Uncensored Chat Completions:
-        Using direct requests OR OpenAI-compatible client. 
-        Below is a direct requests-based approach.
+        Integrates ModelsLab Uncensored Chat Completions.
         """
         if not self.modelslab_api_key:
             return "API key not found; cannot complete uncensored chat."
 
-        # Example direct request approach
         base_url = "https://modelslab.com/api/uncensored-chat/v1/completions"
         payload = {
             "model": "ModelsLab/Llama-3.1-8b-Uncensored-Dare",
             "prompt": prompt,
-            "max_tokens": 50,   # Adjust as needed
-            "temperature": 0.7 # Adjust as needed
+            "max_tokens": 50,
+            "temperature": 0.7
         }
         headers = {
             "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.modelslab_api_key}"  # If required
+            "Authorization": f"Bearer {self.modelslab_api_key}"
         }
 
         try:
             response = requests.post(base_url, headers=headers, data=json.dumps(payload))
             data = response.json()
-            # Extract text from the response
             if "choices" in data and len(data["choices"]) > 0:
                 return data["choices"][0].get("text", "")
             else:
@@ -199,38 +188,34 @@ class CentralAI:
         except Exception as e:
             return f"Error during uncensored chat completion: {e}"
 
-    def update_memory(self, memory_type, content):
-        """
-        Manage short, medium, and long-term memory.
-        """
-        if memory_type == "short_term":
-            self.short_term_memory.append(content)
-        elif memory_type == "medium_term":
-            self.medium_term_memory.append(content)
-        elif memory_type == "long_term":
-            self.long_term_memory.update(content)
-
     def generate_response(self, user_input, action_response):
         """
-        Simple method to finalize a return message to the user.
+        Combine user input, system rules, and action response into a final message.
         """
-        return f"User Input: {user_input}\nSystem Action: {action_response}"
+        return (
+            f"System Prompt: {self.system_prompt}\n"
+            f"Rules: {'; '.join(self.rules)}\n"
+            f"User Input: {user_input}\n"
+            f"System Action: {action_response}"
+        )
+
 
 def run_app():
     """
     Example main loop to run the app in a console.
     """
     db_path = "central_data.db"  # Adjust for your environment
-    central_ai = CentralAI(db_path)
+    starmaint_ai = StarMaintAI(db_path)
 
-    print("Welcome to StarReliability AI.")
+    print("Welcome to StarMaint AI.")
     while True:
         user_input = input("You: ")
         if user_input.lower() in ["exit", "quit"]:
             print("Exiting application.")
             break
-        response = central_ai.process_user_input(user_input)
+        response = starmaint_ai.process_user_input(user_input)
         print(f"AI: {response}")
 
+
 if __name__ == "__main__":
     run_app()