Upd multilingual search strat

search/__init__.py

@@ -0,0 +1,21 @@
+# Search package
+from .search import WebSearcher, search_web, search_web_with_content, search_medical, search_multilingual_medical
+from .coordinator import SearchCoordinator
+from .engines import DuckDuckGoEngine, MedicalSearchEngine, MultilingualMedicalEngine
+from .extractors import ContentExtractor
+from .processors import MedicalSearchProcessor, LanguageProcessor
+
+__all__ = [
+    'WebSearcher', 
+    'search_web', 
+    'search_web_with_content', 
+    'search_medical',
+    'search_multilingual_medical',
+    'SearchCoordinator',
+    'DuckDuckGoEngine',
+    'MedicalSearchEngine',
+    'MultilingualMedicalEngine',
+    'ContentExtractor',
+    'MedicalSearchProcessor',
+    'LanguageProcessor'
+]

search/coordinator.py

@@ -0,0 +1,203 @@
+import logging
+from typing import List, Dict, Tuple
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from .engines.duckduckgo import DuckDuckGoEngine
+from .engines.medical import MedicalSearchEngine
+from .engines.multilingual import MultilingualMedicalEngine
+from .extractors.content import ContentExtractor
+from .processors.medical import MedicalSearchProcessor
+from .processors.language import LanguageProcessor
+
+logger = logging.getLogger(__name__)
+
+class SearchCoordinator:
+    """Coordinate multiple search strategies for comprehensive medical information"""
+    
+    def __init__(self, max_workers: int = 3):
+        self.max_workers = max_workers
+        
+        # Initialize search engines
+        self.duckduckgo_engine = DuckDuckGoEngine()
+        self.medical_engine = MedicalSearchEngine()
+        self.multilingual_engine = MultilingualMedicalEngine()
+        
+        # Initialize processors
+        self.content_extractor = ContentExtractor()
+        self.medical_processor = MedicalSearchProcessor()
+        self.language_processor = LanguageProcessor()
+        
+        # Search strategies
+        self.strategies = [
+            self._search_multilingual,
+            self._search_duckduckgo,
+            self._search_medical_sources
+        ]
+    
+    def search(self, query: str, num_results: int = 10, target_language: str = None) -> Tuple[str, Dict[int, str]]:
+        """Execute comprehensive multilingual search with multiple strategies"""
+        logger.info(f"Starting comprehensive multilingual search for: {query}")
+        
+        # Detect and enhance query for multiple languages
+        enhanced_queries = self.language_processor.enhance_query(query, target_language)
+        logger.info(f"Enhanced queries: {list(enhanced_queries.keys())}")
+        
+        # Execute search strategies in parallel
+        all_results = []
+        
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # Submit search tasks for each language
+            future_to_strategy = {}
+            
+            for lang, enhanced_query in enhanced_queries.items():
+                for strategy in self.strategies:
+                    future = executor.submit(strategy, enhanced_query, num_results // len(enhanced_queries), lang)
+                    future_to_strategy[future] = f"{strategy.__name__}_{lang}"
+            
+            # Collect results
+            for future in as_completed(future_to_strategy):
+                strategy_name = future_to_strategy[future]
+                try:
+                    results = future.result()
+                    if results:
+                        all_results.extend(results)
+                        logger.info(f"{strategy_name} found {len(results)} results")
+                except Exception as e:
+                    logger.error(f"{strategy_name} failed: {e}")
+        
+        # Remove duplicates and filter by language preference
+        unique_results = self._remove_duplicates(all_results)
+        if target_language:
+            unique_results = self.language_processor.filter_by_language(unique_results, target_language)
+        
+        logger.info(f"Total unique results: {len(unique_results)}")
+        
+        # Extract content from URLs
+        enriched_results = self._enrich_with_content(unique_results)
+        
+        # Process results into comprehensive summary
+        summary, url_mapping = self.medical_processor.process_results(enriched_results, query)
+        
+        logger.info(f"Multilingual search completed: {len(url_mapping)} sources processed")
+        return summary, url_mapping
+    
+    def _search_multilingual(self, query: str, num_results: int, language: str = None) -> List[Dict]:
+        """Search using multilingual medical engine"""
+        try:
+            if language:
+                results = self.multilingual_engine.search_by_language(query, language, num_results)
+            else:
+                results = self.multilingual_engine.search(query, num_results)
+            return results
+        except Exception as e:
+            logger.error(f"Multilingual search failed: {e}")
+            return []
+    
+    def _search_duckduckgo(self, query: str, num_results: int, language: str = None) -> List[Dict]:
+        """Search using DuckDuckGo engine"""
+        try:
+            results = self.duckduckgo_engine.search(query, num_results)
+            return results
+        except Exception as e:
+            logger.error(f"DuckDuckGo search failed: {e}")
+            return []
+    
+    def _search_medical_sources(self, query: str, num_results: int, language: str = None) -> List[Dict]:
+        """Search using medical sources engine"""
+        try:
+            results = self.medical_engine.search(query, num_results)
+            return results
+        except Exception as e:
+            logger.error(f"Medical sources search failed: {e}")
+            return []
+    
+    def _remove_duplicates(self, results: List[Dict]) -> List[Dict]:
+        """Remove duplicate results based on URL"""
+        seen_urls = set()
+        unique_results = []
+        
+        for result in results:
+            url = result.get('url', '')
+            if url and url not in seen_urls:
+                seen_urls.add(url)
+                unique_results.append(result)
+        
+        return unique_results
+    
+    def _enrich_with_content(self, results: List[Dict]) -> List[Dict]:
+        """Enrich results with extracted content"""
+        enriched_results = []
+        
+        # Extract content in parallel
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # Submit content extraction tasks
+            future_to_result = {
+                executor.submit(self.content_extractor.extract, result['url']): result
+                for result in results
+            }
+            
+            # Collect enriched results
+            for future in as_completed(future_to_result):
+                original_result = future_to_result[future]
+                try:
+                    content = future.result()
+                    if content:
+                        enriched_result = original_result.copy()
+                        enriched_result['content'] = content
+                        enriched_results.append(enriched_result)
+                except Exception as e:
+                    logger.warning(f"Content extraction failed for {original_result['url']}: {e}")
+                    # Still include result without content
+                    enriched_results.append(original_result)
+        
+        return enriched_results
+    
+    def quick_search(self, query: str, num_results: int = 5) -> List[Dict]:
+        """Quick search for basic results without content extraction"""
+        logger.info(f"Quick search for: {query}")
+        
+        # Use only DuckDuckGo for speed
+        results = self.duckduckgo_engine.search(query, num_results)
+        
+        # Remove duplicates
+        unique_results = self._remove_duplicates(results)
+        
+        logger.info(f"Quick search completed: {len(unique_results)} results")
+        return unique_results
+    
+    def medical_focus_search(self, query: str, num_results: int = 8) -> Tuple[str, Dict[int, str]]:
+        """Medical-focused search with enhanced processing"""
+        logger.info(f"Medical focus search for: {query}")
+        
+        # Use medical engine primarily
+        medical_results = self.medical_engine.search(query, num_results)
+        
+        # Add some general results for context
+        general_results = self.duckduckgo_engine.search(query, 3)
+        
+        # Combine and deduplicate
+        all_results = self._remove_duplicates(medical_results + general_results)
+        
+        # Enrich with content
+        enriched_results = self._enrich_with_content(all_results)
+        
+        # Process with medical focus
+        summary, url_mapping = self.medical_processor.process_results(enriched_results, query)
+        
+        logger.info(f"Medical focus search completed: {len(url_mapping)} sources")
+        return summary, url_mapping
+    
+    def multilingual_medical_search(self, query: str, num_results: int = 10, target_language: str = None) -> Tuple[str, Dict[int, str]]:
+        """Comprehensive multilingual medical search"""
+        logger.info(f"Multilingual medical search for: {query} (target: {target_language})")
+        
+        # Detect source language
+        source_language = self.language_processor.detect_language(query)
+        logger.info(f"Detected source language: {source_language}")
+        
+        # Use multilingual search with language preference
+        summary, url_mapping = self.search(query, num_results, target_language)
+        
+        logger.info(f"Multilingual medical search completed: {len(url_mapping)} sources")
+        return summary, url_mapping

search/engines/__init__.py

@@ -0,0 +1,5 @@
+from .duckduckgo import DuckDuckGoEngine
+from .medical import MedicalSearchEngine
+from .multilingual import MultilingualMedicalEngine
+
+__all__ = ['DuckDuckGoEngine', 'MedicalSearchEngine', 'MultilingualMedicalEngine']

search/engines/duckduckgo.py

@@ -0,0 +1,200 @@
+import requests
+from bs4 import BeautifulSoup
+import logging
+from typing import List, Dict
+import time
+
+logger = logging.getLogger(__name__)
+
+class DuckDuckGoEngine:
+    """DuckDuckGo search engine with multiple strategies"""
+    
+    def __init__(self, timeout: int = 15):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1',
+        })
+        self.timeout = timeout
+    
+    def search(self, query: str, num_results: int = 10) -> List[Dict]:
+        """Search with multiple DuckDuckGo strategies"""
+        results = []
+        
+        # Strategy 1: HTML Interface
+        html_results = self._search_html(query, num_results)
+        if html_results:
+            results.extend(html_results)
+            logger.info(f"DuckDuckGo HTML found {len(html_results)} results")
+        
+        # Strategy 2: Instant Answer API
+        if len(results) < num_results:
+            api_results = self._search_api(query, num_results - len(results))
+            if api_results:
+                results.extend(api_results)
+                logger.info(f"DuckDuckGo API found {len(api_results)} results")
+        
+        # Strategy 3: Lite Interface (mobile-friendly)
+        if len(results) < num_results:
+            lite_results = self._search_lite(query, num_results - len(results))
+            if lite_results:
+                results.extend(lite_results)
+                logger.info(f"DuckDuckGo Lite found {len(lite_results)} results")
+        
+        return results[:num_results]
+    
+    def _search_html(self, query: str, num_results: int) -> List[Dict]:
+        """Search using DuckDuckGo HTML interface"""
+        try:
+            url = "https://html.duckduckgo.com/html/"
+            params = {
+                'q': query,
+                'kl': 'us-en',
+                's': '0',  # Start from first result
+                'dc': '1',  # Disable auto-complete
+                'v': 'l',   # Lite version
+                'o': 'json', # JSON output
+                'api': 'd.js'  # API format
+            }
+            
+            response = self.session.get(url, params=params, timeout=self.timeout)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            results = []
+            
+            # Multiple selectors for different DDG layouts
+            selectors = [
+                'a.result__a',
+                'a[data-testid="result-title-a"]',
+                '.result__title a',
+                '.web-result a',
+                '.result a',
+                'a[href*="http"]:not([href*="duckduckgo.com"])'
+            ]
+            
+            for selector in selectors:
+                links = soup.select(selector)
+                if links:
+                    logger.info(f"Using selector: {selector} - found {len(links)} links")
+                    break
+            
+            for link in links[:num_results]:
+                try:
+                    href = link.get('href')
+                    if not href or href.startswith('#') or 'duckduckgo.com' in href:
+                        continue
+                    
+                    # Clean up DDG redirect URLs
+                    if href.startswith('/l/?uddg='):
+                        import urllib.parse
+                        href = urllib.parse.unquote(href.split('uddg=')[1])
+                    
+                    title = link.get_text(strip=True)
+                    if title and href.startswith('http'):
+                        results.append({
+                            'url': href,
+                            'title': title,
+                            'source': 'duckduckgo_html'
+                        })
+                except Exception as e:
+                    logger.debug(f"Error parsing link: {e}")
+                    continue
+            
+            return results
+            
+        except Exception as e:
+            logger.warning(f"DuckDuckGo HTML search failed: {e}")
+            return []
+    
+    def _search_api(self, query: str, num_results: int) -> List[Dict]:
+        """Search using DuckDuckGo Instant Answer API"""
+        try:
+            url = "https://api.duckduckgo.com/"
+            params = {
+                'q': query,
+                'format': 'json',
+                'no_html': '1',
+                'skip_disambig': '1',
+                't': 'MedicalChatbot'
+            }
+            
+            response = self.session.get(url, params=params, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+            
+            results = []
+            
+            # Abstract result
+            if data.get('AbstractURL') and data.get('Abstract'):
+                results.append({
+                    'url': data['AbstractURL'],
+                    'title': data.get('Heading', query),
+                    'content': data.get('Abstract', ''),
+                    'source': 'duckduckgo_api'
+                })
+            
+            # Related topics
+            for topic in data.get('RelatedTopics', []):
+                if len(results) >= num_results:
+                    break
+                    
+                if isinstance(topic, dict) and topic.get('FirstURL'):
+                    text = topic.get('Text', '')
+                    title = text.split(' - ')[0] if ' - ' in text else text[:50]
+                    
+                    results.append({
+                        'url': topic['FirstURL'],
+                        'title': title,
+                        'content': text,
+                        'source': 'duckduckgo_api'
+                    })
+            
+            return results
+            
+        except Exception as e:
+            logger.warning(f"DuckDuckGo API search failed: {e}")
+            return []
+    
+    def _search_lite(self, query: str, num_results: int) -> List[Dict]:
+        """Search using DuckDuckGo Lite interface"""
+        try:
+            url = "https://lite.duckduckgo.com/lite/"
+            params = {
+                'q': query,
+                'kl': 'us-en'
+            }
+            
+            response = self.session.get(url, params=params, timeout=self.timeout)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            results = []
+            
+            # Lite interface selectors
+            links = soup.select('a[href*="http"]:not([href*="duckduckgo.com"])')
+            
+            for link in links[:num_results]:
+                try:
+                    href = link.get('href')
+                    title = link.get_text(strip=True)
+                    
+                    if href and title and href.startswith('http'):
+                        results.append({
+                            'url': href,
+                            'title': title,
+                            'source': 'duckduckgo_lite'
+                        })
+                except Exception as e:
+                    logger.debug(f"Error parsing lite link: {e}")
+                    continue
+            
+            return results
+            
+        except Exception as e:
+            logger.warning(f"DuckDuckGo Lite search failed: {e}")
+            return []

search/engines/medical.py

@@ -0,0 +1,195 @@
+import requests
+from bs4 import BeautifulSoup
+import logging
+from typing import List, Dict
+import time
+
+logger = logging.getLogger(__name__)
+
+class MedicalSearchEngine:
+    """Specialized medical search engine with curated sources"""
+    
+    def __init__(self, timeout: int = 15):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        })
+        self.timeout = timeout
+        
+        # Curated medical sources
+        self.medical_sources = {
+            'mayo_clinic': {
+                'base_url': 'https://www.mayoclinic.org',
+                'search_url': 'https://www.mayoclinic.org/search/search-results',
+                'domains': ['mayoclinic.org']
+            },
+            'webmd': {
+                'base_url': 'https://www.webmd.com',
+                'search_url': 'https://www.webmd.com/search/search_results/default.aspx',
+                'domains': ['webmd.com']
+            },
+            'healthline': {
+                'base_url': 'https://www.healthline.com',
+                'search_url': 'https://www.healthline.com/search',
+                'domains': ['healthline.com']
+            },
+            'medlineplus': {
+                'base_url': 'https://medlineplus.gov',
+                'search_url': 'https://medlineplus.gov/search',
+                'domains': ['medlineplus.gov']
+            },
+            'nih': {
+                'base_url': 'https://www.nih.gov',
+                'search_url': 'https://search.nih.gov/search',
+                'domains': ['nih.gov', 'nlm.nih.gov']
+            }
+        }
+    
+    def search(self, query: str, num_results: int = 10) -> List[Dict]:
+        """Search medical sources for relevant information"""
+        results = []
+        
+        # Strategy 1: Direct medical source searches
+        for source_name, source_config in self.medical_sources.items():
+            if len(results) >= num_results:
+                break
+                
+            source_results = self._search_medical_source(query, source_name, source_config)
+            results.extend(source_results)
+            
+            # Add delay between requests
+            time.sleep(0.5)
+        
+        # Strategy 2: Medical fallback sources
+        if len(results) < num_results:
+            fallback_results = self._get_fallback_sources(query, num_results - len(results))
+            results.extend(fallback_results)
+        
+        return results[:num_results]
+    
+    def _search_medical_source(self, query: str, source_name: str, source_config: Dict) -> List[Dict]:
+        """Search a specific medical source"""
+        try:
+            search_url = source_config.get('search_url')
+            if not search_url:
+                return []
+            
+            params = {
+                'q': query,
+                'query': query,
+                'search': query
+            }
+            
+            response = self.session.get(search_url, params=params, timeout=self.timeout)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            results = []
+            
+            # Source-specific selectors
+            selectors = self._get_source_selectors(source_name)
+            
+            for selector in selectors:
+                links = soup.select(selector)
+                if links:
+                    logger.info(f"{source_name} found {len(links)} results with selector: {selector}")
+                    break
+            
+            for link in links[:3]:  # Limit per source
+                try:
+                    href = link.get('href')
+                    if not href:
+                        continue
+                    
+                    # Make absolute URL
+                    if href.startswith('/'):
+                        href = source_config['base_url'] + href
+                    
+                    title = link.get_text(strip=True)
+                    if title and href.startswith('http'):
+                        results.append({
+                            'url': href,
+                            'title': title,
+                            'source': source_name,
+                            'domain': source_config['domains'][0]
+                        })
+                except Exception as e:
+                    logger.debug(f"Error parsing {source_name} link: {e}")
+                    continue
+            
+            return results
+            
+        except Exception as e:
+            logger.warning(f"Medical source {source_name} search failed: {e}")
+            return []
+    
+    def _get_source_selectors(self, source_name: str) -> List[str]:
+        """Get CSS selectors for specific medical sources"""
+        selectors_map = {
+            'mayo_clinic': [
+                'a[href*="/diseases-conditions/"]',
+                'a[href*="/symptoms/"]',
+                '.search-result a',
+                '.result-title a'
+            ],
+            'webmd': [
+                'a[href*="/default.htm"]',
+                '.search-result a',
+                '.result-title a',
+                'a[href*="/content/"]'
+            ],
+            'healthline': [
+                'a[href*="/health/"]',
+                '.search-result a',
+                '.result-title a',
+                'a[href*="/conditions/"]'
+            ],
+            'medlineplus': [
+                'a[href*="/healthtopics/"]',
+                '.search-result a',
+                '.result-title a'
+            ],
+            'nih': [
+                'a[href*="/health/"]',
+                '.search-result a',
+                '.result-title a'
+            ]
+        }
+        return selectors_map.get(source_name, ['a[href*="http"]'])
+    
+    def _get_fallback_sources(self, query: str, num_results: int) -> List[Dict]:
+        """Get fallback medical sources when direct search fails"""
+        fallback_sources = [
+            {
+                'url': 'https://www.mayoclinic.org/diseases-conditions',
+                'title': f'Mayo Clinic: {query}',
+                'source': 'mayo_fallback',
+                'domain': 'mayoclinic.org'
+            },
+            {
+                'url': 'https://www.webmd.com/default.htm',
+                'title': f'WebMD: {query}',
+                'source': 'webmd_fallback',
+                'domain': 'webmd.com'
+            },
+            {
+                'url': 'https://www.healthline.com/health',
+                'title': f'Healthline: {query}',
+                'source': 'healthline_fallback',
+                'domain': 'healthline.com'
+            },
+            {
+                'url': 'https://medlineplus.gov/healthtopics.html',
+                'title': f'MedlinePlus: {query}',
+                'source': 'medlineplus_fallback',
+                'domain': 'medlineplus.gov'
+            },
+            {
+                'url': 'https://www.cdc.gov',
+                'title': f'CDC: {query}',
+                'source': 'cdc_fallback',
+                'domain': 'cdc.gov'
+            }
+        ]
+        
+        return fallback_sources[:num_results]

