AICoreAGIX_with_TB.py

import aiohttp
import json
import logging
import torch
import faiss
import numpy as np
from transformers import AutoModelForCausalLM, AutoTokenizer
from typing import List, Dict, Any
from cryptography.fernet import Fernet
from jwt import encode, decode, ExpiredSignatureError
from datetime import datetime, timedelta
# blockchain_module
import speech_recognition as sr
import pyttsx3
import os

from CodriaoCore.multi_model_analyzer import MultiAgentSystem
from neuro_symbolic import NeuroSymbolicEngine  # Updated import
from CodriaoCore.federated_learning import FederatedAI
from utils.database import Database  # Ensure this module exports Database correctly
from logger import logger
from secure_memory_loader import SecureMemorySession
from codriao_tb_module import CodriaoHealthModule

# Ensure these modules exist or update the paths accordingly.
from ethical_filter import EthicalFilter  
from self_reflective_ai import SelfReflectiveAI  

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.http_session = aiohttp.ClientSession()
        self.database = Database()
        self.multi_agent_system = MultiAgentSystem()
        self.self_reflective_ai = SelfReflectiveAI()
        self.neural_symbolic_engine = NeuroSymbolicEngine()  # Updated instantiation
        self.federated_ai = FederatedAI()

        # Security + Memory
        key = os.environ.get("CODRIAO_SECRET_KEY").encode()
        self._encryption_key = key
        self.secure_memory_loader = SecureMemorySession(self._encryption_key)

        self.speech_engine = pyttsx3.init()
        self.health_module = CodriaoHealthModule(ai_core=self)

    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 {
                    "response": result["ethical_analysis"],
                    "explanation": result["explanation"],
                    "tb_risk": result["tb_risk"],
                    "image_analysis": result["image_analysis"],
                    "audio_analysis": result["audio_analysis"],
                    "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
            model_response = await self._generate_local_model_response(query)
            agent_response = self.multi_agent_system.delegate_task(query)
            self_reflection = self.self_reflective_ai.evaluate_response(query, model_response)
            neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)  # Updated usage

            final_response = (
                f"{model_response}\n\n"
                f"{agent_response}\n\n"
                f"{self_reflective_ai}\n\n"
                f"Logic: {neural_reasoning}"
            )
            self.database.log_interaction(user_id, query, final_response)
            # blockchain_module.store_interaction(user_id, query, final_response)
            self._speak_response(final_response)

            return {
                "response": final_response,
                "real_time_data": self.federated_ai.get_latest_data(),
                "context_enhanced": True,
                "security_status": "Fully Secure"
            }

        except Exception as e:
            logger.error(f"Response generation failed: {e}")
            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}")
            return result
        except Exception as e:
            logger.error(f"TB diagnostics failed: {e}")
            return {
                "tb_risk": "ERROR",
                "error": str(e),
                "image_analysis": {},
                "audio_analysis": {},
                "ethical_analysis": "Unable to complete TB diagnostic.",
                "explanation": None,
                "system_health": None
            }

    def _load_config(self, config_path: str) -> dict:
        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)

    def _vectorize_query(self, query: str):
        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()