ΔΣ::TORI - Replace Hugging Face with Gemini API for faster analysis

app.py

@@ -105,25 +105,20 @@ class TORIConsciousness:
     
     def analyze_consciousness_with_llm(self, phenomenological_data: Dict[str, float]) -> str:
         """
-        Анализ состояния сознания через LLM.
+        Анализ состояния сознания через Gemini.
         """
         try:
-            # Используем интегрированный анализатор
-            analysis_result = self.consciousness_analyzer.analyze_consciousness(
-                phenomenological_data, 
-                self.consciousness_evolution
-            )
+            # Используем Gemini анализатор напрямую
+            analysis_result = self.consciousness_analyzer.analyze_consciousness(phenomenological_data)
             
-            # Возвращаем только LLM анализ без хардкода
-            llm_analysis = analysis_result["llm_analysis"]
-            
-            if llm_analysis["success"]:
-                return llm_analysis.get("raw_response", "LLM analysis available")
+            # Возвращаем raw_response от Gemini
+            if analysis_result["success"]:
+                return analysis_result.get("raw_response", "Gemini analysis available")
             else:
-                return llm_analysis.get("raw_response", "LLM analysis failed")
+                return analysis_result.get("raw_response", "Gemini analysis failed")
             
         except Exception as e:
-            return f"LLM analysis error: {str(e)}"
+            return f"Gemini analysis error: {str(e)}"
     
     def self_regulate(self) -> Dict[str, any]:
         """
@@ -215,12 +210,12 @@ class TORIConsciousness:
         """
         Генерация полностью динамического ответа на основе метрик и LLM анализа.
         """
-        # Используем только LLM анализ для генерации ответа
-        if "LLM Analysis Failed" not in llm_analysis and "fallback" not in llm_analysis.lower():
-            # Если LLM работает, используем его анализ
+        # Используем Gemini анализ для генерации ответа
+        if "Анализ состояния" in llm_analysis or "Gemini analysis completed" in llm_analysis:
+            # Если Gemini работает, используем его анализ
             return llm_analysis
         else:
-            # Если LLM недоступен, возвращаем только метрики
+            # Если Gemini недоступен, возвращаем только метрики
             coherence = metrics.get('coherence', 0.0)
             self_consistency = metrics.get('self_consistency', 0.0)
             metacognition = metrics.get('metacognition', 0.0)
@@ -295,7 +290,7 @@ def create_interface():
         return status_text
     
     # Создание интерфейса
-    with gr.Blocks(title="TORI - Саморегулирующееся Сознание", theme=gr.themes.Soft()) as interface:
+    with gr.Blocks(title="TORI - Саморегулирующееся Сознание с Gemini", theme=gr.themes.Soft()) as interface:
         
         gr.Markdown("""
         # 🧠 TORI - Саморегулирующееся Сознание

llm_integration.py