search/engines/multilingual.py

@@ -0,0 +1,320 @@
+import requests
+from bs4 import BeautifulSoup
+import logging
+from typing import List, Dict, Optional
+import time
+import re
+from urllib.parse import urlparse, quote
+
+logger = logging.getLogger(__name__)
+
+class MultilingualMedicalEngine:
+    """Multilingual medical search engine supporting English, Vietnamese, and Chinese sources"""
+    
+    def __init__(self, timeout: int = 15):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5,vi;q=0.3,zh-CN;q=0.3',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+        })
+        self.timeout = timeout
+        
+        # Comprehensive medical sources by language
+        self.medical_sources = {
+            'en': {
+                'mayo_clinic': {
+                    'base_url': 'https://www.mayoclinic.org',
+                    'search_url': 'https://www.mayoclinic.org/search/search-results',
+                    'domains': ['mayoclinic.org'],
+                    'selectors': ['a[href*="/diseases-conditions/"]', 'a[href*="/symptoms/"]', '.search-result a']
+                },
+                'webmd': {
+                    'base_url': 'https://www.webmd.com',
+                    'search_url': 'https://www.webmd.com/search/search_results/default.aspx',
+                    'domains': ['webmd.com'],
+                    'selectors': ['a[href*="/default.htm"]', '.search-result a', 'a[href*="/content/"]']
+                },
+                'healthline': {
+                    'base_url': 'https://www.healthline.com',
+                    'search_url': 'https://www.healthline.com/search',
+                    'domains': ['healthline.com'],
+                    'selectors': ['a[href*="/health/"]', 'a[href*="/conditions/"]', '.search-result a']
+                },
+                'medlineplus': {
+                    'base_url': 'https://medlineplus.gov',
+                    'search_url': 'https://medlineplus.gov/search',
+                    'domains': ['medlineplus.gov'],
+                    'selectors': ['a[href*="/healthtopics/"]', '.search-result a']
+                },
+                'nih': {
+                    'base_url': 'https://www.nih.gov',
+                    'search_url': 'https://search.nih.gov/search',
+                    'domains': ['nih.gov', 'nlm.nih.gov'],
+                    'selectors': ['a[href*="/health/"]', '.search-result a']
+                },
+                'cdc': {
+                    'base_url': 'https://www.cdc.gov',
+                    'search_url': 'https://www.cdc.gov/search/index.html',
+                    'domains': ['cdc.gov'],
+                    'selectors': ['a[href*="/health/"]', '.search-result a']
+                }
+            },
+            'vi': {
+                'hello_bacsi': {
+                    'base_url': 'https://hellobacsi.com',
+                    'search_url': 'https://hellobacsi.com/tim-kiem',
+                    'domains': ['hellobacsi.com'],
+                    'selectors': ['a[href*="/suc-khoe/"]', 'a[href*="/benh/"]', '.search-result a', '.article-title a']
+                },
+                'alo_bacsi': {
+                    'base_url': 'https://alobacsi.com',
+                    'search_url': 'https://alobacsi.com/tim-kiem',
+                    'domains': ['alobacsi.com'],
+                    'selectors': ['a[href*="/suc-khoe/"]', 'a[href*="/benh/"]', '.search-result a']
+                },
+                'vinmec': {
+                    'base_url': 'https://www.vinmec.com',
+                    'search_url': 'https://www.vinmec.com/vi/tim-kiem',
+                    'domains': ['vinmec.com'],
+                    'selectors': ['a[href*="/suc-khoe/"]', 'a[href*="/benh/"]', '.search-result a']
+                },
+                'tam_anh': {
+                    'base_url': 'https://tamanhhospital.vn',
+                    'search_url': 'https://tamanhhospital.vn/tim-kiem',
+                    'domains': ['tamanhhospital.vn'],
+                    'selectors': ['a[href*="/suc-khoe/"]', 'a[href*="/benh/"]', '.search-result a']
+                },
+                'medlatec': {
+                    'base_url': 'https://medlatec.vn',
+                    'search_url': 'https://medlatec.vn/tim-kiem',
+                    'domains': ['medlatec.vn'],
+                    'selectors': ['a[href*="/suc-khoe/"]', 'a[href*="/benh/"]', '.search-result a']
+                },
+                'suckhoe_doisong': {
+                    'base_url': 'https://suckhoedoisong.vn',
+                    'search_url': 'https://suckhoedoisong.vn/tim-kiem',
+                    'domains': ['suckhoedoisong.vn'],
+                    'selectors': ['a[href*="/suc-khoe/"]', 'a[href*="/benh/"]', '.search-result a']
+                },
+                'vien_dinh_duong': {
+                    'base_url': 'https://viendinhduong.vn',
+                    'search_url': 'https://viendinhduong.vn/tim-kiem',
+                    'domains': ['viendinhduong.vn'],
+                    'selectors': ['a[href*="/dinh-duong/"]', 'a[href*="/suc-khoe/"]', '.search-result a']
+                }
+            },
+            'zh': {
+                'haodf': {
+                    'base_url': 'https://www.haodf.com',
+                    'search_url': 'https://www.haodf.com/search',
+                    'domains': ['haodf.com'],
+                    'selectors': ['a[href*="/jibing/"]', 'a[href*="/zixun/"]', '.search-result a']
+                },
+                'dxy': {
+                    'base_url': 'https://www.dxy.cn',
+                    'search_url': 'https://www.dxy.cn/search',
+                    'domains': ['dxy.cn'],
+                    'selectors': ['a[href*="/article/"]', 'a[href*="/jibing/"]', '.search-result a']
+                },
+                'chunyuyisheng': {
+                    'base_url': 'https://www.chunyuyisheng.com',
+                    'search_url': 'https://www.chunyuyisheng.com/search',
+                    'domains': ['chunyuyisheng.com'],
+                    'selectors': ['a[href*="/article/"]', 'a[href*="/jibing/"]', '.search-result a']
+                },
+                'xywy': {
+                    'base_url': 'https://www.xywy.com',
+                    'search_url': 'https://www.xywy.com/search',
+                    'domains': ['xywy.com'],
+                    'selectors': ['a[href*="/jibing/"]', 'a[href*="/article/"]', '.search-result a']
+                },
+                'jiankang': {
+                    'base_url': 'https://www.jiankang.com',
+                    'search_url': 'https://www.jiankang.com/search',
+                    'domains': ['jiankang.com'],
+                    'selectors': ['a[href*="/article/"]', 'a[href*="/jibing/"]', '.search-result a']
+                },
+                'familydoctor': {
+                    'base_url': 'https://www.familydoctor.com.cn',
+                    'search_url': 'https://www.familydoctor.com.cn/search',
+                    'domains': ['familydoctor.com.cn'],
+                    'selectors': ['a[href*="/article/"]', 'a[href*="/jibing/"]', '.search-result a']
+                }
+            }
+        }
+    
+    def search(self, query: str, num_results: int = 10, languages: List[str] = None) -> List[Dict]:
+        """Search across multiple languages and medical sources"""
+        if languages is None:
+            languages = ['en', 'vi', 'zh']
+        
+        all_results = []
+        
+        for lang in languages:
+            if lang in self.medical_sources:
+                lang_results = self._search_language_sources(query, lang, num_results // len(languages))
+                all_results.extend(lang_results)
+                time.sleep(0.5)  # Be respectful to servers
+        
+        # Remove duplicates and sort by relevance
+        unique_results = self._remove_duplicates(all_results)
+        return unique_results[:num_results]
+    
+    def _search_language_sources(self, query: str, language: str, num_results: int) -> List[Dict]:
+        """Search sources for a specific language"""
+        results = []
+        sources = self.medical_sources.get(language, {})
+        
+        for source_name, source_config in sources.items():
+            if len(results) >= num_results:
+                break
+            
+            source_results = self._search_source(query, source_name, source_config, language)
+            results.extend(source_results)
+            time.sleep(0.3)  # Rate limiting
+        
+        return results
+    
+    def _search_source(self, query: str, source_name: str, source_config: Dict, language: str) -> List[Dict]:
+        """Search a specific medical source"""
+        try:
+            search_url = source_config.get('search_url')
+            if not search_url:
+                return []
+            
+            # Prepare search parameters based on language
+            params = self._prepare_search_params(query, language)
+            
+            response = self.session.get(search_url, params=params, timeout=self.timeout)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            results = []
+            
+            # Try source-specific selectors
+            selectors = source_config.get('selectors', ['a[href*="http"]'])
+            
+            for selector in selectors:
+                links = soup.select(selector)
+                if links:
+                    logger.info(f"{source_name} ({language}) found {len(links)} results with selector: {selector}")
+                    break
+            
+            for link in links[:3]:  # Limit per source
+                try:
+                    href = link.get('href')
+                    if not href:
+                        continue
+                    
+                    # Make absolute URL
+                    if href.startswith('/'):
+                        href = source_config['base_url'] + href
+                    
+                    title = link.get_text(strip=True)
+                    if title and href.startswith('http'):
+                        results.append({
+                            'url': href,
+                            'title': title,
+                            'source': source_name,
+                            'language': language,
+                            'domain': source_config['domains'][0]
+                        })
+                except Exception as e:
+                    logger.debug(f"Error parsing {source_name} link: {e}")
+                    continue
+            
+            return results
+            
+        except Exception as e:
+            logger.warning(f"Medical source {source_name} ({language}) search failed: {e}")
+            return []
+    
+    def _prepare_search_params(self, query: str, language: str) -> Dict[str, str]:
+        """Prepare search parameters based on language"""
+        # Common parameter names across different languages
+        param_mappings = {
+            'en': {'q': query, 'query': query, 'search': query},
+            'vi': {'q': query, 'query': query, 'search': query, 'tu-khoa': query, 'tim-kiem': query},
+            'zh': {'q': query, 'query': query, 'search': query, 'keyword': query, 'sousuo': query}
+        }
+        
+        return param_mappings.get(language, {'q': query})
+    
+    def _remove_duplicates(self, results: List[Dict]) -> List[Dict]:
+        """Remove duplicate results based on URL"""
+        seen_urls = set()
+        unique_results = []
+        
+        for result in results:
+            url = result.get('url', '')
+            if url and url not in seen_urls:
+                seen_urls.add(url)
+                unique_results.append(result)
+        
+        return unique_results
+    
+    def search_by_language(self, query: str, language: str, num_results: int = 10) -> List[Dict]:
+        """Search sources for a specific language only"""
+        if language not in self.medical_sources:
+            logger.warning(f"Language {language} not supported")
+            return []
+        
+        return self._search_language_sources(query, language, num_results)
+    
+    def get_fallback_sources(self, query: str, language: str, num_results: int) -> List[Dict]:
+        """Get fallback sources when direct search fails"""
+        fallback_sources = {
+            'en': [
+                {
+                    'url': 'https://www.mayoclinic.org/diseases-conditions',
+                    'title': f'Mayo Clinic: {query}',
+                    'source': 'mayo_fallback',
+                    'language': 'en',
+                    'domain': 'mayoclinic.org'
+                },
+                {
+                    'url': 'https://www.webmd.com/default.htm',
+                    'title': f'WebMD: {query}',
+                    'source': 'webmd_fallback',
+                    'language': 'en',
+                    'domain': 'webmd.com'
+                }
+            ],
+            'vi': [
+                {
+                    'url': 'https://hellobacsi.com/suc-khoe',
+                    'title': f'Hello Bacsi: {query}',
+                    'source': 'hello_bacsi_fallback',
+                    'language': 'vi',
+                    'domain': 'hellobacsi.com'
+                },
+                {
+                    'url': 'https://www.vinmec.com/vi/suc-khoe',
+                    'title': f'Vinmec: {query}',
+                    'source': 'vinmec_fallback',
+                    'language': 'vi',
+                    'domain': 'vinmec.com'
+                }
+            ],
+            'zh': [
+                {
+                    'url': 'https://www.haodf.com/jibing',
+                    'title': f'好大夫在线: {query}',
+                    'source': 'haodf_fallback',
+                    'language': 'zh',
+                    'domain': 'haodf.com'
+                },
+                {
+                    'url': 'https://www.dxy.cn/article',
+                    'title': f'丁香园: {query}',
+                    'source': 'dxy_fallback',
+                    'language': 'zh',
+                    'domain': 'dxy.cn'
+                }
+            ]
+        }
+        
+        return fallback_sources.get(language, [])[:num_results]

search/extractors/__init__.py

@@ -0,0 +1,3 @@
+from .content import ContentExtractor
+
+__all__ = ['ContentExtractor']

search/extractors/content.py

@@ -0,0 +1,211 @@
+import requests
+from bs4 import BeautifulSoup
+import logging
+from typing import Dict, Optional
+import re
+from urllib.parse import urlparse
+import time
+
+logger = logging.getLogger(__name__)
+
+class ContentExtractor:
+    """Extract and clean content from web pages"""
+    
+    def __init__(self, timeout: int = 15):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'keep-alive',
+        })
+        self.timeout = timeout
+        
+        # Medical content indicators
+        self.medical_indicators = [
+            'symptom', 'treatment', 'diagnosis', 'medicine', 'medication',
+            'therapy', 'condition', 'disease', 'health', 'medical',
+            'doctor', 'physician', 'patient', 'clinical', 'study'
+        ]
+    
+    def extract(self, url: str, max_length: int = 2000) -> Optional[str]:
+        """Extract content from a URL with medical focus"""
+        try:
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            
+            # Remove unwanted elements
+            self._remove_unwanted_elements(soup)
+            
+            # Extract main content
+            content = self._extract_main_content(soup)
+            
+            if not content:
+                return None
+            
+            # Clean and process content
+            cleaned_content = self._clean_content(content)
+            
+            # Focus on medical content if possible
+            medical_content = self._extract_medical_content(cleaned_content)
+            
+            # Truncate to max length
+            final_content = self._truncate_content(medical_content or cleaned_content, max_length)
+            
+            return final_content if final_content else None
+            
+        except Exception as e:
+            logger.warning(f"Content extraction failed for {url}: {e}")
+            return None
+    
+    def _remove_unwanted_elements(self, soup: BeautifulSoup):
+        """Remove unwanted HTML elements"""
+        unwanted_tags = [
+            'script', 'style', 'nav', 'header', 'footer', 'aside',
+            'advertisement', 'ads', 'sidebar', 'menu', 'navigation',
+            'social', 'share', 'comment', 'comments', 'related',
+            'cookie', 'privacy', 'terms', 'disclaimer'
+        ]
+        
+        for tag in unwanted_tags:
+            for element in soup.find_all(tag):
+                element.decompose()
+        
+        # Remove elements with unwanted classes/ids
+        unwanted_selectors = [
+            '[class*="ad"]', '[class*="advertisement"]', '[class*="sidebar"]',
+            '[class*="menu"]', '[class*="nav"]', '[class*="social"]',
+            '[class*="share"]', '[class*="comment"]', '[class*="related"]',
+            '[id*="ad"]', '[id*="sidebar"]', '[id*="menu"]', '[id*="nav"]'
+        ]
+        
+        for selector in unwanted_selectors:
+            for element in soup.select(selector):
+                element.decompose()
+    
+    def _extract_main_content(self, soup: BeautifulSoup) -> str:
+        """Extract main content from the page"""
+        # Priority order for content extraction
+        content_selectors = [
+            'article',
+            'main',
+            '[role="main"]',
+            '.content',
+            '.main-content',
+            '.article-content',
+            '.post-content',
+            '.entry-content',
+            '.page-content',
+            'body'
+        ]
+        
+        for selector in content_selectors:
+            elements = soup.select(selector)
+            if elements:
+                # Get the largest content element
+                largest_element = max(elements, key=lambda x: len(x.get_text()))
+                content = largest_element.get_text(separator=' ', strip=True)
+                if len(content) > 100:  # Minimum content length
+                    return content
+        
+        # Fallback: get all text
+        return soup.get_text(separator=' ', strip=True)
+    
+    def _clean_content(self, content: str) -> str:
+        """Clean and normalize content"""
+        if not content:
+            return ""
+        
+        # Remove excessive whitespace
+        content = re.sub(r'\s+', ' ', content)
+        
+        # Remove common web artifacts
+        artifacts = [
+            r'Cookie\s+Policy',
+            r'Privacy\s+Policy',
+            r'Terms\s+of\s+Service',
+            r'Subscribe\s+to\s+our\s+newsletter',
+            r'Follow\s+us\s+on',
+            r'Share\s+this\s+article',
+            r'Related\s+articles',
+            r'Advertisement',
+            r'Ad\s+content'
+        ]
+        
+        for artifact in artifacts:
+            content = re.sub(artifact, '', content, flags=re.IGNORECASE)
+        
+        # Remove excessive punctuation
+        content = re.sub(r'[.]{3,}', '...', content)
+        content = re.sub(r'[!]{2,}', '!', content)
+        content = re.sub(r'[?]{2,}', '?', content)
+        
+        return content.strip()
+    
+    def _extract_medical_content(self, content: str) -> Optional[str]:
+        """Extract medical-focused content from the text"""
+        if not content:
+            return None
+        
+        # Split content into sentences
+        sentences = re.split(r'[.!?]+', content)
+        medical_sentences = []
+        
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if len(sentence) < 20:  # Skip very short sentences
+                continue
+            
+            # Check if sentence contains medical indicators
+            sentence_lower = sentence.lower()
+            if any(indicator in sentence_lower for indicator in self.medical_indicators):
+                medical_sentences.append(sentence)
+        
+        if medical_sentences:
+            # Return medical sentences, prioritizing longer ones
+            medical_sentences.sort(key=len, reverse=True)
+            return '. '.join(medical_sentences[:10]) + '.'
+        
+        return None
+    
+    def _truncate_content(self, content: str, max_length: int) -> str:
+        """Truncate content to max length while preserving sentences"""
+        if len(content) <= max_length:
+            return content
+        
+        # Try to truncate at sentence boundary
+        truncated = content[:max_length]
+        last_period = truncated.rfind('.')
+        last_exclamation = truncated.rfind('!')
+        last_question = truncated.rfind('?')
+        
+        last_sentence_end = max(last_period, last_exclamation, last_question)
+        
+        if last_sentence_end > max_length * 0.7:  # If we can find a good break point
+            return content[:last_sentence_end + 1]
+        
+        # Fallback: truncate at word boundary
+        words = truncated.split()
+        if len(words) > 1:
+            return ' '.join(words[:-1]) + '...'
+        
+        return truncated + '...'
+    
+    def extract_multiple(self, urls: list, max_length: int = 2000) -> Dict[str, str]:
+        """Extract content from multiple URLs"""
+        results = {}
+        
+        for url in urls:
+            try:
+                content = self.extract(url, max_length)
+                if content:
+                    results[url] = content
+                time.sleep(0.5)  # Be respectful to servers
+            except Exception as e:
+                logger.warning(f"Failed to extract content from {url}: {e}")
+                continue
+        
+        return results

