Update README.md

README.md

@@ -758,4 +758,516 @@ def main():
         print("\n👋 Система завершена.")
 
 if __name__ == "__main__":
-    main() ``` </pre>
+    main() ``` </pre>
+
+# A Deep Research system has been developed for our model specifically for the agent system
+<pre> ```import asyncio
+import aiohttp
+import time
+import json
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+from urllib.parse import urlencode, urlparse
+import re
+from bs4 import BeautifulSoup
+import logging
+
+# Настройка логирования
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SearchQuery:
+    """Класс для хранения информации о поисковом запросе"""
+    query: str
+    purpose: str
+    priority: int
+    expected_results: int = 3
+
+@dataclass
+class WebResult:
+    """Класс для хранения результатов веб-поиска"""
+    url: str
+    title: str
+    snippet: str
+    content: str = ""
+    relevance_score: float = 0.0
+    source_type: str = "web"
+
+@dataclass
+class SearchPlan:
+    """Класс для хранения плана поиска"""
+    main_query: str
+    sub_queries: List[SearchQuery]
+    expected_outcome: str
+    search_strategy: str
+
+class IntelligentWebSearchSystem:
+    def __init__(self):
+        self.session = None
+        self.search_engines = {
+            'duckduckgo': 'https://duckduckgo.com/html/?q=',
+            'bing': 'https://www.bing.com/search?q=',
+            'google': 'https://www.google.com/search?q='
+        }
+
+        # Мета-промпт для планирования поиска
+        self.planning_prompt = """You are an Expert Web Search Planner. Your mission is to create comprehensive search strategies for any user query.
+
+CRITICAL INSTRUCTIONS:
+- Always respond in the SAME LANGUAGE as the user's query (Russian/English/etc.)
+- Create detailed search plans with multiple targeted queries
+- Focus on gathering comprehensive information from diverse sources
+- Prioritize queries by importance and relevance
+
+PLANNING METHODOLOGY:
+1. Analyze the user's query to understand:
+   - Core information needs
+   - Context and background requirements
+   - Specific details needed
+   - Current/recent information requirements
+
+2. Create a strategic search plan with:
+   - 8-10 targeted search queries
+   - Clear purpose for each query
+   - Priority ranking (1-10)
+   - Expected number of results to examine
+
+3. Search strategy should cover:
+   - Direct answers to the main question
+   - Background and context information
+   - Recent developments and news
+   - Technical details and specifications
+   - Alternative perspectives and opinions
+   - Related concepts and comparisons
+
+4. Query formulation best practices:
+   - Use specific keywords and phrases
+   - Include relevant technical terms
+   - Consider different phrasings of the same concept
+   - Add date constraints for recent information
+   - Include source-specific searches when relevant
+
+RESPONSE FORMAT:
+Provide a JSON-like structure with:
+- main_query: The original user query
+- expected_outcome: What comprehensive answer should be achieved
+- search_strategy: Overall approach description
+- sub_queries: List of targeted search queries with purpose and priority
+
+Example structure:
+{
+    "main_query": "user's original question",
+    "expected_outcome": "comprehensive answer covering all aspects",
+    "search_strategy": "multi-faceted approach covering X, Y, Z",
+    "sub_queries": [
+        {
+            "query": "specific search terms",
+            "purpose": "what this search aims to find",
+            "priority": 9,
+            "expected_results": 5
+        }
+    ]
+}"""
+
+    async def __aenter__(self):
+        """Асинхронный контекст-менеджер для сессии"""
+        self.session = aiohttp.ClientSession(
+            timeout=aiohttp.ClientTimeout(total=30),
+            headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+        )
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Закрытие сессии"""
+        if self.session:
+            await self.session.close()
+
+    def create_search_plan(self, user_query: str) -> SearchPlan:
+        """Создание плана поиска на основе запроса пользователя"""
+        print(f"🧠 Создание плана поиска для: {user_query}")
+
+        # Базовый план поиска (в реальной системе здесь был бы AI-планировщик)
+        plan = self._generate_search_plan(user_query)
+
+        print(f"📋 План создан: {len(plan.sub_queries)} поисковых запросов")
+        return plan
+
+    def _generate_search_plan(self, user_query: str) -> SearchPlan:
+        """Генерация плана поиска (упрощенная версия)"""
+        # Определяем тип запроса
+        query_lower = user_query.lower()
+
+        # Базовые запросы
+        sub_queries = [
+            SearchQuery(
+                query=user_query,
+                purpose="Прямой ответ на основной вопрос",
+                priority=10,
+                expected_results=5
+            )
+        ]
+
+        # Добавляем контекстные запросы
+        if any(word in query_lower for word in ['что такое', 'что это', 'определение']):
+            sub_queries.extend([
+                SearchQuery(
+                    query=f"{user_query} определение",
+                    purpose="Получение точного определения",
+                    priority=9,
+                    expected_results=3
+                ),
+                SearchQuery(
+                    query=f"{user_query} примеры",
+                    purpose="Практические примеры",
+                    priority=7,
+                    expected_results=3
+                )
+            ])
+
+        if any(word in query_lower for word in ['как', 'способ', 'метод']):
+            sub_queries.extend([
+                SearchQuery(
+                    query=f"{user_query} инструкция",
+                    purpose="Пошаговые инструкции",
+                    priority=9,
+                    expected_results=4
+                ),
+                SearchQuery(
+                    query=f"{user_query} советы",
+                    purpose="Практические советы",
+                    priority=8,
+                    expected_results=3
+                )
+            ])
+
+        # Добавляем запросы для актуальной информации
+        sub_queries.extend([
+            SearchQuery(
+                query=f"{user_query} 2024 2025",
+                purpose="Актуальная информация",
+                priority=8,
+                expected_results=3
+            ),
+            SearchQuery(
+                query=f"{user_query} новости",
+                purpose="Последние новости и развития",
+                priority=7,
+                expected_results=3
+            ),
+            SearchQuery(
+                query=f"{user_query} обзор",
+                purpose="Аналитические обзоры",
+                priority=6,
+                expected_results=3
+            )
+        ])
+
+        # Добавляем альтернативные формулировки
+        sub_queries.extend([
+            SearchQuery(
+                query=f"{user_query} подробно",
+                purpose="Детальная информация",
+                priority=6,
+                expected_results=3
+            ),
+            SearchQuery(
+                query=f"{user_query} преимущества недостатки",
+                purpose="Анализ плюсов и минусов",
+                priority=5,
+                expected_results=3
+            ),
+            SearchQuery(
+                query=f"{user_query} сравнение",
+                purpose="Сравнительный анализ",
+                priority=5,
+                expected_results=2
+            )
+        ])
+
+        # Ограничиваем до 10 запросов
+        sub_queries = sorted(sub_queries, key=lambda x: x.priority, reverse=True)[:10]
+
+        return SearchPlan(
+            main_query=user_query,
+            sub_queries=sub_queries,
+            expected_outcome=f"Comprehensive information about: {user_query}",
+            search_strategy="Multi-faceted search covering definitions, examples, recent developments, and practical applications"
+        )
+
+    async def search_duckduckgo(self, query: str, max_results: int = 5) -> List[Dict[str, Any]]:
+        """Поиск в DuckDuckGo"""
+        try:
+            search_url = f"https://duckduckgo.com/html/?q={urlencode({'q': query})}"
+
+            async with self.session.get(search_url) as response:
+                if response.status == 200:
+                    html = await response.text()
+                    soup = BeautifulSoup(html, 'html.parser')
+
+                    results = []
+                    for result in soup.find_all('div', class_='result')[:max_results]:
+                        title_elem = result.find('h2')
+                        snippet_elem = result.find('div', class_='result__snippet')
+                        link_elem = result.find('a', class_='result__a')
+
+                        if title_elem and link_elem:
+                            results.append({
+                                'title': title_elem.get_text(strip=True),
+                                'url': link_elem.get('href', ''),
+                                'snippet': snippet_elem.get_text(strip=True) if snippet_elem else '',
+                                'source': 'DuckDuckGo'
+                            })
+
+                    return results
+
+        except Exception as e:
+            logger.error(f"Error searching DuckDuckGo: {e}")
+            return []
+
+    async def search_bing(self, query: str, max_results: int = 5) -> List[Dict[str, Any]]:
+        """Поиск в Bing (упрощенная версия)"""
+        try:
+            search_url = f"https://www.bing.com/search?q={urlencode({'q': query})}"
+
+            async with self.session.get(search_url) as response:
+                if response.status == 200:
+                    html = await response.text()
+                    soup = BeautifulSoup(html, 'html.parser')
+
+                    results = []
+                    for result in soup.find_all('li', class_='b_algo')[:max_results]:
+                        title_elem = result.find('h2')
+                        snippet_elem = result.find('div', class_='b_caption')
+                        link_elem = title_elem.find('a') if title_elem else None
+
+                        if title_elem and link_elem:
+                            results.append({
+                                'title': title_elem.get_text(strip=True),
+                                'url': link_elem.get('href', ''),
+                                'snippet': snippet_elem.get_text(strip=True) if snippet_elem else '',
+                                'source': 'Bing'
+                            })
+
+                    return results
+
+        except Exception as e:
+            logger.error(f"Error searching Bing: {e}")
+            return []
+
+    async def fetch_webpage_content(self, url: str, max_length: int = 5000) -> str:
+        """Получение содержимого веб-страницы"""
+        try:
+            async with self.session.get(url) as response:
+                if response.status == 200:
+                    html = await response.text()
+                    soup = BeautifulSoup(html, 'html.parser')
+
+                    # Удаляем скрипты и стили
+                    for script in soup(["script", "style"]):
+                        script.decompose()
+
+                    # Извлекаем текст
+                    text = soup.get_text()
+
+                    # Очищаем текст
+                    lines = (line.strip() for line in text.splitlines())
+                    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+                    text = ' '.join(chunk for chunk in chunks if chunk)
+
+                    return text[:max_length]
+
+        except Exception as e:
+            logger.error(f"Error fetching {url}: {e}")
+            return ""
+
+    async def execute_search_query(self, search_query: SearchQuery) -> List[WebResult]:
+        """Выполнение одного поискового запроса"""
+        print(f"🔍 Поиск: {search_query.query} (приоритет: {search_query.priority})")
+
+        # Выполняем поиск в разных источниках
+        tasks = [
+            self.search_duckduckgo(search_query.query, search_query.expected_results),
+            self.search_bing(search_query.query, search_query.expected_results)
+        ]
+
+        search_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Объединяем результаты
+        all_results = []
+        for results in search_results:
+            if isinstance(results, list):
+                all_results.extend(results)
+
+        # Удаляем дубликаты по URL
+        unique_results = {}
+        for result in all_results:
+            url = result.get('url', '')
+            if url and url not in unique_results:
+                unique_results[url] = result
+
+        # Преобразуем в WebResult объекты
+        web_results = []
+        for result in list(unique_results.values())[:search_query.expected_results]:
+            web_result = WebResult(
+                url=result['url'],
+                title=result['title'],
+                snippet=result['snippet'],
+                source_type=result.get('source', 'web')
+            )
+            web_results.append(web_result)
+
+        print(f"✅ Найдено {len(web_results)} результатов для: {search_query.query}")
+        return web_results
+
+    async def fetch_detailed_content(self, web_results: List[WebResult]) -> List[WebResult]:
+        """Получение детального содержимого веб-страниц"""
+        print(f"📄 Загрузка содержимого {len(web_results)} страниц...")
+
+        tasks = []
+        for result in web_results:
+            task = asyncio.create_task(
+                self.fetch_webpage_content(result.url),
+                name=f"fetch_{result.url}"
+            )
+            tasks.append((result, task))
+
+        for result, task in tasks:
+            try:
+                content = await task
+                result.content = content
+                result.relevance_score = len(content) / 1000  # Простая оценка релевантности
+                print(f"✅ Загружено: {result.title[:50]}...")
+            except Exception as e:
+                logger.error(f"Error loading content for {result.url}: {e}")
+                result.content = result.snippet
+                result.relevance_score = 0.1
+
+        return web_results
+
+    async def execute_search_plan(self, plan: SearchPlan) -> Dict[str, Any]:
+        """Выполнение плана поиска"""
+        print(f"\n🚀 Выполнение плана поиска для: {plan.main_query}")
+        print(f"📊 Запросов в плане: {len(plan.sub_queries)}")
+        print("="*60)
+
+        start_time = time.time()
+
+        # Создаем задачи для всех поисковых запросов
+        search_tasks = []
+        for query in plan.sub_queries:
+            task = asyncio.create_task(
+                self.execute_search_query(query),
+                name=f"search_{query.query}"
+            )
+            search_tasks.append((query, task))
+
+        # Выполняем все поисковые запросы параллельно
+        all_results = []
+        for query, task in search_tasks:
+            try:
+                results = await task
+                all_results.extend(results)
+            except Exception as e:
+                logger.error(f"Error executing search query '{query.query}': {e}")
+
+        print(f"\n📊 Собрано {len(all_results)} результатов поиска")
+
+        # Получаем детальное содержимое страниц
+        detailed_results = await self.fetch_detailed_content(all_results)
+
+        # Сортируем по релевантности
+        detailed_results.sort(key=lambda x: x.relevance_score, reverse=True)
+
+        end_time = time.time()
+
+        return {
+            'plan': plan,
+            'results': detailed_results,
+            'total_results': len(detailed_results),
+            'execution_time': end_time - start_time,
+            'queries_executed': len(plan.sub_queries)
+        }
+
+    def format_search_results(self, search_data: Dict[str, Any]) -> str:
+        """Форматирование результатов поиска"""
+        plan = search_data['plan']
+        results = search_data['results']
+
+        output = f"""
+🎯 РЕЗУЛЬТАТЫ ИНТЕЛЛЕКТУАЛЬНОГО ПОИСКА
+{'='*60}
+
+📝 ИСХОДНЫЙ ЗАПРОС: {plan.main_query}
+🎯 ЦЕЛЬ ПОИСКА: {plan.expected_outcome}
+📊 СТРАТЕГИЯ: {plan.search_strategy}
+
+📈 СТАТИСТИКА:
+• Выполнено запросов: {search_data['queries_executed']}
+• Найдено результатов: {search_data['total_results']}
+• Время выполнения: {search_data['execution_time']:.2f} секунд
+
+🔍 ВЫПОЛНЕННЫЕ ЗАПРОСЫ:
+"""
+
+        for i, query in enumerate(plan.sub_queries, 1):
+            output += f"  {i}. {query.query} (приоритет: {query.priority}) - {query.purpose}\n"
+
+        output += f"\n📋 ТОП-10 НАИБОЛЕЕ РЕЛЕВАНТНЫХ РЕЗУЛЬТАТОВ:\n{'-'*60}\n"
+
+        for i, result in enumerate(results[:10], 1):
+            content_preview = result.content[:300] + "..." if len(result.content) > 300 else result.content
+            output += f"""
+{i}. 📄 {result.title}
+   🌐 URL: {result.url}
+   📊 Релевантность: {result.relevance_score:.2f}
+   📝 Краткое описание: {result.snippet}
+   📖 Содержимое: {content_preview}
+   {'-'*40}
+"""
+
+        return output
+
+async def main():
+    """Основная функция"""
+    print("🌐 Система интеллектуального поиска в интернете")
+    print("="*60)
+    print("💡 Система создает план поиска и выполняет 10 запросов параллельно")
+    print("🔍 Каждый запрос обрабатывается в нескольких поисковых системах")
+    print("📄 Автоматически загружается содержимое найденных страниц")
+    print("="*60)
+
+    async with IntelligentWebSearchSystem() as search_system:
+        while True:
+            try:
+                user_query = input("\n🔍 Введите запрос для поиска (или 'exit' для выхода): ").strip()
+
+                if user_query.lower() in ['exit', 'quit']:
+                    print("👋 Завершение работы...")
+                    break
+
+                if not user_query:
+                    print("⚠️ Пожалуйста, введите непустой запрос.")
+                    continue
+
+                # Создаем план поиска
+                plan = search_system.create_search_plan(user_query)
+
+                # Выполняем план
+                search_results = await search_system.execute_search_plan(plan)
+
+                # Выводим результаты
+                formatted_results = search_system.format_search_results(search_results)
+                print(formatted_results)
+
+            except KeyboardInterrupt:
+                print("\n\n❌ Прервано пользователем.")
+                break
+            except Exception as e:
+                print(f"❌ Ошибка: {e}")
+                logger.error(f"Unexpected error: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main()) ``` </pre>