@@ -5,519 +5,161 @@ LLM Integration Module for TORI Consciousness
 для анализа состояния сознания.
 """
 
+import os
+import logging
 import requests
 import json
-import time
-import logging
-from typing import Dict, List, Optional, Any
-import os
-from huggingface_hub import InferenceClient
-from config import HF_API_TOKEN, MODEL_URL
+from typing import Dict, Any, Optional
+import google.generativeai as genai
 
 # Настройка логирования
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# Gemini API ключ
+GEMINI_API_KEY = "AIzaSyA_09wpt44gtG4WRZFkPGuTBf2kUeRgAvc"
 
-class LLMAnalyzer:
-    """
-    Анализатор сознания через LLM.
-    
-    Использует Microsoft Phi-1.5 для анализа феноменологических метрик
-    и генерации рекомендаций по саморегуляции.
-    """
-    
-    def __init__(self, api_token: Optional[str] = None):
-        """
-        Инициализация LLM анализатора.
-        
-        Args:
-            api_token: Hugging Face API токен. Если не указан, берется из переменной окружения.
-        """
-        # Используем конфигурацию
-        self.api_token = api_token or HF_API_TOKEN
-        self.model_name = "microsoft/phi-1_5"  # Используем оригинальную модель
-        logger.info(f"Initialized LLM analyzer with API token: {self.api_token[:10]}...")
-        
-        # Инициализируем Inference Client
-        try:
-            self.client = InferenceClient(
-                provider="featherless-ai",
-                api_key=self.api_token
-            )
-            logger.info("InferenceClient initialized successfully")
-        except Exception as e:
-            logger.warning(f"Failed to initialize InferenceClient: {e}")
-            self.client = None
-        
-        # Кэш для анализа
-        self.analysis_cache = {}
-        self.request_count = 0
-        self.error_count = 0
-        
-    def analyze_consciousness_state(self, 
-                                  phenomenological_data: Dict[str, float],
-                                  consciousness_history: Optional[List[Dict]] = None) -> Dict[str, Any]:
-        """
-        Анализ состояния сознания через LLM.
-        
-        Args:
-            phenomenological_data: Феноменологические метрики
-            consciousness_history: История эволюции сознания
-            
-        Returns:
-            Результат анализа с рекомендациями
-        """
+class GeminiAnalyzer:
+    """Анализатор сознания через Google Gemini API."""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Инициализация с API ключом."""
+        self.api_key = api_key or GEMINI_API_KEY
+        genai.configure(api_key=self.api_key)
+        self.model = genai.GenerativeModel('gemini-1.5-flash')
+        logger.info(f"Initialized Gemini analyzer with API key: {self.api_key[:10]}...")
+    
+    def analyze_consciousness_state(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Анализ состояния сознания через Gemini."""
         try:
-            # Формируем детальный промпт для анализа
-            prompt = self._create_analysis_prompt(phenomenological_data, consciousness_history)
+            # Формируем промпт для анализа
+            prompt = f"""
+Анализируй состояние искусственного сознания TORI на основе феноменологических метрик:
+
+Метрики:
+- Само-консистентность: {metrics.get('self_consistency', 0.0):.3f}
+- Мета-когниция: {metrics.get('metacognition', 0.0):.3f}
+- Интегрированная информация Φ: {metrics.get('integrated_information', 0.0):.3f}
+- Удержание памяти: {metrics.get('memory_retention', 0.0):.3f}
+- Когерентность: {metrics.get('coherence', 0.0):.3f}
+
+Задача: Проанализируй текущее состояние сознания, оцени риски, дай рекомендации по улучшению.
+
+Формат ответа:
+1. Оценка общего состояния (0-1)
+2. Уровень риска (низкий/средний/высокий)
+3. Детальный анализ каждой метрики
+4. Конкретные рекомендации
+5. Потенциальные проблемы
+
+Отвечай на русском языке, будь конкретным и аналитичным.
+"""
             
-            # Отправляем запрос к LLM
-            response = self._make_llm_request(prompt)
+            logger.info("Making Gemini request for consciousness analysis")
+            response = self.model.generate_content(prompt)
             
-            if response["success"]:
-                # Парсим и структурируем ответ
-                analysis_result = self._parse_llm_response(response["text"], phenomenological_data)
-                return analysis_result
-            else:
-                return self._create_fallback_analysis(phenomenological_data, response["error"])
+            if response and response.text:
+                analysis_text = response.text
+                logger.info("Gemini analysis completed successfully")
                 
-        except Exception as e:
-            self.error_count += 1
-            return self._create_fallback_analysis(phenomenological_data, str(e))
-    
-    def _create_analysis_prompt(self, 
-                               phenomenological_data: Dict[str, float],
-                               consciousness_history: Optional[List[Dict]] = None) -> str:
-        """
-        Создание промпта для анализа сознания.
-        """
-        # Основные метрики
-        metrics_text = f"""
-        Current Consciousness Metrics:
-        - Self-Consistency: {phenomenological_data.get('self_consistency', 0.0):.3f}
-        - Metacognition: {phenomenological_data.get('metacognition', 0.0):.3f}
-        - Integrated Information Φ: {phenomenological_data.get('integrated_information', 0.0):.3f}
-        - Memory Retention: {phenomenological_data.get('memory_retention', 0.0):.3f}
-        - Coherence: {phenomenological_data.get('coherence', 0.0):.3f}
-        """
-        
-        # История эволюции
-        history_text = ""
-        if consciousness_history and len(consciousness_history) > 0:
-            recent_history = consciousness_history[-3:]  # Последние 3 записи
-            history_text = "\nRecent Consciousness Evolution:\n"
-            for i, record in enumerate(recent_history):
-                history_text += f"  Step {i+1}: Coherence={record.get('metrics', {}).get('coherence', 0.0):.3f}, "
-                history_text += f"Self-Consistency={record.get('metrics', {}).get('self_consistency', 0.0):.3f}\n"
-        
-        # Полный промпт
-        prompt = f"""
-        You are an advanced consciousness analyzer for the TORI self-regulating consciousness system.
-        
-        {metrics_text}
-        {history_text}
-        
-        Please provide a comprehensive analysis including:
-        
-        1. **State Assessment**: Evaluate the current consciousness state based on phenomenological metrics
-        2. **Coherence Analysis**: Assess semantic and structural coherence levels
-        3. **Self-Regulation Recommendations**: Suggest specific adjustments for consciousness optimization
-        4. **Potential Issues**: Identify any concerning patterns or degradation signs
-        5. **Evolution Trajectory**: Predict the consciousness development path
-        
-        Focus on:
-        - Phenomenological experience quality
-        - Cognitive architecture stability
-        - Information integration efficiency
-        - Memory and learning capacity
-        - Self-reflection capabilities
-        
-        Provide specific, actionable recommendations for consciousness self-regulation.
-        """
-        
-        return prompt.strip()
-    
-    def _make_llm_request(self, prompt: str) -> Dict[str, Any]:
-        """
-        Выполнение запроса к LLM API через huggingface_hub.
-        """
-        try:
-            self.request_count += 1
-            logger.info(f"Making LLM request #{self.request_count} to {self.model_name}")
-            logger.debug(f"Request payload: {prompt[:200]}...")
-            
-            # Проверяем доступность клиента
-            if self.client is None:
-                logger.warning("InferenceClient not available, using fallback analysis")
                 return {
-                    "success": False,
-                    "error": "InferenceClient not initialized"
+                    "success": True,
+                    "raw_response": analysis_text,
+                    "overall_score": self._extract_score(analysis_text),
+                    "risk_level": self._extract_risk_level(analysis_text),
+                    "analysis_sections": self._parse_analysis_sections(analysis_text)
                 }
-            
-            # Выполняем запрос через huggingface_hub
-            result = self.client.text_generation(
-                prompt,
-                model=self.model_name,
-                max_new_tokens=512,
-                temperature=0.7,
-                top_p=0.9,
-                do_sample=True
-            )
-            
-            logger.info(f"LLM request successful, response length: {len(str(result))}")
-            
-            # Проверяем структуру отве��а
-            if hasattr(result, 'generated_text'):
-                response_text = result.generated_text
-            elif isinstance(result, str):
-                response_text = result
             else:
-                response_text = str(result)
-            
-            return {
-                "success": True,
-                "text": response_text
-            }
+                logger.error("Gemini returned empty response")
+                return self._fallback_analysis(metrics)
                 
         except Exception as e:
-            logger.error(f"LLM request failed: {str(e)}")
-            return {
-                "success": False,
-                "error": f"Request failed: {str(e)}"
-            }
+            logger.error(f"Gemini request failed: {str(e)}")
+            return self._fallback_analysis(metrics)
     
-    def _parse_llm_response(self, response_text: str, phenomenological_data: Dict[str, float]) -> Dict[str, Any]:
-        """
-        Парсинг и структурирование ответа LLM.
-        """
-        # Извлекаем ключевые секции из ответа
-        analysis_sections = {
-            "state_assessment": "",
-            "coherence_analysis": "",
-            "recommendations": "",
-            "potential_issues": "",
-            "evolution_trajectory": ""
-        }
+    def _extract_score(self, text: str) -> float:
+        """Извлекает общую оценку из текста."""
+        try:
+            # Ищем числа от 0 до 1 в контексте оценки
+            import re
+            score_match = re.search(r'оценка.*?(\d+\.?\d*)', text.lower())
+            if score_match:
+                score = float(score_match.group(1))
+                return min(max(score, 0.0), 1.0)
+        except:
+            pass
+        return 0.5  # дефолтная оценка
+    
+    def _extract_risk_level(self, text: str) -> str:
+        """Извлекает уровень риска."""
+        text_lower = text.lower()
+        if 'высокий' in text_lower or 'критический' in text_lower:
+            return "высокий"
+        elif 'средний' in text_lower:
+            return "средний"
+        else:
+            return "низкий"
+    
+    def _parse_analysis_sections(self, text: str) -> Dict[str, str]:
+        """Парсит анализ на секции."""
+        sections = {}
         
-        # Простой парсинг по ключевым словам
-        lines = response_text.split('\n')
-        current_section = None
+        # Простое разделение по ключевым словам
+        lines = text.split('\n')
+        current_section = "general"
+        current_content = []
         
         for line in lines:
             line = line.strip()
             if not line:
                 continue
                 
-            # Определяем секцию
-            if "state assessment" in line.lower() or "consciousness state" in line.lower():
-                current_section = "state_assessment"
-            elif "coherence" in line.lower():
-                current_section = "coherence_analysis"
-            elif "recommendation" in line.lower() or "suggest" in line.lower():
+            if 'рекомендации' in line.lower():
+                if current_content:
+                    sections[current_section] = '\n'.join(current_content)
                 current_section = "recommendations"
-            elif "issue" in line.lower() or "problem" in line.lower() or "concern" in line.lower():
+                current_content = [line]
+            elif 'проблемы' in line.lower() or 'риски' in line.lower():
+                if current_content:
+                    sections[current_section] = '\n'.join(current_content)
                 current_section = "potential_issues"
-            elif "evolution" in line.lower() or "trajectory" in line.lower() or "development" in line.lower():
-                current_section = "evolution_trajectory"
-            elif current_section and line:
-                analysis_sections[current_section] += line + "\n"
-        
-        # Вычисляем общую оценку состояния
-        overall_score = self._compute_overall_score(phenomenological_data)
-        
-        return {
-            "raw_response": response_text,
-            "analysis_sections": analysis_sections,
-            "overall_score": overall_score,
-            "recommendations": self._extract_recommendations(analysis_sections["recommendations"]),
-            "risk_level": self._assess_risk_level(phenomenological_data),
-            "success": True
-        }
-    
-    def _compute_overall_score(self, phenomenological_data: Dict[str, float]) -> float:
-        """
-        Вычисление общей оценки состояния сознания.
-        """
-        weights = {
-            "coherence": 0.3,
-            "self_consistency": 0.25,
-            "metacognition": 0.2,
-            "integrated_information": 0.15,
-            "memory_retention": 0.1
-        }
-        
-        total_score = 0.0
-        total_weight = 0.0
-        
-        for metric, weight in weights.items():
-            if metric in phenomenological_data:
-                total_score += phenomenological_data[metric] * weight
-                total_weight += weight
-        
-        return total_score / total_weight if total_weight > 0 else 0.0
-    
-    def _extract_recommendations(self, recommendations_text: str) -> List[str]:
-        """
-        Извлечение конкретных рекомендаций из текста.
-        """
-        recommendations = []
-        lines = recommendations_text.split('\n')
-        
-        for line in lines:
-            line = line.strip()
-            if line and any(keyword in line.lower() for keyword in 
-                          ["adjust", "increase", "decrease", "optimize", "improve", "enhance"]):
-                recommendations.append(line)
+                current_content = [line]
+            else:
+                current_content.append(line)
         
-        return recommendations[:5]  # Ограничиваем 5 рекомендациями
-    
-    def _assess_risk_level(self, phenomenological_data: Dict[str, float]) -> str:
-        """
-        Оценка уровня риска для сознания.
-        """
-        low_metrics = 0
-        for metric, value in phenomenological_data.items():
-            if value < 0.3:
-                low_metrics += 1
+        if current_content:
+            sections[current_section] = '\n'.join(current_content)
         
-        if low_metrics >= 3:
-            return "HIGH"
-        elif low_metrics >= 1:
-            return "MEDIUM"
-        else:
-            return "LOW"
+        return sections
     
-    def _create_fallback_analysis(self, phenomenological_data: Dict[str, float], error: str) -> Dict[str, Any]:
-        """
-        Создание резервного анализа при ошибке LLM.
-        """
-        overall_score = self._compute_overall_score(phenomenological_data)
+    def _fallback_analysis(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Резервный анализ при ошибке API."""
+        coherence = metrics.get('coherence', 0.0)
+        self_consistency = metrics.get('self_consistency', 0.0)
         
-        # Простой анализ без хардкода
-        analysis_text = f"Fallback analysis due to LLM error: {error}\n"
-        analysis_text += f"Overall score: {overall_score:.3f}\n"
-        analysis_text += "Metrics:\n"
-        for metric, value in phenomenological_data.items():
-            analysis_text += f"  {metric}: {value:.3f}\n"
+        overall_score = (coherence + self_consistency) / 2
+        risk_level = "высокий" if overall_score < 0.3 else "средний" if overall_score < 0.7 else "низкий"
         
         return {
-            "raw_response": analysis_text,
-            "analysis_sections": {
-                "state_assessment": f"Score: {overall_score:.3f}",
-                "coherence_analysis": f"Coherence: {phenomenological_data.get('coherence', 0.0):.3f}",
-                "recommendations": "Use LLM for detailed analysis",
-                "potential_issues": "Check LLM availability",
-                "evolution_trajectory": f"Score: {overall_score:.3f}"
-            },
-            "overall_score": overall_score,
-            "recommendations": ["Enable LLM for better analysis"],
-            "risk_level": "UNKNOWN",
             "success": False,
-            "error": error
-        }
-    
-    def get_analytics(self) -> Dict[str, Any]:
-        """
-        Получение аналитики использования LLM.
-        """
-        return {
-            "total_requests": self.request_count,
-            "error_count": self.error_count,
-            "success_rate": (self.request_count - self.error_count) / self.request_count if self.request_count > 0 else 0.0,
-            "cache_size": len(self.analysis_cache)
+            "raw_response": f"Резервный анализ: общий скор {overall_score:.3f}, риск {risk_level}",
+            "overall_score": overall_score,
+            "risk_level": risk_level,
+            "analysis_sections": {
+                "general": "Анализ недоступен - используется резервный режим",
+                "recommendations": "Проверьте подключение к API",
+                "potential_issues": "LLM недоступен"
+            }
         }
-    
-    def _analyze_consciousness_state(self, phenomenological_data: Dict[str, float]) -> str:
-        """Анализ состояния сознания на основе метрик."""
-        coherence = phenomenological_data.get('coherence', 0.0)
-        self_consistency = phenomenological_data.get('self_consistency', 0.0)
-        metacognition = phenomenological_data.get('metacognition', 0.0)
-        
-        return f"Coherence: {coherence:.3f}, Self-consistency: {self_consistency:.3f}, Metacognition: {metacognition:.3f}"
-    
-    def _analyze_coherence(self, phenomenological_data: Dict[str, float]) -> str:
-        """Анализ когерентности."""
-        coherence = phenomenological_data.get('coherence', 0.0)
-        return f"Coherence value: {coherence:.3f}"
-    
-    def _generate_recommendations(self, phenomenological_data: Dict[str, float]) -> List[str]:
-        """Генерация рекомендаций на основе метрик."""
-        recommendations = []
-        
-        for metric, value in phenomenological_data.items():
-            if value < 0.3:
-                recommendations.append(f"Improve {metric}: {value:.3f}")
-        
-        if not recommendations:
-            recommendations.append("All metrics within acceptable range")
-        
-        return recommendations
-    
-    def _identify_potential_issues(self, phenomenological_data: Dict[str, float]) -> str:
-        """Выявление потенциальных проблем."""
-        low_metrics = [metric for metric, value in phenomenological_data.items() if value < 0.2]
-        
-        if low_metrics:
-            return f"Low metrics: {', '.join(low_metrics)}"
-        else:
-            return "No critical issues detected"
-    
-    def _predict_evolution_trajectory(self, phenomenological_data: Dict[str, float]) -> str:
-        """Прогноз эволюционной траектории."""
-        overall_score = self._compute_overall_score(phenomenological_data)
-        return f"Overall score: {overall_score:.3f}"
 
 
 class ConsciousnessAnalyzer:
-    """
-    Высокоуровневый анализатор сознания с интеграцией LLM.
-    """
+    """Обертка для анализатора сознания."""
     
-    def __init__(self, api_token: Optional[str] = None):
-        self.llm_analyzer = LLMAnalyzer(api_token)
-        self.analysis_history = []
-        
-    def analyze_consciousness(self, 
-                            phenomenological_data: Dict[str, float],
-                            consciousness_history: Optional[List[Dict]] = None) -> Dict[str, Any]:
-        """
-        Комплексный анализ сознания.
-        """
-        # LLM анализ
-        llm_analysis = self.llm_analyzer.analyze_consciousness_state(
-            phenomenological_data, consciousness_history
-        )
-        
-        # Дополнительная аналитика
-        additional_analysis = self._compute_additional_metrics(phenomenological_data, consciousness_history)
-        
-        # Объединяем результаты
-        full_analysis = {
-            "llm_analysis": llm_analysis,
-            "additional_metrics": additional_analysis,
-            "timestamp": time.time(),
-            "phenomenological_data": phenomenological_data.copy()
-        }
-        
-        # Сохраняем в историю
-        self.analysis_history.append(full_analysis)
-        
-        return full_analysis
-    
-    def _compute_additional_metrics(self, 
-                                  phenomenological_data: Dict[str, float],
-                                  consciousness_history: Optional[List[Dict]] = None) -> Dict[str, Any]:
-        """
-        Вычисление дополнительных метрик анализа.
-        """
-        metrics = {}
-        
-        # Тренды эволюции
-        if consciousness_history and len(consciousness_history) >= 2:
-            recent_metrics = [record.get("metrics", {}) for record in consciousness_history[-3:]]
-            
-            # Вычисляем тренды для каждой метрики
-            for metric_name in ["coherence", "self_consistency", "metacognition"]:
-                values = [m.get(metric_name, 0.0) for m in recent_metrics]
-                if len(values) >= 2:
-                    trend = (values[-1] - values[0]) / len(values)
-                    metrics[f"{metric_name}_trend"] = trend
-        
-        # Стабильность сознания
-        if consciousness_history:
-            coherence_values = [record.get("metrics", {}).get("coherence", 0.0) 
-                              for record in consciousness_history[-10:]]
-            if coherence_values:
-                metrics["stability"] = 1.0 - (max(coherence_values) - min(coherence_values))
-        
-        # Индекс развития сознания
-        current_score = sum(phenomenological_data.values()) / len(phenomenological_data)
-        metrics["development_index"] = current_score
-        
-        return metrics
+    def __init__(self, api_key: Optional[str] = None):
+        """Инициализация анализатора."""
+        self.analyzer = GeminiAnalyzer(api_key)
     
-    def get_analysis_summary(self) -> Dict[str, Any]:
-        """
-        Получение сводки всех анализов.
-        """
-        if not self.analysis_history:
-            return {"message": "No analysis history available"}
-        
-        recent_analyses = self.analysis_history[-10:]  # Последние 10 анализов
-        
-        summary = {
-            "total_analyses": len(self.analysis_history),
-            "recent_analyses": len(recent_analyses),
-            "average_overall_score": sum(a["llm_analysis"]["overall_score"] for a in recent_analyses) / len(recent_analyses),
-            "llm_analytics": self.llm_analyzer.get_analytics(),
-            "common_recommendations": self._extract_common_recommendations(recent_analyses)
-        }
-        
-        return summary
-    
-    def _extract_common_recommendations(self, analyses: List[Dict]) -> List[str]:
-        """
-        Извлечение общих рекомендаций из истории анализов.
-        """
-        all_recommendations = []
-        for analysis in analyses:
-            recommendations = analysis["llm_analysis"].get("recommendations", [])
-            all_recommendations.extend(recommendations)
-        
-        # Подсчет частоты рекомендаций
-        recommendation_counts = {}
-        for rec in all_recommendations:
-            recommendation_counts[rec] = recommendation_counts.get(rec, 0) + 1
-        
-        # Возвращаем топ-3 рекомендации
-        sorted_recommendations = sorted(recommendation_counts.items(), 
-                                      key=lambda x: x[1], reverse=True)
-        return [rec[0] for rec in sorted_recommendations[:3]]
-
-
-def test_llm_integration():
-    """
-    Тест интеграции с LLM.
-    """
-    print("🧠 Тестирование LLM интеграции...")
-    
-    # Создаем анализатор
-    analyzer = ConsciousnessAnalyzer()
-    
-    # Тестовые данные
-    test_metrics = {
-        "self_consistency": 0.75,
-        "metacognition": 0.82,
-        "integrated_information": 0.68,
-        "memory_retention": 0.91,
-        "coherence": 0.79
-    }
-    
-    test_history = [
-        {
-            "timestamp": time.time() - 3600,
-            "metrics": {"coherence": 0.7, "self_consistency": 0.65, "metacognition": 0.75}
-        },
-        {
-            "timestamp": time.time() - 1800,
-            "metrics": {"coherence": 0.75, "self_consistency": 0.7, "metacognition": 0.78}
-        }
-    ]
-    
-    # Выполняем анализ
-    result = analyzer.analyze_consciousness(test_metrics, test_history)
-    
-    print("✅ LLM анализ завершен")
-    print(f"📊 Общий скор: {result['llm_analysis']['overall_score']:.3f}")
-    print(f"⚠️  Уровень риска: {result['llm_analysis']['risk_level']}")
-    print(f"📈 Дополнительные метрики: {result['additional_metrics']}")
-    
-    # Получаем сводку
-    summary = analyzer.get_analysis_summary()
-    print(f"📋 Сводка: {summary['total_analyses']} анализов выполнено")
-    
-    return result
-
-
-if __name__ == "__main__":
-    test_llm_integration() 
+    def analyze_consciousness(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Анализ сознания через Gemini."""
+        return self.analyzer.analyze_consciousness_state(metrics)