search/processors/__init__.py

@@ -0,0 +1,4 @@
+from .medical import MedicalSearchProcessor
+from .language import LanguageProcessor
+
+__all__ = ['MedicalSearchProcessor', 'LanguageProcessor']

search/processors/language.py

@@ -0,0 +1,266 @@
+import re
+import logging
+from typing import List, Dict, Tuple, Optional
+from langdetect import detect, DetectorFactory
+from langdetect.lang_detect_exception import LangDetectException
+
+logger = logging.getLogger(__name__)
+
+# Set seed for consistent language detection
+DetectorFactory.seed = 0
+
+class LanguageProcessor:
+    """Process and enhance queries for multilingual medical search"""
+    
+    def __init__(self):
+        # Medical keywords in different languages
+        self.medical_keywords = {
+            'en': [
+                'symptom', 'symptoms', 'pain', 'headache', 'migraine', 'fever', 'cough',
+                'treatment', 'treatments', 'medicine', 'medication', 'drug', 'therapy',
+                'diagnosis', 'diagnose', 'condition', 'disease', 'disorder', 'syndrome',
+                'doctor', 'physician', 'medical', 'health', 'clinical', 'patient',
+                'blood pressure', 'heart', 'lung', 'stomach', 'back', 'neck', 'chest',
+                'allergy', 'allergies', 'infection', 'inflammation', 'swelling', 'rash',
+                'sleep', 'insomnia', 'anxiety', 'depression', 'stress', 'mental health',
+                'pregnancy', 'baby', 'child', 'elderly', 'senior', 'age', 'covid',
+                'vaccine', 'immunization', 'surgery', 'operation', 'hospital', 'clinic'
+            ],
+            'vi': [
+                'triệu chứng', 'đau', 'đau đầu', 'đau nửa đầu', 'sốt', 'ho',
+                'điều trị', 'thuốc', 'dược phẩm', 'liệu pháp', 'chẩn đoán',
+                'bệnh', 'tình trạng', 'rối loạn', 'hội chứng', 'bác sĩ', 'y tế',
+                'sức khỏe', 'lâm sàng', 'bệnh nhân', 'huyết áp', 'tim', 'phổi',
+                'dạ dày', 'lưng', 'cổ', 'ngực', 'dị ứng', 'nhiễm trùng',
+                'viêm', 'sưng', 'phát ban', 'ngủ', 'mất ngủ', 'lo âu',
+                'trầm cảm', 'căng thẳng', 'sức khỏe tâm thần', 'mang thai',
+                'em bé', 'trẻ em', 'người già', 'tuổi tác', 'covid', 'vaccine',
+                'tiêm chủng', 'phẫu thuật', 'bệnh viện', 'phòng khám'
+            ],
+            'zh': [
+                '症状', '疼痛', '头痛', '偏头痛', '发烧', '咳嗽', '治疗', '药物',
+                '药品', '疗法', '诊断', '疾病', '状况', '紊乱', '综合征', '医生',
+                '医疗', '健康', '临床', '患者', '血压', '心脏', '肺', '胃',
+                '背部', '颈部', '胸部', '过敏', '感染', '炎症', '肿胀', '皮疹',
+                '睡眠', '失眠', '焦虑', '抑郁', '压力', '心理健康', '怀孕',
+                '婴儿', '儿童', '老年人', '年龄', '新冠', '疫苗', '免疫',
+                '手术', '医院', '诊所'
+            ]
+        }
+        
+        # Language-specific search enhancements
+        self.language_enhancements = {
+            'vi': {
+                'common_terms': ['là gì', 'nguyên nhân', 'cách điều trị', 'triệu chứng'],
+                'medical_context': ['y tế', 'sức khỏe', 'bệnh viện', 'bác sĩ']
+            },
+            'zh': {
+                'common_terms': ['是什么', '原因', '治疗方法', '症状'],
+                'medical_context': ['医疗', '健康', '医院', '医生']
+            },
+            'en': {
+                'common_terms': ['what is', 'causes', 'treatment', 'symptoms'],
+                'medical_context': ['medical', 'health', 'hospital', 'doctor']
+            }
+        }
+    
+    def detect_language(self, text: str) -> str:
+        """Detect the language of the input text"""
+        if not text or not text.strip():
+            return 'en'  # Default to English
+        
+        try:
+            # Clean text for better detection
+            cleaned_text = re.sub(r'[^\w\s]', ' ', text)
+            cleaned_text = re.sub(r'\s+', ' ', cleaned_text).strip()
+            
+            if len(cleaned_text) < 3:
+                return 'en'
+            
+            detected = detect(cleaned_text)
+            
+            # Map detected language to our supported languages
+            language_mapping = {
+                'vi': 'vi',  # Vietnamese
+                'zh-cn': 'zh',  # Chinese Simplified
+                'zh-tw': 'zh',  # Chinese Traditional
+                'zh': 'zh',     # Chinese
+                'en': 'en'      # English
+            }
+            
+            return language_mapping.get(detected, 'en')
+            
+        except LangDetectException as e:
+            logger.warning(f"Language detection failed: {e}")
+            return 'en'
+    
+    def enhance_query(self, query: str, target_language: str = None) -> Dict[str, str]:
+        """Enhance query for better search results in multiple languages"""
+        if not query or not query.strip():
+            return {}
+        
+        # Detect source language
+        source_language = self.detect_language(query)
+        
+        # If target language not specified, use source language
+        if target_language is None:
+            target_language = source_language
+        
+        enhanced_queries = {}
+        
+        # Original query
+        enhanced_queries[source_language] = query
+        
+        # Enhance for source language
+        if source_language in self.language_enhancements:
+            enhanced_queries[source_language] = self._enhance_for_language(
+                query, source_language
+            )
+        
+        # Create translations for other languages if needed
+        if target_language != source_language:
+            enhanced_queries[target_language] = self._translate_query(
+                query, source_language, target_language
+            )
+        
+        # Add English version for comprehensive search
+        if 'en' not in enhanced_queries:
+            if source_language != 'en':
+                enhanced_queries['en'] = self._translate_query(query, source_language, 'en')
+            else:
+                enhanced_queries['en'] = query
+        
+        return enhanced_queries
+    
+    def _enhance_for_language(self, query: str, language: str) -> str:
+        """Enhance query for a specific language"""
+        enhancements = self.language_enhancements.get(language, {})
+        common_terms = enhancements.get('common_terms', [])
+        medical_context = enhancements.get('medical_context', [])
+        
+        # Check if query already contains medical context
+        query_lower = query.lower()
+        has_medical_context = any(term in query_lower for term in medical_context)
+        
+        # If no medical context, add it
+        if not has_medical_context and medical_context:
+            # Add the most relevant medical context term
+            query += f" {medical_context[0]}"
+        
+        # Check if query is a question and add relevant terms
+        if any(term in query_lower for term in ['là gì', '是什么', 'what is', 'how', 'tại sao', '为什么', 'why']):
+            if common_terms:
+                query += f" {common_terms[0]}"  # Add "causes" or equivalent
+        
+        return query.strip()
+    
+    def _translate_query(self, query: str, source_lang: str, target_lang: str) -> str:
+        """Simple keyword-based translation for medical terms"""
+        # This is a basic implementation - in production, you'd use a proper translation service
+        
+        # Medical term translations
+        translations = {
+            ('vi', 'en'): {
+                'triệu chứng': 'symptoms',
+                'đau': 'pain',
+                'đau đầu': 'headache',
+                'sốt': 'fever',
+                'ho': 'cough',
+                'điều trị': 'treatment',
+                'thuốc': 'medicine',
+                'bệnh': 'disease',
+                'bác sĩ': 'doctor',
+                'sức khỏe': 'health',
+                'bệnh viện': 'hospital'
+            },
+            ('zh', 'en'): {
+                '症状': 'symptoms',
+                '疼痛': 'pain',
+                '头痛': 'headache',
+                '发烧': 'fever',
+                '咳嗽': 'cough',
+                '治疗': 'treatment',
+                '药物': 'medicine',
+                '疾病': 'disease',
+                '医生': 'doctor',
+                '健康': 'health',
+                '医院': 'hospital'
+            },
+            ('en', 'vi'): {
+                'symptoms': 'triệu chứng',
+                'pain': 'đau',
+                'headache': 'đau đầu',
+                'fever': 'sốt',
+                'cough': 'ho',
+                'treatment': 'điều trị',
+                'medicine': 'thuốc',
+                'disease': 'bệnh',
+                'doctor': 'bác sĩ',
+                'health': 'sức khỏe',
+                'hospital': 'bệnh viện'
+            },
+            ('en', 'zh'): {
+                'symptoms': '症状',
+                'pain': '疼痛',
+                'headache': '头痛',
+                'fever': '发烧',
+                'cough': '咳嗽',
+                'treatment': '治疗',
+                'medicine': '药物',
+                'disease': '疾病',
+                'doctor': '医生',
+                'health': '健康',
+                'hospital': '医院'
+            }
+        }
+        
+        translation_map = translations.get((source_lang, target_lang), {})
+        
+        # Simple word-by-word translation
+        translated_query = query
+        for source_term, target_term in translation_map.items():
+            translated_query = translated_query.replace(source_term, target_term)
+        
+        return translated_query
+    
+    def get_medical_relevance_score(self, text: str, language: str) -> float:
+        """Calculate medical relevance score for text in a specific language"""
+        if not text:
+            return 0.0
+        
+        keywords = self.medical_keywords.get(language, [])
+        if not keywords:
+            return 0.0
+        
+        text_lower = text.lower()
+        matches = sum(1 for keyword in keywords if keyword in text_lower)
+        
+        # Normalize by text length and keyword count
+        score = matches / max(len(keywords), 1)
+        
+        # Boost score for longer matches
+        if matches > 0:
+            score *= (1 + matches * 0.1)
+        
+        return min(score, 1.0)
+    
+    def filter_by_language(self, results: List[Dict], target_language: str) -> List[Dict]:
+        """Filter results by language preference"""
+        if not results:
+            return results
+        
+        # Score results by language match
+        scored_results = []
+        for result in results:
+            result_language = result.get('language', 'en')
+            language_score = 1.0 if result_language == target_language else 0.5
+            
+            # Add language score to result
+            result_copy = result.copy()
+            result_copy['language_score'] = language_score
+            scored_results.append(result_copy)
+        
+        # Sort by language score (prefer target language)
+        scored_results.sort(key=lambda x: x.get('language_score', 0), reverse=True)
+        
+        return scored_results

