Initial commit: Agentic Skill Builder for MCP Hackathon 2025

.env

@@ -0,0 +1,22 @@
+# Azure Cosmos DB Configuration
+COSMOS_ENDPOINT=cosmosgremlinai.gremlin.cosmosdb.azure.com
+COSMOS_USERNAME=/dbs/graphdb/colls/ProductsGraph
+COSMOS_PASSWORD=vIoky0D389svaUPQSMqUxf4O3eqQpyOTHWt88izYnVDyLz05q6O7UVEYx7v2pGFBQFGuRWyP6ztlACDbbsMTSw==
+COSMOS_DATABASE=graphdb
+COSMOS_GRAPH=ProductsGraph
+
+# Azure OpenAI Configuration
+AZURE_OPENAI_ENDPOINT="https://aihubeastus26267492086.openai.azure.com/"
+AZURE_OPENAI_KEY="2oQRUb4k4Ws3oqaOJyC4ybWCPT3nmTpmIlAXvGzYRvWYFfCDsE8GJQQJ99BEACHYHv6XJ3w3AAAAACOGH87p"
+AZURE_OPENAI_API_VERSION="2024-12-01-preview"
+
+# LLM Model Configuration
+AZURE_OPENAI_LLM_DEPLOYMENT="gpt-4.1"
+AZURE_OPENAI_LLM_MODEL="gpt-4.1"
+
+# Embeddings Model Configuration  
+AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT="text-embedding-3-small"
+AZURE_OPENAI_EMBEDDINGS_MODEL="text-embedding-3-small"
+
+# Graphiti Configuration
+GRAPHITI_GROUP_NAME="manybirds_graph"

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

PRD.md

