@ngocsangairvds/vsaf 3.2.16 → 4.0.0

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

@@ -1,1120 +0,0 @@
-#!/usr/bin/env python3
-"""
-VDS Brain Agent - Intelligent LLM Agent for MCP Tool Orchestration
-
-This module implements the main orchestrator for the VDS AI "services brain"
-that can intelligently select and execute tools across verified MCP servers.
-Based on real MCP tool testing and evaluation results.
-
-Author: VDS AI Team
-Version: 1.0.0
-"""
-
-import asyncio
-import logging
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-from typing import Any
-
-from brain.memory_manager import create_brain_memory_manager
-
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import ToolExecutionError
-
-# Import existing MCP infrastructure
-from vds_memory_orchestrator.service.mcp.official_mcp_client import official_mcp_client
-
-logger = logging.getLogger(__name__)
-
-
-class ResearchIntent(Enum):
-    """Research intent categories for intelligent tool selection."""
-
-    COMPREHENSIVE_RESEARCH = "comprehensive_research"
-    REAL_TIME_INFORMATION = "real_time_information"
-    TECHNICAL_DOCUMENTATION = "technical_documentation"
-    CODE_PATTERNS = "code_patterns"
-    COMPETITIVE_ANALYSIS = "competitive_analysis"
-    ACADEMIC_RESEARCH = "academic_research"
-    ARCHITECTURE_PATTERNS = "architecture_patterns"
-    TUTORIAL_CONTENT = "tutorial_content"
-
-
-@dataclass
-class ResearchQuery:
-    """Structured research query with intent analysis."""
-
-    original_query: str
-    intent: ResearchIntent
-    keywords: list[str]
-    complexity_score: float  # 0.0-1.0
-    priority: str  # high, medium, low
-    context: dict[str, Any] = field(default_factory=dict)
-    timestamp: datetime = field(default_factory=datetime.now)
-
-
-@dataclass
-class ToolCapability:
-    """MCP tool capability definition."""
-
-    name: str
-    server_name: str
-    intents: list[ResearchIntent]
-    strengths: list[str]
-    avg_response_time: float
-    cost_per_use: float
-    quality_score: float  # 0.0-1.0
-    max_results: int
-    special_features: list[str] = field(default_factory=list)
-
-
-@dataclass
-class ResearchResult:
-    """Consolidated research result from multiple tools."""
-
-    query: ResearchQuery
-    tools_used: list[str]
-    combined_results: list[dict[str, Any]]
-    synthesis: str
-    confidence_score: float  # 0.0-1.0
-    execution_time: float
-    cost_incurred: float
-    metadata: dict[str, Any] = field(default_factory=dict)
-    timestamp: datetime = field(default_factory=datetime.now)
-
-
-class VDSBrainAgent:
-    """
-    VDS Brain Agent - Intelligent LLM Agent Orchestrator
-
-    This class implements the main orchestrator for the VDS AI "services brain"
-    that can intelligently select and execute tools across verified MCP servers
-    based on real testing and evaluation results.
-    """
-
-    def __init__(self, session_id: str = "default"):
-        """Initialize the VDS Brain Agent."""
-        # Use the global official MCP client instance
-        self.mcp_client = official_mcp_client
-        self.session_id = session_id
-        self.memory_manager = create_brain_memory_manager(session_id)
-
-        # Initialize tool capabilities based on real MCP testing results
-        self.tool_capabilities = self._initialize_tool_capabilities()
-
-        # Performance metrics
-        self.performance_metrics = {
-            "total_queries": 0,
-            "successful_queries": 0,
-            "avg_response_time": 0.0,
-            "total_cost": 0.0,
-            "tool_usage": {},
-        }
-
-        logger.info("VDS Brain Agent initialized with %d tools", len(self.tool_capabilities))
-
-    async def _ensure_mcp_ready(self):
-        if not self.mcp_client.initialized:
-            await self.mcp_client.initialize()
-
-    def _initialize_tool_capabilities(self) -> dict[str, ToolCapability]:
-        """
-        Initialize tool capabilities based on real MCP testing results.
-
-        Returns:
-            Dictionary of tool capabilities keyed by tool name
-        """
-        capabilities = {
-            # Exa Search - Primary research engine (⭐⭐⭐⭐⭐)
-            "exa_search": ToolCapability(
-                name="exa_search",
-                server_name="exa-official",
-                intents=[
-                    ResearchIntent.COMPREHENSIVE_RESEARCH,
-                    ResearchIntent.ACADEMIC_RESEARCH,
-                    ResearchIntent.COMPETITIVE_ANALYSIS,
-                ],
-                strengths=[
-                    "neural_search",
-                    "high_quality_results",
-                    "content_extraction",
-                ],
-                avg_response_time=4.64,
-                cost_per_use=0.01,
-                quality_score=0.95,
-                max_results=10,
-                special_features=[
-                    "neural_search",
-                    "publication_metadata",
-                    "author_info",
-                ],
-            ),
-            # Brave Search - Real-time information (⭐⭐⭐⭐⭐)
-            "brave_search": ToolCapability(
-                name="brave_search",
-                server_name="brave-search-official",
-                intents=[
-                    ResearchIntent.REAL_TIME_INFORMATION,
-                    ResearchIntent.COMPREHENSIVE_RESEARCH,
-                ],
-                strengths=["fast_response", "current_information", "official_sources"],
-                avg_response_time=1.8,
-                cost_per_use=0.005,
-                quality_score=0.90,
-                max_results=20,
-                special_features=["real_time_search", "official_source_priority"],
-            ),
-            # BrightData - Enterprise search (⭐⭐⭐⭐⭐)
-            "brightdata_search": ToolCapability(
-                name="search_engine",
-                server_name="brightdata-official",
-                intents=[
-                    ResearchIntent.COMPETITIVE_ANALYSIS,
-                    ResearchIntent.REAL_TIME_INFORMATION,
-                ],
-                strengths=["google_integration", "serp_format", "global_ranking"],
-                avg_response_time=2.2,
-                cost_per_use=0.008,
-                quality_score=0.92,
-                max_results=10,
-                special_features=["google_search", "rank_tracking", "ai_overviews"],
-            ),
-            # Context7 - Technical documentation (⭐⭐⭐⭐⭐)
-            "context7_docs": ToolCapability(
-                name="get-library-docs",
-                server_name="context7-official",
-                intents=[
-                    ResearchIntent.TECHNICAL_DOCUMENTATION,
-                    ResearchIntent.CODE_PATTERNS,
-                ],
-                strengths=["extensive_library_db", "trust_scores", "code_examples"],
-                avg_response_time=1.5,
-                cost_per_use=0.003,
-                quality_score=0.88,
-                max_results=15,
-                special_features=["library_search", "code_snippets", "version_support"],
-            ),
-            # Medium Search - Academic content (⭐⭐⭐⭐)
-            "medium_search": ToolCapability(
-                name="search_medium_topic",
-                server_name="medium-search-official",
-                intents=[
-                    ResearchIntent.ACADEMIC_RESEARCH,
-                    ResearchIntent.TUTORIAL_CONTENT,
-                ],
-                strengths=["research_ready_format", "quality_metrics", "author_data"],
-                avg_response_time=0.15,
-                cost_per_use=0.002,
-                quality_score=0.80,
-                max_results=8,
-                special_features=["research_format", "clap_metrics", "reading_time"],
-            ),
-            # DocFork - Technical architecture (⭐⭐⭐)
-            "docfork_search": ToolCapability(
-                name="docfork_search_docs",
-                server_name="docfork-official",
-                intents=[
-                    ResearchIntent.ARCHITECTURE_PATTERNS,
-                    ResearchIntent.TECHNICAL_DOCUMENTATION,
-                ],
-                strengths=["technical_patterns", "best_practices", "architecture_docs"],
-                avg_response_time=2.0,
-                cost_per_use=0.004,
-                quality_score=0.75,
-                max_results=12,
-                special_features=["architecture_search", "pattern_matching"],
-            ),
-            # grep-mcp - Code patterns (⭐⭐)
-            "grep_search": ToolCapability(
-                name="searchGitHub",
-                server_name="grep-mcp-official",
-                intents=[
-                    ResearchIntent.CODE_PATTERNS,
-                    ResearchIntent.TECHNICAL_DOCUMENTATION,
-                ],
-                strengths=[
-                    "code_pattern_search",
-                    "github_integration",
-                    "real_code_examples",
-                ],
-                avg_response_time=3.0,
-                cost_per_use=0.006,
-                quality_score=0.70,
-                max_results=20,
-                special_features=["code_search", "language_filter", "repo_specific"],
-            ),
-            # DeepWiki - GitHub documentation and code (⭐⭐⭐)
-            "deepwiki_read_wiki": ToolCapability(
-                name="read_wiki_contents",
-                server_name="deepwiki-official",
-                intents=[
-                    ResearchIntent.TECHNICAL_DOCUMENTATION,
-                    ResearchIntent.CODE_PATTERNS,
-                    ResearchIntent.ACADEMIC_RESEARCH,
-                ],
-                strengths=[
-                    "github_integration",
-                    "documentation_search",
-                    "project_insights",
-                ],
-                avg_response_time=2.5,
-                cost_per_use=0.005,
-                quality_score=0.78,
-                max_results=25,
-                special_features=[
-                    "repo_wiki_search",
-                    "project_analysis",
-                    "documentation_extraction",
-                ],
-            ),
-            # Tavily - Advanced search and research (⭐⭐⭐⭐⭐)
-            "tavily_search": ToolCapability(
-                name="tavily_search",
-                server_name="tavily-official",
-                intents=[
-                    ResearchIntent.COMPREHENSIVE_RESEARCH,
-                    ResearchIntent.REAL_TIME_INFORMATION,
-                    ResearchIntent.COMPETITIVE_ANALYSIS,
-                ],
-                strengths=[
-                    "comprehensive_search",
-                    "real_time_data",
-                    "content_extraction",
-                ],
-                avg_response_time=2.8,
-                cost_per_use=0.009,
-                quality_score=0.91,
-                max_results=10,
-                special_features=["deep_search", "news_search", "content_crawling"],
-            ),
-            # Perplexity - AI-powered search (⭐⭐⭐⭐)
-            "perplexity_search": ToolCapability(
-                name="perplexity_search",
-                server_name="perplexity-official",
-                intents=[
-                    ResearchIntent.COMPREHENSIVE_RESEARCH,
-                    ResearchIntent.REAL_TIME_INFORMATION,
-                    ResearchIntent.ACADEMIC_RESEARCH,
-                ],
-                strengths=[
-                    "ai_powered_search",
-                    "comprehensive_answers",
-                    "up_to_date_info",
-                ],
-                avg_response_time=3.5,
-                cost_per_use=0.012,
-                quality_score=0.85,
-                max_results=10,
-                special_features=[
-                    "ai_synthesis",
-                    "current_knowledge",
-                    "detailed_analysis",
-                ],
-            ),
-        }
-
-        logger.info("Initialized %d tool capabilities from real MCP testing", len(capabilities))
-        return capabilities
-
-    async def analyze_query_intent(self, query: str) -> ResearchQuery:
-        """
-        Analyze the query to determine research intent and characteristics.
-
-        Args:
-            query: The original research query
-
-        Returns:
-            ResearchQuery object with intent analysis
-        """
-        # Simple keyword-based intent analysis (can be enhanced with LLM)
-        query_lower = query.lower()
-
-        # Determine intent based on keywords
-        if any(word in query_lower for word in ["tutorial", "how to", "learn", "example"]):
-            intent = ResearchIntent.TECHNICAL_DOCUMENTATION
-        elif any(word in query_lower for word in ["latest", "news", "current", "today", "recent"]):
-            intent = ResearchIntent.REAL_TIME_INFORMATION
-        elif any(word in query_lower for word in ["architecture", "design", "pattern", "system"]):
-            intent = ResearchIntent.ARCHITECTURE_PATTERNS
-        elif any(
-            word in query_lower for word in ["code", "implementation", "github", "repository"]
-        ):
-            intent = ResearchIntent.CODE_PATTERNS
-        elif any(
-            word in query_lower for word in ["competitor", "competition", "market", "analysis"]
-        ):
-            intent = ResearchIntent.COMPETITIVE_ANALYSIS
-        elif any(word in query_lower for word in ["research", "study", "paper", "academic"]):
-            intent = ResearchIntent.ACADEMIC_RESEARCH
-        else:
-            intent = ResearchIntent.COMPREHENSIVE_RESEARCH
-
-        # Calculate complexity score based on query length and complexity
-        complexity_score = min(len(query.split()) / 20.0, 1.0)
-
-        # Extract keywords (simple implementation)
-        keywords = [word.strip() for word in query.split() if len(word) > 3]
-
-        # Determine priority based on keywords
-        priority = (
-            "high"
-            if any(word in query_lower for word in ["urgent", "important", "critical"])
-            else "medium"
-        )
-
-        return ResearchQuery(
-            original_query=query,
-            intent=intent,
-            keywords=keywords,
-            complexity_score=complexity_score,
-            priority=priority,
-            context={"source": "vds_brain_agent"},
-        )
-
-    def select_optimal_tools(self, research_query: ResearchQuery) -> list[str]:
-        """
-        Select optimal tools for the given research query.
-
-        Args:
-            research_query: Analyzed research query
-
-        Returns:
-            List of selected tool names in priority order
-        """
-        # Find tools that support the query's intent
-        candidate_tools = []
-
-        for tool_name, capability in self.tool_capabilities.items():
-            if research_query.intent in capability.intents:
-                candidate_tools.append((tool_name, capability))
-
-        # Sort by quality score and response time
-        candidate_tools.sort(
-            key=lambda x: (x[1].quality_score, -x[1].avg_response_time), reverse=True
-        )
-
-        # Select top tools based on complexity and priority
-        if research_query.complexity_score > 0.7 or research_query.priority == "high":
-            # Use multiple tools for complex or high-priority queries
-            selected_tools = [tool[0] for tool in candidate_tools[:3]]
-        else:
-            # Use single best tool for simple queries
-            selected_tools = [candidate_tools[0][0]] if candidate_tools else []
-
-        logger.info(
-            "Selected %d tools for intent %s: %s",
-            len(selected_tools),
-            research_query.intent.value,
-            selected_tools,
-        )
-
-        return selected_tools
-
-    async def execute_tool(self, tool_name: str, research_query: ResearchQuery) -> dict[str, Any]:
-        """
-        Execute a specific tool for the research query.
-
-        Args:
-            tool_name: Name of the tool to execute
-            research_query: The research query
-
-        Returns:
-            Tool execution result
-        """
-        capability = self.tool_capabilities.get(tool_name)
-        if not capability:
-            raise ValueError(f"Unknown tool: {tool_name}")
-
-        # Prepare tool-specific arguments
-        if tool_name == "exa_search":
-            arguments = {
-                "query": research_query.original_query,
-                "numResults": min(capability.max_results, 10),
-            }
-        elif tool_name == "brave_search":
-            arguments = {
-                "query": research_query.original_query,
-                "count": min(capability.max_results, 10),
-                "search_depth": "basic",
-            }
-        elif tool_name == "brightdata_search":
-            arguments = {"query": research_query.original_query, "engine": "google"}
-        elif tool_name == "context7_docs":
-            # For Context7, first resolve library ID then get docs
-            # Try to extract library name from query
-            query_lower = research_query.original_query.lower()
-
-            # Map common libraries to their Context7 IDs
-            library_mapping = {
-                "redis": "/redis/redis-doc",
-                "python": "/python/python-docs",
-                "javascript": "/mozilla/mdn",
-                "react": "/react/docs",
-                "docker": "/docker/docs",
-                "kubernetes": "/kubernetes/docs",
-                "nodejs": "/nodejs/nodejs-docs",
-                "mongodb": "/mongodb/docs",
-            }
-
-            # Find best library match
-            selected_library = None
-            for lib_name, lib_id in library_mapping.items():
-                if lib_name in query_lower:
-                    selected_library = lib_id
-                    break
-
-            # Default to Redis if no match found
-            if not selected_library:
-                selected_library = "/redis/redis-doc"
-
-            arguments = {
-                "context7CompatibleLibraryID": selected_library,
-                "topic": research_query.original_query,
-                "tokens": 4000,
-            }
-        elif tool_name == "medium_search":
-            arguments = {
-                "query": research_query.original_query,
-                "limit": min(capability.max_results, 5),
-                "outputFormat": "research-ready",
-            }
-        elif tool_name == "docfork_search":
-            arguments = {"query": research_query.original_query, "tokens": "dynamic"}
-        elif tool_name == "grep_search":
-            # For code search, use keywords from the query
-            code_pattern = (
-                research_query.keywords[0]
-                if research_query.keywords
-                else research_query.original_query
-            )
-            arguments = {
-                "query": code_pattern,
-                "language": [
-                    "Python",
-                    "Java",
-                    "TypeScript",
-                    "JavaScript",
-                    "Go",
-                    "Rust",
-                ],
-                "matchCase": False,
-            }
-        elif tool_name == "deepwiki_read_wiki":
-            # For DeepWiki, try to extract GitHub repository from query
-            query_lower = research_query.original_query.lower()
-
-            # Look for GitHub repository patterns
-            import re
-
-            # Pattern: owner/repo or github.com/owner/repo
-            repo_match = re.search(
-                r"(?:github\.com/)?([a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+)", query_lower
-            )
-
-            if repo_match:
-                repo_name = repo_match.group(1)
-            else:
-                # Try common repositories related to VDS or fintech
-                if "viettel" in query_lower or "vds" in query_lower:
-                    repo_name = "viettel-digital/viettel-money"
-                elif "fintech" in query_lower:
-                    repo_name = "fintech/open-banking"
-                elif "microservices" in query_lower:
-                    repo_name = "microservices-patterns/microservices"
-                else:
-                    repo_name = "microsoft/azure-samples"  # Default large repo
-
-            arguments = {"repoName": repo_name}
-        elif tool_name == "tavily_search":
-            # For Tavily, use comprehensive search parameters
-            arguments = {
-                "query": research_query.original_query,
-                "max_results": min(capability.max_results, 10),
-                "search_depth": "basic",
-                "include_raw_content": False,
-                "include_images": False,
-            }
-        elif tool_name == "perplexity_search":
-            # For Perplexity, use the full query
-            arguments = {
-                "query": research_query.original_query,
-                "max_results": min(capability.max_results, 10),
-            }
-        else:
-            arguments = {"query": research_query.original_query}
-
-        # Execute the tool
-        try:
-            await self._ensure_mcp_ready()
-            response = await self.mcp_client.execute_tool(
-                tool_name=tool_name,
-                arguments=arguments,
-                preferred_servers=[capability.server_name],
-                timeout=30.0,
-            )
-
-            self.performance_metrics["tool_usage"][tool_name] = (
-                self.performance_metrics["tool_usage"].get(tool_name, 0) + 1
-            )
-
-            return {
-                "tool_name": tool_name,
-                "success": response.success,
-                "result": response.result,
-                "execution_time": response.execution_time,
-                "capability": capability,
-            }
-
-        except ToolExecutionError as exc:
-            logger.exception("Tool %s failed: %s", tool_name, exc)
-            return {
-                "tool_name": tool_name,
-                "success": False,
-                "error": str(exc),
-                "capability": capability,
-            }
-
-    async def synthesize_results(
-        self, research_query: ResearchQuery, tool_results: list[dict[str, Any]]
-    ) -> tuple[str, float]:
-        """
-        Synthesize results from multiple tools into a comprehensive answer.
-
-        Args:
-            research_query: The original research query
-            tool_results: Results from executed tools
-
-        Returns:
-            Tuple of (synthesized_answer, confidence_score)
-        """
-        successful_results = [r for r in tool_results if r["success"]]
-
-        if not successful_results:
-            return "No successful tool executions to synthesize.", 0.0
-
-        # Collect all relevant information
-        all_results = []
-        total_weight = 0.0
-
-        for result in successful_results:
-            capability = result["capability"]
-            weight = capability.quality_score
-            total_weight += weight
-
-            # Extract relevant information based on tool type
-            tool_data = result["result"]
-
-            if result["tool_name"] == "exa_search":
-                if isinstance(tool_data, dict) and "results" in tool_data:
-                    for item in tool_data["results"]:
-                        all_results.append(
-                            {
-                                "source": "Exa Search",
-                                "title": item.get("title", ""),
-                                "content": item.get("text", ""),
-                                "url": item.get("url", ""),
-                                "weight": weight,
-                                "features": capability.special_features,
-                            }
-                        )
-
-            elif result["tool_name"] == "brave_search":
-                if isinstance(tool_data, list):
-                    for item in tool_data:
-                        all_results.append(
-                            {
-                                "source": "Brave Search",
-                                "title": item.get("title", ""),
-                                "content": item.get("description", ""),
-                                "url": item.get("url", ""),
-                                "weight": weight,
-                                "features": capability.special_features,
-                            }
-                        )
-
-            elif result["tool_name"] == "brightdata_search":
-                if isinstance(tool_data, dict) and "organic" in tool_data:
-                    for item in tool_data["organic"]:
-                        all_results.append(
-                            {
-                                "source": "BrightData (Google)",
-                                "title": item.get("title", ""),
-                                "content": item.get("description", ""),
-                                "url": item.get("link", ""),
-                                "weight": weight,
-                                "features": capability.special_features,
-                            }
-                        )
-
-            elif result["tool_name"] == "medium_search":
-                if isinstance(tool_data, dict) and "results" in tool_data:
-                    for item in tool_data["results"]:
-                        all_results.append(
-                            {
-                                "source": "Medium Search",
-                                "title": item.get("title", ""),
-                                "content": item.get("summary", ""),
-                                "url": item.get("url", ""),
-                                "weight": weight,
-                                "features": capability.special_features,
-                                "metadata": {
-                                    "claps": item.get("claps", 0),
-                                    "reading_time": item.get("readingTime", 0),
-                                },
-                            }
-                        )
-
-            elif result["tool_name"] == "context7_docs":
-                if isinstance(tool_data, dict):
-                    all_results.append(
-                        {
-                            "source": "Context7 Documentation",
-                            "title": "Technical Documentation",
-                            "content": str(tool_data)[:500],  # Truncate for brevity
-                            "url": "",
-                            "weight": weight,
-                            "features": capability.special_features,
-                        }
-                    )
-
-            elif result["tool_name"] == "docfork_search":
-                if isinstance(tool_data, list):
-                    for item in tool_data[:5]:  # Limit to top 5 results
-                        all_results.append(
-                            {
-                                "source": "DocFork Documentation",
-                                "title": item.get("title", ""),
-                                "content": item.get("title", ""),  # DocFork often returns titles
-                                "url": item.get("url", ""),
-                                "weight": weight,
-                                "features": capability.special_features,
-                            }
-                        )
-
-            elif result["tool_name"] == "grep_search":
-                if isinstance(tool_data, dict) and "results" in tool_data:
-                    for item in tool_data["results"][:3]:  # Limit to top 3 code results
-                        all_results.append(
-                            {
-                                "source": "GitHub Code Search",
-                                "title": f"Code: {item.get('repository', 'Unknown')}",
-                                "content": item.get("snippet", ""),
-                                "url": item.get("url", ""),
-                                "weight": weight,
-                                "features": capability.special_features,
-                            }
-                        )
-
-            elif result["tool_name"] == "deepwiki_read_wiki":
-                # DeepWiki provides GitHub repository wiki content
-                if isinstance(tool_data, dict):
-                    wiki_content = tool_data.get("content", "")
-                    repo_name = tool_data.get("repo_name", "Unknown Repository")
-
-                    all_results.append(
-                        {
-                            "source": "DeepWiki (GitHub)",
-                            "title": f"GitHub Wiki: {repo_name}",
-                            "content": wiki_content[:500]
-                            + ("..." if len(wiki_content) > 500 else ""),  # Truncate for brevity
-                            "url": f"https://github.com/{repo_name}",
-                            "weight": weight,
-                            "features": capability.special_features,
-                            "metadata": {
-                                "repo_name": repo_name,
-                                "content_type": "wiki_documentation",
-                            },
-                        }
-                    )
-
-            elif result["tool_name"] == "perplexity_search":
-                # Perplexity provides AI-generated comprehensive answers
-                if isinstance(tool_data, dict):
-                    ai_answer = tool_data.get("answer", "")
-                    sources = tool_data.get("sources", [])
-
-                    # Create result from AI answer
-                    all_results.append(
-                        {
-                            "source": "Perplexity AI",
-                            "title": "AI-Generated Research Analysis",
-                            "content": ai_answer[:800] + ("..." if len(ai_answer) > 800 else ""),
-                            "url": "",  # Perplexity typically doesn't provide URLs
-                            "weight": weight + 0.2,  # Boost AI-generated content
-                            "features": capability.special_features,
-                            "metadata": {
-                                "ai_generated": True,
-                                "sources_count": len(sources),
-                                "content_type": "ai_synthesis",
-                            },
-                        }
-                    )
-
-                    # Also add individual sources if available
-                    for source in sources[:3]:  # Limit to top 3 sources
-                        if isinstance(source, dict):
-                            all_results.append(
-                                {
-                                    "source": "Perplexity Source",
-                                    "title": source.get("title", ""),
-                                    "content": source.get("snippet", "")[:300],
-                                    "url": source.get("url", ""),
-                                    "weight": weight * 0.8,  # Slightly lower weight for sources
-                                    "features": capability.special_features,
-                                }
-                            )
-
-        # Sort results by weight and relevance
-        all_results.sort(key=lambda x: x["weight"], reverse=True)
-
-        # Synthesize the answer
-        if not all_results:
-            return "No relevant results found across all tools.", 0.0
-
-        # Calculate confidence score
-        confidence_score = min(total_weight / len(successful_results), 1.0)
-
-        # Build synthesized answer
-        synthesis_parts = []
-
-        # Introduction
-        synthesis_parts.append(f"## Research Results for: {research_query.original_query}")
-        synthesis_parts.append(f"**Intent Analysis**: {research_query.intent.value}")
-        synthesis_parts.append(
-            f"**Tools Used**: {', '.join([r['tool_name'] for r in successful_results])}"
-        )
-        synthesis_parts.append(f"**Confidence Score**: {confidence_score:.2f}")
-        synthesis_parts.append("")
-
-        # Top results
-        synthesis_parts.append("### Key Findings:")
-        for i, result in enumerate(all_results[:5], 1):
-            synthesis_parts.append(f"{i}. **{result['title']}** ({result['source']})")
-            synthesis_parts.append(f"   {result['content'][:200]}...")
-            if result["url"]:
-                synthesis_parts.append(f"   🔗 [View Source]({result['url']})")
-            synthesis_parts.append("")
-
-        # Additional insights
-        if len(all_results) > 5:
-            synthesis_parts.append("### Additional Results")
-            synthesis_parts.append(
-                f"Found {len(all_results)} total results from {len(successful_results)} tools."
-            )
-
-            # Group by source
-            source_counts = {}
-            for result in all_results:
-                source = result["source"]
-                source_counts[source] = source_counts.get(source, 0) + 1
-
-            synthesis_parts.append("**Source Distribution:**")
-            for source, count in source_counts.items():
-                synthesis_parts.append(f"- {source}: {count} results")
-
-        return "\n".join(synthesis_parts), confidence_score
-
-    async def process_research_request(self, query: str) -> ResearchResult:
-        """
-        Process a research request from query to final synthesized results.
-
-        Args:
-            query: The research query string
-
-        Returns:
-            ResearchResult with comprehensive findings
-        """
-        start_time = datetime.now()
-
-        try:
-            # Update metrics
-            self.performance_metrics["total_queries"] += 1
-
-            # Step 1: Analyze query intent
-            research_query = await self.analyze_query_intent(query)
-            logger.info("Analyzed query intent: %s", research_query.intent.value)
-
-            # Step 2: Select optimal tools
-            selected_tools = self.select_optimal_tools(research_query)
-            logger.info("Selected tools: %s", selected_tools)
-
-            if not selected_tools:
-                raise ValueError("No suitable tools found for the query")
-
-            # Step 3: Execute tools (can be parallel for compatible tools)
-            tool_results = []
-            total_cost = 0.0
-
-            # Execute tools concurrently when possible
-            if len(selected_tools) > 1:
-                # Create tasks for parallel execution
-                tasks = [
-                    self.execute_tool(tool_name, research_query) for tool_name in selected_tools
-                ]
-                tool_results = await asyncio.gather(*tasks, return_exceptions=True)
-
-                # Process results and handle exceptions
-                processed_results = []
-                for i, result in enumerate(tool_results):
-                    if isinstance(result, Exception):
-                        logger.error(
-                            "Tool %s failed with exception: %s",
-                            selected_tools[i],
-                            str(result),
-                        )
-                        processed_results.append(
-                            {
-                                "tool_name": selected_tools[i],
-                                "success": False,
-                                "error": str(result),
-                            }
-                        )
-                    else:
-                        processed_results.append(result)
-                        # Add cost
-                        capability = self.tool_capabilities.get(selected_tools[i])
-                        if capability:
-                            total_cost += capability.cost_per_use
-
-                tool_results = processed_results
-            else:
-                # Single tool execution
-                result = await self.execute_tool(selected_tools[0], research_query)
-                tool_results = [result]
-                capability = self.tool_capabilities.get(selected_tools[0])
-                if capability:
-                    total_cost += capability.cost_per_use
-
-            # Step 4: Synthesize results
-            synthesis, confidence_score = await self.synthesize_results(
-                research_query, tool_results
-            )
-
-            # Calculate execution time
-            execution_time = (datetime.now() - start_time).total_seconds()
-
-            # Create result
-            research_result = ResearchResult(
-                query=research_query,
-                tools_used=selected_tools,
-                combined_results=tool_results,
-                synthesis=synthesis,
-                confidence_score=confidence_score,
-                execution_time=execution_time,
-                cost_incurred=total_cost,
-                metadata={
-                    "successful_tools": len([r for r in tool_results if r["success"]]),
-                    "total_tools": len(selected_tools),
-                    "intent": research_query.intent.value,
-                },
-            )
-
-            # Step 5: Store in memory for learning
-            await self._store_research_memory(
-                research_query, tool_results, synthesis, research_result
-            )
-
-            # Update metrics
-            self.performance_metrics["successful_queries"] += 1
-            self.performance_metrics["total_cost"] += total_cost
-            self.performance_metrics["avg_response_time"] = (
-                self.performance_metrics["avg_response_time"]
-                * (self.performance_metrics["successful_queries"] - 1)
-                + execution_time
-            ) / self.performance_metrics["successful_queries"]
-
-            logger.info(
-                "Research completed successfully in %.2f seconds with confidence %.2f",
-                execution_time,
-                confidence_score,
-            )
-
-            return research_result
-
-        except Exception as e:
-            logger.exception("Research processing failed: %s", str(e))
-            execution_time = (datetime.now() - start_time).total_seconds()
-
-            # Return failed result
-            return ResearchResult(
-                query=await self.analyze_query_intent(query),
-                tools_used=[],
-                combined_results=[],
-                synthesis=f"Research failed due to error: {str(e)}",
-                confidence_score=0.0,
-                execution_time=execution_time,
-                cost_incurred=0.0,
-                metadata={"error": str(e)},
-            )
-
-    async def _store_research_memory(
-        self,
-        research_query: ResearchQuery,
-        tool_results: list[dict[str, Any]],
-        synthesis: str,
-        research_result: ResearchResult,
-    ):
-        """
-        Store research results in memory for learning and future reference.
-
-        Args:
-            research_query: The analyzed research query
-            tool_results: Results from tool executions
-            synthesis: Synthesized research answer
-            research_result: Complete research result for storage
-        """
-        try:
-            # Store in brain agent memory for future learning
-            memory_data = {
-                "query": research_query.original_query,
-                "intent": research_query.intent.value,
-                "tools_used": research_result.tools_used,
-                "successful_tools": [r["tool_name"] for r in tool_results if r["success"]],
-                "synthesis": synthesis,
-                "confidence": research_result.confidence_score,
-                "execution_time": research_result.execution_time,
-                "cost": research_result.cost_incurred,
-                "timestamp": datetime.now().isoformat(),
-                "keywords": research_query.keywords,
-                "session_id": self.session_id,
-                "metadata": research_result.metadata,
-            }
-
-            # Use brain agent memory manager
-            success = await self.memory_manager.store_research_result(memory_data)
-
-            # Store individual tool performance data
-            for result in tool_results:
-                performance_data = {
-                    "execution_time": result.get("execution_time", 0),
-                    "success": result.get("success", False),
-                    "error": result.get("error"),
-                    "query_type": research_query.intent.value,
-                    "quality_score": result.get("capability", {}).get("quality_score", 0),
-                    "cost": result.get("capability", {}).get("cost_per_use", 0),
-                }
-                await self.memory_manager.store_tool_performance(
-                    result["tool_name"], performance_data
-                )
-
-            if success:
-                logger.info("Research result stored in brain memory for learning")
-            else:
-                logger.warning("Failed to store research result in memory")
-
-        except Exception as e:
-            logger.exception("Error storing research memory: %s", str(e))
-
-    def get_performance_metrics(self) -> dict[str, Any]:
-        """
-        Get current performance metrics.
-
-        Returns:
-            Dictionary of performance metrics
-        """
-        return {
-            **self.performance_metrics,
-            "success_rate": (
-                self.performance_metrics["successful_queries"]
-                / max(self.performance_metrics["total_queries"], 1)
-            )
-            * 100,
-            "available_tools": len(self.tool_capabilities),
-        }
-
-    async def test_all_tools(self) -> dict[str, Any]:
-        """
-        Test all configured tools for connectivity and basic functionality.
-
-        Returns:
-            Dictionary with test results for each tool
-        """
-        test_results = {}
-
-        for tool_name, capability in self.tool_capabilities.items():
-            try:
-                # Create a simple test query
-                test_query = ResearchQuery(
-                    original_query="test query",
-                    intent=capability.intents[0],
-                    keywords=["test"],
-                    complexity_score=0.3,
-                    priority="low",
-                )
-
-                result = await self.execute_tool(tool_name, test_query)
-                test_results[tool_name] = {
-                    "status": "success" if result["success"] else "failed",
-                    "execution_time": result.get("execution_time", 0),
-                    "error": result.get("error", None),
-                }
-
-            except Exception as e:
-                test_results[tool_name] = {"status": "error", "error": str(e)}
-
-        return test_results
-
-
-# Utility functions for external integration
-
-
-async def create_vds_brain_agent(session_id: str = "default") -> VDSBrainAgent:
-    """
-    Factory function to create and initialize a VDS Brain Agent.
-
-    Args:
-        session_id: Session identifier for the agent
-
-    Returns:
-        Initialized VDSBrainAgent instance
-    """
-    agent = VDSBrainAgent(session_id=session_id)
-
-    # Test all tools on startup
-    logger.info("Testing MCP tools connectivity...")
-    test_results = await agent.test_all_tools()
-
-    successful_tools = [
-        name for name, result in test_results.items() if result["status"] == "success"
-    ]
-    logger.info("MCP tools ready: %d/%d successful", len(successful_tools), len(test_results))
-
-    if len(successful_tools) == 0:
-        logger.warning("No MCP tools are working. Check configuration and connectivity.")
-
-    # Initialize brain memory
-    try:
-        memory_stats = agent.memory_manager.get_memory_statistics()
-        logger.info(f"Brain memory initialized: {memory_stats['storage_type']} storage")
-    except Exception as e:
-        logger.warning(f"Brain memory initialization issue: {e}")
-
-    return agent
-
-
-if __name__ == "__main__":
-    # Example usage
-    async def main():
-        agent = await create_vds_brain_agent()
-
-        # Test research query
-        result = await agent.process_research_request(
-            "Viettel Digital Services VDS platform microservices architecture"
-        )
-
-        print("=== RESEARCH RESULT ===")
-        print(f"Query: {result.query.original_query}")
-        print(f"Intent: {result.query.intent.value}")
-        print(f"Tools Used: {', '.join(result.tools_used)}")
-        print(f"Confidence: {result.confidence_score:.2f}")
-        print(f"Execution Time: {result.execution_time:.2f}s")
-        print(f"Cost: ${result.cost_incurred:.4f}")
-        print("\nSYNTHESIS:")
-        print(result.synthesis)
-
-        print("\n=== PERFORMANCE METRICS ===")
-        metrics = agent.get_performance_metrics()
-        for key, value in metrics.items():
-            print(f"{key}: {value}")
-
-    asyncio.run(main())