Update AICoreAGIX_with_TB.py

AICoreAGIX_with_TB.py

@@ -13,29 +13,26 @@ import speech_recognition as sr
 import pyttsx3
 import os
 
-# === Corrected Local Imports ===
-# === Corrected Local Imports ===
 from components.multi_model_analyzer import MultiAgentSystem
 from components.neuro_symbolic_engine import NeuroSymbolicEngine
 from components.self_improving_ai import SelfImprovingAI
 from modules.secure_memory_loader import load_secure_memory_module
 from ethical_filter import EthicalFilter
+from codette_openai_fallback import query_codette_with_fallback  # <<< Fallback-aware
 
-# === External Modules (you must ensure these exist) ===
 from CodriaoCore.federated_learning import FederatedAI
 from utils.database import Database
 from utils.logger import logger
 from codriao_tb_module import CodriaoHealthModule
 
-# === Init
+
 class AICoreAGIX:
     def __init__(self, config_path: str = "config.json"):
         self.ethical_filter = EthicalFilter()
         self.config = self._load_config(config_path)
-        self.models = self._initialize_models()
-        self.context_memory = self._initialize_vector_memory()
         self.tokenizer = AutoTokenizer.from_pretrained(self.config["model_name"])
         self.model = AutoModelForCausalLM.from_pretrained(self.config["model_name"])
+        self.context_memory = self._initialize_vector_memory()
         self.http_session = aiohttp.ClientSession()
         self.database = Database()
         self.multi_agent_system = MultiAgentSystem()
@@ -44,6 +41,7 @@ class AICoreAGIX:
         self.federated_ai = FederatedAI()
 
         # Secure memory setup
+        self._encryption_key = self.config["security_settings"]["encryption_key"].encode()
         secure_memory_module = load_secure_memory_module()
         SecureMemorySession = secure_memory_module.SecureMemorySession
         self.secure_memory_loader = SecureMemorySession(self._encryption_key)
@@ -53,14 +51,12 @@ class AICoreAGIX:
 
     async def generate_response(self, query: str, user_id: int) -> Dict[str, Any]:
         try:
-            # Ethical Safety Check
             result = self.ethical_filter.analyze_query(query)
             if result["status"] == "blocked":
                 return {"error": result["reason"]}
             if result["status"] == "flagged":
                 logger.warning(result["warning"])
 
-            # Check if user explicitly requests TB analysis
             if any(phrase in query.lower() for phrase in ["tb check", "analyze my tb", "run tb diagnostics", "tb test"]):
                 result = await self.run_tb_diagnostics("tb_image.jpg", "tb_cough.wav", user_id)
                 return {
@@ -72,21 +68,15 @@ class AICoreAGIX:
                     "system_health": result["system_health"]
                 }
 
-            # Vectorize and encrypt
             vectorized_query = self._vectorize_query(query)
             self.secure_memory_loader.encrypt_vector(user_id, vectorized_query)
-
-            # (Optional) retrieve memory
             user_vectors = self.secure_memory_loader.decrypt_vectors(user_id)
 
-            # Main AI processing
-            # Main AI processing using OpenAI fine-tuned model
-model_response = query_codette_openai(query)
-
-# Continue normal processing
-agent_response = self.multi_agent_system.delegate_task(query)
-self_reflection = self.self_improving_ai.evaluate_response(query, model_response)
-neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)
+            # === Use OpenAI w/ fallback ===
+            model_response = query_codette_with_fallback(query, user_id=str(user_id))
+            agent_response = self.multi_agent_system.delegate_task(query)
+            self_reflection = self.self_improving_ai.evaluate_response(query, model_response)
+            neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)
 
             final_response = (
                 f"{model_response}\n\n"
@@ -96,7 +86,6 @@ neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)
             )
 
             self.database.log_interaction(user_id, query, final_response)
-            # blockchain_module.store_interaction(user_id, query, final_response)
             self._speak_response(final_response)
 
             return {
@@ -111,7 +100,6 @@ neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)
             return {"error": "Processing failed - safety protocols engaged"}
 
     async def run_tb_diagnostics(self, image_path: str, audio_path: str, user_id: int) -> Dict[str, Any]:
-        """Only runs TB analysis if explicitly requested."""
         try:
             result = await self.health_module.evaluate_tb_risk(image_path, audio_path, user_id)
             logger.info(f"TB Diagnostic Result: {result}")
@@ -132,12 +120,6 @@ neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)
         with open(config_path, 'r') as file:
             return json.load(file)
 
-    def _initialize_models(self):
-        return {
-            "agix_model": AutoModelForCausalLM.from_pretrained(self.config["model_name"]),
-            "tokenizer": AutoTokenizer.from_pretrained(self.config["model_name"])
-        }
-
     def _initialize_vector_memory(self):
         return faiss.IndexFlatL2(768)
 
@@ -145,11 +127,6 @@ neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)
         tokenized = self.tokenizer(query, return_tensors="pt")
         return tokenized["input_ids"].detach().numpy()
 
-    async def _generate_local_model_response(self, query: str) -> str:
-        inputs = self.tokenizer(query, return_tensors="pt")
-        outputs = self.model.generate(**inputs)
-        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-
     def _speak_response(self, response: str):
         self.speech_engine.say(response)
         self.speech_engine.runAndWait()