@@ -0,0 +1,168 @@
+
+
+# Product Requirements Document (PRD)
+
+## Product Name
+
+**Agentic Skill Builder**
+
+## Purpose
+
+Agentic Skill Builder is an AI-powered microlearning platform designed to help users learn new skills through bite-sized lessons and adaptive quizzes. The platform leverages Azure OpenAI for content generation, Gradio for user interaction, and Model Context Protocol (MCP) for agent interoperability.
+
+---
+
+## 1. Objectives
+
+- **Deliver Personalized Microlearning:** Provide users with concise, high-quality lessons and adaptive quizzes tailored to their chosen skill.
+- **Showcase Agentic Workflows:** Demonstrate how multiple AI agents (lesson generator, quiz generator, progress tracker) can collaborate to enhance learning.
+- **Enable Interoperability via MCP:** Allow external agents and applications to interact with the learning modules and user progress through MCP endpoints.
+- **Offer a Polished, User-Friendly Interface:** Use Gradio to deliver an intuitive, engaging, and accessible experience.
+
+---
+
+## 2. Target Users
+
+- **Lifelong Learners:** Individuals seeking to acquire or reinforce skills in short, focused sessions.
+- **Hackathon Participants:** Developers and researchers interested in agentic workflows and MCP integration.
+- **Educational Institutions:** Teachers and trainers looking for AI-driven microlearning tools.
+- **Integration Developers:** Teams building apps that could benefit from plug-and-play learning modules.
+
+---
+
+## 3. Features \& Requirements
+
+### 3.1 Core Features
+
+#### 3.1.1 Skill Selection
+
+- Users can select from a list of predefined skills (e.g., Python, Spanish, Public Speaking) or enter a custom skill/topic.
+
+
+#### 3.1.2 Micro-Lesson Delivery
+
+- For the chosen skill, the system generates and presents a concise, focused lesson (text, optionally with links to videos or code snippets).
+- Lessons are generated dynamically using Azure OpenAI.
+
+
+#### 3.1.3 Adaptive Quiz
+
+- After each lesson, users receive a short quiz (e.g., multiple choice, fill-in-the-blank) tailored to the lesson content.
+- The quiz adapts in difficulty based on user performance over time.
+
+
+#### 3.1.4 Progress Tracking
+
+- The system tracks user progress (e.g., lessons completed, quiz accuracy, streaks).
+- Progress is displayed visually (e.g., progress bars, charts).
+
+
+#### 3.1.5 Recommendations
+
+- Based on performance, the system recommends the next lesson, a review session, or an increased difficulty level.
+
+
+### 3.2 Agentic Architecture
+
+- **Lesson Agent:** Generates concise lessons for the selected skill.
+- **Quiz Agent:** Creates contextually relevant quizzes based on the lesson.
+- **Progress Agent:** Monitors and updates user progress, provides feedback, and recommends next steps.
+- **Orchestrator:** Coordinates the flow between agents and the user interface.
+
+
+### 3.3 MCP Integration
+
+- Expose endpoints for:
+    - Fetching the next lesson for a user/skill.
+    - Retrieving user progress data.
+    - Submitting quiz results.
+- Ensure endpoints are documented and compatible with the Model Context Protocol.
+
+
+### 3.4 User Interface
+
+- **Built with Gradio:**
+    - Step-by-step workflow: Skill selection → Lesson → Quiz → Feedback/Progress.
+    - Clean, accessible design with clear navigation.
+    - Responsive for desktop and mobile.
+
+---
+
+## 4. Non-Functional Requirements
+
+- **Performance:** Lessons and quizzes should be generated in under 5 seconds.
+- **Scalability:** Support at least 100 concurrent users for demo purposes.
+- **Security:** User data (progress, answers) is stored securely and not shared without consent.
+- **Accessibility:** UI should be usable with screen readers and keyboard navigation.
+- **Reliability:** System should handle API failures gracefully and provide user-friendly error messages.
+
+---
+
+## 5. Optional \& Stretch Features
+
+- **Speech-to-Text Input:** For language practice, allow users to answer quizzes verbally.
+- **Leaderboard:** Display top learners (opt-in).
+- **Daily Reminders:** Send notifications or emails to encourage regular learning.
+- **Custom Content Upload:** Allow educators to add their own lesson modules.
+- **Multi-modal Lessons:** Incorporate images, audio, or video if supported by Azure OpenAI.
+
+---
+
+## 6. Technical Stack
+
+- **Backend:** Azure OpenAI (GPT-3.5, GPT-4, or GPT-4o)
+- **Frontend:** Gradio (Python)
+- **MCP Integration:** Gradio MCP server functionality
+- **Data Storage:** In-memory or lightweight database (for hackathon demo)
+- **Deployment:** Hugging Face Spaces or Azure App Service
+
+---
+
+## 7. Success Metrics
+
+- **User Engagement:** Number of lessons/quizzes completed per user.
+- **Learning Outcomes:** Improvement in quiz scores over sessions.
+- **MCP Usage:** Number of successful external calls to MCP endpoints.
+- **User Satisfaction:** Positive feedback from hackathon judges and users.
+
+---
+
+## 8. Risks \& Mitigations
+
+| Risk | Mitigation |
+| :-- | :-- |
+| Slow response from Azure OpenAI | Cache common lessons/quizzes, optimize prompts |
+| User data loss (demo) | Regular backups, clear communication |
+| MCP integration complexity | Use official Gradio MCP templates and docs |
+| Overly generic lessons/quizzes | Refine prompts, add manual review if possible |
+
+
+---
+
+## 9. Milestones \& Timeline
+
+| Milestone | Target Date |
+| :-- | :-- |
+| Project setup \& Azure OpenAI config | Day 1 |
+| Core agent logic implemented | Day 2 |
+| Gradio UI complete | Day 3 |
+| MCP endpoints exposed \& tested | Day 4 |
+| Polish, optional features, testing | Day 5 |
+| Submission \& documentation | Day 6 |
+
+
+---
+
+## 10. Appendix
+
+- **References:**
+    - [Gradio Documentation](https://www.gradio.app/)
+    - [Azure OpenAI Documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/)
+    - [Model Context Protocol](https://modelcontextprotocol.io/)
+- **Contact:**
+    - Hackathon team email/slack/discord
+
+---
+
+**This PRD is designed for clarity, feasibility, and alignment with hackathon goals. Let me know if you need a version tailored for a specific audience (e.g., business, technical, or educational) or want to add/remove features!**
+

README.md

@@ -0,0 +1,300 @@
+---
+title: Agentic Skill Builder - MCP Hackathon 2025
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: space_app.py
+pinned: false
+license: mit
+tags:
+  - mcp-server-track
+  - agents
+  - education
+  - microlearning
+  - azure-openai
+  - model-context-protocol
+short_description: AI-powered microlearning platform with MCP integration for the Gradio Agents & MCP Hackathon 2025
+---
+
+# 🚀 Agentic Skill Builder
+
+**Track:** mcp-server-track
+
+An AI-powered microlearning platform that leverages Azure OpenAI, Gradio, and Model Context Protocol (MCP) to deliver personalized bite-sized lessons and adaptive quizzes.
+
+🎓 **Submitted for the Gradio Agents & MCP Hackathon 2025** 🚀
+
+## 🎬 Demo Video
+
+**MCP Server in Action:** [Demo Video Link](https://your-demo-video-link.com)
+
+*Note: The video demonstrates the MCP server endpoints being used by various MCP clients, showcasing the seamless integration between the Gradio interface and Model Context Protocol functionality.*
+
+## 🏆 Hackathon Highlights
+
+This submission demonstrates several key innovations for the **Gradio Agents & MCP Hackathon 2025**:
+
+### 🤖 **Track 1: MCP Server/Tool**
+- ✅ **Dual-Purpose Application**: Single app serving both Gradio interface AND MCP server
+- ✅ **Full MCP Protocol Implementation**: Complete endpoints for lesson generation, progress tracking, and quiz submission
+- ✅ **External Agent Integration**: Ready for use by Claude Desktop, Cursor, or any MCP client
+
+### 🧠 **Agentic Architecture Innovation**
+- **🎓 Lesson Agent**: AI-powered content generation with Azure OpenAI
+- **🧪 Quiz Agent**: Adaptive quiz creation based on lesson content and user performance  
+- **📊 Progress Agent**: Smart difficulty adjustment and learning recommendations
+- **🎯 Orchestrator**: Seamless coordination between all agents and user interactions
+
+### 🔗 **MCP Endpoints Showcase**
+- `GET /mcp/skills` - Discover available learning skills
+- `POST /mcp/lesson/generate` - Generate personalized micro-lessons
+- `GET /mcp/progress/{user_id}` - Access detailed learning analytics
+- `POST /mcp/quiz/submit` - Submit and score quiz attempts
+
+### 💡 **Unique Features**
+- **Microlearning Focus**: 3-5 minute bite-sized lessons perfect for busy learners
+- **Adaptive Difficulty**: AI automatically adjusts based on quiz performance
+- **Any Skill Learning**: Works for both predefined and custom skills
+- **Real-time Analytics**: Live progress tracking and personalized recommendations
+
+## ✨ Features
+
+- 🎯 **Skill Selection**: Choose from predefined skills or enter custom topics
+- 📚 **AI-Generated Micro-Lessons**: Concise, focused lessons (3-5 minutes)
+- 🧠 **Adaptive Quizzes**: Smart quizzes that adjust difficulty based on performance
+- 📊 **Progress Tracking**: Visual progress monitoring and analytics
+- 🤖 **Agentic Architecture**: Multiple specialized AI agents working together
+- 🔗 **MCP Integration**: Model Context Protocol endpoints for external integration
+- 🎨 **Modern UI**: Clean, responsive Gradio interface
+
+## 🏗️ Architecture
+
+The application uses an agentic architecture with specialized AI agents:
+
+- **Lesson Agent**: Generates personalized micro-lessons
+- **Quiz Agent**: Creates adaptive quizzes based on lesson content
+- **Progress Agent**: Tracks learning progress and provides recommendations
+- **Orchestrator**: Coordinates agent interactions and user flow
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- **Python 3.10.16** installed
+- Azure OpenAI subscription with API key
+- Access to GPT-4 model deployment
+
+### Installation
+
+1. **Clone and navigate to the project:**
+   ```powershell
+   cd c:\Users\shyamsridhar\code\hf-hackathon
+   ```
+
+2. **Create and activate a virtual environment:**
+   ```powershell
+   python -m venv .venv
+   .venv\Scripts\Activate
+   ```
+   *(On macOS/Linux, use `source .venv/bin/activate`)*
+
+3. **Install dependencies:**
+   ```powershell
+   pip install -r requirements.txt
+   ```
+
+4. **Configure environment variables:**
+   - Your `.env` file is already configured with Azure OpenAI credentials
+   - Verify the credentials are correct and models are deployed
+
+5. **Run the application:**
+   ```powershell
+   python run.py
+   ```
+
+   Choose from three options:
+   - **Option 1**: Gradio App only (recommended for demo)
+   - **Option 2**: MCP Server only
+   - **Option 3**: Both services
+
+## 🎯 Usage
+
+### Learning Flow
+
+1. **Select a Skill**: Choose from predefined skills or enter a custom topic
+2. **Read the Lesson**: Engage with AI-generated micro-content
+3. **Take the Quiz**: Test your understanding with adaptive questions
+4. **View Results**: Get detailed feedback and progress updates
+5. **Continue Learning**: Follow AI recommendations for next steps
+
+### Available Skills
+
+- Python Programming
+- Spanish Language
+- Public Speaking
+- Data Science
+- Machine Learning
+- JavaScript
+- Project Management
+- Digital Marketing
+- Creative Writing
+- Photography
+
+*Plus any custom skill you can imagine!*
+
+## 🔗 MCP Endpoints
+
+The application exposes Model Context Protocol endpoints at `http://localhost:8000`:
+
+- `GET /skills` - List available skills
+- `POST /lesson/generate` - Generate lesson for a skill
+- `GET /progress/{user_id}` - Get user progress data
+- `POST /quiz/submit` - Submit quiz results
+- `POST /quiz/generate` - Generate quiz for a lesson
+
+### API Documentation
+
+Visit `http://localhost:8000/docs` for interactive API documentation.
+
+## 📊 Progress Dashboard
+
+Track your learning journey with:
+
+- **Lessons Completed**: Number of lessons finished per skill
+- **Quiz Performance**: Average scores and improvement trends
+- **Difficulty Progression**: Automatic difficulty adjustment
+- **Learning Streaks**: Consistent learning tracking
+- **AI Recommendations**: Personalized next steps
+
+## 🔧 Configuration
+
+### Environment Variables
+
+The `.env` file contains your Azure OpenAI configuration:
+
+```properties
+# Azure OpenAI Configuration
+AZURE_OPENAI_ENDPOINT="your-endpoint"
+AZURE_OPENAI_KEY="your-api-key"
+AZURE_OPENAI_API_VERSION="2024-12-01-preview"
+AZURE_OPENAI_LLM_DEPLOYMENT="gpt-4.1"
+AZURE_OPENAI_LLM_MODEL="gpt-4.1"
+```
+
+### Optional Settings
+
+You can add these optional environment variables:
+
+```properties
+DEBUG=false
+LOG_LEVEL=INFO
+GRADIO_PORT=7860
+MCP_PORT=8000
+MAX_QUIZ_QUESTIONS=5
+DEFAULT_LESSON_DURATION=5
+```
+
+## 🧪 Development
+
+### Running in Development Mode
+
+```powershell
+# Install development dependencies
+pip install -r requirements.txt
+
+# Run with auto-reload
+python app.py
+```
+
+### Testing MCP Endpoints
+
+```bash
+# Test lesson generation
+curl -X POST "http://localhost:8000/lesson/generate" \
+  -H "Content-Type: application/json" \
+  -d '{"skill": "Python Programming", "user_id": "test_user"}'
+
+# Get user progress
+curl "http://localhost:8000/progress/test_user?skill=Python%20Programming"
+```
+
+## 📱 Deployment
+
+### Local Deployment
+
+```powershell
+python run.py
+```
+
+### Hugging Face Spaces
+
+1. Create a new Space on Hugging Face
+2. Upload your code
+3. Set environment variables in Space settings
+4. The app will auto-deploy
+
+### Azure App Service
+
+1. Create an Azure App Service
+2. Deploy using Git or ZIP
+3. Configure environment variables
+4. Set startup command: `python app.py`
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+1. **Azure OpenAI Connection Error**
+   - Verify your endpoint URL and API key
+   - Check if your model deployment is active
+   - Ensure you have sufficient quota
+
+2. **Module Import Errors**
+   - Activate your virtual environment
+   - Install requirements: `pip install -r requirements.txt`
+
+3. **Port Already in Use**
+   - Change ports in environment variables
+   - Kill existing processes: `netstat -ano | findstr :7860`
+
+### Logs
+
+Check application logs in `agentic_skill_builder.log` for detailed error information.
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## 📄 License
+
+This project is part of a hackathon submission. See the full requirements in `i dont want the code but a detailed prd document.md`.
+
+## 🏆 Hackathon Features
+
+This implementation demonstrates:
+
+- ✅ **Agentic Workflows**: Multiple AI agents collaborating
+- ✅ **Azure OpenAI Integration**: Modern SDK usage with best practices
+- ✅ **Adaptive Learning**: Smart difficulty adjustment
+- ✅ **Modern UI**: Gradio-based responsive interface
+- ✅ **MCP Protocol**: External agent integration capability
+- ✅ **Progress Analytics**: Comprehensive learning tracking
+- ✅ **Error Handling**: Robust error management and fallbacks
+
+## 📞 Support
+
+For issues or questions:
+1. Check the troubleshooting section
+2. Review the logs in `agentic_skill_builder.log`
+3. Verify your Azure OpenAI configuration
+4. Ensure all dependencies are installed correctly
+
+---
+
+**Happy Learning! 🎓**

README_spaces.md

@@ -0,0 +1,17 @@
+title: Agentic Skill Builder - MCP Hackathon 2025
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: space_app.py
+pinned: false
+license: mit
+tags:
+  - mcp-server-track
+  - agents
+  - education
+  - microlearning
+  - azure-openai
+  - model-context-protocol
+short_description: AI-powered microlearning platform with MCP integration for the Gradio Agents & MCP Hackathon 2025

app.py

@@ -0,0 +1,647 @@
+import os
+import json
+import asyncio
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+import logging
+
+from dotenv import load_dotenv
+import gradio as gr
+from openai import AzureOpenAI
+import pandas as pd
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Azure OpenAI client configuration
+client = AzureOpenAI(
+    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT", "").replace('"', ''),
+    api_key=os.getenv("AZURE_OPENAI_KEY", "").replace('"', ''),
+    api_version=os.getenv("AZURE_OPENAI_API_VERSION", "2024-12-01-preview").replace('"', ''),
+)
+
+# Model configurations
+LLM_DEPLOYMENT = os.getenv("AZURE_OPENAI_LLM_DEPLOYMENT", "gpt-4.1").replace('"', '')
+LLM_MODEL = os.getenv("AZURE_OPENAI_LLM_MODEL", "gpt-4.1").replace('"', '')
+
+@dataclass
+class UserProgress:
+    """Data class to track user learning progress"""
+    user_id: str
+    skill: str
+    lessons_completed: int = 0
+    quiz_scores: List[float] = None
+    current_difficulty: str = "beginner"
+    streak_days: int = 0
+    total_time_spent: int = 0  # minutes
+    last_activity: str = ""
+    
+    def __post_init__(self):
+        if self.quiz_scores is None:
+            self.quiz_scores = []
+    
+    def get_average_score(self) -> float:
+        """Calculate average quiz score"""
+        return sum(self.quiz_scores) / len(self.quiz_scores) if self.quiz_scores else 0.0
+    
+    def add_quiz_score(self, score: float):
+        """Add a new quiz score and update difficulty if needed"""
+        self.quiz_scores.append(score)
+        # Adaptive difficulty adjustment
+        avg_score = self.get_average_score()
+        if avg_score >= 0.8 and len(self.quiz_scores) >= 3:
+            if self.current_difficulty == "beginner":
+                self.current_difficulty = "intermediate"
+            elif self.current_difficulty == "intermediate":
+                self.current_difficulty = "advanced"
+        elif avg_score < 0.6 and len(self.quiz_scores) >= 3:
+            if self.current_difficulty == "advanced":
+                self.current_difficulty = "intermediate"
+            elif self.current_difficulty == "intermediate":
+                self.current_difficulty = "beginner"
+
+@dataclass
+class Lesson:
+    """Data class for lesson content"""
+    title: str
+    content: str
+    skill: str
+    difficulty: str
+    duration_minutes: int
+    key_concepts: List[str]
+
+@dataclass
+class Quiz:
+    """Data class for quiz content"""
+    questions: List[Dict]
+    skill: str
+    difficulty: str
+    lesson_title: str
+
+class LessonAgent:
+    """Agent responsible for generating personalized micro-lessons"""
+    
+    def __init__(self, client: AzureOpenAI):
+        self.client = client
+        self.model = LLM_DEPLOYMENT
+    
+    async def generate_lesson(self, skill: str, difficulty: str = "beginner", 
+                            previous_lessons: List[str] = None) -> Lesson:
+        """Generate a personalized micro-lesson"""
+        try:
+            previous_context = ""
+            if previous_lessons:
+                previous_context = f"\nPrevious lessons covered: {', '.join(previous_lessons[-3:])}"
+            
+            prompt = f"""
+            Create a concise, engaging micro-lesson for the skill: {skill}
+            Difficulty level: {difficulty}
+            {previous_context}
+            
+            Requirements:
+            - Lesson should be 3-5 minutes to read
+            - Include practical examples
+            - Focus on one key concept
+            - Make it actionable
+            - Include 3-5 key takeaways
+            
+            Format your response as JSON with these fields:
+            {{
+                "title": "Lesson title",
+                "content": "Main lesson content (200-400 words)",
+                "duration_minutes": 4,
+                "key_concepts": ["concept1", "concept2", "concept3"]
+            }}
+            """
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": "You are an expert educator creating micro-lessons. Always respond with valid JSON."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.7,
+                max_tokens=1000
+            )
+            
+            lesson_data = json.loads(response.choices[0].message.content)
+            
+            return Lesson(
+                title=lesson_data["title"],
+                content=lesson_data["content"],
+                skill=skill,
+                difficulty=difficulty,
+                duration_minutes=lesson_data["duration_minutes"],
+                key_concepts=lesson_data["key_concepts"]
+            )
+            
+        except Exception as e:
+            logger.error(f"Error generating lesson: {e}")
+            # Fallback lesson
+            return Lesson(
+                title=f"Introduction to {skill}",
+                content=f"Let's start learning about {skill}. This is a fundamental skill that can help you grow professionally and personally.",
+                skill=skill,
+                difficulty=difficulty,
+                duration_minutes=3,
+                key_concepts=["basics", "fundamentals", "getting started"]
+            )
+
+class QuizAgent:
+    """Agent responsible for generating adaptive quizzes"""
+    
+    def __init__(self, client: AzureOpenAI):
+        self.client = client
+        self.model = LLM_DEPLOYMENT
+    
+    async def generate_quiz(self, lesson: Lesson, user_progress: UserProgress) -> Quiz:
+        """Generate an adaptive quiz based on the lesson content"""
+        try:
+            avg_score = user_progress.get_average_score()
+            
+            prompt = f"""
+            Create a quiz for this lesson:
+            Title: {lesson.title}
+            Content: {lesson.content}
+            Key concepts: {', '.join(lesson.key_concepts)}
+            
+            User's average score: {avg_score:.1f}
+            Current difficulty: {lesson.difficulty}
+            
+            Create 3-5 questions that test understanding of the lesson.
+            Mix question types: multiple choice, true/false, and short answer.
+            
+            Format as JSON:
+            {{
+                "questions": [
+                    {{
+                        "type": "multiple_choice",
+                        "question": "Question text?",
+                        "options": ["A", "B", "C", "D"],
+                        "correct_answer": "A",
+                        "explanation": "Why this is correct"
+                    }},
+                    {{
+                        "type": "true_false",
+                        "question": "Statement to evaluate",
+                        "correct_answer": true,
+                        "explanation": "Explanation"
+                    }}
+                ]
+            }}
+            """
+            
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": "You are a quiz expert. Always respond with valid JSON."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.7,
+                max_tokens=1200
+            )
+            
+            quiz_data = json.loads(response.choices[0].message.content)
+            
+            return Quiz(
+                questions=quiz_data["questions"],
+                skill=lesson.skill,
+                difficulty=lesson.difficulty,
+                lesson_title=lesson.title
+            )
+            
+        except Exception as e:
+            logger.error(f"Error generating quiz: {e}")
+            # Fallback quiz
+            return Quiz(
+                questions=[{
+                    "type": "multiple_choice",
+                    "question": f"What is the main topic of this lesson about {lesson.skill}?",
+                    "options": [lesson.skill, "Something else", "Not sure", "All of the above"],
+                    "correct_answer": lesson.skill,
+                    "explanation": f"This lesson focuses on {lesson.skill}"
+                }],
+                skill=lesson.skill,
+                difficulty=lesson.difficulty,
+                lesson_title=lesson.title
+            )
+
+class ProgressAgent:
+    """Agent responsible for tracking progress and making recommendations"""
+    
+    def __init__(self):
+        self.user_data: Dict[str, UserProgress] = {}
+    
+    def get_user_progress(self, user_id: str, skill: str) -> UserProgress:
+        """Get or create user progress tracking"""
+        key = f"{user_id}_{skill}"
+        if key not in self.user_data:
+            self.user_data[key] = UserProgress(user_id=user_id, skill=skill)
+        return self.user_data[key]
+    
+    def update_progress(self, user_id: str, skill: str, lesson_completed: bool = False, 
+                       quiz_score: float = None) -> UserProgress:
+        """Update user progress after lesson/quiz completion"""
+        progress = self.get_user_progress(user_id, skill)
+        
+        if lesson_completed:
+            progress.lessons_completed += 1
+            progress.last_activity = datetime.now().strftime("%Y-%m-%d %H:%M")
+        
+        if quiz_score is not None:
+            progress.add_quiz_score(quiz_score)
+        
+        return progress
+    
+    def get_recommendation(self, progress: UserProgress) -> str:
+        """Generate learning recommendations based on progress"""
+        avg_score = progress.get_average_score()
+        
+        if progress.lessons_completed == 0:
+            return "🎯 Ready to start your learning journey! Begin with your first lesson."
+        elif avg_score >= 0.8:
+            return f"🌟 Excellent work! You're mastering {progress.skill}. Ready for the next challenge?"
+        elif avg_score >= 0.6:
+            return f"📈 Good progress! Keep practicing {progress.skill} to build confidence."
+        else:
+            return f"💪 Don't give up! Review the concepts and try again. Practice makes perfect!"
+
+class AgenticSkillBuilder:
+    """Main orchestrator for the agentic skill building platform"""
+    
+    def __init__(self):
+        self.lesson_agent = LessonAgent(client)
+        self.quiz_agent = QuizAgent(client)
+        self.progress_agent = ProgressAgent()
+        self.current_lesson: Optional[Lesson] = None
+        self.current_quiz: Optional[Quiz] = None
+        self.current_user = "demo_user"  # In a real app, this would be from authentication
+        
+        # Predefined skills
+        self.predefined_skills = [
+            "Python Programming", "Spanish Language", "Public Speaking", 
+            "Data Science", "Machine Learning", "JavaScript", "Project Management",
+            "Digital Marketing", "Creative Writing", "Photography"
+        ]
+    
+    async def start_lesson(self, skill: str) -> Tuple[str, str, str]:
+        """Start a new lesson for the selected skill"""
+        try:
+            progress = self.progress_agent.get_user_progress(self.current_user, skill)
+            
+            # Get list of previous lesson titles for context
+            previous_lessons = []  # In a real app, you'd store this
+            
+            self.current_lesson = await self.lesson_agent.generate_lesson(
+                skill, progress.current_difficulty, previous_lessons
+            )
+            
+            lesson_content = f"""
+            # 📚 {self.current_lesson.title}
+            
+            **Skill:** {self.current_lesson.skill} | **Level:** {self.current_lesson.difficulty.title()} | **Duration:** ~{self.current_lesson.duration_minutes} min
+            
+            {self.current_lesson.content}
+            
+            ### 🔑 Key Concepts:
+            {chr(10).join([f"• {concept}" for concept in self.current_lesson.key_concepts])}
+            """
+            
+            return lesson_content, "✅ Complete Lesson", ""
+            
+        except Exception as e:
+            logger.error(f"Error starting lesson: {e}")
+            return f"❌ Error generating lesson: {str(e)}", "Try Again", ""
+    
+    async def complete_lesson_and_start_quiz(self) -> Tuple[str, str, str]:
+        """Mark lesson as complete and start the quiz"""
+        if not self.current_lesson:
+            return "⚠️ No active lesson to complete.", "", ""
+        
+        try:
+            # Update progress
+            progress = self.progress_agent.update_progress(
+                self.current_user, self.current_lesson.skill, lesson_completed=True
+            )
+            
+            # Generate quiz
+            self.current_quiz = await self.quiz_agent.generate_quiz(self.current_lesson, progress)
+            
+            quiz_content = f"""
+            # 🧠 Quiz: {self.current_lesson.title}
+            
+            Test your understanding of the lesson. Answer all questions to see your results!
+            
+            """
+            
+            # Add questions to the content
+            for i, q in enumerate(self.current_quiz.questions, 1):
+                quiz_content += f"\n**Question {i}:** {q['question']}\n"
+                if q['type'] == 'multiple_choice':
+                    quiz_content += f"Options: {', '.join(q['options'])}\n"
+                elif q['type'] == 'true_false':
+                    quiz_content += "Answer: True or False\n"
+            
+            return quiz_content, "📝 Submit Quiz", ""
+            
+        except Exception as e:
+            logger.error(f"Error generating quiz: {e}")
+            return f"❌ Error generating quiz: {str(e)}", "", ""
+    
+    def submit_quiz(self, *answers) -> Tuple[str, str, str]:
+        """Process quiz submission and show results"""
+        if not self.current_quiz:
+            return "⚠️ No active quiz to submit.", "", ""
+        
+        try:
+            correct_answers = 0
+            total_questions = len(self.current_quiz.questions)
+            results = []
+            
+            for i, (question, answer) in enumerate(zip(self.current_quiz.questions, answers)):
+                if answer is None or answer == "":
+                    continue
+                    
+                is_correct = False
+                correct_answer = question['correct_answer']
+                
+                if question['type'] == 'multiple_choice':
+                    is_correct = answer.strip().upper() == str(correct_answer).upper()
+                elif question['type'] == 'true_false':
+                    is_correct = answer.lower() == str(correct_answer).lower()
+                
+                if is_correct:
+                    correct_answers += 1
+                
+                results.append({
+                    'question': question['question'],
+                    'your_answer': answer,
+                    'correct_answer': correct_answer,
+                    'is_correct': is_correct,
+                    'explanation': question.get('explanation', '')
+                })
+            
+            score = correct_answers / total_questions if total_questions > 0 else 0
+            
+            # Update progress with quiz score
+            progress = self.progress_agent.update_progress(
+                self.current_user, self.current_lesson.skill, quiz_score=score
+            )
+            
+            # Generate results content
+            results_content = f"""
+            # 🎯 Quiz Results
+            
+            **Score:** {correct_answers}/{total_questions} ({score:.1%})
+            
+            **Performance:** {'🌟 Excellent!' if score >= 0.8 else '👍 Good work!' if score >= 0.6 else '💪 Keep practicing!'}
+            
+            ### Detailed Results:
+            """
+            
+            for i, result in enumerate(results, 1):
+                status = "✅" if result['is_correct'] else "❌"
+                results_content += f"""
+                **Q{i}:** {result['question']}
+                {status} Your answer: {result['your_answer']}
+                Correct answer: {result['correct_answer']}
+                {result['explanation']}
+                
+                """
+            
+            # Add progress and recommendations
+            recommendation = self.progress_agent.get_recommendation(progress)
+            
+            results_content += f"""
+            ### 📊 Your Progress
+            - **Lessons completed:** {progress.lessons_completed}
+            - **Average score:** {progress.get_average_score():.1%}
+            - **Current level:** {progress.current_difficulty.title()}
+            
+            ### 🎯 Recommendation
+            {recommendation}
+            """
+            
+            return results_content, "🔄 Start New Lesson", ""
+            
+        except Exception as e:
+            logger.error(f"Error processing quiz: {e}")
+            return f"❌ Error processing quiz: {str(e)}", "", ""
+
+# Initialize the main application
+app = AgenticSkillBuilder()
+
+def create_interface():
+    """Create the Gradio interface"""
+    
+    with gr.Blocks(
+        title="Agentic Skill Builder",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 800px !important;
+            margin: auto !important;
+        }
+        """
+    ) as demo:
+        
+        # Header
+        gr.Markdown("""
+        # 🚀 Agentic Skill Builder
+        ### AI-Powered Microlearning Platform
+        
+        Learn new skills through bite-sized lessons and adaptive quizzes powered by Azure OpenAI!
+        """)
+        
+        # State variables
+        current_skill = gr.State("")
+        with gr.Tab("🎯 Start Learning"):
+            gr.Markdown("### Choose a skill to begin your microlearning journey")
+            
+            with gr.Row():
+                with gr.Column():
+                    skill_dropdown = gr.Dropdown(
+                        choices=app.predefined_skills,
+                        label="📚 Select a Skill",
+                        info="Choose from popular skills..."
+                    )
+                    custom_skill = gr.Textbox(
+                        label="✍️ Or enter a custom skill",
+                        info="e.g., Cooking, Guitar, Time Management..."
+                    )
+                    
+                    start_btn = gr.Button("🚀 Start Learning", variant="primary", size="lg")
+            
+            # Lesson content area
+            lesson_output = gr.Markdown(visible=False)
+            lesson_btn = gr.Button("Complete Lesson", visible=False)
+            
+            # Quiz area
+            quiz_output = gr.Markdown(visible=False)
+            
+            # Dynamic quiz inputs (will be created based on quiz content)
+            quiz_inputs = []
+            for i in range(5):  # Max 5 questions
+                quiz_inputs.append(gr.Textbox(label=f"Answer {i+1}", visible=False))
+            
+            quiz_submit_btn = gr.Button("Submit Quiz", visible=False)
+            
+            # Results area
+            results_output = gr.Markdown(visible=False)
+            restart_btn = gr.Button("Start New Lesson", visible=False)
+        
+        with gr.Tab("📊 Progress Dashboard"):
+            gr.Markdown("### Your Learning Analytics")
+            
+            progress_display = gr.Markdown("""
+            **Welcome to your progress dashboard!**
+            
+            Complete some lessons to see your learning analytics here.
+            """)
+            
+            refresh_progress_btn = gr.Button("🔄 Refresh Progress")
+        
+        with gr.Tab("🔗 MCP Endpoints"):
+            gr.Markdown("""
+            ### Model Context Protocol Integration
+            
+            This application exposes MCP endpoints for integration with external agents:
+            
+            - **GET /lesson/{skill}** - Fetch next lesson for a skill
+            - **GET /progress/{user_id}** - Get user progress data  
+            - **POST /quiz/submit** - Submit quiz results
+            
+            *Coming soon: Full MCP server implementation*
+            """)
+          # Event handlers
+        async def handle_start_learning(skill_choice, custom_skill_input):
+            skill = custom_skill_input.strip() if custom_skill_input.strip() else skill_choice
+            if not skill:
+                return [
+                    gr.update(value="⚠️ Please select or enter a skill to continue."),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    skill
+                ] + [gr.update(visible=False, value="") for _ in range(5)]
+            
+            lesson_content, btn_text, _ = await app.start_lesson(skill)
+            
+            return [
+                gr.update(value=lesson_content),
+                gr.update(value=btn_text, visible=True),
+                gr.update(visible=False),
+                skill
+            ] + [gr.update(visible=False, value="") for _ in range(5)]
+        
+        async def handle_complete_lesson():
+            quiz_content, btn_text, _ = await app.complete_lesson_and_start_quiz()
+            
+            # Show quiz inputs based on number of questions
+            quiz_updates = []
+            if app.current_quiz:
+                for i, question in enumerate(app.current_quiz.questions):
+                    if i < len(quiz_inputs):
+                        label = f"Q{i+1}: {question['question'][:50]}..."
+                        quiz_updates.append(gr.update(label=label, visible=True))
+                    else:
+                        quiz_updates.append(gr.update(visible=False))
+                # Hide remaining inputs
+                for i in range(len(app.current_quiz.questions), len(quiz_inputs)):
+                    quiz_updates.append(gr.update(visible=False))
+            else:
+                quiz_updates = [gr.update(visible=False) for _ in range(len(quiz_inputs))]
+            
+            return [
+                gr.update(visible=False),
+                gr.update(value=quiz_content, visible=True),
+                gr.update(value=btn_text, visible=True),
+                gr.update(visible=False)
+            ] + quiz_updates
+        
+        def handle_submit_quiz(*answers):
+            # Filter out None values and empty strings
+            valid_answers = [ans for ans in answers if ans is not None and ans != ""]
+            
+            results_content, btn_text, _ = app.submit_quiz(*valid_answers)
+            
+            return [
+                gr.update(visible=False),
+                gr.update(value=results_content, visible=True),
+                gr.update(value=btn_text, visible=True),
+                gr.update(visible=False)
+            ] + [gr.update(visible=False) for _ in range(len(quiz_inputs))]
+        
+        def handle_restart():
+            return [
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                ""
+            ] + [gr.update(visible=False, value="") for _ in range(len(quiz_inputs))]
+        
+        def update_progress_display():
+            if not app.progress_agent.user_data:
+                return "**No learning data yet.** Complete some lessons to see your progress!"
+            
+            progress_content = "# 📊 Your Learning Progress\n\n"
+            
+            for key, progress in app.progress_agent.user_data.items():
+                progress_content += f"""
+                **Skill:** {progress.skill}
+                - Lessons completed: {progress.lessons_completed}
+                - Average quiz score: {progress.get_average_score():.1%}
+                - Current difficulty: {progress.current_difficulty.title()}
+                - Last activity: {progress.last_activity or 'Never'}
+                
+                """
+            return progress_content
+        
+        # Wire up the events
+        start_btn.click(
+            handle_start_learning,
+            inputs=[skill_dropdown, custom_skill],
+            outputs=[lesson_output, lesson_btn, quiz_output, current_skill] + quiz_inputs[:5]
+        )
+        
+        lesson_btn.click(
+            handle_complete_lesson,
+            outputs=[lesson_btn, quiz_output, quiz_submit_btn, results_output] + quiz_inputs
+        )
+        
+        quiz_submit_btn.click(
+            handle_submit_quiz,
+            inputs=quiz_inputs,
+            outputs=[quiz_submit_btn, results_output, restart_btn, quiz_output] + quiz_inputs
+        )
+        
+        restart_btn.click(
+            handle_restart,
+            outputs=[lesson_output, quiz_output, results_output, lesson_btn, restart_btn, current_skill] + quiz_inputs
+        )
+        
+        refresh_progress_btn.click(
+            update_progress_display,
+            outputs=[progress_display]
+        )
+    
+    return demo
+
+def main():
+    """Main application entry point"""
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,86 @@
+"""
+Configuration module for Agentic Skill Builder
+Handles environment variables, logging, and application settings
+"""
+
+import os
+import logging
+from typing import Optional
+from dataclasses import dataclass
+
+@dataclass
+class AzureOpenAIConfig:
+    """Configuration for Azure OpenAI service"""
+    endpoint: str
+    api_key: str
+    api_version: str
+    llm_deployment: str
+    llm_model: str
+    embeddings_deployment: str
+    embeddings_model: str
+    
+    @classmethod
+    def from_env(cls) -> 'AzureOpenAIConfig':
+        """Create configuration from environment variables"""
+        return cls(
+            endpoint=os.getenv("AZURE_OPENAI_ENDPOINT", "").replace('"', ''),
+            api_key=os.getenv("AZURE_OPENAI_KEY", "").replace('"', ''),
+            api_version=os.getenv("AZURE_OPENAI_API_VERSION", "2024-12-01-preview").replace('"', ''),
+            llm_deployment=os.getenv("AZURE_OPENAI_LLM_DEPLOYMENT", "gpt-4.1").replace('"', ''),
+            llm_model=os.getenv("AZURE_OPENAI_LLM_MODEL", "gpt-4.1").replace('"', ''),
+            embeddings_deployment=os.getenv("AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT", "text-embedding-3-small").replace('"', ''),
+            embeddings_model=os.getenv("AZURE_OPENAI_EMBEDDINGS_MODEL", "text-embedding-3-small").replace('"', '')
+        )
+    
+    def validate(self) -> bool:
+        """Validate that all required settings are present"""
+        required_fields = [self.endpoint, self.api_key, self.llm_deployment]
+        return all(field.strip() for field in required_fields)
+
+@dataclass
+class AppConfig:
+    """Main application configuration"""
+    debug: bool = False
+    log_level: str = "INFO"
+    gradio_port: int = 7860
+    mcp_port: int = 8000
+    max_quiz_questions: int = 5
+    default_lesson_duration: int = 5
+    azure_openai: Optional[AzureOpenAIConfig] = None
+    
+    @classmethod
+    def from_env(cls) -> 'AppConfig':
+        """Create configuration from environment variables"""
+        return cls(
+            debug=os.getenv("DEBUG", "false").lower() == "true",
+            log_level=os.getenv("LOG_LEVEL", "INFO").upper(),
+            gradio_port=int(os.getenv("GRADIO_PORT", "7860")),
+            mcp_port=int(os.getenv("MCP_PORT", "8000")),
+            max_quiz_questions=int(os.getenv("MAX_QUIZ_QUESTIONS", "5")),
+            default_lesson_duration=int(os.getenv("DEFAULT_LESSON_DURATION", "5")),
+            azure_openai=AzureOpenAIConfig.from_env()
+        )
+
+def setup_logging(config: AppConfig):
+    """Setup application logging"""
+    logging.basicConfig(
+        level=getattr(logging, config.log_level),
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler(),
+            logging.FileHandler('agentic_skill_builder.log')
+        ]
+    )
+
+def get_config() -> AppConfig:
+    """Get application configuration"""
+    config = AppConfig.from_env()
+    
+    # Validate Azure OpenAI configuration
+    if not config.azure_openai or not config.azure_openai.validate():
+        raise ValueError(
+            "Azure OpenAI configuration is incomplete. "
+            "Please check your .env file for AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_KEY, and AZURE_OPENAI_LLM_DEPLOYMENT"
+        )
+    
+    return config

demo_video_script.md

@@ -0,0 +1,212 @@
+# 🎬 Demo Video Script - Agentic Skill Builder MCP Server
+
+## Video Duration: 3-5 minutes
+## Target Audience: Hackathon judges and MCP developers
+
+---
+
+## 🎯 **Opening (0:00 - 0:30)**
+
+**Visual:** Screen showing the Gradio interface running on localhost:7860
+**Narration:** 
+> "Welcome to the Agentic Skill Builder - our submission for the Gradio Agents & MCP Hackathon 2025, Track 1: MCP Server/Tool. This is a unique AI-powered microlearning platform that serves both as a beautiful Gradio interface AND a fully functional MCP server."
+
+---
+
+## 🔗 **MCP Server Demonstration (0:30 - 2:00)**
+
+### Part 1: Server Status & Endpoints (0:30 - 1:00)
+**Visual:** Browser showing http://localhost:8001/
+**Narration:**
+> "First, let me show you our MCP server running on port 8001. This endpoint provides metadata about our hackathon submission."
+
+**Action:** Show JSON response with hackathon information
+
+**Visual:** Terminal/Postman showing MCP endpoints
+**Narration:**
+> "Our MCP server exposes four key endpoints:
+> - GET /mcp/skills - Lists available learning skills
+> - POST /mcp/lesson/generate - Creates personalized lessons
+> - GET /mcp/progress/{user_id} - Tracks learning progress
+> - POST /mcp/quiz/submit - Processes quiz submissions"
+
+### Part 2: Live MCP Endpoint Testing (1:00 - 2:00)
+**Visual:** Testing each MCP endpoint with curl or PowerShell
+**Narration:**
+> "Let me demonstrate these endpoints in action. First, getting available skills..."
+
+**Action:** Show GET /mcp/skills response
+```powershell
+curl http://localhost:8001/mcp/skills
+```
+**Expected Response:**
+```json
+{
+  "predefined_skills": ["Python Programming", "Spanish Language", "Public Speaking", "Data Science", "Machine Learning", "JavaScript", "Project Management", "Digital Marketing", "Creative Writing", "Photography"]
+}
+```
+
+> "Now generating a personalized lesson for Python Programming..."
+
+**Action:** Show POST /mcp/lesson/generate with request body and response
+```powershell
+curl -X POST http://localhost:8001/mcp/lesson/generate `
+  -H "Content-Type: application/json" `
+  -d '{
+    "skill": "Python Programming",
+    "level": "beginner",
+    "user_context": "I want to learn Python for data analysis"
+  }'
+```
+**Expected Response:**
+```json
+{
+  "lesson_id": "lesson_12345",
+  "skill": "Python Programming",
+  "title": "Introduction to Python for Data Analysis",
+  "content": "Python is a powerful programming language...",
+  "difficulty": "beginner",
+  "estimated_time": "15 minutes",
+  "mcp_server": "Agentic Skill Builder"
+}
+```
+
+> "Let's check user progress to see learning analytics..."
+
+**Action:** Show GET /mcp/progress/demo_user response
+```powershell
+curl http://localhost:8001/mcp/progress/demo_user
+```
+**Expected Response:**
+```json
+{
+  "user_id": "demo_user",
+  "skills_progress": {
+    "Python Programming": {
+      "lessons_completed": 2,
+      "quiz_scores": [85, 92],
+      "current_level": "intermediate"
+    }
+  },
+  "total_skills_learning": 1,
+  "mcp_server": "Agentic Skill Builder",
+  "timestamp": "2025-06-07T04:48:36.691517"
+}
+```
+
+> "Finally, let's submit a quiz answer to show the interactive capabilities..."
+
+**Action:** Show POST /mcp/quiz/submit with request body and response
+```powershell
+curl -X POST http://localhost:8001/mcp/quiz/submit `
+  -H "Content-Type: application/json" `
+  -d '{
+    "user_id": "demo_user",
+    "quiz_id": "quiz_python_001",
+    "answers": ["list", "dictionary", "tuple"],
+    "skill": "Python Programming"
+  }'
+```
+**Expected Response:**
+```json
+{
+  "quiz_id": "quiz_python_001",
+  "user_id": "demo_user",
+  "score": 85,
+  "feedback": "Great job! You correctly identified Python data structures.",
+  "passed": true,
+  "mcp_server": "Agentic Skill Builder"
+}
+```
+
+---
+
+## 🎨 **Gradio Interface Demo (2:00 - 3:30)**
+
+### Part 1: Learning Flow (2:00 - 3:00)
+**Visual:** Gradio interface at localhost:7860
+**Narration:**
+> "Now let's see the beautiful Gradio interface in action. The same AI agents that power our MCP endpoints create this seamless learning experience."
+
+**Action:** 
+1. Select "Data Science" skill
+2. Click "Start Learning"
+3. Show generated lesson content
+4. Complete lesson and start quiz
+5. Answer quiz questions
+6. Show results and progress
+
+### Part 2: MCP Testing Interface (3:00 - 3:30)
+**Visual:** Built-in MCP endpoint testing section in Gradio
+**Narration:**
+> "What makes this special is that we've built MCP endpoint testing directly into our Gradio interface. You can test all our MCP endpoints without leaving the app."
+
+**Action:** Show the MCP endpoint testing interface working
+
+---
+
+## 🏆 **Hackathon Highlights (3:30 - 4:30)**
+
+**Visual:** Split screen showing both Gradio UI and MCP endpoints
+**Narration:**
+> "This submission perfectly demonstrates the agentic architecture we've built:
+> - Three specialized AI agents working together
+> - Lesson Agent generates personalized content
+> - Quiz Agent creates adaptive assessments  
+> - Progress Agent tracks learning analytics
+> - All coordinated by our main orchestrator"
+
+**Visual:** Show the architecture diagram or code structure
+**Narration:**
+> "The same agents power both the beautiful user interface AND the MCP protocol endpoints, making our platform ready for integration with Claude Desktop, Cursor, or any MCP client."
+
+---
+
+## 🚀 **Call to Action (4:30 - 5:00)**
+
+**Visual:** README.md showing deployment instructions
+**Narration:**
+> "You can deploy this immediately to Hugging Face Spaces using our space_app.py file, or run it locally following our comprehensive documentation. This represents the future of AI-powered education - agentic, interoperable, and ready for the Model Context Protocol ecosystem."
+
+**Visual:** Final shot of both servers running simultaneously
+**Narration:**
+> "Thank you for watching our Agentic Skill Builder demo. We're excited to contribute to the MCP ecosystem and the future of AI agents working together!"
+
+---
+
+## 📝 **Recording Checklist**
+
+### Before Recording:
+- [ ] Ensure both servers are running (Gradio on 7860, MCP on 8001)
+- [ ] Prepare browser tabs for all endpoints
+- [ ] Have curl commands or Postman collection ready
+- [ ] Test the complete learning flow works
+- [ ] Check audio/screen recording quality
+
+### During Recording:
+- [ ] Speak clearly and at moderate pace
+- [ ] Show actual JSON responses from MCP endpoints
+- [ ] Demonstrate real-time lesson generation
+- [ ] Highlight the dual-purpose architecture
+- [ ] Keep within 5-minute time limit
+
+### After Recording:
+- [ ] Upload to YouTube/Vimeo
+- [ ] Update README.md with video link
+- [ ] Add video link to HF Spaces README
+- [ ] Verify video is publicly accessible
+
+---
+
+## 🎥 **Technical Recording Tips**
+
+1. **Use OBS Studio or similar** for high-quality screen recording
+2. **Record at 1080p** for clear text visibility
+3. **Use good microphone** for clear narration
+4. **Multiple takes OK** - edit together the best parts
+5. **Add captions** for accessibility
+6. **Include timestamps** in video description
+
+---
+
+**Ready to showcase the future of agentic learning with MCP integration! 🚀**

deployment_guide.md

@@ -0,0 +1,138 @@
+# 🚀 Hugging Face Spaces Deployment Guide
+
+## 📋 Pre-Deployment Checklist
+
+### ✅ **Files Ready for Upload:**
+- `space_app.py` - Main application file (Gradio + MCP server)
+- `requirements.txt` - HF Spaces optimized dependencies  
+- `README_spaces.md` - Spaces configuration (rename to README.md)
+- `config.py` - Configuration utilities
+- `.env` - Environment variables (handle separately)
+
+### ✅ **Configuration Complete:**
+- App file specified: `space_app.py`
+- SDK: `gradio 4.44.0`
+- Tags include: `mcp-server-track`
+- License: MIT
+
+---
+
+## 🔧 **Deployment Steps**
+
+### **Step 1: Create Hugging Face Space**
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. **Important:** Create under the `Agents-MCP-Hackathon` organization
+4. Space name: `agentic-skill-builder`
+5. Choose "Gradio" as SDK
+6. Set to Public
+7. Click "Create Space"
+
+### **Step 2: Upload Files**
+
+Upload these files to your new Space:
+
+```
+📁 agentic-skill-builder/
+├── 📄 README.md (renamed from README_spaces.md)
+├── 📄 space_app.py
+├── 📄 requirements.txt
+├── 📄 config.py
+└── 📄 .env (create in Spaces settings)
+```
+
+### **Step 3: Configure Environment Variables**
+
+In your HF Space settings, add these environment variables:
+
+```env
+AZURE_OPENAI_ENDPOINT=your-azure-endpoint
+AZURE_OPENAI_KEY=your-api-key
+AZURE_OPENAI_API_VERSION=2024-12-01-preview
+AZURE_OPENAI_LLM_DEPLOYMENT=gpt-4.1
+AZURE_OPENAI_LLM_MODEL=gpt-4.1
+```
+
+**⚠️ Important:** Never commit your `.env` file with real credentials to a public repo!
+
+### **Step 4: Verify Deployment**
+
+Once deployed, your Space should:
+- ✅ Show the Gradio interface
+- ✅ Respond to MCP endpoints at `https://your-space-name.hf.space/mcp/skills`
+- ✅ Generate lessons and quizzes
+- ✅ Include hackathon branding and MCP testing interface
+
+---
+
+## 🔍 **Testing Your Deployed Space**
+
+### **Gradio Interface Test:**
+1. Visit your Space URL
+2. Select a skill (e.g., "Python Programming")
+3. Complete the full learning flow
+4. Verify AI generates lessons and quizzes
+
+### **MCP Endpoints Test:**
+```bash
+# Test from anywhere on the internet
+curl https://your-space-name.hf.space/mcp/skills
+curl https://your-space-name.hf.space/mcp/progress/test_user
+```
+
+---
+
+## 📝 **Post-Deployment Updates**
+
+### **Update README.md with:**
+1. **Live demo link:** Replace local URLs with your HF Space URL
+2. **Video link:** Add your demo video URL
+3. **Deployment status:** Confirm it's live and working
+
+### **Example Updates:**
+```markdown
+## 🎬 Demo Video
+**MCP Server in Action:** [https://youtu.be/your-video-id](https://youtu.be/your-video-id)
+
+## 🌐 Live Demo
+**Try it now:** [https://huggingface.co/spaces/Agents-MCP-Hackathon/agentic-skill-builder](https://huggingface.co/spaces/Agents-MCP-Hackathon/agentic-skill-builder)
+
+## 🔗 MCP Endpoints
+Test our live MCP server at: `https://your-space-name.hf.space/mcp/`
+```
+
+---
+
+## 🏆 **Final Hackathon Submission Checklist**
+
+- [ ] ✅ Space deployed under Agents-MCP-Hackathon organization
+- [ ] ✅ "mcp-server-track" tag in README
+- [ ] ✅ Demo video uploaded and linked
+- [ ] ✅ Live MCP endpoints working
+- [ ] ✅ Gradio interface fully functional
+- [ ] ✅ All dependencies working in cloud environment
+- [ ] ✅ Documentation updated with live links
+
+---
+
+## 🚨 **Troubleshooting Common Issues**
+
+### **Build Failures:**
+- Check `requirements.txt` for incompatible versions
+- Verify all imports work in `space_app.py`
+- Ensure environment variables are set correctly
+
+### **MCP Endpoints Not Working:**
+- Verify FastAPI routes are properly configured
+- Check if app.mount() is correctly set up
+- Test endpoints locally first
+
+### **Azure OpenAI Errors:**
+- Confirm environment variables are set in Spaces settings
+- Check Azure OpenAI quota and model availability
+- Verify API key permissions
+
+---
+
+**Ready to deploy! Your agentic skill builder will be live for the world to see! 🌍✨**

hf-hackathon.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}

mcp_server.py

@@ -0,0 +1,269 @@
+"""
+MCP Server Integration for Agentic Skill Builder
+This module provides Model Context Protocol endpoints for external agent integration.
+"""
+
+import json
+import asyncio
+from typing import Dict, Any, List
+from dataclasses import asdict
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException, Depends
+from pydantic import BaseModel
+import uvicorn
+
+# Import from main app
+from app import AgenticSkillBuilder, UserProgress
+
+# FastAPI app for MCP endpoints
+mcp_app = FastAPI(
+    title="Agentic Skill Builder MCP Server",
+    description="Model Context Protocol endpoints for microlearning integration",
+    version="1.0.0"
+)
+
+# Global app instance
+skill_builder = AgenticSkillBuilder()
+
+# Pydantic models for API
+class LessonRequest(BaseModel):
+    skill: str
+    user_id: str = "default_user"
+    difficulty: str = "beginner"
+
+class QuizSubmission(BaseModel):
+    user_id: str
+    skill: str
+    lesson_title: str
+    answers: List[str]
+
+class ProgressResponse(BaseModel):
+    user_id: str
+    skill: str
+    lessons_completed: int
+    average_score: float
+    current_difficulty: str
+    recommendations: str
+
+@mcp_app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "name": "Agentic Skill Builder MCP Server",
+        "version": "1.0.0",
+        "description": "MCP endpoints for AI-powered microlearning",
+        "endpoints": {
+            "GET /lesson/{skill}": "Fetch next lesson for a skill",
+            "GET /progress/{user_id}": "Get user progress data",
+            "POST /quiz/submit": "Submit quiz results",
+            "GET /skills": "List available skills"
+        }
+    }
+
+@mcp_app.get("/skills")
+async def get_available_skills():
+    """Get list of available predefined skills"""
+    return {
+        "predefined_skills": skill_builder.predefined_skills,
+        "custom_skills_supported": True,
+        "message": "You can also request lessons for any custom skill"
+    }
+
+@mcp_app.post("/lesson/generate")
+async def generate_lesson(request: LessonRequest):
+    """Generate a new lesson for the specified skill and user"""
+    try:
+        # Set current user
+        skill_builder.current_user = request.user_id
+        
+        # Get user progress
+        progress = skill_builder.progress_agent.get_user_progress(
+            request.user_id, request.skill
+        )
+        
+        # Generate lesson
+        lesson = await skill_builder.lesson_agent.generate_lesson(
+            skill=request.skill,
+            difficulty=request.difficulty or progress.current_difficulty,
+            previous_lessons=[]  # Could be enhanced to track previous lessons
+        )
+        
+        return {
+            "lesson": {
+                "title": lesson.title,
+                "content": lesson.content,
+                "skill": lesson.skill,
+                "difficulty": lesson.difficulty,
+                "duration_minutes": lesson.duration_minutes,
+                "key_concepts": lesson.key_concepts
+            },
+            "user_context": {
+                "user_id": request.user_id,
+                "current_difficulty": progress.current_difficulty,
+                "lessons_completed": progress.lessons_completed
+            },
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating lesson: {str(e)}")
+
+@mcp_app.get("/progress/{user_id}")
+async def get_user_progress(user_id: str, skill: str = None):
+    """Get user progress data for all skills or a specific skill"""
+    try:
+        if skill:
+            # Get progress for specific skill
+            progress = skill_builder.progress_agent.get_user_progress(user_id, skill)
+            recommendation = skill_builder.progress_agent.get_recommendation(progress)
+            
+            return ProgressResponse(
+                user_id=progress.user_id,
+                skill=progress.skill,
+                lessons_completed=progress.lessons_completed,
+                average_score=progress.get_average_score(),
+                current_difficulty=progress.current_difficulty,
+                recommendations=recommendation
+            )
+        else:
+            # Get progress for all skills
+            user_progress_data = {}
+            for key, progress in skill_builder.progress_agent.user_data.items():
+                if progress.user_id == user_id:
+                    user_progress_data[progress.skill] = {
+                        "lessons_completed": progress.lessons_completed,
+                        "average_score": progress.get_average_score(),
+                        "current_difficulty": progress.current_difficulty,
+                        "quiz_scores": progress.quiz_scores,
+                        "last_activity": progress.last_activity
+                    }
+            
+            return {
+                "user_id": user_id,
+                "skills_progress": user_progress_data,
+                "total_skills_learning": len(user_progress_data),
+                "timestamp": datetime.now().isoformat()
+            }
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching progress: {str(e)}")
+
+@mcp_app.post("/quiz/submit")
+async def submit_quiz_results(submission: QuizSubmission):
+    """Submit quiz results and get feedback"""
+    try:
+        # Set current user
+        skill_builder.current_user = submission.user_id
+        
+        # Calculate score (simplified scoring)
+        if not skill_builder.current_quiz or len(submission.answers) == 0:
+            raise HTTPException(status_code=400, detail="No active quiz or no answers provided")
+        
+        correct_answers = 0
+        total_questions = len(skill_builder.current_quiz.questions)
+        
+        for i, (question, answer) in enumerate(zip(skill_builder.current_quiz.questions, submission.answers)):
+            if i >= len(submission.answers):
+                break
+                
+            correct_answer = str(question['correct_answer']).lower()
+            user_answer = answer.lower().strip()
+            
+            if user_answer == correct_answer:
+                correct_answers += 1
+        
+        score = correct_answers / total_questions if total_questions > 0 else 0
+        
+        # Update progress
+        progress = skill_builder.progress_agent.update_progress(
+            submission.user_id, submission.skill, quiz_score=score
+        )
+        
+        # Get recommendation
+        recommendation = skill_builder.progress_agent.get_recommendation(progress)
+        
+        return {
+            "quiz_results": {
+                "score": score,
+                "correct_answers": correct_answers,
+                "total_questions": total_questions,
+                "percentage": f"{score:.1%}"
+            },
+            "updated_progress": {
+                "lessons_completed": progress.lessons_completed,
+                "average_score": progress.get_average_score(),
+                "current_difficulty": progress.current_difficulty
+            },
+            "recommendation": recommendation,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing quiz submission: {str(e)}")
+
+@mcp_app.post("/quiz/generate")
+async def generate_quiz_for_lesson(lesson_title: str, skill: str, user_id: str = "default_user"):
+    """Generate a quiz for a specific lesson"""
+    try:
+        # Set current user
+        skill_builder.current_user = user_id
+        
+        # Get user progress
+        progress = skill_builder.progress_agent.get_user_progress(user_id, skill)
+        
+        # Create a mock lesson object for quiz generation
+        from app import Lesson
+        mock_lesson = Lesson(
+            title=lesson_title,
+            content=f"This is content for {lesson_title}",
+            skill=skill,
+            difficulty=progress.current_difficulty,
+            duration_minutes=5,
+            key_concepts=["concept1", "concept2"]
+        )
+        
+        # Generate quiz
+        quiz = await skill_builder.quiz_agent.generate_quiz(mock_lesson, progress)
+        
+        # Store current quiz for submission
+        skill_builder.current_quiz = quiz
+        
+        return {
+            "quiz": {
+                "lesson_title": lesson_title,
+                "skill": skill,
+                "difficulty": quiz.difficulty,
+                "questions": quiz.questions
+            },
+            "instructions": "Submit answers using the /quiz/submit endpoint",
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating quiz: {str(e)}")
+
+@mcp_app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "service": "Agentic Skill Builder MCP Server"
+    }
+
+def run_mcp_server():
+    """Run the MCP server"""
+    uvicorn.run(
+        "mcp_server:mcp_app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )
+
+if __name__ == "__main__":
+    print("🚀 Starting Agentic Skill Builder MCP Server...")
+    print("📚 MCP endpoints will be available at http://localhost:8000")
+    print("📖 API documentation at http://localhost:8000/docs")
+    run_mcp_server()

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=4.44.0
+openai>=1.12.0
+python-dotenv>=1.0.0
+pandas>=2.0.0
+uvicorn>=0.24.0
+fastapi>=0.104.0
+pydantic>=2.0.0
+aiohttp>=3.9.0
+requests>=2.31.0

run.py

@@ -0,0 +1,82 @@
+"""
+Launcher script for Agentic Skill Builder
+Runs both the Gradio interface and MCP server
+"""
+
+import asyncio
+import subprocess
+import sys
+import time
+import threading
+from pathlib import Path
+
+def run_gradio_app():
+    """Run the main Gradio application"""
+    print("🚀 Starting Gradio App...")
+    subprocess.run([sys.executable, "app.py"])
+
+def run_mcp_server():
+    """Run the MCP server"""
+    print("🔗 Starting MCP Server...")
+    subprocess.run([sys.executable, "mcp_server.py"])
+
+def main():
+    """Main launcher function"""
+    print("=" * 60)
+    print("🎓 AGENTIC SKILL BUILDER")
+    print("   AI-Powered Microlearning Platform")
+    print("=" * 60)
+    print()
+    
+    # Check if we're in the right directory
+    if not Path("app.py").exists():
+        print("❌ Error: app.py not found. Please run this script from the project directory.")
+        return
+    
+    print("Choose how to run the application:")
+    print("1. Gradio App only (recommended for demo)")
+    print("2. MCP Server only")
+    print("3. Both Gradio App and MCP Server")
+    print()
+    
+    choice = input("Enter your choice (1-3): ").strip()
+    
+    if choice == "1":
+        print("\n🎯 Starting Gradio App...")
+        print("📱 Interface will be available at: http://localhost:7860")
+        run_gradio_app()
+    
+    elif choice == "2":
+        print("\n🔗 Starting MCP Server...")
+        print("🌐 API will be available at: http://localhost:8000")
+        print("📚 API docs at: http://localhost:8000/docs")
+        run_mcp_server()
+    
+    elif choice == "3":
+        print("\n🚀 Starting both services...")
+        print("📱 Gradio App: http://localhost:7860")
+        print("🌐 MCP Server: http://localhost:8000")
+        print("📚 API docs: http://localhost:8000/docs")
+        print()
+        
+        # Start MCP server in a separate thread
+        mcp_thread = threading.Thread(target=run_mcp_server, daemon=True)
+        mcp_thread.start()
+        
+        # Give MCP server time to start
+        time.sleep(2)
+        
+        # Start Gradio app (this will block)
+        run_gradio_app()
+    
+    else:
+        print("❌ Invalid choice. Please run the script again.")
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\n👋 Goodbye! Thanks for using Agentic Skill Builder!")
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        print("Please check your configuration and try again.")

space_app.py

@@ -0,0 +1,541 @@
+"""
+Agentic Skill Builder - Hackathon Submission
+A unified app.py that serves both Gradio interface and MCP server endpoints
+for the Gradio Agents & MCP Hackathon 2025
+"""
+
+import os
+import json
+import asyncio
+import threading
+import time
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+import logging
+
+from dotenv import load_dotenv
+import gradio as gr
+from openai import AzureOpenAI
+import pandas as pd
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Azure OpenAI client configuration
+client = AzureOpenAI(
+    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT", "").replace('"', ''),
+    api_key=os.getenv("AZURE_OPENAI_KEY", "").replace('"', ''),
+    api_version=os.getenv("AZURE_OPENAI_API_VERSION", "2024-12-01-preview").replace('"', ''),
+)
+
+# Model configurations
+LLM_DEPLOYMENT = os.getenv("AZURE_OPENAI_LLM_DEPLOYMENT", "gpt-4").replace('"', '')
+LLM_MODEL = os.getenv("AZURE_OPENAI_LLM_MODEL", "gpt-4").replace('"', '')
+
+# Import all classes from the main app
+from app import (
+    UserProgress, Lesson, Quiz, LessonAgent, QuizAgent, 
+    ProgressAgent, AgenticSkillBuilder
+)
+
+# Create global instances
+app_instance = AgenticSkillBuilder()
+
+# ===== MCP SERVER INTEGRATION =====
+
+# FastAPI app for MCP endpoints
+mcp_app = FastAPI(
+    title="Agentic Skill Builder MCP Server",
+    description="Model Context Protocol endpoints for microlearning integration - Hackathon 2025",
+    version="1.0.0"
+)
+
+# Pydantic models for API
+class LessonRequest(BaseModel):
+    skill: str
+    user_id: str = "default_user"
+    difficulty: str = "beginner"
+
+class QuizSubmission(BaseModel):
+    user_id: str
+    skill: str
+    lesson_title: str
+    answers: List[str]
+
+@mcp_app.get("/")
+async def root():
+    """Root endpoint with hackathon information"""
+    return {
+        "name": "Agentic Skill Builder MCP Server",
+        "version": "1.0.0",
+        "hackathon": "Gradio Agents & MCP Hackathon 2025",
+        "track": "mcp-server-track",
+        "description": "MCP endpoints for AI-powered microlearning",
+        "endpoints": {
+            "GET /mcp/lesson/generate": "Generate next lesson for a skill",
+            "GET /mcp/progress/{user_id}": "Get user progress data",
+            "POST /mcp/quiz/submit": "Submit quiz results",
+            "GET /mcp/skills": "List available skills"
+        }
+    }
+
+@mcp_app.get("/mcp/skills")
+async def get_available_skills():
+    """Get list of available predefined skills"""
+    return {
+        "predefined_skills": app_instance.predefined_skills,
+        "custom_skills_supported": True,
+        "message": "You can also request lessons for any custom skill"
+    }
+
+@mcp_app.post("/mcp/lesson/generate")
+async def generate_lesson_mcp(request: LessonRequest):
+    """Generate a new lesson via MCP endpoint"""
+    try:
+        app_instance.current_user = request.user_id
+        progress = app_instance.progress_agent.get_user_progress(request.user_id, request.skill)
+        
+        lesson = await app_instance.lesson_agent.generate_lesson(
+            skill=request.skill,
+            difficulty=request.difficulty or progress.current_difficulty,
+            previous_lessons=[]
+        )
+        
+        return {
+            "lesson": {
+                "title": lesson.title,
+                "content": lesson.content,
+                "skill": lesson.skill,
+                "difficulty": lesson.difficulty,
+                "duration_minutes": lesson.duration_minutes,
+                "key_concepts": lesson.key_concepts
+            },
+            "user_context": {
+                "user_id": request.user_id,
+                "current_difficulty": progress.current_difficulty,
+                "lessons_completed": progress.lessons_completed
+            },
+            "mcp_server": "Agentic Skill Builder",
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating lesson: {str(e)}")
+
+@mcp_app.get("/mcp/progress/{user_id}")
+async def get_user_progress_mcp(user_id: str, skill: str = None):
+    """Get user progress data via MCP endpoint"""
+    try:
+        if skill:
+            progress = app_instance.progress_agent.get_user_progress(user_id, skill)
+            recommendation = app_instance.progress_agent.get_recommendation(progress)
+            
+            return {
+                "user_id": progress.user_id,
+                "skill": progress.skill,
+                "lessons_completed": progress.lessons_completed,
+                "average_score": progress.get_average_score(),
+                "current_difficulty": progress.current_difficulty,
+                "recommendations": recommendation,
+                "mcp_server": "Agentic Skill Builder"
+            }
+        else:
+            user_progress_data = {}
+            for key, progress in app_instance.progress_agent.user_data.items():
+                if progress.user_id == user_id:
+                    user_progress_data[progress.skill] = {
+                        "lessons_completed": progress.lessons_completed,
+                        "average_score": progress.get_average_score(),
+                        "current_difficulty": progress.current_difficulty,
+                        "quiz_scores": progress.quiz_scores,
+                        "last_activity": progress.last_activity
+                    }
+            
+            return {
+                "user_id": user_id,
+                "skills_progress": user_progress_data,
+                "total_skills_learning": len(user_progress_data),
+                "mcp_server": "Agentic Skill Builder",
+                "timestamp": datetime.now().isoformat()
+            }
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching progress: {str(e)}")
+
+@mcp_app.post("/mcp/quiz/submit")
+async def submit_quiz_results_mcp(submission: QuizSubmission):
+    """Submit quiz results via MCP endpoint"""
+    try:
+        app_instance.current_user = submission.user_id
+        
+        if not app_instance.current_quiz or len(submission.answers) == 0:
+            raise HTTPException(status_code=400, detail="No active quiz or no answers provided")
+        
+        correct_answers = 0
+        total_questions = len(app_instance.current_quiz.questions)
+        
+        for i, (question, answer) in enumerate(zip(app_instance.current_quiz.questions, submission.answers)):
+            if i >= len(submission.answers):
+                break
+                
+            correct_answer = str(question['correct_answer']).lower()
+            user_answer = answer.lower().strip()
+            
+            if user_answer == correct_answer:
+                correct_answers += 1
+        
+        score = correct_answers / total_questions if total_questions > 0 else 0
+        
+        progress = app_instance.progress_agent.update_progress(
+            submission.user_id, submission.skill, quiz_score=score
+        )
+        
+        recommendation = app_instance.progress_agent.get_recommendation(progress)
+        
+        return {
+            "quiz_results": {
+                "score": score,
+                "correct_answers": correct_answers,
+                "total_questions": total_questions,
+                "percentage": f"{score:.1%}"
+            },
+            "updated_progress": {
+                "lessons_completed": progress.lessons_completed,
+                "average_score": progress.get_average_score(),
+                "current_difficulty": progress.current_difficulty
+            },
+            "recommendation": recommendation,
+            "mcp_server": "Agentic Skill Builder",
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing quiz submission: {str(e)}")
+
+# ===== GRADIO INTERFACE =====
+
+def create_interface():
+    """Create the Gradio interface with enhanced hackathon features"""
+    
+    with gr.Blocks(
+        title="Agentic Skill Builder - MCP Hackathon 2025",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 900px !important;
+            margin: auto !important;
+        }
+        .hackathon-header {
+            background: linear-gradient(90deg, #ff7b7b, #667eea);
+            color: white;
+            padding: 1rem;
+            border-radius: 10px;
+            margin-bottom: 1rem;
+        }
+        """
+    ) as demo:
+        
+        # Enhanced Header for Hackathon
+        gr.HTML("""
+        <div class="hackathon-header">
+            <h1>🚀 Agentic Skill Builder</h1>
+            <h3>AI-Powered Microlearning with MCP Integration</h3>
+            <p><strong>🏆 Gradio Agents & MCP Hackathon 2025 Submission</strong></p>
+            <p>Track: MCP Server/Tool • Demonstrating Agentic AI Workflows</p>
+        </div>
+        """)
+        
+        # State variables
+        current_skill = gr.State("")
+        
+        with gr.Tab("🎯 Microlearning Experience"):
+            gr.Markdown("""
+            ### 🎓 Start Your AI-Powered Learning Journey
+            Choose any skill and let our agentic AI system create personalized lessons and adaptive quizzes for you!
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    skill_dropdown = gr.Dropdown(
+                        choices=app_instance.predefined_skills,
+                        label="📚 Select a Popular Skill",
+                        info="Choose from trending skills..."
+                    )
+                    custom_skill = gr.Textbox(
+                        label="✍️ Or Enter Any Custom Skill",
+                        info="e.g., Quantum Computing, Meditation, Game Development...",
+                        placeholder="What would you like to learn today?"
+                    )
+                    
+                    start_btn = gr.Button("🚀 Start Learning", variant="primary", size="lg")
+            
+            # Learning content areas
+            lesson_output = gr.Markdown(visible=False)
+            lesson_btn = gr.Button("Complete Lesson", visible=False)
+            
+            quiz_output = gr.Markdown(visible=False)
+            quiz_inputs = []
+            for i in range(5):
+                quiz_inputs.append(gr.Textbox(label=f"Answer {i+1}", visible=False))
+            
+            quiz_submit_btn = gr.Button("Submit Quiz", visible=False)
+            results_output = gr.Markdown(visible=False)
+            restart_btn = gr.Button("Start New Lesson", visible=False)
+        
+        with gr.Tab("📊 Progress Analytics"):
+            gr.Markdown("### 📈 Your Learning Analytics Dashboard")
+            progress_display = gr.Markdown("Complete some lessons to see your learning analytics!")
+            refresh_progress_btn = gr.Button("🔄 Refresh Progress")
+        
+        with gr.Tab("🔗 MCP Server Demo"):
+            gr.Markdown("""
+            ### 🤖 Model Context Protocol Integration
+            
+            **This app is BOTH a Gradio interface AND an MCP server!**
+            
+            #### 🌐 Available MCP Endpoints:
+            
+            - **GET `/mcp/skills`** - List available learning skills
+            - **POST `/mcp/lesson/generate`** - Generate personalized lessons
+            - **GET `/mcp/progress/{user_id}`** - Get learning progress data
+            - **POST `/mcp/quiz/submit`** - Submit quiz answers
+            
+            #### 🧪 Try the MCP Server:
+            
+            The MCP server is running alongside this Gradio interface! External agents can connect to these endpoints to:
+            - Generate lessons for any skill
+            - Track learning progress
+            - Submit quiz results
+            - Access learning analytics
+            
+            **Example MCP Usage:**
+            ```bash
+            # Get available skills
+            curl https://your-space-url.com/mcp/skills
+            
+            # Generate a lesson
+            curl -X POST https://your-space-url.com/mcp/lesson/generate \\
+                 -H "Content-Type: application/json" \\
+                 -d '{"skill": "Python Programming", "user_id": "agent_user"}'
+            ```
+            
+            #### 🎯 Hackathon Innovation:
+            - **Agentic Architecture**: Multiple AI agents (Lesson, Quiz, Progress) collaborate
+            - **MCP Protocol**: Full Model Context Protocol implementation
+            - **Adaptive Learning**: AI adjusts difficulty based on performance
+            - **Real-time Integration**: Seamless connection between UI and MCP endpoints
+            """)
+            
+            # MCP Demo Interface
+            gr.Markdown("#### 🧪 Test MCP Endpoints Directly:")
+            
+            with gr.Row():
+                with gr.Column():
+                    mcp_skill_input = gr.Textbox(label="Skill for MCP Test", value="Python Programming")
+                    mcp_user_input = gr.Textbox(label="User ID for MCP Test", value="mcp_test_user")
+                    mcp_test_btn = gr.Button("🧪 Test MCP Lesson Generation", variant="secondary")
+                
+                with gr.Column():
+                    mcp_output = gr.JSON(label="MCP Server Response")
+        
+        # Event handlers (same as original app.py)
+        async def handle_start_learning(skill_choice, custom_skill_input):
+            skill = custom_skill_input.strip() if custom_skill_input.strip() else skill_choice
+            if not skill:
+                return [
+                    gr.update(value="⚠️ Please select or enter a skill to continue."),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    skill
+                ] + [gr.update(visible=False, value="") for _ in range(5)]
+            
+            lesson_content, btn_text, _ = await app_instance.start_lesson(skill)
+            
+            return [
+                gr.update(value=lesson_content),
+                gr.update(value=btn_text, visible=True),
+                gr.update(visible=False),
+                skill
+            ] + [gr.update(visible=False, value="") for _ in range(5)]
+        
+        async def handle_complete_lesson():
+            quiz_content, btn_text, _ = await app_instance.complete_lesson_and_start_quiz()
+            
+            quiz_updates = []
+            if app_instance.current_quiz:
+                for i, question in enumerate(app_instance.current_quiz.questions):
+                    if i < len(quiz_inputs):
+                        label = f"Q{i+1}: {question['question'][:50]}..."
+                        quiz_updates.append(gr.update(label=label, visible=True))
+                    else:
+                        quiz_updates.append(gr.update(visible=False))
+                for i in range(len(app_instance.current_quiz.questions), len(quiz_inputs)):
+                    quiz_updates.append(gr.update(visible=False))
+            else:
+                quiz_updates = [gr.update(visible=False) for _ in range(len(quiz_inputs))]
+            
+            return [
+                gr.update(visible=False),
+                gr.update(value=quiz_content, visible=True),
+                gr.update(value=btn_text, visible=True),
+                gr.update(visible=False)
+            ] + quiz_updates
+        
+        def handle_submit_quiz(*answers):
+            valid_answers = [ans for ans in answers if ans is not None and ans != ""]
+            results_content, btn_text, _ = app_instance.submit_quiz(*valid_answers)
+            
+            return [
+                gr.update(visible=False),
+                gr.update(value=results_content, visible=True),
+                gr.update(value=btn_text, visible=True),
+                gr.update(visible=False)
+            ] + [gr.update(visible=False) for _ in range(len(quiz_inputs))]
+        
+        def handle_restart():
+            return [
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                ""
+            ] + [gr.update(visible=False, value="") for _ in range(len(quiz_inputs))]
+        
+        def update_progress_display():
+            if not app_instance.progress_agent.user_data:
+                return "**No learning data yet.** Complete some lessons to see your progress!"
+            
+            progress_content = "# 📊 Your Learning Progress\n\n"
+            for key, progress in app_instance.progress_agent.user_data.items():
+                progress_content += f"""
+                **Skill:** {progress.skill}
+                - Lessons completed: {progress.lessons_completed}
+                - Average quiz score: {progress.get_average_score():.1%}
+                - Current difficulty: {progress.current_difficulty.title()}
+                - Last activity: {progress.last_activity or 'Never'}
+                
+                """
+            return progress_content
+        
+        async def test_mcp_endpoint(skill, user_id):
+            """Test MCP endpoint directly from the interface"""
+            try:
+                # Simulate MCP endpoint call
+                request_data = {
+                    "skill": skill,
+                    "user_id": user_id,
+                    "difficulty": "beginner"
+                }
+                
+                # Generate lesson using the app instance
+                app_instance.current_user = user_id
+                progress = app_instance.progress_agent.get_user_progress(user_id, skill)
+                lesson = await app_instance.lesson_agent.generate_lesson(skill, progress.current_difficulty, [])
+                
+                response = {
+                    "mcp_endpoint": "/mcp/lesson/generate",
+                    "request": request_data,
+                    "response": {
+                        "lesson": {
+                            "title": lesson.title,
+                            "content": lesson.content[:200] + "...",  # Truncated for display
+                            "skill": lesson.skill,
+                            "difficulty": lesson.difficulty,
+                            "duration_minutes": lesson.duration_minutes,
+                            "key_concepts": lesson.key_concepts
+                        },
+                        "user_context": {
+                            "user_id": user_id,
+                            "current_difficulty": progress.current_difficulty,
+                            "lessons_completed": progress.lessons_completed
+                        },
+                        "mcp_server": "Agentic Skill Builder",
+                        "status": "success"
+                    }
+                }
+                
+                return response
+                
+            except Exception as e:
+                return {
+                    "mcp_endpoint": "/mcp/lesson/generate", 
+                    "error": str(e),
+                    "status": "error"
+                }
+        
+        # Wire up events
+        start_btn.click(
+            handle_start_learning,
+            inputs=[skill_dropdown, custom_skill],
+            outputs=[lesson_output, lesson_btn, quiz_output, current_skill] + quiz_inputs[:5]
+        )
+        
+        lesson_btn.click(
+            handle_complete_lesson,
+            outputs=[lesson_btn, quiz_output, quiz_submit_btn, results_output] + quiz_inputs
+        )
+        
+        quiz_submit_btn.click(
+            handle_submit_quiz,
+            inputs=quiz_inputs,
+            outputs=[quiz_submit_btn, results_output, restart_btn, quiz_output] + quiz_inputs
+        )
+        
+        restart_btn.click(
+            handle_restart,
+            outputs=[lesson_output, quiz_output, results_output, lesson_btn, restart_btn, current_skill] + quiz_inputs
+        )
+        
+        refresh_progress_btn.click(
+            update_progress_display,
+            outputs=[progress_display]
+        )
+        
+        mcp_test_btn.click(
+            test_mcp_endpoint,
+            inputs=[mcp_skill_input, mcp_user_input],
+            outputs=[mcp_output]
+        )
+    
+    return demo
+
+# ===== MAIN APPLICATION =====
+
+def run_mcp_server():
+    """Run the MCP server in a separate thread"""
+    uvicorn.run(
+        mcp_app,
+        host="0.0.0.0",
+        port=8001,  # Different port to avoid conflicts
+        log_level="info"
+    )
+
+def main():
+    """Main application entry point for Hugging Face Spaces"""
+    # Start MCP server in background thread
+    mcp_thread = threading.Thread(target=run_mcp_server, daemon=True)
+    mcp_thread.start()
+    
+    # Give MCP server time to start
+    time.sleep(2)
+    
+    # Create and launch Gradio interface
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,  # Enable sharing for demo purposes
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

validate_hackathon.py

@@ -0,0 +1,235 @@
+"""
+Hackathon Validation Script
+Tests the MCP server functionality for submission requirements
+"""
+
+import asyncio
+import requests
+import time
+import subprocess
+import threading
+from datetime import datetime
+
+def test_mcp_server_endpoints():
+    """Test MCP server endpoints to ensure hackathon compliance"""
+    print("🧪 HACKATHON VALIDATION - MCP SERVER TESTING")
+    print("=" * 60)
+    
+    base_url = "http://localhost:8001"  # MCP server port
+    
+    tests = [
+        ("Root endpoint", "GET", "/"),
+        ("Skills list", "GET", "/mcp/skills"),
+        ("Progress endpoint", "GET", "/mcp/progress/test_user"),
+    ]
+    
+    print(f"🌐 Testing MCP server at {base_url}")
+    print(f"📋 Running {len(tests)} endpoint tests...\n")
+    
+    results = []
+    
+    for test_name, method, endpoint in tests:
+        try:
+            url = f"{base_url}{endpoint}"
+            print(f"🔄 Testing {test_name}: {method} {endpoint}")
+            
+            if method == "GET":
+                response = requests.get(url, timeout=5)
+            elif method == "POST":
+                response = requests.post(url, json={}, timeout=5)
+            
+            if response.status_code == 200:
+                print(f"  ✅ SUCCESS: {response.status_code}")
+                try:
+                    data = response.json()
+                    if "mcp" in str(data).lower() or "agentic" in str(data).lower():
+                        print(f"  🎯 MCP-compliant response detected")
+                except:
+                    pass
+                results.append((test_name, True, response.status_code))
+            else:
+                print(f"  ❌ FAILED: {response.status_code}")
+                results.append((test_name, False, response.status_code))
+                
+        except requests.exceptions.RequestException as e:
+            print(f"  ❌ CONNECTION ERROR: {e}")
+            results.append((test_name, False, "Connection Error"))
+        
+        print()
+    
+    # Summary
+    print("📊 TEST SUMMARY")
+    print("-" * 40)
+    passed = sum(1 for _, success, _ in results if success)
+    total = len(results)
+    print(f"✅ Passed: {passed}/{total}")
+    
+    if passed == total:
+        print("🎉 ALL MCP ENDPOINT TESTS PASSED!")
+    else:
+        print("⚠️  Some tests failed. Check the MCP server.")
+    
+    return results
+
+def test_post_endpoints():
+    """Test POST endpoints with sample data"""
+    print("\n🧪 TESTING POST ENDPOINTS")
+    print("=" * 40)
+    
+    base_url = "http://localhost:8001"
+    
+    # Test lesson generation
+    try:
+        print("🔄 Testing lesson generation...")
+        lesson_data = {
+            "skill": "Python Programming",
+            "user_id": "test_user",
+            "difficulty": "beginner"
+        }
+        response = requests.post(f"{base_url}/mcp/lesson/generate", json=lesson_data, timeout=10)
+        if response.status_code == 200:
+            print("  ✅ Lesson generation successful")
+            data = response.json()
+            if "lesson" in data:
+                print("  🎯 Lesson data structure valid")
+        else:
+            print(f"  ❌ Lesson generation failed: {response.status_code}")
+    except Exception as e:
+        print(f"  ❌ Lesson generation error: {e}")
+
+    # Test quiz submission
+    try:
+        print("🔄 Testing quiz submission...")
+        quiz_data = {
+            "user_id": "test_user",
+            "skill": "Python Programming",
+            "lesson_title": "Variables and Data Types",
+            "answers": ["correct", "incorrect", "correct"]
+        }
+        response = requests.post(f"{base_url}/mcp/quiz/submit", json=quiz_data, timeout=10)
+        if response.status_code == 200:
+            print("  ✅ Quiz submission successful")
+        else:
+            print(f"  ❌ Quiz submission failed: {response.status_code}")
+    except Exception as e:
+        print(f"  ❌ Quiz submission error: {e}")
+
+def validate_hackathon_requirements():
+    """Validate all hackathon submission requirements"""
+    print("\n🏆 HACKATHON SUBMISSION VALIDATION")
+    print("=" * 50)
+    
+    requirements = []
+    
+    # Check README.md for required tag
+    try:
+        with open("README.md", "r", encoding="utf-8") as f:
+            readme_content = f.read()
+            if "mcp-server-track" in readme_content:
+                print("✅ README.md contains 'mcp-server-track' tag")
+                requirements.append(("README tag", True))
+            else:
+                print("❌ README.md missing 'mcp-server-track' tag")
+                requirements.append(("README tag", False))
+    except FileNotFoundError:
+        print("❌ README.md not found")
+        requirements.append(("README file", False))
+    
+    # Check for demo video link
+    try:
+        with open("README.md", "r", encoding="utf-8") as f:
+            readme_content = f.read()
+            if "demo-video-link.com" in readme_content or "your-demo-video-link.com" in readme_content:
+                print("⚠️  Demo video link is placeholder - needs actual video")
+                requirements.append(("Demo video", False))
+            elif any(video_keyword in readme_content.lower() for video_keyword in ["youtube.com", "vimeo.com", "loom.com", "demo video"]):
+                print("✅ Demo video link appears to be present")
+                requirements.append(("Demo video", True))
+            else:
+                print("❌ Demo video link not found")
+                requirements.append(("Demo video", False))
+    except:
+        requirements.append(("Demo video check", False))
+    
+    # Check space_app.py exists and has MCP endpoints
+    try:
+        with open("space_app.py", "r", encoding="utf-8") as f:
+            app_content = f.read()
+            if "FastAPI" in app_content and "@mcp_app" in app_content:
+                print("✅ space_app.py has MCP server integration")
+                requirements.append(("MCP integration", True))
+            else:
+                print("❌ space_app.py missing MCP server integration")
+                requirements.append(("MCP integration", False))
+    except FileNotFoundError:
+        print("❌ space_app.py not found")
+        requirements.append(("Main app file", False))
+    
+    # Check requirements.txt
+    try:
+        with open("requirements.txt", "r") as f:
+            reqs = f.read()
+            if "gradio" in reqs and "fastapi" in reqs:
+                print("✅ requirements.txt has necessary dependencies")
+                requirements.append(("Dependencies", True))
+            else:
+                print("❌ requirements.txt missing key dependencies")
+                requirements.append(("Dependencies", False))
+    except FileNotFoundError:
+        print("❌ requirements.txt not found")
+        requirements.append(("Requirements file", False))
+    
+    print("\n📋 SUBMISSION CHECKLIST")
+    print("-" * 30)
+    passed = sum(1 for _, success in requirements if success)
+    total = len(requirements)
+    
+    for req_name, success in requirements:
+        status = "✅" if success else "❌"
+        print(f"{status} {req_name}")
+    
+    print(f"\n📊 Overall Score: {passed}/{total}")
+    
+    if passed == total:
+        print("🎉 READY FOR HACKATHON SUBMISSION!")
+    else:
+        print("⚠️  Please address the failed requirements above.")
+    
+    return requirements
+
+def main():
+    """Main validation function"""
+    print("🚀 AGENTIC SKILL BUILDER - HACKATHON VALIDATION")
+    print("=" * 60)
+    print(f"⏰ Validation Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print()
+    
+    # First validate file-based requirements
+    validate_hackathon_requirements()
+    
+    # Ask user if they want to test the running server
+    print("\n" + "="*60)
+    print("🌐 MCP SERVER TESTING")
+    print("To test MCP endpoints, the server should be running on localhost:8001")
+    print("You can start it with: python space_app.py")
+    
+    try:
+        # Try to test if server is running
+        response = requests.get("http://localhost:8001", timeout=2)
+        print("✅ Server detected running!")
+        test_mcp_server_endpoints()
+        test_post_endpoints()
+    except:
+        print("⚠️  Server not detected. Start the server to test MCP endpoints.")
+        print("   Command: python space_app.py")
+    
+    print("\n" + "="*60)
+    print("🎯 NEXT STEPS FOR HACKATHON SUBMISSION:")
+    print("1. 📹 Record demo video showing MCP server in action")
+    print("2. 🔗 Update README.md with actual demo video link")
+    print("3. 🚀 Upload to Hugging Face Spaces under Agents-MCP-Hackathon org")
+    print("4. ✅ Ensure all MCP endpoints work in the deployed Space")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()