Upload app.py

app.py

@@ -1,886 +1,399 @@
-import gradio as gr
-import time
-from typing import Dict, List, Tuple
-from dataclasses import dataclass
+"""
+Real MCP Integration - Replace Mock Data with Live Topcoder MCP
+This replaces your SimpleIntelligenceEngine with real MCP integration
+"""
+import asyncio
+import httpx
+import json
+import logging
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass, asdict
+from datetime import datetime, timedelta
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 @dataclass
 class Challenge:
-    """Challenge data structure"""
     id: str
     title: str
     description: str
     technologies: List[str]
     difficulty: str
-    prize: int
-    timeline: str
-    registrants: int
-    score: float = 0.0
+    prize: str
+    time_estimate: str
+    compatibility_score: float = 0.0
+    rationale: str = ""
 
-class SimpleIntelligenceEngine:
-    """Intelligence engine for Topcoder challenges"""
+@dataclass
+class Skill:
+    name: str
+    category: str
+    description: str
+    relevance_score: float = 0.0
+
+@dataclass
+class UserProfile:
+    skills: List[str]
+    experience_level: str
+    time_available: str
+    interests: List[str]
+
+class RealMCPIntelligenceEngine:
+    """Production MCP Integration - Real Topcoder Data"""
     
     def __init__(self):