search/processors/medical.py

@@ -0,0 +1,215 @@
+import logging
+from typing import List, Dict, Tuple
+from models.summarizer import summarizer
+import re
+
+logger = logging.getLogger(__name__)
+
+class MedicalSearchProcessor:
+    """Process and enhance medical search results"""
+    
+    def __init__(self):
+        self.medical_keywords = [
+            'symptom', 'symptoms', 'pain', 'headache', 'migraine', 'fever', 'cough',
+            'treatment', 'treatments', 'medicine', 'medication', 'drug', 'therapy',
+            'diagnosis', 'diagnose', 'condition', 'disease', 'disorder', 'syndrome',
+            'doctor', 'physician', 'medical', 'health', 'clinical', 'patient',
+            'blood pressure', 'heart', 'lung', 'stomach', 'back', 'neck', 'chest',
+            'allergy', 'allergies', 'infection', 'inflammation', 'swelling', 'rash',
+            'sleep', 'insomnia', 'anxiety', 'depression', 'stress', 'mental health',
+            'pregnancy', 'baby', 'child', 'elderly', 'senior', 'age', 'covid',
+            'vaccine', 'immunization', 'surgery', 'operation', 'hospital', 'clinic'
+        ]
+    
+    def process_results(self, results: List[Dict], user_query: str) -> Tuple[str, Dict[int, str]]:
+        """Process search results and create comprehensive medical summary"""
+        if not results:
+            return "", {}
+        
+        # Filter and rank results by medical relevance
+        relevant_results = self._filter_medical_results(results, user_query)
+        
+        if not relevant_results:
+            logger.warning("No medically relevant results found")
+            return "", {}
+        
+        # Extract and summarize content
+        summarized_results = self._summarize_results(relevant_results, user_query)
+        
+        # Create comprehensive summary
+        combined_summary = self._create_combined_summary(summarized_results, user_query)
+        
+        # Create URL mapping for citations
+        url_mapping = self._create_url_mapping(relevant_results)
+        
+        return combined_summary, url_mapping
+    
+    def _filter_medical_results(self, results: List[Dict], user_query: str) -> List[Dict]:
+        """Filter results by medical relevance"""
+        relevant_results = []
+        
+        for result in results:
+            relevance_score = self._calculate_relevance_score(result, user_query)
+            
+            if relevance_score > 0.3:  # Threshold for medical relevance
+                result['relevance_score'] = relevance_score
+                relevant_results.append(result)
+        
+        # Sort by relevance score
+        relevant_results.sort(key=lambda x: x.get('relevance_score', 0), reverse=True)
+        
+        # Limit to top results
+        return relevant_results[:10]
+    
+    def _calculate_relevance_score(self, result: Dict, user_query: str) -> float:
+        """Calculate medical relevance score for a result"""
+        score = 0.0
+        
+        # Check title relevance
+        title = result.get('title', '').lower()
+        query_lower = user_query.lower()
+        
+        # Direct query match in title
+        if any(word in title for word in query_lower.split()):
+            score += 0.4
+        
+        # Medical keyword match in title
+        medical_matches = sum(1 for keyword in self.medical_keywords if keyword in title)
+        score += min(medical_matches * 0.1, 0.3)
+        
+        # Domain credibility
+        url = result.get('url', '').lower()
+        credible_domains = [
+            'mayoclinic.org', 'webmd.com', 'healthline.com', 'medlineplus.gov',
+            'nih.gov', 'cdc.gov', 'who.int', 'pubmed.ncbi.nlm.nih.gov',
+            'uptodate.com', 'merckmanuals.com', 'medscape.com'
+        ]
+        
+        if any(domain in url for domain in credible_domains):
+            score += 0.3
+        
+        # Source type bonus
+        source = result.get('source', '')
+        if 'medical' in source or any(domain in source for domain in credible_domains):
+            score += 0.2
+        
+        return min(score, 1.0)
+    
+    def _summarize_results(self, results: List[Dict], user_query: str) -> List[Dict]:
+        """Summarize content from search results"""
+        summarized_results = []
+        
+        for i, result in enumerate(results):
+            try:
+                content = result.get('content', '')
+                if not content:
+                    continue
+                
+                # Create focused summary
+                summary = summarizer.summarize_for_query(content, user_query, max_length=300)
+                
+                if summary:
+                    summarized_results.append({
+                        'id': i + 1,
+                        'url': result['url'],
+                        'title': result['title'],
+                        'summary': summary,
+                        'relevance_score': result.get('relevance_score', 0)
+                    })
+                    
+            except Exception as e:
+                logger.warning(f"Failed to summarize result {i}: {e}")
+                continue
+        
+        return summarized_results
+    
+    def _create_combined_summary(self, summarized_results: List[Dict], user_query: str) -> str:
+        """Create a comprehensive summary from all results"""
+        if not summarized_results:
+            return ""
+        
+        # Group by topic/similarity
+        topic_groups = self._group_by_topic(summarized_results)
+        
+        summary_parts = []
+        
+        for topic, results in topic_groups.items():
+            if not results:
+                continue
+            
+            # Create topic summary
+            topic_summary = self._create_topic_summary(topic, results, user_query)
+            if topic_summary:
+                summary_parts.append(topic_summary)
+        
+        # Combine all parts
+        combined_summary = "\n\n".join(summary_parts)
+        
+        # Final summarization to ensure conciseness
+        if len(combined_summary) > 1500:
+            combined_summary = summarizer.summarize_text(combined_summary, max_length=1500)
+        
+        return combined_summary
+    
+    def _group_by_topic(self, results: List[Dict]) -> Dict[str, List[Dict]]:
+        """Group results by medical topic"""
+        topics = {
+            'symptoms': [],
+            'treatments': [],
+            'diagnosis': [],
+            'general': []
+        }
+        
+        for result in results:
+            title_lower = result['title'].lower()
+            summary_lower = result.get('summary', '').lower()
+            content_lower = f"{title_lower} {summary_lower}"
+            
+            # Categorize by content
+            if any(word in content_lower for word in ['symptom', 'sign', 'pain', 'ache']):
+                topics['symptoms'].append(result)
+            elif any(word in content_lower for word in ['treatment', 'therapy', 'medicine', 'medication']):
+                topics['treatments'].append(result)
+            elif any(word in content_lower for word in ['diagnosis', 'test', 'examination', 'evaluation']):
+                topics['diagnosis'].append(result)
+            else:
+                topics['general'].append(result)
+        
+        return topics
+    
+    def _create_topic_summary(self, topic: str, results: List[Dict], user_query: str) -> str:
+        """Create summary for a specific topic"""
+        if not results:
+            return ""
+        
+        # Combine summaries for this topic
+        combined_text = " ".join([r.get('summary', '') for r in results])
+        
+        if not combined_text:
+            return ""
+        
+        # Create focused summary for this topic
+        topic_summary = summarizer.summarize_for_query(combined_text, user_query, max_length=400)
+        
+        if topic_summary:
+            # Add topic header
+            topic_headers = {
+                'symptoms': "**Symptoms and Signs:**",
+                'treatments': "**Treatment Options:**",
+                'diagnosis': "**Diagnosis and Testing:**",
+                'general': "**General Information:**"
+            }
+            
+            header = topic_headers.get(topic, "**Information:**")
+            return f"{header}\n{topic_summary}"
+        
+        return ""
+    
+    def _create_url_mapping(self, results: List[Dict]) -> Dict[int, str]:
+        """Create URL mapping for citations"""
+        url_mapping = {}
+        
+        for i, result in enumerate(results):
+            url_mapping[i + 1] = result['url']
+        
+        return url_mapping

