@ngocsangairvds/vsaf 3.2.16 → 4.0.0

package/tools/vds-scripts/memory_orchestrator/src/vds_memory_orchestrator/service/brain/research_analyzer.py

@@ -1,839 +0,0 @@
-#!/usr/bin/env python3
-"""
-Research Intent Analyzer - Enhanced Query Analysis for VDS Brain Agent
-
-This module provides intelligent query analysis capabilities using both
-rule-based and LLM-powered methods for determining research intent,
-complexity, and optimal tool selection strategies.
-
-Author: VDS AI Team
-Version: 1.0.0
-"""
-
-import asyncio
-import logging
-import re
-from dataclasses import dataclass
-from datetime import datetime
-from enum import Enum
-
-from .vds_brain_agent import ResearchIntent, ResearchQuery
-
-logger = logging.getLogger(__name__)
-
-
-class QueryComplexity(Enum):
-    """Query complexity levels."""
-
-    SIMPLE = "simple"
-    MODERATE = "moderate"
-    COMPLEX = "complex"
-    VERY_COMPLEX = "very_complex"
-
-
-class InformationType(Enum):
-    """Types of information requested."""
-
-    FACTUAL = "factual"
-    ANALYTICAL = "analytical"
-    TUTORIAL = "tutorial"
-    COMPARATIVE = "comparative"
-    TECHNICAL = "technical"
-    NEWS = "news"
-    RESEARCH = "research"
-
-
-@dataclass
-class IntentSignals:
-    """Signals detected in the query for intent determination."""
-
-    keywords: list[str]
-    patterns: list[str]
-    question_words: list[str]
-    temporal_indicators: list[str]
-    technical_terms: list[str]
-    domain_specific: list[str]
-
-
-@dataclass
-class ComplexityMetrics:
-    """Metrics for determining query complexity."""
-
-    word_count: int
-    sentence_count: int
-    avg_word_length: float
-    technical_density: float
-    question_complexity: int
-    multi_intent_score: float
-
-
-class ResearchIntentAnalyzer:
-    """
-    Enhanced Research Intent Analyzer for VDS Brain Agent
-
-    Combines rule-based analysis with pattern recognition to accurately
-    determine research intent, complexity, and optimal tool selection.
-    """
-
-    def __init__(self):
-        """Initialize the research intent analyzer."""
-        # Intent keyword mappings
-        self.intent_keywords = {
-            ResearchIntent.COMPREHENSIVE_RESEARCH: [
-                "research",
-                "study",
-                "investigate",
-                "explore",
-                "analyze",
-                "examine",
-                "understand",
-                "overview",
-                "comprehensive",
-                "detailed",
-                "thorough",
-            ],
-            ResearchIntent.REAL_TIME_INFORMATION: [
-                "latest",
-                "current",
-                "recent",
-                "today",
-                "now",
-                "news",
-                "update",
-                "breaking",
-                "happening",
-                "trending",
-                "live",
-                "real-time",
-            ],
-            ResearchIntent.TECHNICAL_DOCUMENTATION: [
-                "documentation",
-                "guide",
-                "manual",
-                "reference",
-                "api",
-                "sdk",
-                "tutorial",
-                "how to",
-                "implement",
-                "setup",
-                "configure",
-                "install",
-            ],
-            ResearchIntent.CODE_PATTERNS: [
-                "code",
-                "example",
-                "implementation",
-                "github",
-                "repository",
-                "source",
-                "programming",
-                "development",
-                "script",
-                "function",
-                "class",
-                "method",
-            ],
-            ResearchIntent.COMPETITIVE_ANALYSIS: [
-                "competitor",
-                "competition",
-                "market",
-                "alternative",
-                "vs",
-                "versus",
-                "compare",
-                "comparison",
-                "benchmark",
-                "analysis",
-                "industry",
-            ],
-            ResearchIntent.ACADEMIC_RESEARCH: [
-                "academic",
-                "research",
-                "paper",
-                "study",
-                "journal",
-                "scholar",
-                "university",
-                "publication",
-                "thesis",
-                "dissertation",
-                "scientific",
-            ],
-            ResearchIntent.ARCHITECTURE_PATTERNS: [
-                "architecture",
-                "design",
-                "pattern",
-                "system",
-                "structure",
-                "framework",
-                "microservices",
-                "scalability",
-                "performance",
-                "infrastructure",
-            ],
-        }
-
-        # Information type indicators
-        self.info_type_patterns = {
-            InformationType.FACTUAL: [
-                r"\b(what|where|when|who)\b",
-                r"\b(define|describe|explain)\b",
-            ],
-            InformationType.ANALYTICAL: [
-                r"\b(why|how)\b",
-                r"\b(analyze|evaluate|assess)\b",
-            ],
-            InformationType.TUTORIAL: [
-                r"\b(how to|tutorial|guide|step by step)\b",
-                r"\b(learn|master)\b",
-            ],
-            InformationType.COMPARATIVE: [
-                r"\b(compare|versus|vs|difference|better)\b",
-                r"\b(alternative|option)\b",
-            ],
-            InformationType.TECHNICAL: [
-                r"\b(api|sdk|framework|library|tool)\b",
-                r"\b(implement|integrate)\b",
-            ],
-            InformationType.NEWS: [
-                r"\b(latest|recent|current|breaking|news)\b",
-                r"\b(today|this week|recently)\b",
-            ],
-            InformationType.RESEARCH: [
-                r"\b(research|study|investigation|analysis)\b",
-                r"\b(findings|results)\b",
-            ],
-        }
-
-        # Complexity indicators
-        self.complexity_indicators = {
-            "simple_words": ["what", "who", "where", "when", "list", "show"],
-            "moderate_words": ["how", "why", "explain", "describe", "compare"],
-            "complex_words": [
-                "analyze",
-                "evaluate",
-                "synthesize",
-                "integrate",
-                "optimize",
-            ],
-            "technical_terms": [
-                "architecture",
-                "microservices",
-                "api",
-                "framework",
-                "algorithm",
-                "implementation",
-                "integration",
-                "scalability",
-                "performance",
-            ],
-            "question_patterns": [
-                r"\b(what|who|where|when)\b.+?\?",  # Simple questions
-                r"\b(how|why)\b.+?\?",  # Moderate questions
-                r"\b(analyze|evaluate|compare)\b.+?\?",  # Complex questions
-            ],
-        }
-
-        # Domain-specific terms for VDS context
-        self.vds_domain_terms = [
-            "viettel",
-            "vds",
-            "digital services",
-            "fintech",
-            "microservices",
-            "architecture",
-            "platform",
-            "system",
-            "integration",
-            "api",
-            "blockchain",
-            "ai",
-            "machine learning",
-            "cloud",
-            "devops",
-        ]
-
-        logger.info("Research Intent Analyzer initialized")
-
-    def extract_query_signals(self, query: str) -> IntentSignals:
-        """
-        Extract various signals from the query for intent analysis.
-
-        Args:
-            query: The research query string
-
-        Returns:
-            IntentSignals object with extracted signals
-        """
-        query_lower = query.lower()
-
-        # Extract keywords (meaningful words longer than 3 characters)
-        keywords = [word.strip() for word in re.findall(r"\b[a-zA-Z]{4,}\b", query_lower)]
-
-        # Extract question words
-        question_words = re.findall(r"\b(what|who|where|when|why|how|which|whose)\b", query_lower)
-
-        # Extract temporal indicators
-        temporal_patterns = [
-            r"\b(today|now|current|recent|latest)\b",
-            r"\b(this week|this month|this year)\b",
-            r"\b(in \d+ days|in \d+ weeks|in \d+ months)\b",
-            r"\b(last week|last month|last year)\b",
-            r"\b(upcoming|future|next)\b",
-            r"\b(?:19|20)\d{2}\b",
-        ]
-        temporal_indicators = []
-        for pattern in temporal_patterns:
-            temporal_indicators.extend(re.findall(pattern, query_lower))
-
-        # Extract technical terms
-        technical_terms = []
-        for term in self.complexity_indicators["technical_terms"]:
-            if term in query_lower:
-                technical_terms.append(term)
-
-        # Extract domain-specific terms
-        domain_specific = []
-        for term in self.vds_domain_terms:
-            if term in query_lower:
-                domain_specific.append(term)
-
-        # Extract patterns (special constructs)
-        patterns = []
-        if re.search(r"\?", query):
-            patterns.append("question")
-        if re.search(r"\b(compare|versus|vs)\b", query_lower):
-            patterns.append("comparison")
-        if re.search(r"\b(how to|tutorial|guide)\b", query_lower):
-            patterns.append("tutorial")
-        if re.search(r"\b(example|sample|demo)\b", query_lower):
-            patterns.append("example_request")
-        if re.search(r"\b(list|show|display)\b", query_lower):
-            patterns.append("list_request")
-
-        return IntentSignals(
-            keywords=keywords,
-            patterns=patterns,
-            question_words=question_words,
-            temporal_indicators=temporal_indicators,
-            technical_terms=technical_terms,
-            domain_specific=domain_specific,
-        )
-
-    def calculate_complexity_metrics(self, query: str, signals: IntentSignals) -> ComplexityMetrics:
-        """
-        Calculate complexity metrics for the query.
-
-        Args:
-            query: The research query
-            signals: Extracted intent signals
-
-        Returns:
-            ComplexityMetrics object
-        """
-        words = query.split()
-        sentences = re.split(r"[.!?]+", query.strip())
-        sentences = [s.strip() for s in sentences if s.strip()]
-
-        # Basic metrics
-        word_count = len(words)
-        sentence_count = len(sentences)
-        avg_word_length = sum(len(word) for word in words) / max(len(words), 1)
-
-        # Technical density (ratio of technical terms to total words)
-        technical_density = len(signals.technical_terms) / max(word_count, 1)
-
-        # Question complexity (based on question words and patterns)
-        question_complexity = 0
-        if "question" in signals.patterns:
-            if any(word in signals.question_words for word in ["what", "who", "where", "when"]):
-                question_complexity = 1
-            elif any(word in signals.question_words for word in ["how", "why"]):
-                question_complexity = 2
-            else:
-                question_complexity = 3
-
-        # Multi-intent score (based on multiple patterns or topics)
-        multi_intent_score = len(signals.patterns) / 5.0  # Normalize to 0-1
-
-        return ComplexityMetrics(
-            word_count=word_count,
-            sentence_count=sentence_count,
-            avg_word_length=avg_word_length,
-            technical_density=technical_density,
-            question_complexity=question_complexity,
-            multi_intent_score=multi_intent_score,
-        )
-
-    def determine_information_type(self, query: str, _signals: IntentSignals) -> InformationType:
-        """
-        Determine the type of information requested.
-
-        Args:
-            query: The research query
-            signals: Extracted intent signals
-
-        Returns:
-            InformationType enum value
-        """
-        query_lower = query.lower()
-        type_scores = {}
-
-        for info_type, patterns in self.info_type_patterns.items():
-            score = 0
-            for pattern in patterns:
-                matches = len(re.findall(pattern, query_lower))
-                score += matches
-            type_scores[info_type] = score
-
-        # Return the type with the highest score
-        if not type_scores or max(type_scores.values()) == 0:
-            return InformationType.FACTUAL
-
-        return max(type_scores, key=type_scores.get)
-
-    def determine_intent_score(
-        self, query: str, signals: IntentSignals
-    ) -> dict[ResearchIntent, float]:
-        """
-        Calculate intent scores for all possible intents.
-
-        Args:
-            query: The research query
-            signals: Extracted intent signals
-
-        Returns:
-            Dictionary mapping intents to confidence scores
-        """
-        query_lower = query.lower()
-        intent_scores = {}
-
-        for intent, keywords in self.intent_keywords.items():
-            score = 0.0
-
-            # Keyword matching
-            keyword_matches = sum(1 for keyword in keywords if keyword in query_lower)
-            score += keyword_matches * 2.0
-
-            # Pattern matching
-            if intent == ResearchIntent.TECHNICAL_DOCUMENTATION and "tutorial" in signals.patterns:
-                score += 3.0
-            elif intent == ResearchIntent.REAL_TIME_INFORMATION and signals.temporal_indicators:
-                score += len(signals.temporal_indicators) * 2.0
-            elif intent == ResearchIntent.CODE_PATTERNS and signals.technical_terms:
-                score += len(signals.technical_terms) * 1.5
-            elif intent == ResearchIntent.COMPETITIVE_ANALYSIS and "comparison" in signals.patterns:
-                score += 3.0
-            elif intent == ResearchIntent.ARCHITECTURE_PATTERNS and signals.domain_specific:
-                score += len(signals.domain_specific) * 1.0
-
-            # Domain-specific boosting
-            if intent == ResearchIntent.ARCHITECTURE_PATTERNS and "architecture" in query_lower:
-                score += 5.0
-            elif intent == ResearchIntent.CODE_PATTERNS and "code" in query_lower:
-                score += 4.0
-            elif intent == ResearchIntent.REAL_TIME_INFORMATION and signals.temporal_indicators:
-                score += 3.0
-
-            intent_scores[intent] = score
-
-        # Normalize scores to 0-1 range
-        max_score = max(intent_scores.values()) if intent_scores else 1.0
-        if max_score > 0:
-            intent_scores = {intent: score / max_score for intent, score in intent_scores.items()}
-
-        return intent_scores
-
-    def determine_complexity_level(
-        self, metrics: ComplexityMetrics, signals: IntentSignals
-    ) -> QueryComplexity:
-        """
-        Determine the complexity level of the query.
-
-        Args:
-            metrics: Calculated complexity metrics
-            signals: Extracted intent signals
-
-        Returns:
-            QueryComplexity enum value
-        """
-        complexity_score = 0.0
-
-        # Word count contribution
-        if metrics.word_count > 20:
-            complexity_score += 2.0
-        elif metrics.word_count > 10:
-            complexity_score += 1.0
-
-        # Technical density contribution
-        complexity_score += metrics.technical_density * 3.0
-
-        # Question complexity contribution
-        complexity_score += metrics.question_complexity
-
-        # Multi-intent contribution
-        complexity_score += metrics.multi_intent_score * 2.0
-
-        # Pattern contribution
-        complexity_score += len(signals.patterns) * 0.5
-
-        # Determine complexity level
-        if complexity_score <= 2.0:
-            return QueryComplexity.SIMPLE
-        elif complexity_score <= 4.0:
-            return QueryComplexity.MODERATE
-        elif complexity_score <= 6.0:
-            return QueryComplexity.COMPLEX
-        else:
-            return QueryComplexity.VERY_COMPLEX
-
-    def determine_priority(
-        self, query: str, signals: IntentSignals, complexity: QueryComplexity
-    ) -> str:
-        """
-        Determine the priority of the research query.
-
-        Args:
-            query: The research query
-            signals: Extracted intent signals
-            complexity: Query complexity level
-
-        Returns:
-            Priority level (high, medium, low)
-        """
-        query_lower = query.lower()
-
-        # High priority indicators
-        high_priority_words = ["urgent", "important", "critical", "asap", "immediately"]
-        if any(word in query_lower for word in high_priority_words):
-            return "high"
-
-        # Medium priority indicators
-        medium_priority_words = ["need", "require", "should", "would like"]
-        if any(word in query_lower for word in medium_priority_words):
-            return "medium"
-
-        # Complex queries get higher priority
-        if complexity in [QueryComplexity.COMPLEX, QueryComplexity.VERY_COMPLEX]:
-            return "high"
-
-        # Real-time information requests get higher priority
-        if signals.temporal_indicators:
-            return "medium"
-
-        return "low"
-
-    async def analyze_query(self, query: str) -> ResearchQuery:
-        """
-        Perform comprehensive analysis of the research query.
-
-        Args:
-            query: The research query string
-
-        Returns:
-            ResearchQuery object with comprehensive analysis
-        """
-        # Extract signals from query
-        signals = self.extract_query_signals(query)
-
-        # Calculate complexity metrics
-        metrics = self.calculate_complexity_metrics(query, signals)
-
-        # Determine information type
-        info_type = self.determine_information_type(query, signals)
-
-        # Calculate intent scores
-        intent_scores = self.determine_intent_score(query, signals)
-
-        # Determine primary intent (highest scoring)
-        primary_intent = (
-            max(intent_scores, key=intent_scores.get)
-            if intent_scores
-            else ResearchIntent.COMPREHENSIVE_RESEARCH
-        )
-
-        # Determine complexity level
-        complexity_level = self.determine_complexity_level(metrics, signals)
-
-        # Convert complexity level to score (0.0-1.0)
-        complexity_score_map = {
-            QueryComplexity.SIMPLE: 0.2,
-            QueryComplexity.MODERATE: 0.5,
-            QueryComplexity.COMPLEX: 0.8,
-            QueryComplexity.VERY_COMPLEX: 1.0,
-        }
-        complexity_score = complexity_score_map[complexity_level]
-
-        # Determine priority
-        priority = self.determine_priority(query, signals, complexity_level)
-
-        # Create context object
-        context = {
-            "signals": {
-                "keywords": signals.keywords,
-                "patterns": signals.patterns,
-                "question_words": signals.question_words,
-                "temporal_indicators": signals.temporal_indicators,
-                "technical_terms": signals.technical_terms,
-                "domain_specific": signals.domain_specific,
-            },
-            "metrics": {
-                "word_count": metrics.word_count,
-                "sentence_count": metrics.sentence_count,
-                "avg_word_length": metrics.avg_word_length,
-                "technical_density": metrics.technical_density,
-                "question_complexity": metrics.question_complexity,
-                "multi_intent_score": metrics.multi_intent_score,
-            },
-            "information_type": info_type.value,
-            "complexity_level": complexity_level.value,
-            "intent_scores": {intent.value: score for intent, score in intent_scores.items()},
-            "confidence": max(intent_scores.values()) if intent_scores else 0.0,
-        }
-
-        return ResearchQuery(
-            original_query=query,
-            intent=primary_intent,
-            keywords=signals.keywords,
-            complexity_score=complexity_score,
-            priority=priority,
-            context=context,
-            timestamp=datetime.now(),
-        )
-
-    def get_analysis_explanation(self, research_query: ResearchQuery) -> str:
-        """
-        Generate a human-readable explanation of the query analysis.
-
-        Args:
-            research_query: The analyzed research query
-
-        Returns:
-            String explanation of the analysis
-        """
-        context = research_query.context
-        signals = context["signals"]
-        metrics = context["metrics"]
-        intent_scores = context["intent_scores"]
-
-        explanation_parts = []
-
-        # Original query
-        explanation_parts.append(f"**Original Query**: {research_query.original_query}")
-
-        # Primary intent
-        explanation_parts.append(f"**Primary Intent**: {research_query.intent.value}")
-        explanation_parts.append(f"**Confidence**: {context['confidence']:.2f}")
-
-        # Intent breakdown
-        explanation_parts.append("\n**Intent Scores**:")
-        for intent, score in sorted(intent_scores.items(), key=lambda x: x[1], reverse=True):
-            explanation_parts.append(f"- {intent}: {score:.2f}")
-
-        # Complexity analysis
-        explanation_parts.append("\n**Complexity Analysis**:")
-        explanation_parts.append(f"- Level: {context['complexity_level']}")
-        explanation_parts.append(f"- Score: {research_query.complexity_score:.2f}")
-        explanation_parts.append(f"- Word Count: {metrics['word_count']}")
-        explanation_parts.append(f"- Technical Density: {metrics['technical_density']:.2f}")
-        explanation_parts.append(f"- Question Complexity: {metrics['question_complexity']}")
-
-        # Detected signals
-        if any(signals.values()):
-            explanation_parts.append("\n**Detected Signals**:")
-            if signals["keywords"]:
-                explanation_parts.append(f"- Keywords: {', '.join(signals['keywords'][:10])}")
-            if signals["patterns"]:
-                explanation_parts.append(f"- Patterns: {', '.join(signals['patterns'])}")
-            if signals["temporal_indicators"]:
-                explanation_parts.append(f"- Temporal: {', '.join(signals['temporal_indicators'])}")
-            if signals["technical_terms"]:
-                explanation_parts.append(
-                    f"- Technical Terms: {', '.join(signals['technical_terms'])}"
-                )
-            if signals["domain_specific"]:
-                explanation_parts.append(
-                    f"- Domain-Specific: {', '.join(signals['domain_specific'])}"
-                )
-
-        # Priority and recommendations
-        explanation_parts.append(f"\n**Priority**: {research_query.priority}")
-        explanation_parts.append(f"**Information Type**: {context['information_type']}")
-
-        return "\n".join(explanation_parts)
-
-    async def batch_analyze_queries(self, queries: list[str]) -> list[ResearchQuery]:
-        """
-        Analyze multiple queries in batch.
-
-        Args:
-            queries: List of query strings
-
-        Returns:
-            List of ResearchQuery objects
-        """
-        tasks = [self.analyze_query(query) for query in queries]
-        return await asyncio.gather(*tasks)
-
-
-# Utility functions
-
-
-def create_research_analyzer() -> ResearchIntentAnalyzer:
-    """
-    Factory function to create a research intent analyzer.
-
-    Returns:
-        Initialized ResearchIntentAnalyzer instance
-    """
-    return ResearchIntentAnalyzer()
-
-
-async def validate_research_analyzer(test_queries: list[str] = None) -> dict:
-    """
-    Validate research intent analyzer functionality with realistic test queries.
-
-    This is a production validation function that tests the analyzer's ability
-    to correctly categorize and analyze different types of research queries.
-
-    Args:
-        test_queries: Optional list of test queries, defaults to comprehensive test set
-
-    Returns:
-        Dictionary containing validation results and performance metrics
-    """
-    logger.info("Starting research intent analyzer validation")
-
-    if test_queries is None:
-        test_queries = [
-            "Viettel Digital Services VDS platform microservices architecture",
-            "Latest news about Viettel Money fintech developments",
-            "How to implement Redis caching in Python applications",
-            "Compare microservices vs monolithic architecture patterns",
-            "What are the best practices for API security in 2024",
-            "Research competitive analysis of digital payment platforms in Vietnam",
-            "Find documentation for Spring Boot REST APIs",
-            "Current trends in AI-powered fintech solutions",
-            "Implement OAuth 2.0 authentication in Node.js applications",
-            "Vietnam digital banking competitive landscape analysis",
-        ]
-
-    try:
-        analyzer = create_research_analyzer()
-        validation_results = {
-            "tests": [],
-            "success_count": 0,
-            "total_tests": 0,
-            "intent_distribution": {},
-            "performance_metrics": {},
-            "timestamp": datetime.now().isoformat(),
-        }
-
-        # Test each query
-        for i, query in enumerate(test_queries, 1):
-            try:
-                # Analyze the query
-                start_time = time.time()
-                research_query = await analyzer.analyze_query(query)
-                analysis_time = time.time() - start_time
-
-                # Validate results
-                if research_query and research_query.intent:
-                    intent = research_query.intent.value
-                    confidence = research_query.confidence
-
-                    # Track intent distribution
-                    if intent not in validation_results["intent_distribution"]:
-                        validation_results["intent_distribution"][intent] = 0
-                    validation_results["intent_distribution"][intent] += 1
-
-                    # Validate quality metrics
-                    quality_checks = []
-                    if confidence > 0.5:
-                        quality_checks.append("Confidence adequate")
-                    if research_query.keywords:
-                        quality_checks.append("Keywords extracted")
-                    if research_query.complexity_score > 0:
-                        quality_checks.append("Complexity calculated")
-
-                    if len(quality_checks) >= 2:
-                        validation_results["tests"].append(
-                            f"✅ Test {i}: {intent} - {confidence:.2f} confidence - {analysis_time:.3f}s"
-                        )
-                        validation_results["success_count"] += 1
-                    else:
-                        validation_results["tests"].append(
-                            f"⚠️  Test {i}: {intent} - Low quality - {quality_checks}"
-                        )
-                else:
-                    validation_results["tests"].append(f"❌ Test {i}: No analysis results")
-
-            except Exception as e:
-                validation_results["tests"].append(f"❌ Test {i}: Error - {str(e)}")
-
-            validation_results["total_tests"] += 1
-
-        # Calculate performance metrics
-        success_rate = (
-            validation_results["success_count"] / validation_results["total_tests"]
-        ) * 100
-        validation_results["performance_metrics"] = {
-            "success_rate": success_rate,
-            "total_queries": len(test_queries),
-            "avg_analysis_time": analysis_time if "analysis_time" in locals() else 0,
-            "intent_variety": len(validation_results["intent_distribution"]),
-            "most_common_intent": max(
-                validation_results["intent_distribution"].items(), key=lambda x: x[1]
-            )[0]
-            if validation_results["intent_distribution"]
-            else None,
-        }
-
-        validation_results["status"] = "PASSED" if success_rate >= 80 else "FAILED"
-
-        logger.info(f"Research analyzer validation completed: {success_rate:.1f}% success rate")
-        return validation_results
-
-    except Exception as e:
-        logger.exception(f"Research analyzer validation failed: {str(e)}")
-        return {
-            "status": "ERROR",
-            "error": str(e),
-            "timestamp": datetime.now().isoformat(),
-        }
-
-
-if __name__ == "__main__":
-    import asyncio
-    import time
-
-    async def run_analyzer_validation():
-        """Run research intent analyzer validation."""
-        print("🔍 VDS Research Intent Analyzer Validation")
-        print("=" * 50)
-
-        results = await validate_research_analyzer()
-
-        print(f"\nValidation Status: {results['status']}")
-        print(f"Success Rate: {results['performance_metrics']['success_rate']:.1f}%")
-        print(f"Queries Tested: {results['performance_metrics']['total_queries']}")
-        print(f"Intent Varieties: {results['performance_metrics']['intent_variety']}")
-        print(f"Most Common Intent: {results['performance_metrics']['most_common_intent']}")
-        print("\nTest Results:")
-        for test in results.get("tests", []):
-            print(f"  {test}")
-
-        if results.get("intent_distribution"):
-            print("\nIntent Distribution:")
-            for intent, count in results["intent_distribution"].items():
-                print(f"  {intent}: {count}")
-
-        if results["status"] == "PASSED":
-            print("\n🎉 Research analyzer validation completed successfully!")
-        else:
-            print(
-                f"\n❌ Research analyzer validation failed: {results.get('error', 'Low success rate')}"
-            )
-
-    asyncio.run(run_analyzer_validation())