-        print("🤖 Initializing Topcoder Intelligence Engine...")
-        self.challenges = [
-            Challenge(
-                id="30174840",
-                title="React Component Library Development",
-                description="Build a comprehensive React component library with TypeScript support and Storybook documentation. Perfect for developers looking to create reusable UI components.",
-                technologies=["React", "TypeScript", "Storybook", "CSS", "Jest"],
-                difficulty="Intermediate",
-                prize=3000,
-                timeline="14 days",
-                registrants=45
-            ),
-            Challenge(
-                id="30174841",
-                title="Python API Performance Optimization",
-                description="Optimize existing Python FastAPI application for better performance and scalability. Focus on database queries, caching strategies, and async processing.",
-                technologies=["Python", "FastAPI", "PostgreSQL", "Redis", "Docker"],
-                difficulty="Advanced",
-                prize=5000,
-                timeline="21 days",
-                registrants=28
-            ),
-            Challenge(
-                id="30174842",
-                title="Mobile App UI/UX Design",
-                description="Design modern, accessible mobile app interface with dark mode support and responsive layouts for both iOS and Android platforms.",
-                technologies=["Figma", "UI/UX", "Mobile Design", "Accessibility", "Prototyping"],
-                difficulty="Beginner",
-                prize=2000,
-                timeline="10 days",
-                registrants=67
-            ),
-            Challenge(
-                id="30174843",
-                title="Blockchain Smart Contract Development",
-                description="Develop secure smart contracts for DeFi applications with comprehensive testing suite and gas optimization techniques.",
-                technologies=["Solidity", "Web3", "JavaScript", "Hardhat", "Testing"],
-                difficulty="Advanced",
-                prize=7500,
-                timeline="28 days",
-                registrants=19
-            ),
-            Challenge(
-                id="30174844",
-                title="Data Visualization Dashboard",
-                description="Create interactive data visualization dashboard using modern charting libraries with real-time data updates and export capabilities.",
-                technologies=["D3.js", "JavaScript", "HTML", "CSS", "Chart.js"],
-                difficulty="Intermediate",
-                prize=4000,
-                timeline="18 days",
-                registrants=33
-            ),
-            Challenge(
-                id="30174845",
-                title="Machine Learning Model Deployment",
-                description="Deploy ML models to production with API endpoints, monitoring, and auto-scaling capabilities using cloud platforms.",
-                technologies=["Python", "TensorFlow", "Docker", "Kubernetes", "AWS"],
-                difficulty="Advanced",
-                prize=6000,
-                timeline="25 days",
-                registrants=24
-            )
-        ]
-        print(f"✅ Loaded {len(self.challenges)} challenges from Topcoder database")
+        self.mcp_url = "https://api.topcoder-dev.com/v6/mcp"
+        self.session_id = None
+        self.is_connected = False
+        self.challenges_cache = {}
+        self.skills_cache = {}
+        self.cache_expiry = None
+        
+        # Initialize connection
+        asyncio.create_task(self.initialize_connection())
+    
+    async def initialize_connection(self):
+        """Initialize MCP connection and authenticate if needed"""
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                
+                # Step 1: Try initialization
+                init_request = {
+                    "jsonrpc": "2.0",
+                    "id": 1,
+                    "method": "initialize",
+                    "params": {
+                        "protocolVersion": "2024-11-05",
+                        "capabilities": {
+                            "roots": {"listChanged": True},
+                            "sampling": {}
+                        },
+                        "clientInfo": {
+                            "name": "topcoder-intelligence-assistant",
+                            "version": "1.0.0"
+                        }
+                    }
+                }
+                
+                headers = {
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/event-stream"
+                }
+                
+                response = await client.post(
+                    f"{self.mcp_url}/mcp",
+                    json=init_request,
+                    headers=headers
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    if "result" in result:
+                        self.is_connected = True
+                        logger.info("✅ MCP Connection established")
+                        
+                        # Extract session info if provided
+                        server_info = result["result"].get("serverInfo", {})
+                        if "sessionId" in server_info:
+                            self.session_id = server_info["sessionId"]
+                            logger.info(f"🔑 Session ID obtained: {self.session_id[:10]}...")
+                        
+                        return True
+                
+                logger.warning(f"⚠️ MCP initialization failed: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ MCP connection failed: {e}")
+            return False
     
-    def get_personalized_recommendations(self, user_profile: Dict, query: str = "") -> List[Challenge]:
-        """Generate AI-powered personalized recommendations"""
-        print(f"🔍 Analyzing profile: {user_profile.get('skills', [])} | Level: {user_profile.get('experience_level')}")
+    async def call_mcp_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Optional[Dict]:
+        """Call an MCP tool with proper error handling"""
+        
+        if not self.is_connected:
+            await self.initialize_connection()
+        
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                
+                request_data = {
+                    "jsonrpc": "2.0",
+                    "id": datetime.now().timestamp(),
+                    "method": "tools/call",
+                    "params": {
+                        "name": tool_name,
+                        "arguments": arguments
+                    }
+                }
+                
+                headers = {
+                    "Content-Type": "application/json",
+                    "Accept": "application/json"
+                }
+                
+                # Add session ID if we have one
+                if self.session_id:
+                    headers["X-Session-ID"] = self.session_id
+                
+                response = await client.post(
+                    f"{self.mcp_url}/mcp",
+                    json=request_data,
+                    headers=headers
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    if "result" in result:
+                        return result["result"]
+                    elif "error" in result:
+                        logger.error(f"MCP tool error: {result['error']}")
+                        return None
+                else:
+                    logger.error(f"MCP tool call failed: {response.status_code} - {response.text}")
+                    return None
+                    
+        except Exception as e:
+            logger.error(f"MCP tool call exception: {e}")
+            return None
+    
+    async def fetch_challenges(self, limit: int = 50, technologies: List[str] = None) -> List[Challenge]:
+        """Fetch real challenges from Topcoder MCP"""
         
-        # Simulate intelligent processing
-        time.sleep(0.8)  # Realistic processing time
+        # Check cache first
+        cache_key = f"challenges_{limit}_{technologies}"
+        if (self.cache_expiry and datetime.now() < self.cache_expiry and 
+            cache_key in self.challenges_cache):
+            return self.challenges_cache[cache_key]
         
-        scored_challenges = []
-        user_skills = set(skill.lower().strip() for skill in user_profile.get('skills', []))
-        user_level = user_profile.get('experience_level', 'Intermediate').lower()
+        arguments = {"limit": limit}
+        if technologies:
+            arguments["technologies"] = technologies
         
-        for challenge in self.challenges:
-            score = 0.0
-            
-            # Advanced skill matching algorithm (40% weight)
-            challenge_techs = set(tech.lower() for tech in challenge.technologies)
-            skill_overlap = len(user_skills.intersection(challenge_techs))
-            if challenge_techs:
-                # Bonus for exact matches, partial credit for related skills
-                exact_match_score = (skill_overlap / len(challenge_techs)) * 30
-                coverage_score = min(skill_overlap * 10, 10)  # Bonus for multiple matches
-                score += exact_match_score + coverage_score
-            
-            # Experience level compatibility (30% weight)
-            level_mapping = {'beginner': 1, 'intermediate': 2, 'advanced': 3}
-            user_level_num = level_mapping.get(user_level, 2)
-            challenge_level_num = level_mapping.get(challenge.difficulty.lower(), 2)
-            
-            # Perfect match gets full points, adjacent levels get partial
-            level_diff = abs(user_level_num - challenge_level_num)
-            if level_diff == 0:
-                level_score = 30
-            elif level_diff == 1:
-                level_score = 20
-            else:
-                level_score = 5
-            score += level_score
+        result = await self.call_mcp_tool("query-tc-challenges", arguments)
+        
+        if result and "content" in result:
+            challenges_data = result["content"]
             
-            # Query/Interest relevance (20% weight)
-            if query:
-                query_words = set(query.lower().split())
-                challenge_content = (challenge.title + " " + challenge.description).lower()
-                challenge_words = set(challenge_content.split())
-                
-                # Exact phrase matching
-                query_overlap = len(query_words.intersection(challenge_words))
-                # Bonus for title matches
-                title_matches = len(query_words.intersection(set(challenge.title.lower().split())))
-                
-                relevance_score = min(query_overlap * 3 + title_matches * 5, 20)
-                score += relevance_score
-            else:
-                score += 10  # Base score when no specific query
+            challenges = []
+            for item in challenges_data:
+                if isinstance(item, dict):
+                    challenge = Challenge(
+                        id=str(item.get("id", "")),
+                        title=item.get("title", "Unknown Challenge"),
+                        description=item.get("description", "")[:200] + "...",
+                        technologies=item.get("technologies", []),
+                        difficulty=item.get("difficulty", "Unknown"),
+                        prize=f"${item.get('prize', 0):,}",
+                        time_estimate=f"{item.get('duration', 0)} hours"
+                    )
+                    challenges.append(challenge)
             
-            # Market attractiveness (10% weight)
-            # Higher prizes and reasonable competition levels get bonus points
-            prize_score = min(challenge.prize / 1000 * 2, 8)  # Max 8 points for prize
-            competition_bonus = 2 if 20 <= challenge.registrants <= 50 else 0  # Sweet spot
-            score += prize_score + competition_bonus
+            # Cache results for 1 hour
+            self.challenges_cache[cache_key] = challenges
+            self.cache_expiry = datetime.now() + timedelta(hours=1)
             
-            challenge.score = round(score, 1)
-            scored_challenges.append(challenge)
+            logger.info(f"✅ Fetched {len(challenges)} real challenges from MCP")
+            return challenges
+        
+        logger.warning("❌ Failed to fetch challenges, returning empty list")
+        return []
+    
+    async def fetch_skills(self, category: str = None) -> List[Skill]:
+        """Fetch real skills from Topcoder MCP"""
         
-        # Sort by score and return top recommendations
-        scored_challenges.sort(key=lambda x: x.score, reverse=True)
-        top_recommendations = scored_challenges[:4]  # Return top 4
+        cache_key = f"skills_{category}"
+        if (self.cache_expiry and datetime.now() < self.cache_expiry and 
+            cache_key in self.skills_cache):
+            return self.skills_cache[cache_key]
         
-        print(f"✅ Generated {len(top_recommendations)} recommendations:")
-        for i, rec in enumerate(top_recommendations, 1):
-            print(f"   {i}. {rec.title} - {rec.score}% compatibility")
+        arguments = {}
+        if category:
+            arguments["category"] = category
         
-        return top_recommendations
+        result = await self.call_mcp_tool("query-tc-skills", arguments)
+        
+        if result and "content" in result:
+            skills_data = result["content"]
+            
+            skills = []
+            for item in skills_data:
+                if isinstance(item, dict):
+                    skill = Skill(
+                        name=item.get("name", "Unknown Skill"),
+                        category=item.get("category", "General"),
+                        description=item.get("description", "")
+                    )
+                    skills.append(skill)
+            
+            self.skills_cache[cache_key] = skills
+            logger.info(f"✅ Fetched {len(skills)} real skills from MCP")
+            return skills
+        
+        logger.warning("❌ Failed to fetch skills, returning empty list")
+        return []
     
-    def get_user_insights(self, user_profile: Dict) -> Dict:
-        """Generate comprehensive user insights"""
-        skills = user_profile.get('skills', [])
-        level = user_profile.get('experience_level', 'Intermediate')
-        time_available = user_profile.get('time_available', '1-2 weeks')
-        
-        # Analyze skill categories
-        frontend_skills = ['react', 'javascript', 'css', 'html', 'vue', 'angular']
-        backend_skills = ['python', 'java', 'node', 'fastapi', 'django', 'flask']
-        data_skills = ['sql', 'postgresql', 'mongodb', 'redis', 'elasticsearch']
-        devops_skills = ['docker', 'kubernetes', 'aws', 'azure', 'terraform']
-        
-        user_skills_lower = [skill.lower() for skill in skills]
-        
-        # Calculate strengths
-        frontend_count = sum(1 for skill in user_skills_lower if any(fs in skill for fs in frontend_skills))
-        backend_count = sum(1 for skill in user_skills_lower if any(bs in skill for bs in backend_skills))
-        data_count = sum(1 for skill in user_skills_lower if any(ds in skill for ds in data_skills))
-        devops_count = sum(1 for skill in user_skills_lower if any(ds in skill for ds in devops_skills))
-        
-        # Determine profile type
-        if frontend_count >= 2 and backend_count >= 1:
-            profile_type = "Full-Stack Developer"
-        elif frontend_count >= 2:
-            profile_type = "Frontend Specialist"
-        elif backend_count >= 2:
-            profile_type = "Backend Developer"
-        elif data_count >= 2:
-            profile_type = "Data Engineer"
-        else:
-            profile_type = "Versatile Developer"
-        
-        # Generate insights
-        insights = {
-            'profile_type': profile_type,
-            'strengths': f"Strong {profile_type.lower()} with expertise in {', '.join(skills[:3]) if skills else 'multiple technologies'}",
-            'growth_areas': self._suggest_growth_areas(user_skills_lower, frontend_count, backend_count, data_count, devops_count),
-            'skill_progression': f"Ready for {level.lower()} to advanced challenges based on current skill set",
-            'market_trends': self._get_market_trends(skills),
-            'time_optimization': f"With {time_available}, you can complete 1-2 medium challenges or 1 large project",
-            'success_probability': self._calculate_success_probability(level, len(skills))
+    def extract_technologies_from_query(self, query: str) -> List[str]:
+        """Extract technology keywords from user query"""
+        tech_keywords = {
+            'python', 'java', 'javascript', 'react', 'node', 'angular', 'vue',
+            'aws', 'docker', 'kubernetes', 'api', 'rest', 'graphql', 'sql',
+            'mongodb', 'postgresql', 'machine learning', 'ai', 'blockchain',
+            'ios', 'android', 'flutter', 'swift', 'kotlin', 'c++', 'c#',
+            'ruby', 'php', 'go', 'rust', 'typescript', 'html', 'css'
         }
         
-        print(f"✅ Generated insights for {profile_type} at {level} level")
-        return insights
-    
-    def _suggest_growth_areas(self, user_skills: List[str], frontend: int, backend: int, data: int, devops: int) -> str:
-        """Suggest areas for skill growth"""
-        suggestions = []
-        
-        if devops < 1:
-            suggestions.append("cloud technologies (AWS, Docker)")
-        if data < 1 and backend >= 1:
-            suggestions.append("database optimization and caching")
-        if frontend >= 1 and "typescript" not in str(user_skills):
-            suggestions.append("TypeScript for better code quality")
-        if backend >= 1 and "api" not in str(user_skills):
-            suggestions.append("API design and microservices")
-        
-        if not suggestions:
-            suggestions = ["emerging technologies", "system design", "performance optimization"]
-        
-        return "Consider exploring " + ", ".join(suggestions[:3])
+        query_lower = query.lower()
+        found_techs = [tech for tech in tech_keywords if tech in query_lower]
+        return found_techs
     
-    def _get_market_trends(self, skills: List[str]) -> str:
-        """Get relevant market trends"""
-        hot_skills = {
-            'react': 'React continues to dominate frontend development',
-            'python': 'Python shows strong growth in AI/ML and backend',
-            'typescript': 'TypeScript adoption is accelerating rapidly',
-            'docker': 'Containerization skills are increasingly essential',
-            'aws': 'Cloud skills command premium salaries'
+    def calculate_compatibility_score(self, challenge: Challenge, user_profile: UserProfile, query: str) -> float:
+        """Calculate compatibility score using real challenge data"""
+        
+        score = 0.0
+        factors = []
+        
+        # 1. Skill matching (40%)
+        user_skills_lower = [skill.lower() for skill in user_profile.skills]
+        challenge_techs_lower = [tech.lower() for tech in challenge.technologies]
+        
+        skill_matches = len(set(user_skills_lower) & set(challenge_techs_lower))
+        skill_score = min(skill_matches / max(len(challenge.technologies), 1), 1.0) * 0.4
+        score += skill_score
+        factors.append(f"Skill match: {skill_matches}/{len(challenge.technologies)} technologies")
+        
+        # 2. Experience level matching (30%)
+        experience_mapping = {
+            "beginner": {"Beginner": 1.0, "Intermediate": 0.7, "Advanced": 0.3},
+            "intermediate": {"Beginner": 0.5, "Intermediate": 1.0, "Advanced": 0.8},
+            "advanced": {"Beginner": 0.3, "Intermediate": 0.8, "Advanced": 1.0}
         }
         
-        for skill in skills:
-            if skill.lower() in hot_skills:
-                return hot_skills[skill.lower()]
+        exp_score = experience_mapping.get(user_profile.experience_level.lower(), {}).get(challenge.difficulty, 0.5) * 0.3
+        score += exp_score
+        factors.append(f"Experience match: {user_profile.experience_level} → {challenge.difficulty}")
+        
+        # 3. Query relevance (20%)
+        query_techs = self.extract_technologies_from_query(query)
+        query_matches = len(set([tech.lower() for tech in query_techs]) & set(challenge_techs_lower))
+        query_score = min(query_matches / max(len(query_techs), 1), 1.0) * 0.2 if query_techs else 0.1
+        score += query_score
+        factors.append(f"Query relevance: {query_matches} matches")
+        
+        # 4. Time availability (10%)
+        time_mapping = {
+            "2-4 hours": {"1-2 hours": 1.0, "2-4 hours": 1.0, "4+ hours": 0.7},
+            "4-8 hours": {"2-4 hours": 0.8, "4+ hours": 1.0, "1-2 hours": 0.6},
+            "8+ hours": {"4+ hours": 1.0, "2-4 hours": 0.7, "1-2 hours": 0.4}
+        }
         
-        return "Full-stack and cloud skills are in highest demand"
-    
-    def _calculate_success_probability(self, level: str, skill_count: int) -> str:
-        """Calculate success probability"""
-        base_score = {'beginner': 60, 'intermediate': 75, 'advanced': 85}.get(level.lower(), 70)
-        skill_bonus = min(skill_count * 3, 15)
-        total = base_score + skill_bonus
-        
-        if total >= 85:
-            return f"{total}% - Excellent match for success"
-        elif total >= 70:
-            return f"{total}% - Good probability of success"
-        else:
-            return f"{total}% - Consider skill development first"
-
-# Initialize the intelligence engine
-print("🚀 Starting Topcoder Intelligence Assistant...")
-intelligence_engine = SimpleIntelligenceEngine()
-
-def format_challenge_card(challenge: Challenge) -> str:
-    """Format challenge as professional HTML card"""
-    tech_badges = " ".join([
-        f"<span style='background:#e74c3c;color:white;padding:4px 10px;border-radius:15px;font-size:0.8em;margin:2px;display:inline-block;font-weight:500'>{tech}</span>" 
-        for tech in challenge.technologies
-    ])
-    
-    # Dynamic score coloring
-    if challenge.score >= 80:
-        score_color = "#00b894"
-        score_label = "Excellent Match"
-    elif challenge.score >= 65:
-        score_color = "#f39c12" 
-        score_label = "Good Match"
-    else:
-        score_color = "#e74c3c"
-        score_label = "Fair Match"
-    
-    return f"""
-    <div style='border:1px solid #e0e6ed;border-radius:12px;padding:25px;margin:15px 0;background:white;box-shadow:0 3px 10px rgba(0,0,0,0.1);transition:transform 0.2s ease'>
-        <div style='display:flex;justify-content:space-between;align-items:flex-start;margin-bottom:15px'>
-            <h3 style='margin:0;color:#2c3e50;font-size:1.3em;font-weight:600'>{challenge.title}</h3>
-            <div style='text-align:center'>
-                <div style='background:{score_color};color:white;padding:8px 16px;border-radius:25px;font-weight:600;font-size:1em'>{challenge.score}%</div>
-                <div style='color:{score_color};font-size:0.8em;margin-top:4px;font-weight:500'>{score_label}</div>
-            </div>
-        </div>
-        
-        <p style='color:#6c757d;margin:15px 0;line-height:1.6;font-size:0.95em'>{challenge.description}</p>
-        
-        <div style='margin:20px 0'>
-            <strong style='color:#2c3e50;font-size:0.9em'>Technologies:</strong><br>
-            <div style='margin-top:8px'>{tech_badges}</div>
-        </div>
-        
-        <div style='display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:15px;margin-top:20px;padding-top:20px;border-top:1px solid #f8f9fa'>
-            <div style='text-align:center;padding:10px'>
-                <div style='font-size:1.2em;font-weight:600;color:#27ae60'>${challenge.prize:,}</div>
-                <div style='font-size:0.8em;color:#6c757d;margin-top:2px'>Prize</div>
-            </div>
-            <div style='text-align:center;padding:10px'>
-                <div style='font-size:1.1em;font-weight:600;color:#3498db'>{challenge.difficulty}</div>
-                <div style='font-size:0.8em;color:#6c757d;margin-top:2px'>Level</div>
-            </div>
-            <div style='text-align:center;padding:10px'>
-                <div style='font-size:1.1em;font-weight:600;color:#e67e22'>{challenge.timeline}</div>
-                <div style='font-size:0.8em;color:#6c757d;margin-top:2px'>Timeline</div>
-            </div>
-            <div style='text-align:center;padding:10px'>
-                <div style='font-size:1.1em;font-weight:600;color:#9b59b6'>{challenge.registrants}</div>
-                <div style='font-size:0.8em;color:#6c757d;margin-top:2px'>Registered</div>
-            </div>
-        </div>
-    </div>
-    """
-
-def format_insights_panel(insights: Dict) -> str:
-    """Format insights as comprehensive dashboard"""
-    return f"""
-    <div style='background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);color:white;padding:25px;border-radius:12px;margin:15px 0;box-shadow:0 4px 15px rgba(102,126,234,0.3)'>
-        <h3 style='margin:0 0 20px 0;font-size:1.4em;text-align:center'>🎯 Your Intelligence Profile</h3>
-        
-        <div style='display:grid;grid-template-columns:repeat(auto-fit,minmax(250px,1fr));gap:20px'>
-            <div style='background:rgba(255,255,255,0.1);padding:15px;border-radius:8px'>
-                <div style='font-weight:600;margin-bottom:8px'>👤 Developer Type</div>
-                <div style='opacity:0.9'>{insights['profile_type']}</div>
-            </div>
-            <div style='background:rgba(255,255,255,0.1);padding:15px;border-radius:8px'>
-                <div style='font-weight:600;margin-bottom:8px'>💪 Core Strengths</div>
-                <div style='opacity:0.9'>{insights['strengths']}</div>
-            </div>
-            <div style='background:rgba(255,255,255,0.1);padding:15px;border-radius:8px'>
-                <div style='font-weight:600;margin-bottom:8px'>📈 Growth Focus</div>
-                <div style='opacity:0.9'>{insights['growth_areas']}</div>
-            </div>
-            <div style='background:rgba(255,255,255,0.1);padding:15px;border-radius:8px'>
-                <div style='font-weight:600;margin-bottom:8px'>🚀 Progression Path</div>
-                <div style='opacity:0.9'>{insights['skill_progression']}</div>
-            </div>
-            <div style='background:rgba(255,255,255,0.1);padding:15px;border-radius:8px'>
-                <div style='font-weight:600;margin-bottom:8px'>📊 Market Intelligence</div>
-                <div style='opacity:0.9'>{insights['market_trends']}</div>
-            </div>
-            <div style='background:rgba(255,255,255,0.1);padding:15px;border-radius:8px'>
-                <div style='font-weight:600;margin-bottom:8px'>🎯 Success Probability</div>
-                <div style='opacity:0.9'>{insights['success_probability']}</div>
-            </div>
-        </div>
-    </div>
-    """
-
-def get_recommendations(skills_input: str, experience_level: str, time_available: str, interests: str) -> Tuple[str, str]:
-    """Main recommendation function with enhanced error handling"""
-    start_time = time.time()
-    
-    print(f"\n🎯 NEW RECOMMENDATION REQUEST:")
-    print(f"   Skills: {skills_input}")
-    print(f"   Level: {experience_level}")
-    print(f"   Time: {time_available}")
-    print(f"   Interests: {interests}")
-    
-    # Input validation
-    if not skills_input.strip():
-        error_msg = """
-        <div style='background:#fff3cd;border:1px solid #ffeaa7;color:#856404;padding:20px;border-radius:8px;text-align:center'>
-            ⚠️ <strong>Please enter at least one skill</strong><br>
-            <small>Example: Python, JavaScript, React, CSS</small>
-        </div>
-        """
-        return error_msg, ""
+        time_score = 0.1  # Default
+        for user_time, challenge_map in time_mapping.items():
+            if user_time in user_profile.time_available:
+                time_score = challenge_map.get(challenge.time_estimate, 0.5) * 0.1
+                break
+        
+        score += time_score
+        factors.append(f"Time fit: {user_profile.time_available} vs {challenge.time_estimate}")
+        
+        return min(score, 1.0), factors
     
-    try:
-        # Parse and clean skills
-        skills = [skill.strip() for skill in skills_input.split(',') if skill.strip()]
-        
-        # Create comprehensive user profile
-        user_profile = {
-            'skills': skills,
-            'experience_level': experience_level,
-            'time_available': time_available,
-            'interests': interests
-        }
+    async def get_personalized_recommendations(self, user_profile: UserProfile, query: str = "") -> Dict[str, Any]:
+        """Get personalized recommendations using real MCP data"""
+        
+        start_time = datetime.now()
+        
+        # Fetch real challenges with technology filter if possible
+        query_techs = self.extract_technologies_from_query(query)
+        challenges = await self.fetch_challenges(limit=100, technologies=query_techs if query_techs else None)
+        
+        if not challenges:
+            # Fallback message
+            return {
+                "recommendations": [],
+                "insights": {
+                    "total_challenges": 0,
+                    "processing_time": f"{(datetime.now() - start_time).total_seconds():.3f}s",
+                    "data_source": "MCP (No data available)",
+                    "message": "Unable to fetch real challenge data. Please check MCP connection."
+                }
+            }
+        
+        # Score and rank challenges
+        scored_challenges = []
+        for challenge in challenges:
+            score, factors = self.calculate_compatibility_score(challenge, user_profile, query)
+            challenge.compatibility_score = score
+            challenge.rationale = f"Score: {score:.1%}. " + "; ".join(factors[:2])
+            scored_challenges.append(challenge)
         
-        # Get AI recommendations
-        recommendations = intelligence_engine.get_personalized_recommendations(user_profile, interests)
-        insights = intelligence_engine.get_user_insights(user_profile)
-        
-        # Format results
-        if recommendations:
-            recommendations_html = f"""
-            <div style='background:#d4edda;border:1px solid #c3e6cb;color:#155724;padding:15px;border-radius:8px;margin-bottom:20px;text-align:center'>
-                ✅ <strong>Found {len(recommendations)} perfect matches for your profile!</strong><br>
-                <small>Personalized using AI analysis of {len(skills)} skills and {experience_level} experience level</small>
-            </div>
-            """
-            for challenge in recommendations:
-                recommendations_html += format_challenge_card(challenge)
-        else:
-            recommendations_html = """
-            <div style='background:#f8d7da;border:1px solid #f5c6cb;color:#721c24;padding:20px;border-radius:8px;text-align:center'>
-                🔍 <strong>No perfect matches found</strong><br>
-                <small>Try different skills, experience level, or interests</small>
-            </div>
-            """
-        
-        insights_html = format_insights_panel(insights)
-        
-        processing_time = round(time.time() - start_time, 2)
-        print(f"✅ Request completed successfully in {processing_time}s")
-        print(f"📊 Returned {len(recommendations)} recommendations with comprehensive insights\n")
-        
-        return recommendations_html, insights_html
-        
-    except Exception as e:
-        error_msg = f"""
-        <div style='background:#f8d7da;border:1px solid #f5c6cb;color:#721c24;padding:20px;border-radius:8px;text-align:center'>
-            ❌ <strong>Processing Error</strong><br>
-            <small>{str(e)}</small><br>
-            <small>Please try again or contact support</small>
-        </div>
-        """
-        print(f"❌ Error processing request: {str(e)}")
-        return error_msg, ""
+        # Sort by compatibility score
+        scored_challenges.sort(key=lambda x: x.compatibility_score, reverse=True)
+        
+        # Take top 5 recommendations
+        recommendations = scored_challenges[:5]
+        
+        # Get skills for gap analysis
+        skills = await self.fetch_skills()
+        
+        # Processing time
+        processing_time = (datetime.now() - start_time).total_seconds()
+        
+        return {
+            "recommendations": [asdict(rec) for rec in recommendations],
+            "insights": {
+                "total_challenges": len(challenges),
+                "average_score": sum(c.compatibility_score for c in challenges) / len(challenges),
+                "processing_time": f"{processing_time:.3f}s",
+                "data_source": "Real Topcoder MCP",
+                "top_score": recommendations[0].compatibility_score if recommendations else 0,
+                "skills_available": len(skills),
+                "technologies_detected": query_techs,
+                "cache_status": "Fresh data" if not self.cache_expiry else "Cached data"
+            }
+        }
 
-def chat_with_agent(message: str, history: List[Tuple[str, str]]) -> Tuple[List[Tuple[str, str]], str]:
-    """Enhanced chat functionality"""
-    print(f"💬 Chat: {message}")
+# Example usage and testing
+async def test_real_mcp_engine():
+    """Test the real MCP integration"""
     
-    # Enhanced response system
-    responses = {
-        "hello": "Hi there! 🚀 I'm your Topcoder Challenge Intelligence Assistant! I help developers like you discover perfect challenges that match your skills and career goals. Try the recommendations tab above to get started!",
-        "help": "I can help you:\n• Find challenges perfectly matched to your skills\n• Analyze your developer profile and strengths\n• Recommend career growth paths\n• Provide market insights and trends\n\nUse the 'Challenge Recommendations' tab to get personalized suggestions!",
-        "python": "Python is fantastic! 🐍 It's one of the most in-demand skills right now. I have many Python challenges from web APIs to data science projects. What's your experience level and what type of Python work interests you most?",
-        "react": "React is hot in the market! ⚛️ Perfect choice for frontend development. I can recommend React challenges from component libraries to full-stack applications. The demand for React developers is consistently high!",
-        "javascript": "JavaScript opens so many doors! 🌟 From frontend to backend (Node.js), it's incredibly versatile. What type of JavaScript projects interest you most - web apps, APIs, or maybe mobile development?",
-        "beginner": "Welcome to your development journey! 🌱 I specialize in finding beginner-friendly challenges that build confidence while teaching real-world skills. What technologies are you most excited to learn?",
-        "intermediate": "Great level to be at! 🚀 You're ready for some really interesting challenges. I can help you find projects that push your skills to the next level. What's your main focus area?",
-        "advanced": "Impressive! 💪 You're ready for complex, high-value challenges. I can recommend advanced projects with substantial prizes and technical depth. What cutting-edge technologies interest you?",
-        "test": "All systems running perfectly! ✅\n• Intelligence Engine: Operational\n• Challenge Database: 6 sample challenges loaded\n• Recommendation Algorithm: Multi-factor scoring active\n• Performance: Sub-2-second response times\n\nReady to find your perfect challenge!",
-        "skills": "I analyze many skills including:\n• Frontend: React, JavaScript, CSS, HTML, Vue, Angular\n• Backend: Python, Java, Node.js, PHP, C#\n• Database: SQL, MongoDB, PostgreSQL, Redis\n• Cloud: AWS, Azure, Docker, Kubernetes\n• Design: UI/UX, Figma, Adobe Creative Suite\n\nWhat's your strongest skill area?",
-        "prize": "Challenge prizes in our database range from $2,000 to $7,500! 💰 Higher prizes typically mean:\n• More complex technical requirements\n• Longer timelines (2-4 weeks)\n• Advanced skill levels needed\n• Greater competition\n\nI match you with challenges where you have the best chance of success!"
-    }
+    print("🚀 Testing Real MCP Integration")
+    print("=" * 50)
     
-    # Find best response using keyword matching
-    message_lower = message.lower()
-    response = "That's a great question! For the most personalized help, try using the 'Challenge Recommendations' tab above where I can analyze your specific skills and goals. You can also ask me about specific technologies, experience levels, or challenge types!"
+    engine = RealMCPIntelligenceEngine()
     
-    # Smart keyword matching
-    for keyword, reply in responses.items():
-        if keyword in message_lower:
-            response = reply
-            break
+    # Wait for connection
+    await asyncio.sleep(2)
     
-    # Add to chat history
-    history.append((message, response))
-    print("✅ Chat response generated")
+    if not engine.is_connected:
+        print("❌ MCP connection failed - check authentication")
+        return
     
-    return history, ""
-
-def create_interface():
-    """Create enhanced Gradio interface for version 5.39.0"""
-    print("🎨 Creating Gradio interface...")
+    # Test user profile
+    user_profile = UserProfile(
+        skills=["Python", "JavaScript", "API"],
+        experience_level="Intermediate",
+        time_available="4-8 hours",
+        interests=["web development", "API integration"]
+    )
     
-    # Custom CSS for better appearance
-    custom_css = """
-    .gradio-container {
-        max-width: 1400px !important;
-        margin: 0 auto !important;
-    }
-    .tab-nav {
-        border-radius: 8px !important;
-    }
-    .submit-btn {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-        border: none !important;
-    }
-    """
+    # Test recommendations
+    print("\n🧠 Getting Real Recommendations...")
+    recommendations = await engine.get_personalized_recommendations(
+        user_profile, 
+        "I want to work on Python API challenges"
+    )
     
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="🚀 Topcoder Challenge Intelligence Assistant",
-        css=custom_css
-    ) as interface:
-        
-        # Header with enhanced styling
-        gr.Markdown("""
-        # 🚀 Topcoder Challenge Intelligence Assistant
-        
-        ### **Your AI-powered guide to discovering and succeeding in Topcoder challenges**
-        
-        Get **personalized challenge recommendations** powered by advanced algorithms that analyze your skills, experience level, and career goals. Built with the **Model Context Protocol (MCP)** for real-time challenge data.
-        
-        ---
-        """)
-        
-        with gr.Tabs():
-            # Tab 1: Enhanced Challenge Recommendations
-            with gr.TabItem("🎯 Personalized Recommendations", elem_id="recommendations-tab"):
-                gr.Markdown("### 🤖 AI-Powered Challenge Discovery")
-                
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("**Tell me about yourself:**")
-                        
-                        skills_input = gr.Textbox(
-                            label="🛠️ Your Skills & Technologies",
-                            placeholder="Python, React, JavaScript, CSS, Git, Docker...",
-                            info="Enter your skills separated by commas",
-                            lines=2,
-                            value="Python, JavaScript"  # Default for quick testing
-                        )
-                        
-                        experience_level = gr.Dropdown(
-                            choices=["Beginner", "Intermediate", "Advanced"],
-                            label="📊 Experience Level",
-                            value="Intermediate",
-                            info="Your overall development experience"
-                        )
-                        
-                        time_available = gr.Dropdown(
-                            choices=["1-5 days", "1-2 weeks", "2-4 weeks", "1+ months"],
-                            label="⏰ Time Available",
-                            value="1-2 weeks",
-                            info="How much time can you dedicate?"
-                        )
-                        
-                        interests = gr.Textbox(
-                            label="🎯 Current Interests & Goals",
-                            placeholder="web development, mobile apps, API development, UI/UX...",
-                            info="What type of projects excite you most?",
-                            lines=2,
-                            value="web development"  # Default for testing
-                        )
-                        
-                        recommend_btn = gr.Button(
-                            "🚀 Get My Personalized Recommendations", 
-                            variant="primary", 
-                            size="lg",
-                            elem_classes="submit-btn"
-                        )
-                        
-                        gr.Markdown("""
-                        **💡 Pro Tips:**
-                        - Be specific with your skills for better matches
-                        - Include both technical and soft skills
-                        - Mention any particular domains you're interested in
-                        """)
-                    
-                    with gr.Column(scale=2):
-                        insights_output = gr.HTML(
-                            label="🧠 Your Intelligence Profile",
-                            visible=True
-                        )
-                        recommendations_output = gr.HTML(
-                            label="🏆 Recommended Challenges",
-                            visible=True
-                        )
-                
-                # Connect the recommendation system
-                recommend_btn.click(
-                    get_recommendations,
-                    inputs=[skills_input, experience_level, time_available, interests],
-                    outputs=[recommendations_output, insights_output]
-                )
-            
-            # Tab 2: Enhanced Chat Assistant
-            with gr.TabItem("💬 AI Assistant Chat"):
-                gr.Markdown("""
-                ### 🤖 Chat with Your Intelligence Assistant
-                
-                Ask me anything about Topcoder challenges, skill development, or career growth. I'm here to help!
-                """)
-                
-                chatbot = gr.Chatbot(
-                    label="🚀 Topcoder Intelligence Assistant",
-                    height=450,
-                    placeholder="Hi! Ask me about challenges, skills, career advice, or anything else!",
-                    show_label=True
-                )
-                
-                with gr.Row():
-                    chat_input = gr.Textbox(
-                        placeholder="Try: 'hello', 'help', 'python challenges', 'what skills are hot?', or 'test'",
-                        container=False,
-                        scale=4,
-                        show_label=False
-                    )
-                    chat_btn = gr.Button("Send", variant="primary", scale=1)
-                
-                # Enhanced chat examples
-                gr.Examples(
-                    examples=[
-                        "Hello! How can you help me?",
-                        "What Python challenges do you recommend?",
-                        "I'm a beginner, where should I start?", 
-                        "What skills are most in demand?",
-                        "Show me high-prize challenges",
-                        "Test your systems"
-                    ],
-                    inputs=chat_input
-                )
-                
-                # Connect chat functionality
-                chat_btn.click(
-                    chat_with_agent,
-                    inputs=[chat_input, chatbot],
-                    outputs=[chatbot, chat_input]
-                )
-                
-                chat_input.submit(
-                    chat_with_agent,
-                    inputs=[chat_input, chatbot],
-                    outputs=[chatbot, chat_input]
-                )
-            
-            # Tab 3: Performance & Technical Details
-            with gr.TabItem("⚡ System Performance"):
-                gr.Markdown("""
-                ### 🧪 Test Intelligence Engine Performance
-                
-                Monitor system performance and verify all components are working correctly.
-                """)
-                
-                with gr.Row():
-                    with gr.Column():
-                        test_btn = gr.Button("🧪 Run Comprehensive Performance Test", variant="secondary", size="lg")
-                        benchmark_btn = gr.Button("📊 Run Benchmark Test", variant="secondary")
-                        
-                    with gr.Column():
-                        test_output = gr.Textbox(
-                            label="📋 Test Results & Performance Metrics", 
-                            lines=12,
-                            show_label=True
-                        )
-                
-                def run_performance_test():
-                    """Comprehensive system performance test"""
-                    results = []
-                    results.append("🧪 COMPREHENSIVE PERFORMANCE TEST")
-                    results.append("=" * 50)
-                    results.append(f"⏰ Started at: {time.strftime('%Y-%m-%d %H:%M:%S')}")
-                    results.append("")
-                    
-                    total_start = time.time()
-                    
-                    # Test 1: Basic Intelligence Engine
-                    results.append("🔍 Test 1: Basic Recommendation Engine")
-                    start = time.time()
-                    test_profile = {
-                        'skills': ['Python', 'React'],
-                        'experience_level': 'Intermediate',
-                        'time_available': '1-2 weeks',
-                        'interests': 'web development'
-                    }
-                    recs = intelligence_engine.get_personalized_recommendations(test_profile)
-                    test1_time = round(time.time() - start, 3)
-                    results.append(f"   ✅ Generated {len(recs)} recommendations in {test1_time}s")
-                    results.append(f"   📊 Top match: {recs[0].title} ({recs[0].score}%)")
-                    results.append("")
-                    
-                    # Test 2: Complex Profile Analysis
-                    results.append("🔍 Test 2: Complex Profile Analysis")
-                    start = time.time()
-                    complex_profile = {
-                        'skills': ['Python', 'JavaScript', 'React', 'Docker', 'PostgreSQL', 'AWS'],
-                        'experience_level': 'Advanced',
-                        'time_available': '2-4 weeks',
-                        'interests': 'full-stack development microservices cloud architecture'
-                    }
-                    recs = intelligence_engine.get_personalized_recommendations(complex_profile, complex_profile['interests'])
-                    test2_time = round(time.time() - start, 3)
-                    results.append(f"   ✅ Processed {len(complex_profile['skills'])} skills in {test2_time}s")
-                    results.append(f"   🎯 Best match score: {recs[0].score}%")
-                    results.append("")
-                    
-                    # Test 3: Insights Generation
-                    results.append("🔍 Test 3: User Insights Generation")
-                    start = time.time()
-                    insights = intelligence_engine.get_user_insights(complex_profile)
-                    test3_time = round(time.time() - start, 3)
-                    results.append(f"   ✅ Generated comprehensive insights in {test3_time}s")
-                    results.append(f"   👤 Profile Type: {insights['profile_type']}")
-                    results.append(f"   🎯 Success Rate: {insights['success_probability']}")
-                    results.append("")
-                    
-                    # Test 4: Load Testing
-                    results.append("🔍 Test 4: Load Testing (10 concurrent requests)")
-                    start = time.time()
-                    for i in range(10):
-                        test_profile_load = {
-                            'skills': ['Python', 'JavaScript', 'React'][:(i%3)+1],
-                            'experience_level': ['Beginner', 'Intermediate', 'Advanced'][i%3],
-                            'interests': 'testing'
-                        }
-                        intelligence_engine.get_personalized_recommendations(test_profile_load)
-                    test4_time = round(time.time() - start, 3)
-                    avg_time = round(test4_time / 10, 3)
-                    results.append(f"   ✅ Completed 10 requests in {test4_time}s")
-                    results.append(f"   ⚡ Average response time: {avg_time}s")
-                    results.append("")
-                    
-                    # Summary
-                    total_time = round(time.time() - total_start, 3)
-                    results.append("📊 PERFORMANCE SUMMARY")
-                    results.append("-" * 30)
-                    results.append(f"🕐 Total Test Duration: {total_time}s")
-                    results.append(f"⚡ Average Response Time: {round((test1_time + test2_time + test3_time) / 3, 3)}s")
-                    results.append(f"🧠 Intelligence Engine: ✅ OPERATIONAL")
-                    results.append(f"💾 Memory Usage: ✅ OPTIMAL")
-                    results.append(f"🔍 Algorithm Accuracy: ✅ HIGH")
-                    results.append(f"🚀 Ready for Production: ✅ YES")
-                    results.append("")
-                    results.append("🎯 All systems performing excellently!")
-                    
-                    return "\n".join(results)
-                
-                def run_benchmark_test():
-                    """Quick benchmark test"""
-                    results = []
-                    results.append("📊 QUICK BENCHMARK TEST")
-                    results.append("=" * 30)
-                    
-                    start = time.time()
-                    test_profile = {'skills': ['Python'], 'experience_level': 'Intermediate'}
-                    recs = intelligence_engine.get_personalized_recommendations(test_profile)
-                    benchmark_time = round(time.time() - start, 3)
-                    
-                    results.append(f"⚡ Response Time: {benchmark_time}s")
-                    results.append(f"🎯 Recommendations: {len(recs)}")
-                    results.append(f"📊 Status: {'✅ EXCELLENT' if benchmark_time < 1.5 else '⚠️ ACCEPTABLE' if benchmark_time < 3 else '❌ SLOW'}")
-                    
-                    return "\n".join(results)
-                
-                # Connect test functions
-                test_btn.click(run_performance_test, outputs=test_output)
-                benchmark_btn.click(run_benchmark_test, outputs=test_output)
-            
-            # Tab 4: About & Documentation
-            with gr.TabItem("ℹ️ About & Technical Details"):
-                gr.Markdown("""
-                ## 🚀 About This AI Agent
-                
-                ### 🎯 **Mission Statement**
-                This **Topcoder Challenge Intelligence Assistant** revolutionizes how developers discover and engage with coding challenges. Instead of browsing through thousands of opportunities manually, get AI-powered recommendations tailored to your exact skills, experience level, and career goals.
-                
-                ### ✨ **Core Capabilities**
-                
-                #### 🧠 **Advanced Intelligence Engine**
-                - **Multi-Factor Scoring Algorithm**: Analyzes skills, experience, time availability, and interests
-                - **Natural Language Processing**: Understands your goals and matches them with relevant challenges
-                - **Market Intelligence**: Provides insights on trending technologies and career opportunities
-                - **Success Probability Analysis**: Calculates your likelihood of success for each challenge
-                
-                #### 🎯 **Personalized Recommendations**
-                - **Smart Skill Matching**: Advanced algorithms consider skill overlaps and related technologies
-                - **Experience-Level Optimization**: Matches challenges to your exact proficiency level
-                - **Interest Alignment**: Finds projects that match your passions and career goals
-                - **Time-Constraint Awareness**: Recommends challenges that fit your available time
-                
-                #### 📊 **Comprehensive Analytics**
-                - **Developer Profile Analysis**: Identifies your strengths and growth areas
-                - **Market Trend Insights**: Shows current demand for your skills
-                - **Career Progression Paths**: Suggests next steps for professional development
-                - **Success Metrics**: Tracks compatibility scores and success probability
-                
-                ### 🔧 **Technical Architecture**
-                
-                #### **Model Context Protocol (MCP) Integration**
-                ```
-                Server Endpoint: https://api.topcoder-dev.com/v6/mcp
-                Protocol: JSON-RPC 2.0
-                Transport: HTTP with SSE capability
-                Authentication: Session-based (when available)
-                ```
-                
-                #### **Available MCP Tools**
-                - **`query-tc-challenges`**: Access to 4,596+ active challenges with rich metadata
-                - **`query-tc-skills`**: Comprehensive database of 6,535+ categorized skills
-                - **Real-time Updates**: Live challenge data and registration statistics
-                
-                #### **Intelligence Algorithm**
-                ```python
-                def calculate_compatibility_score(user_profile, challenge):
-                    # Multi-factor scoring system:
-                    skill_match_score = analyze_skill_overlap(user_skills, challenge_tech) * 0.4
-                    experience_score = calculate_level_compatibility(user_level, challenge_difficulty) * 0.3
-                    interest_score = nlp_analyze_relevance(user_interests, challenge_content) * 0.2
-                    market_score = assess_market_factors(challenge_prize, competition) * 0.1
-                    
-                    return skill_match_score + experience_score + interest_score + market_score
-                ```
-                
-                ### 🚀 **Deployment & Performance**
-                
-                #### **Platform Specifications**
-                - **Hosting**: Hugging Face Spaces with CPU Basic hardware
-                - **Framework**: Gradio 5.39.0 for optimal user experience
-                - **Dependencies**: Minimal, Windows-compatible package selection
-                - **Performance**: Sub-2-second response times for recommendations
-                
-                #### **Quality Metrics**
-                - **Recommendation Accuracy**: 90%+ user satisfaction in testing
-                - **System Uptime**: 99.9% availability target
-                - **Response Time**: < 2 seconds for standard queries
-                - **Memory Efficiency**: Optimized for CPU Basic constraints
-                
-                ### 💼 **Business Value Proposition**
-                
-                #### **For Individual Developers**
-                - **80% Time Savings**: Skip manual challenge browsing
-                - **Higher Success Rates**: Match challenges to your exact skill level
-                - **Accelerated Growth**: Structured progression paths and skill recommendations
-                - **Market Intelligence**: Stay informed about in-demand technologies
-                
-                #### **For the Topcoder Ecosystem**
-                - **Improved Engagement**: Better challenge-developer matching increases participation
-                - **Quality Improvement**: More qualified participants lead to better solutions
-                - **Data Insights**: Analytics help understand developer needs and market trends
-                - **Community Growth**: Easier entry point for new developers
-                
-                ### 🔮 **Future Roadmap**
-                
-                #### **Planned Enhancements**
-                - **Team Formation AI**: Intelligent matching for collaborative challenges
-                - **Skill Gap Analysis**: Detailed assessments for career planning
-                - **Progress Tracking**: Long-term development monitoring
-                - **Community Features**: Developer networking and mentorship matching
-                
-                #### **Technical Expansion**
-                - **Multi-MCP Integration**: GitHub, web search, and calendar integration
-                - **Advanced ML Models**: Predictive success modeling and personalization
-                - **API Development**: RESTful endpoints for third-party integrations
-                - **Mobile Application**: Native iOS and Android apps
-                
-                ### 🏆 **Awards & Recognition**
-                
-                **Built for the Topcoder MCP Challenge** - Showcasing the power of the Model Context Protocol for creating intelligent, context-aware applications that genuinely improve developer experiences.
-                
-                ---
-                
-                <div style='background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; text-align: center; margin: 20px 0;'>
-                    <h3 style='margin: 0; color: white;'>🤖 Powered by Model Context Protocol (MCP)</h3>
-                    <p style='margin: 10px 0 0 0; opacity: 0.9;'>Empowering developers to discover their next great challenge and accelerate career growth through intelligent AI assistance.</p>
-                </div>
-                """)
-        
-        # Enhanced footer
-        gr.Markdown("""
-        ---
-        <div style='text-align: center; opacity: 0.8; font-size: 0.9em; padding: 20px;'>
-            <strong>🚀 Topcoder Challenge Intelligence Assistant</strong><br>
-            🤖 Powered by Model Context Protocol (MCP) | 🎯 Deployed on Hugging Face Spaces | ⚡ Built with Gradio 5.39.0<br>
-            <em>Revolutionizing challenge discovery through AI-powered personalization</em>
-        </div>
-        """)
+    print(f"\n📊 Results:")
+    print(f"   Challenges found: {recommendations['insights']['total_challenges']}")
+    print(f"   Processing time: {recommendations['insights']['processing_time']}")
+    print(f"   Data source: {recommendations['insights']['data_source']}")
     
-    print("✅ Enhanced Gradio interface created successfully!")
-    return interface
+    for i, rec in enumerate(recommendations['recommendations'][:3], 1):
+        print(f"\n   {i}. {rec['title']}")
+        print(f"      Score: {rec['compatibility_score']:.1%}")
+        print(f"      Technologies: {', '.join(rec['technologies'][:3])}")
 
-# Launch the application
 if __name__ == "__main__":
-    print("\n" + "="*60)
-    print("🚀 TOPCODER CHALLENGE INTELLIGENCE ASSISTANT")
-    print("🤖 Enhanced Version with Gradio 5.39.0")
-    print("="*60)
-    
-    try:
-        interface = create_interface()
-        print("\n🎯 Starting enhanced Gradio server...")
-        print("📊 Initializing AI intelligence engine...")
-        print("🚀 Preparing personalized recommendation system...")
-        
-        interface.launch(
-            share=False,           # Set to True to get public shareable link
-            debug=True,            # Show detailed logs for troubleshooting
-            show_error=True,       # Display any errors in the UI
-            server_port=7860,      # Standard Gradio port
-            show_api=False,        # Hide API documentation for cleaner interface
-            favicon_path=None,     # Can add custom favicon later
-            max_threads=10         # Handle multiple concurrent users
-        )
-        
-    except Exception as e:
-        print(f"❌ Error starting application: {str(e)}")
-        print("\n🔧 Troubleshooting suggestions:")
-        print("1. Verify all dependencies are installed correctly")
-        print("2. Check if port 7860 is available (try different port if needed)")
-        print("3. Ensure you're in the correct virtual environment")
-        print("4. Try running: pip install --upgrade gradio httpx python-dotenv")
+    asyncio.run(test_real_mcp_engine())