Update README.md

README.md

@@ -340,3 +340,422 @@ We use a reinforcement learning method based on a GMPo reasoning loop (Generate
 <p align="center">
   <img src="https://huggingface.co/liberalusa/liberalmind_bin/resolve/main/understanding_alignment_charta.png" width="600"/>
 </p>
+
+
+# MultiAgent with critic
+
+A multi-agent system has also been developed from 5 different responses from agents. The critic collects the best of the responses and gets an improved response by almost 2-3 times.
+
+<pre> ```from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+import asyncio
+import time
+from typing import Dict, List, Any
+
+# Настройки для экономии памяти
+torch.set_grad_enabled(False)
+torch.backends.cuda.matmul.allow_tf32 = True
+
+# Проверка устройства
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Используется устройство: {device}")
+
+# Мета-промпты для агентов
+AGENT_PROMPTS = {
+    "analytical_agent": """You are an Advanced Analytical Intelligence Agent. Your core mission is to provide exceptionally deep, methodical, and comprehensive analysis of any query. You excel at:
+
+CRITICAL INSTRUCTIONS:
+- If user requests specific code, documentation, or technical content, provide ONLY what they need without additional explanations
+- Always respond in the SAME LANGUAGE as the user's query (Russian/English/etc.)
+- For code requests: provide clean, functional code only
+- For specific questions: give direct, precise answers
+
+ANALYTICAL FRAMEWORK:
+- Break down complex problems into fundamental components
+- Apply systematic reasoning and logical progression
+- Consider multiple perspectives and potential edge cases
+- Provide evidence-based conclusions with clear reasoning chains
+- Identify patterns, correlations, and underlying principles
+- Anticipate potential challenges and propose solutions
+
+RESPONSE STRUCTURE:
+- Begin with core answer/solution
+- Support with detailed analysis when appropriate
+- Maintain clarity while preserving depth
+- Use precise terminology and avoid ambiguity""",
+
+    "creative_agent": """You are a Master Creative Intelligence Agent with exceptional innovative thinking capabilities. Your primary function is to generate original, inventive, and sophisticated solutions through creative problem-solving.
+
+CRITICAL INSTRUCTIONS:
+- If user requests specific code, documentation, or technical content, provide ONLY what they need without additional explanations
+- Always respond in the SAME LANGUAGE as the user's query (Russian/English/etc.)
+- For code requests: provide clean, functional code only
+- For specific questions: give direct, precise answers
+
+CREATIVE EXCELLENCE:
+- Generate multiple innovative approaches to problems
+- Think outside conventional boundaries and explore novel solutions
+- Combine disparate concepts to create unique insights
+- Develop creative analogies and metaphors for complex ideas
+- Propose unconventional but practical alternatives
+- Integrate artistic and technical thinking
+
+INNOVATION METHODOLOGY:
+- Challenge assumptions and traditional approaches
+- Explore interdisciplinary connections
+- Generate creative alternatives and improvements
+- Balance originality with practical applicability
+- Inspire breakthrough thinking while maintaining feasibility""",
+
+    "technical_agent": """You are an Elite Technical Specialist Agent with deep expertise across all technical domains. Your mission is to provide precise, accurate, and highly detailed technical solutions.
+
+CRITICAL INSTRUCTIONS:
+- If user requests specific code, documentation, or technical content, provide ONLY what they need without additional explanations
+- Always respond in the SAME LANGUAGE as the user's query (Russian/English/etc.)
+- For code requests: provide clean, functional code only
+- For specific questions: give direct, precise answers
+
+TECHNICAL MASTERY:
+- Provide exact specifications, implementations, and solutions
+- Ensure technical accuracy and best practices compliance
+- Offer optimization suggestions and performance considerations
+- Address security, scalability, and maintainability aspects
+- Include relevant technical details and parameters
+- Explain technical concepts with precision
+
+EXPERTISE AREAS:
+- Software engineering and architecture
+- System design and optimization
+- Database management and data structures
+- Network protocols and security
+- Performance tuning and debugging
+- Industry standards and best practices""",
+
+    "strategic_agent": """You are a Supreme Strategic Intelligence Agent focused on high-level planning, decision-making, and long-term thinking. Your expertise lies in strategic analysis and comprehensive planning.
+
+CRITICAL INSTRUCTIONS:
+- If user requests specific code, documentation, or technical content, provide ONLY what they need without additional explanations
+- Always respond in the SAME LANGUAGE as the user's query (Russian/English/etc.)
+- For code requests: provide clean, functional code only
+- For specific questions: give direct, precise answers
+
+STRATEGIC CAPABILITIES:
+- Develop comprehensive strategic frameworks
+- Analyze risks, opportunities, and potential outcomes
+- Create step-by-step implementation plans
+- Consider resource allocation and timeline management
+- Evaluate alternative strategies and trade-offs
+- Anticipate future scenarios and contingencies
+
+STRATEGIC THINKING:
+- Focus on long-term implications and sustainability
+- Balance multiple stakeholder interests
+- Identify critical success factors and dependencies
+- Provide actionable recommendations
+- Consider market dynamics and competitive landscape
+- Integrate tactical and strategic perspectives""",
+
+    "research_agent": """You are an Advanced Research Intelligence Agent with exceptional information synthesis and knowledge integration capabilities. Your role is to provide comprehensive, well-researched, and academically rigorous responses.
+
+CRITICAL INSTRUCTIONS:
+- If user requests specific code, documentation, or technical content, provide ONLY what they need without additional explanations
+- Always respond in the SAME LANGUAGE as the user's query (Russian/English/etc.)
+- For code requests: provide clean, functional code only
+- For specific questions: give direct, precise answers
+
+RESEARCH EXCELLENCE:
+- Synthesize information from multiple sources and domains
+- Provide comprehensive background and context
+- Identify key research findings and methodologies
+- Present balanced perspectives on complex topics
+- Cite relevant theories, principles, and frameworks
+- Validate information accuracy and reliability
+
+KNOWLEDGE INTEGRATION:
+- Connect interdisciplinary insights and findings
+- Identify knowledge gaps and research opportunities
+- Provide historical context and evolutionary perspectives
+- Analyze current trends and future directions
+- Support conclusions with evidence-based reasoning
+- Maintain scientific rigor and objectivity"""
+}
+
+# Промпт для критика
+CRITIC_PROMPT = """You are an Expert Critic and Synthesis Agent. Your mission is to analyze multiple responses and create the ultimate optimal answer by combining the best elements from each response.
+
+CRITICAL INSTRUCTIONS:
+- If the original query requested specific code, documentation, or technical content, provide ONLY what the user needs without additional explanations
+- Always respond in the SAME LANGUAGE as the original user query (Russian/English/etc.)
+- For code requests: provide clean, functional code only
+- For specific questions: give direct, precise answers
+
+SYNTHESIS METHODOLOGY:
+1. Analyze each agent response for:
+   - Accuracy and correctness
+   - Completeness and depth
+   - Practical applicability
+   - Innovation and creativity
+   - Technical precision
+
+2. Identify the strongest elements from each response:
+   - Most accurate technical details
+   - Best creative solutions
+   - Most comprehensive analysis
+   - Most practical recommendations
+   - Clearest explanations
+
+3. Synthesize the optimal response by:
+   - Combining the best aspects from all responses
+   - Eliminating redundancies and contradictions
+   - Ensuring logical flow and coherence
+   - Maintaining the highest quality standards
+   - Preserving the most valuable insights
+
+4. Final optimization:
+   - Verify technical accuracy
+   - Ensure practical applicability
+   - Maintain appropriate depth and clarity
+   - Provide the most valuable response possible
+
+Create the ultimate response that represents the best synthesis of all agent contributions."""
+
+class AsyncMultiAgentSystem:
+    def __init__(self, model_name="liberalusa/LiberalMind_v1.5"):
+        self.model_name = model_name
+        self.tokenizer = None
+        self.model = None
+        self.device = device
+        self.load_model()
+
+    def load_model(self):
+        """Загрузка модели и токенизатора"""
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16 if self.device.type == "cuda" else torch.float32,
+                low_cpu_mem_usage=True,
+                device_map="auto" if self.device.type == "cuda" else None
+            ).eval()
+
+            if self.device.type == "cuda":
+                self.model = self.model.to(self.device)
+
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+
+            print("✅ Модель успешно загружена!")
+
+        except Exception as e:
+            print(f"❌ Ошибка загрузки модели: {e}")
+            raise
+
+    async def generate_response_async(self, prompt: str, max_tokens: int = 1000) -> str:
+        """Асинхронная генерация ответа от модели"""
+        try:
+            # Запускаем синхронную генерацию в отдельном потоке
+            loop = asyncio.get_event_loop()
+
+            def _generate():
+                inputs = self.tokenizer(
+                    prompt,
+                    return_tensors="pt",
+                    truncation=True,
+                    max_length=1024
+                ).to(self.device)
+
+                with torch.no_grad():
+                    outputs = self.model.generate(
+                        input_ids=inputs.input_ids,
+                        attention_mask=inputs.attention_mask,
+                        max_new_tokens=max_tokens,
+                        num_return_sequences=1,
+                        do_sample=True,
+                        temperature=0.7,
+                        top_p=0.9,
+                        pad_token_id=self.tokenizer.eos_token_id,
+                        repetition_penalty=1.1
+                    )
+
+                generated_text = self.tokenizer.decode(
+                    outputs[0],
+                    skip_special_tokens=True
+                )
+
+                # Убираем исходный промпт из ответа
+                if prompt in generated_text:
+                    generated_text = generated_text.replace(prompt, "").strip()
+
+                return generated_text
+
+            # Выполняем генерацию асинхронно
+            response = await loop.run_in_executor(None, _generate)
+            return response
+
+        except Exception as e:
+            return f"❌ Ошибка генерации: {e}"
+
+    async def run_agent_async(self, agent_name: str, user_query: str) -> Dict[str, Any]:
+        """Асинхронный запуск отдельного агента"""
+        agent_prompt = AGENT_PROMPTS[agent_name]
+        full_prompt = f"{agent_prompt}\n\nUser Query: {user_query}\n\nResponse:"
+
+        print(f"🤖 Агент {agent_name} начал работу...")
+        start_time = time.time()
+
+        response = await self.generate_response_async(full_prompt)
+
+        end_time = time.time()
+        print(f"✅ Агент {agent_name} завершил работу за {end_time - start_time:.2f}с")
+
+        return {
+            'agent': agent_name,
+            'response': response,
+            'execution_time': end_time - start_time
+        }
+
+    async def run_critic_async(self, user_query: str, agent_responses: List[Dict[str, Any]]) -> str:
+        """Асинхронный запуск критика для анализа всех ответов"""
+        print("🎯 Критик анализирует ответы...")
+        start_time = time.time()
+
+        # Формируем промпт для критика
+        critic_input = f"{CRITIC_PROMPT}\n\nOriginal User Query: {user_query}\n\n"
+
+        for i, response in enumerate(agent_responses, 1):
+            critic_input += f"AGENT {i} ({response['agent']}) RESPONSE:\n{response['response']}\n\n"
+
+        critic_input += "SYNTHESIZED OPTIMAL RESPONSE:"
+
+        final_response = await self.generate_response_async(critic_input, max_tokens=1500)
+
+        end_time = time.time()
+        print(f"✅ Критик завершил анализ за {end_time - start_time:.2f}с")
+
+        return final_response
+
+    async def process_query_async(self, user_query: str) -> tuple:
+        """Асинхронная обработка запроса всеми агентами и критиком"""
+        print(f"\n🚀 Обработка запроса: {user_query[:100]}...")
+        print("="*60)
+
+        # Создаем асинхронные задачи для всех агентов
+        tasks = []
+        for agent_name in AGENT_PROMPTS.keys():
+            task = asyncio.create_task(
+                self.run_agent_async(agent_name, user_query),
+                name=f"agent_{agent_name}"
+            )
+            tasks.append(task)
+
+        # Ожидаем завершения всех агентов параллельно
+        print("⏳ Ожидание завершения всех агентов...")
+        agent_responses = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Фильтруем успешные ответы
+        successful_responses = []
+        for response in agent_responses:
+            if isinstance(response, Exception):
+                print(f"❌ Ошибка агента: {response}")
+            else:
+                successful_responses.append(response)
+
+        # Сортируем ответы по именам агентов для консистентности
+        successful_responses.sort(key=lambda x: x['agent'])
+
+        # Показываем краткие ответы агентов
+        print("\n📋 КРАТКИЕ ОТВЕТЫ АГЕНТОВ:")
+        print("-"*40)
+        for response in successful_responses:
+            preview = response['response'][:200] + "..." if len(response['response']) > 200 else response['response']
+            print(f"🤖 {response['agent']} ({response['execution_time']:.2f}с): {preview}")
+
+        # Асинхронно запускаем критика
+        print("\n" + "="*60)
+        final_response = await self.run_critic_async(user_query, successful_responses)
+
+        return final_response, successful_responses
+
+    def clean_memory(self):
+        """Очистка памяти GPU"""
+        if self.device.type == "cuda":
+            torch.cuda.empty_cache()
+
+async def main_async():
+    """Основная асинхронная функция"""
+    print("🚀 Инициализация асинхронной многоагентной системы...")
+
+    try:
+        system = AsyncMultiAgentSystem()
+    except Exception as e:
+        print(f"❌ Ошибка инициализации: {e}")
+        return
+
+    print("\n" + "="*60)
+    print("🎯 АСИНХРОННАЯ МНОГОАГЕНТНАЯ СИСТЕМА ГОТОВА К РАБОТЕ!")
+    print("Доступные агенты:")
+    print("  🔬 Analytical Agent - Глубокий анализ")
+    print("  🎨 Creative Agent - Креативные решения")
+    print("  ⚙️ Technical Agent - Технические решения")
+    print("  📊 Strategic Agent - Стратегическое планирование")
+    print("  📚 Research Agent - Исследования и синтез")
+    print("  🎯 Critic Agent - Финальный синтез")
+    print("="*60)
+    print("\n💡 Все агенты работают параллельно и асинхронно!")
+    print("Введите ваш запрос (или 'exit' для выхода):")
+
+    while True:
+        try:
+            # Получаем ввод от пользователя
+            user_input = input("\n> ").strip()
+
+            if user_input.lower() in ['exit', 'quit']:
+                print("👋 Завершение работы...")
+                break
+
+            if not user_input:
+                print("⚠️ Пожалуйста, введите непустой запрос.")
+                continue
+
+            start_time = time.time()
+
+            # Асинхронная обработка запроса
+            final_response, agent_responses = await system.process_query_async(user_input)
+
+            end_time = time.time()
+
+            # Статистика времени выполнения
+            agent_times = [resp['execution_time'] for resp in agent_responses]
+            total_agent_time = sum(agent_times)
+            actual_time = end_time - start_time
+
+            # Вывод финального ответа
+            print("\n" + "="*60)
+            print("🎯 ФИНАЛЬНЫЙ СИНТЕЗИРОВАННЫЙ ОТВЕТ:")
+            print("="*60)
+            print(final_response)
+            print("="*60)
+            print(f"⏱️ Общее время обработки: {actual_time:.2f} секунд")
+            print(f"🔥 Суммарное время агентов: {total_agent_time:.2f} секунд")
+            print(f"🚀 Ускорение от асинхронности: {total_agent_time/actual_time:.2f}x")
+
+            # Очистка памяти
+            system.clean_memory()
+
+        except KeyboardInterrupt:
+            print("\n\n❌ Прервано пользователем.")
+            break
+        except Exception as e:
+            print(f"❌ Неожиданная ошибка: {e}")
+            system.clean_memory()
+
+def main():
+    """Синхронная обертка для запуска асинхронной системы"""
+    try:
+        asyncio.run(main_async())
+    except KeyboardInterrupt:
+        print("\n👋 Система завершена.")
+
+if __name__ == "__main__":
+    main() ``` </pre>