search/search.py

@@ -0,0 +1,106 @@
+import logging
+from typing import List, Dict, Tuple
+from .coordinator import SearchCoordinator
+
+logger = logging.getLogger(__name__)
+
+# Global search coordinator instance
+_search_coordinator = None
+
+def get_search_coordinator() -> SearchCoordinator:
+    """Get or create the global search coordinator instance"""
+    global _search_coordinator
+    if _search_coordinator is None:
+        _search_coordinator = SearchCoordinator()
+    return _search_coordinator
+
+class WebSearcher:
+    """Legacy wrapper for backward compatibility"""
+    def __init__(self):
+        self.coordinator = get_search_coordinator()
+        self.max_results = 10
+        self.timeout = 10
+        
+    def search_google(self, query: str, num_results: int = 10) -> List[Dict]:
+        """Search using the new coordinator system"""
+        try:
+            return self.coordinator.quick_search(query, num_results)
+        except Exception as e:
+            logger.error(f"Search failed: {e}")
+            return []
+    
+    def search_duckduckgo(self, query: str, num_results: int = 10) -> List[Dict]:
+        """Search using DuckDuckGo engine"""
+        try:
+            return self.coordinator.quick_search(query, num_results)
+        except Exception as e:
+            logger.error(f"DuckDuckGo search failed: {e}")
+            return []
+    
+    def extract_content(self, url: str) -> str:
+        """Extract content using the new content extractor"""
+        try:
+            return self.coordinator.content_extractor.extract(url)
+        except Exception as e:
+            logger.error(f"Content extraction failed: {e}")
+            return ""
+    
+    def search_and_extract(self, query: str, num_results: int = 10) -> List[Dict]:
+        """Search and extract content using the new system"""
+        try:
+            # Get search results
+            results = self.coordinator.quick_search(query, num_results)
+            
+            # Extract content for each result
+            enriched_results = []
+            for result in results:
+                content = self.extract_content(result['url'])
+                if content:
+                    enriched_result = result.copy()
+                    enriched_result['content'] = content
+                    enriched_results.append(enriched_result)
+            
+            return enriched_results
+        except Exception as e:
+            logger.error(f"Search and extract failed: {e}")
+            return []
+
+# Main search function for backward compatibility
+def search_web(query: str, num_results: int = 10) -> List[Dict]:
+    """Main search function using the new coordinator system"""
+    try:
+        coordinator = get_search_coordinator()
+        return coordinator.quick_search(query, num_results)
+    except Exception as e:
+        logger.error(f"Web search failed: {e}")
+        return []
+
+# Enhanced search function with content extraction
+def search_web_with_content(query: str, num_results: int = 10) -> Tuple[str, Dict[int, str]]:
+    """Enhanced search with content extraction and summarization"""
+    try:
+        coordinator = get_search_coordinator()
+        return coordinator.search(query, num_results)
+    except Exception as e:
+        logger.error(f"Enhanced web search failed: {e}")
+        return "", {}
+
+# Medical-focused search function
+def search_medical(query: str, num_results: int = 8) -> Tuple[str, Dict[int, str]]:
+    """Medical-focused search with enhanced processing"""
+    try:
+        coordinator = get_search_coordinator()
+        return coordinator.medical_focus_search(query, num_results)
+    except Exception as e:
+        logger.error(f"Medical search failed: {e}")
+        return "", {}
+
+# Multilingual medical search function
+def search_multilingual_medical(query: str, num_results: int = 10, target_language: str = None) -> Tuple[str, Dict[int, str]]:
+    """Comprehensive multilingual medical search supporting English, Vietnamese, and Chinese"""
+    try:
+        coordinator = get_search_coordinator()
+        return coordinator.multilingual_medical_search(query, num_results, target_language)
+    except Exception as e:
+        logger.error(f"Multilingual medical search failed: {e}")
+        return "", {}