adding app content and source files

app.py

@@ -1,7 +1,768 @@
+#!/usr/bin/env python3
+"""
+Docs Navigator MCP - Modern Gradio UI
+
+An elegant, AI-powered documentation assistant with advanced features.
+"""
+
+import os
 import gradio as gr
+from pathlib import Path
+from typing import List, Dict, Optional
+from anthropic import Anthropic
+from dotenv import load_dotenv
+from document_intelligence import DocumentIntelligence
+import time
+
+# Load environment variables
+load_dotenv()
+
+# Configuration
+DOCS_DIR = Path(__file__).parent / "docs"
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+
+# Initialize services
+client = Anthropic(api_key=ANTHROPIC_API_KEY)
+doc_intelligence = DocumentIntelligence(DOCS_DIR)
+
+# Supported file extensions
+SUPPORTED_EXTENSIONS = {'.md', '.txt', '.rst', '.pdf'}
+
+
+def load_documentation() -> str:
+    """Load all documentation files into a single context."""
+    all_docs = []
+    
+    if not DOCS_DIR.exists():
+        return "Documentation directory not found."
+    
+    for file_path in DOCS_DIR.rglob('*'):
+        if file_path.is_file() and file_path.suffix in SUPPORTED_EXTENSIONS:
+            try:
+                if file_path.suffix == '.pdf':
+                    content = extract_pdf_content(file_path)
+                else:
+                    content = file_path.read_text(encoding='utf-8', errors='ignore')
+                
+                relative_path = file_path.relative_to(DOCS_DIR)
+                all_docs.append(f"=== {relative_path} ===\n{content}\n")
+            except Exception as e:
+                all_docs.append(f"=== {file_path.name} ===\nError reading file: {str(e)}\n")
+    
+    return "\n\n".join(all_docs) if all_docs else "No documentation files found."
+
+
+def extract_pdf_content(pdf_path: Path) -> str:
+    """Extract text content from PDF files."""
+    try:
+        from PyPDF2 import PdfReader
+        reader = PdfReader(pdf_path)
+        content = []
+        
+        for i, page in enumerate(reader.pages, 1):
+            try:
+                text = page.extract_text()
+                content.append(f"--- Page {i} ---\n{text}")
+            except Exception as e:
+                content.append(f"--- Page {i} (Error reading: {str(e)}) ---")
+        
+        return "\n\n".join(content)
+    except Exception as e:
+        return f"Error extracting PDF: {str(e)}"
+
+
+def get_available_files() -> List[str]:
+    """Get list of available documentation files."""
+    files = []
+    if DOCS_DIR.exists():
+        for file_path in DOCS_DIR.rglob('*'):
+            if file_path.is_file() and file_path.suffix in SUPPORTED_EXTENSIONS:
+                files.append(str(file_path.relative_to(DOCS_DIR)))
+    return sorted(files)
+
+
+def chat_with_docs(message: str, history: List[dict], system_prompt: str = None) -> str:
+    """Process user message and generate AI response."""
+    if not ANTHROPIC_API_KEY:
+        return "⚠️ Please set your ANTHROPIC_API_KEY in the .env file."
+    
+    # Load documentation context
+    docs_context = load_documentation()
+    
+    # Build conversation history from messages format
+    messages = []
+    for msg in history:
+        if msg.get("role") == "user":
+            messages.append({"role": "user", "content": msg["content"]})
+        elif msg.get("role") == "assistant":
+            messages.append({"role": "assistant", "content": msg["content"]})
+    
+    messages.append({"role": "user", "content": message})
+    
+    # Default system prompt
+    default_system = f"""You are an expert documentation assistant. You have access to the following documentation:
+
+{docs_context}
+
+Your role is to:
+- Answer questions accurately based on the documentation
+- Provide clear, concise, and helpful responses
+- Reference specific sections when relevant
+- Admit when information is not in the documentation
+- Use markdown formatting for better readability
+- Be friendly and professional
+
+Always base your answers on the provided documentation."""
+    
+    system = system_prompt if system_prompt else default_system
+    
+    try:
+        # Call Claude API with streaming
+        response_text = ""
+        with client.messages.stream(
+            model="claude-3-haiku-20240307",
+            max_tokens=4096,
+            system=system,
+            messages=messages
+        ) as stream:
+            for text in stream.text_stream:
+                response_text += text
+        
+        return response_text
+    
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+def get_document_stats() -> str:
+    """Get statistics about the documentation."""
+    if not DOCS_DIR.exists():
+        return "📁 No documentation directory found"
+    
+    files = list(DOCS_DIR.rglob('*'))
+    doc_files = [f for f in files if f.is_file() and f.suffix in SUPPORTED_EXTENSIONS]
+    
+    total_size = sum(f.stat().st_size for f in doc_files) / 1024  # KB
+    
+    stats = f"""
+📊 **Documentation Statistics**
+
+- 📄 Total Files: {len(doc_files)}
+- 💾 Total Size: {total_size:.1f} KB
+- 📁 Directory: `{DOCS_DIR.name}/`
+
+**File Types:**
+"""
+    
+    by_type = {}
+    for f in doc_files:
+        ext = f.suffix
+        by_type[ext] = by_type.get(ext, 0) + 1
+    
+    for ext, count in sorted(by_type.items()):
+        stats += f"\n- {ext}: {count} files"
+    
+    return stats
+
+
+def analyze_document(file_name: str, analysis_type: str) -> str:
+    """Analyze a specific document."""
+    if not file_name:
+        return "⚠️ Please select a file to analyze"
+    
+    file_path = DOCS_DIR / file_name
+    
+    if not file_path.exists():
+        return f"❌ File not found: {file_name}"
+    
+    try:
+        if file_path.suffix == '.pdf':
+            content = extract_pdf_content(file_path)
+        else:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+        
+        if analysis_type == "Summary":
+            summary = doc_intelligence.generate_smart_summary(content, "medium")
+            return f"📝 **Summary of {file_name}**\n\n{summary}"
+        
+        elif analysis_type == "Key Concepts":
+            concepts = doc_intelligence.extract_key_concepts(content)
+            result = f"🔑 **Key Concepts in {file_name}**\n\n"
+            for i, concept in enumerate(concepts[:10], 1):
+                result += f"{i}. **{concept['concept']}** ({concept['type']}) - appears {concept['frequency']} times\n"
+            return result
+        
+        elif analysis_type == "Readability":
+            analysis = doc_intelligence.analyze_readability(content)
+            return f"""
+📊 **Readability Analysis of {file_name}**
+
+- **Flesch Reading Ease**: {analysis['flesch_score']} ({analysis['complexity']})
+- **Grade Level**: {analysis['grade_level']}
+- **Avg Sentence Length**: {analysis['avg_sentence_length']} words
+- **Total Words**: {analysis['total_words']}
+- **Total Sentences**: {analysis['total_sentences']}
+"""
+        
+        elif analysis_type == "Q&A Extraction":
+            qa_pairs = doc_intelligence.extract_questions_and_answers(content)
+            if not qa_pairs:
+                return f"❓ No Q&A pairs found in {file_name}"
+            
+            result = f"❓ **Questions & Answers from {file_name}**\n\n"
+            for i, qa in enumerate(qa_pairs[:5], 1):
+                result += f"**Q{i}:** {qa['question']}\n**A:** {qa['answer']}\n\n"
+            return result
+    
+    except Exception as e:
+        return f"❌ Error analyzing file: {str(e)}"
+
+
+# Custom CSS for sleek dark mode design with messenger-style chat
+custom_css = """
+/* Dark mode color scheme */
+:root {
+    --bg-primary: #0d1117;
+    --bg-secondary: #161b22;
+    --bg-tertiary: #21262d;
+    --accent-primary: #8b5cf6;
+    --accent-secondary: #a78bfa;
+    --accent-glow: rgba(139, 92, 246, 0.3);
+    --text-primary: #e6edf3;
+    --text-secondary: #8b949e;
+    --border-color: #30363d;
+    --message-user: #8b5cf6;
+    --message-bot: #1f2937;
+}
+
+/* Main container - full dark mode */
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif !important;
+    background: var(--bg-primary) !important;
+}
+
+body, .gradio-container, .main, .contain {
+    background: var(--bg-primary) !important;
+}
+
+/* Header styling - sleek gradient */
+.header-container {
+    background: linear-gradient(135deg, #8b5cf6 0%, #6366f1 50%, #ec4899 100%);
+    padding: 2.5rem 2rem;
+    border-radius: 16px;
+    margin-bottom: 2rem;
+    box-shadow: 0 20px 60px rgba(139, 92, 246, 0.4);
+    border: 1px solid rgba(139, 92, 246, 0.2);
+}
+
+.header-title {
+    color: white;
+    font-size: 2.8rem;
+    font-weight: 900;
+    margin: 0;
+    text-align: center;
+    text-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+    letter-spacing: -0.02em;
+}
+
+.header-subtitle {
+    color: rgba(255, 255, 255, 0.95);
+    font-size: 1.15rem;
+    text-align: center;
+    margin-top: 0.75rem;
+    font-weight: 500;
+    letter-spacing: 0.01em;
+}
+
+/* Messenger-style chat window */
+.chatbot.svelte-1w8gs39 {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 16px !important;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4) !important;
+}
+
+/* Chat messages - messenger style */
+.message-wrap {
+    padding: 0.5rem 1rem !important;
+}
+
+.user-message {
+    background: linear-gradient(135deg, var(--message-user) 0%, #a78bfa 100%) !important;
+    color: white !important;
+    border-radius: 18px 18px 4px 18px !important;
+    padding: 0.875rem 1.25rem !important;
+    margin: 0.5rem 0 !important;
+    max-width: 75% !important;
+    margin-left: auto !important;
+    box-shadow: 0 4px 12px rgba(139, 92, 246, 0.3) !important;
+    font-size: 0.95rem !important;
+    line-height: 1.5 !important;
+}
+
+.bot-message {
+    background: var(--message-bot) !important;
+    color: var(--text-primary) !important;
+    border-radius: 18px 18px 18px 4px !important;
+    padding: 0.875rem 1.25rem !important;
+    margin: 0.5rem 0 !important;
+    max-width: 85% !important;
+    border: 1px solid var(--border-color) !important;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2) !important;
+    font-size: 0.95rem !important;
+    line-height: 1.6 !important;
+}
+
+/* Button styling - modern purple gradient */
+button, .primary-button {
+    background: linear-gradient(135deg, #8b5cf6 0%, #6366f1 100%) !important;
+    border: none !important;
+    border-radius: 12px !important;
+    font-weight: 600 !important;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1) !important;
+    box-shadow: 0 4px 16px var(--accent-glow) !important;
+    color: white !important;
+    padding: 0.75rem 1.5rem !important;
+}
+
+button:hover, .primary-button:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 24px rgba(139, 92, 246, 0.5) !important;
+    background: linear-gradient(135deg, #9d72ff 0%, #7c7eff 100%) !important;
+}
+
+/* Tabs - dark mode */
+.tabs {
+    background: var(--bg-secondary) !important;
+    border-radius: 16px !important;
+    border: 1px solid var(--border-color) !important;
+}
+
+.tab-nav {
+    background: var(--bg-tertiary) !important;
+    border-radius: 12px 12px 0 0 !important;
+    border-bottom: 1px solid var(--border-color) !important;
+    padding: 0.5rem !important;
+}
+
+.tab-nav button {
+    font-weight: 600 !important;
+    border-radius: 10px !important;
+    color: var(--text-secondary) !important;
+    border: none !important;
+    transition: all 0.3s ease !important;
+    padding: 0.75rem 1.5rem !important;
+    margin: 0 0.25rem !important;
+}
+
+.tab-nav button:hover {
+    background: rgba(139, 92, 246, 0.1) !important;
+    color: var(--accent-secondary) !important;
+}
+
+.tab-nav button.selected {
+    background: linear-gradient(135deg, #8b5cf6 0%, #6366f1 100%) !important;
+    color: white !important;
+    box-shadow: 0 4px 12px var(--accent-glow) !important;
+}
+
+/* Input fields - dark mode */
+textarea, input, .input-box {
+    background: var(--bg-tertiary) !important;
+    border: 2px solid var(--border-color) !important;
+    border-radius: 12px !important;
+    color: var(--text-primary) !important;
+    transition: all 0.3s ease !important;
+    padding: 0.875rem 1rem !important;
+}
+
+textarea:focus, input:focus, .input-box:focus {
+    border-color: var(--accent-primary) !important;
+    box-shadow: 0 0 0 3px var(--accent-glow) !important;
+    background: var(--bg-secondary) !important;
+    outline: none !important;
+}
+
+textarea::placeholder, input::placeholder {
+    color: var(--text-secondary) !important;
+    opacity: 0.8 !important;
+}
+
+/* Dropdown styling */
+.dropdown, select {
+    background: var(--bg-tertiary) !important;
+    border: 2px solid var(--border-color) !important;
+    border-radius: 12px !important;
+    color: var(--text-primary) !important;
+    padding: 0.75rem 1rem !important;
+}
+
+/* Stats and info cards - dark mode */
+.stats-box, .info-card {
+    background: var(--bg-secondary) !important;
+    padding: 1.75rem !important;
+    border-radius: 16px !important;
+    border: 1px solid var(--border-color) !important;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3) !important;
+    color: var(--text-primary) !important;
+    transition: transform 0.3s ease, box-shadow 0.3s ease !important;
+}
+
+.info-card:hover, .stats-box:hover {
+    transform: translateY(-4px) !important;
+    box-shadow: 0 12px 32px rgba(139, 92, 246, 0.2) !important;
+    border-color: var(--accent-primary) !important;
+}
+
+/* Markdown content styling - dark mode */
+.markdown-text, .prose {
+    color: var(--text-primary) !important;
+}
+
+.markdown-text h1, .markdown-text h2, .markdown-text h3,
+.prose h1, .prose h2, .prose h3 {
+    color: var(--accent-secondary) !important;
+    font-weight: 700 !important;
+}
+
+.markdown-text strong, .prose strong {
+    color: var(--text-primary) !important;
+    font-weight: 700 !important;
+}
+
+.markdown-text code, .prose code {
+    background: var(--bg-tertiary) !important;
+    color: var(--accent-secondary) !important;
+    padding: 0.2rem 0.5rem !important;
+    border-radius: 6px !important;
+    font-size: 0.9em !important;
+    border: 1px solid var(--border-color) !important;
+}
+
+.markdown-text pre, .prose pre {
+    background: #1a1b26 !important;
+    color: #a9b1d6 !important;
+    padding: 1.25rem !important;
+    border-radius: 12px !important;
+    overflow-x: auto !important;
+    border: 1px solid var(--border-color) !important;
+}
+
+/* Labels and text */
+label, .label {
+    color: var(--text-primary) !important;
+    font-weight: 600 !important;
+    font-size: 0.95rem !important;
+    margin-bottom: 0.5rem !important;
+}
+
+.secondary-text {
+    color: var(--text-secondary) !important;
+}
+
+/* Remove white backgrounds globally */
+.block, .form, .panel {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 12px !important;
+}
+
+/* Scrollbar styling for dark mode */
+::-webkit-scrollbar {
+    width: 10px;
+    height: 10px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+    border-radius: 8px;
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--border-color);
+    border-radius: 8px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--accent-primary);
+}
+
+/* Loading animation */
+.pending {
+    background: linear-gradient(90deg, var(--bg-tertiary) 25%, var(--border-color) 50%, var(--bg-tertiary) 75%);
+    background-size: 200% 100%;
+    animation: loading 1.5s ease-in-out infinite;
+}
+
+@keyframes loading {
+    0% { background-position: 200% 0; }
+    100% { background-position: -200% 0; }
+}
+
+/* Examples section */
+.examples {
+    background: var(--bg-tertiary) !important;
+    border-radius: 12px !important;
+    border: 1px solid var(--border-color) !important;
+    padding: 1rem !important;
+}
+
+.example-item {
+    background: var(--bg-secondary) !important;
+    border: 1px solid var(--border-color) !important;
+    border-radius: 8px !important;
+    color: var(--text-primary) !important;
+    transition: all 0.2s ease !important;
+}
+
+.example-item:hover {
+    background: var(--bg-tertiary) !important;
+    border-color: var(--accent-primary) !important;
+    transform: translateX(4px) !important;
+}
+
+/* Radio buttons */
+.radio-group {
+    background: var(--bg-tertiary) !important;
+    border-radius: 12px !important;
+    padding: 0.5rem !important;
+}
+"""
+
+# Create the Gradio interface with dark theme
+with gr.Blocks(
+    theme=gr.themes.Base(
+        primary_hue="purple",
+        secondary_hue="indigo",
+        neutral_hue="slate",
+        font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"]
+    ).set(
+        body_background_fill="#0d1117",
+        body_background_fill_dark="#0d1117",
+        block_background_fill="#161b22",
+        block_background_fill_dark="#161b22",
+        input_background_fill="#21262d",
+        input_background_fill_dark="#21262d",
+        button_primary_background_fill="linear-gradient(135deg, #8b5cf6 0%, #6366f1 100%)",
+        button_primary_background_fill_dark="linear-gradient(135deg, #8b5cf6 0%, #6366f1 100%)",
+    ),
+    css=custom_css,
+    title="Docs Navigator MCP - AI Documentation Assistant",
+) as demo:
+    
+    # Header with modern dark gradient
+    gr.HTML("""
+        <div class="header-container">
+            <h1 class="header-title">🚀 Docs Navigator MCP</h1>
+            <p class="header-subtitle">Intelligent Documentation Assistant Powered by Claude AI</p>
+        </div>
+    """)
+    
+    with gr.Tabs() as tabs:
+        # Chat Tab - Messenger Style
+        with gr.Tab("💬 Chat", id=0):
+            gr.HTML("""
+                <div style='padding: 1rem 0 0.5rem 0; color: var(--text-secondary); font-size: 0.95rem;'>
+                    <strong style='color: var(--accent-secondary);'>💬 AI Chat Assistant</strong><br>
+                    Ask anything about your documentation - I have full context of all your files.
+                </div>
+            """)
+            
+            chatbot = gr.Chatbot(
+                height=550,
+                placeholder="<div style='text-align: center; padding: 3rem; color: #8b949e;'><div style='font-size: 3rem; margin-bottom: 1rem;'>💬</div><div style='font-size: 1.2rem; font-weight: 600; color: #e6edf3; margin-bottom: 0.5rem;'>Start a Conversation</div><div>Ask me anything about your documentation!</div></div>",
+                show_label=False,
+                avatar_images=("👤", "🤖"),
+                type="messages",
+                layout="bubble",
+                show_copy_button=True
+            )
+            
+            with gr.Row():
+                msg = gr.Textbox(
+                    placeholder="💭 Message the docs assistant...",
+                    show_label=False,
+                    scale=5,
+                    container=False,
+                    lines=1,
+                    max_lines=3
+                )
+                submit_btn = gr.Button("Send", scale=1, variant="primary", elem_classes="primary-button", size="lg")
+            
+            with gr.Row():
+                clear_btn = gr.Button("🗑️ Clear", size="sm", variant="secondary")
+                gr.HTML("<div style='flex-grow: 1;'></div>")
+            
+            with gr.Accordion("💡 Example Questions", open=False):
+                gr.Examples(
+                    examples=[
+                        "What is this documentation about?",
+                        "How do I get started with setup?",
+                        "What are the main features?",
+                        "Show me troubleshooting steps",
+                        "What configuration options are available?",
+                        "Explain the architecture"
+                    ],
+                    inputs=msg,
+                    label=None
+                )
+        
+        # Document Analysis Tab
+        with gr.Tab("🔍 Analysis", id=1):
+            gr.HTML("""
+                <div style='padding: 1rem 0 0.5rem 0; color: var(--text-secondary); font-size: 0.95rem;'>
+                    <strong style='color: var(--accent-secondary);'>🔍 Document Intelligence</strong><br>
+                    Deep analysis of individual documentation files with AI-powered insights.
+                </div>
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    file_dropdown = gr.Dropdown(
+                        choices=get_available_files(),
+                        label="📄 Select Document",
+                        interactive=True,
+                        container=True
+                    )
+                    
+                    analysis_type = gr.Radio(
+                        choices=["Summary", "Key Concepts", "Readability", "Q&A Extraction"],
+                        value="Summary",
+                        label="🎯 Analysis Type",
+                        container=True
+                    )
+                    
+                    analyze_btn = gr.Button("🔎 Analyze Document", variant="primary", elem_classes="primary-button", size="lg")
+                    refresh_btn = gr.Button("🔄 Refresh Files", size="sm", variant="secondary")
+                
+                with gr.Column(scale=2):
+                    analysis_output = gr.Markdown(
+                        value="<div style='text-align: center; padding: 3rem; color: #8b949e;'><div style='font-size: 2.5rem; margin-bottom: 1rem;'>📊</div><div style='font-size: 1.1rem;'>Select a document and analysis type to begin</div></div>",
+                        elem_classes="info-card"
+                    )
+        
+        # Statistics Tab
+        with gr.Tab("📊 Stats", id=2):
+            gr.HTML("""
+                <div style='padding: 1rem 0 0.5rem 0; color: var(--text-secondary); font-size: 0.95rem;'>
+                    <strong style='color: var(--accent-secondary);'>📊 Documentation Overview</strong><br>
+                    Real-time statistics and insights about your documentation collection.
+                </div>
+            """)
+            
+            stats_display = gr.Markdown(
+                value=get_document_stats(),
+                elem_classes="stats-box"
+            )
+            
+            refresh_stats_btn = gr.Button("🔄 Refresh Statistics", variant="secondary", size="sm")
+        
+        # Settings Tab
+        with gr.Tab("⚙️ Settings", id=3):
+            gr.HTML("""
+                <div style='padding: 1rem 0 0.5rem 0; color: var(--text-secondary); font-size: 0.95rem;'>
+                    <strong style='color: var(--accent-secondary);'>⚙️ Configuration</strong><br>
+                    Customize the AI assistant behavior and view system information.
+                </div>
+            """)
+            
+            with gr.Group():
+                custom_system_prompt = gr.Textbox(
+                    label="🎨 Custom System Prompt (Optional)",
+                    placeholder="Enter a custom system prompt to modify the AI's personality and behavior...",
+                    lines=6,
+                    info="💡 Leave empty to use the default documentation assistant prompt",
+                    container=True
+                )
+            
+            gr.HTML("""
+                <div style='margin-top: 2rem; padding: 2rem; background: linear-gradient(135deg, rgba(139, 92, 246, 0.1) 0%, rgba(99, 102, 241, 0.1) 100%); border-radius: 16px; border: 1px solid var(--border-color);'>
+                    <h3 style='color: var(--accent-secondary); margin: 0 0 1rem 0; font-size: 1.5rem;'>📖 About Docs Navigator MCP</h3>
+                    <p style='color: var(--text-primary); line-height: 1.8; margin-bottom: 1.5rem;'>
+                        An intelligent documentation assistant combining <strong>Claude AI</strong> with 
+                        <strong>Model Context Protocol (MCP)</strong> for powerful document analysis and Q&A.
+                    </p>
+                    <div style='display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-top: 1.5rem;'>
+                        <div style='padding: 1rem; background: rgba(139, 92, 246, 0.1); border-radius: 12px; border: 1px solid rgba(139, 92, 246, 0.2);'>
+                            <div style='font-size: 1.5rem; margin-bottom: 0.5rem;'>🤖</div>
+                            <div style='color: var(--text-primary); font-weight: 600;'>Claude 3.5 Sonnet</div>
+                            <div style='color: var(--text-secondary); font-size: 0.85rem;'>Latest AI Model</div>
+                        </div>
+                        <div style='padding: 1rem; background: rgba(139, 92, 246, 0.1); border-radius: 12px; border: 1px solid rgba(139, 92, 246, 0.2);'>
+                            <div style='font-size: 1.5rem; margin-bottom: 0.5rem;'>🔍</div>
+                            <div style='color: var(--text-primary); font-weight: 600;'>Smart Analysis</div>
+                            <div style='color: var(--text-secondary); font-size: 0.85rem;'>Document Intelligence</div>
+                        </div>
+                        <div style='padding: 1rem; background: rgba(139, 92, 246, 0.1); border-radius: 12px; border: 1px solid rgba(139, 92, 246, 0.2);'>
+                            <div style='font-size: 1.5rem; margin-bottom: 0.5rem;'>📄</div>
+                            <div style='color: var(--text-primary); font-weight: 600;'>Multi-Format</div>
+                            <div style='color: var(--text-secondary); font-size: 0.85rem;'>MD, TXT, RST, PDF</div>
+                        </div>
+                        <div style='padding: 1rem; background: rgba(139, 92, 246, 0.1); border-radius: 12px; border: 1px solid rgba(139, 92, 246, 0.2);'>
+                            <div style='font-size: 1.5rem; margin-bottom: 0.5rem;'>⚡</div>
+                            <div style='color: var(--text-primary); font-weight: 600;'>Fast & Responsive</div>
+                            <div style='color: var(--text-secondary); font-size: 0.85rem;'>Streaming Responses</div>
+                        </div>
+                    </div>
+                </div>
+            """)
+            
+            gr.HTML("<div style='margin: 2rem 0 1rem 0; padding-top: 1.5rem; border-top: 1px solid var(--border-color);'></div>")
+            
+            api_status = gr.Markdown(
+                value=f"""
+### 🔑 API Status
+
+{"✅ **Anthropic API Key Configured** - Ready to use!" if ANTHROPIC_API_KEY else "⚠️ **API Key Missing** - Set `ANTHROPIC_API_KEY` in your `.env` file"}
+                """,
+                elem_classes="info-card"
+            )
+    
+    # Event handlers
+    def respond(message, chat_history, system_prompt):
+        if not message.strip():
+            return "", chat_history
+        
+        response = chat_with_docs(message, chat_history, system_prompt if system_prompt.strip() else None)
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": response})
+        return "", chat_history
+    
+    msg.submit(respond, [msg, chatbot, custom_system_prompt], [msg, chatbot])
+    submit_btn.click(respond, [msg, chatbot, custom_system_prompt], [msg, chatbot])
+    clear_btn.click(lambda: [], None, chatbot)
+    
+    analyze_btn.click(
+        analyze_document,
+        [file_dropdown, analysis_type],
+        analysis_output
+    )
+    
+    refresh_btn.click(
+        lambda: gr.update(choices=get_available_files()),
+        None,
+        file_dropdown
+    )
+    
+    refresh_stats_btn.click(
+        get_document_stats,
+        None,
+        stats_display
+    )
 
-def greet(name):
-    return "Hello " + name + "!!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+if __name__ == "__main__":
+    print("🚀 Starting Docs Navigator MCP...")
+    print("📚 AI-Powered Documentation Assistant")
+    print("💡 Ask questions about your documentation!")
+    print("-" * 50)
+    
+    # Detect if running on Hugging Face Spaces
+    is_spaces = os.getenv("SPACE_ID") is not None
+    
+    demo.launch(
+        server_name="0.0.0.0" if is_spaces else "127.0.0.1",
+        server_port=7860,
+        show_error=True,
+        share=False
+    )

requirements.txt

@@ -1,5 +1,5 @@
 mcp[cli]>=0.1.0
 anthropic>=0.36.0
 python-dotenv>=1.0.1
-gradio>=5.0.0
+gradio>=6.0.2
 PyPDF2>=3.0.0

src/__init__.py

@@ -0,0 +1 @@
+# Docs Navigator MCP package

src/agent/client.py

@@ -0,0 +1,215 @@
+# client_agent.py
+import asyncio
+from contextlib import AsyncExitStack
+from typing import Optional
+
+from dotenv import load_dotenv
+from anthropic import Anthropic
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+load_dotenv()
+
+
+class DocsNavigatorClient:
+    def __init__(self):
+        self.session: Optional[ClientSession] = None
+        self.exit_stack = AsyncExitStack()
+        self.anthropic = Anthropic()
+        self._tools_cache = None
+
+    async def connect(self, server_script_path: str = "src/server/server.py"):
+        """
+        Start the docs MCP server (via stdio) and initialize a session.
+        """
+        import os
+        import sys
+        
+        # Try to use uv run first, then fall back to the virtual environment python
+        if os.path.exists(".venv/Scripts/python.exe"):
+            # Windows virtual environment
+            python_path = ".venv/Scripts/python.exe"
+            params = StdioServerParameters(
+                command=python_path,
+                args=[server_script_path],
+                env=None,
+            )
+        elif os.path.exists(".venv/bin/python"):
+            # Unix virtual environment
+            python_path = ".venv/bin/python"
+            params = StdioServerParameters(
+                command=python_path,
+                args=[server_script_path],
+                env=None,
+            )
+        else:
+            # Fallback to system python
+            params = StdioServerParameters(
+                command="python",
+                args=[server_script_path],
+                env=None,
+            )
+        stdio_transport = await self.exit_stack.enter_async_context(
+            stdio_client(params)
+        )
+        self.stdio, self.write = stdio_transport
+        self.session = await self.exit_stack.enter_async_context(
+            ClientSession(self.stdio, self.write)
+        )
+        await self.session.initialize()
+
+        tools_response = await self.session.list_tools()
+        self._tools_cache = [
+            {
+                "name": t.name,
+                "description": t.description,
+                "input_schema": t.inputSchema,
+            }
+            for t in tools_response.tools
+        ]
+
+    async def close(self):
+        await self.exit_stack.aclose()
+
+    async def answer(self, user_query: str) -> str:
+        """
+        Ask the LLM to answer a question, using docs tools when needed.
+        Supports multi-turn conversations with multiple tool calls.
+        """
+        if not self.session:
+            raise RuntimeError("MCP session not initialized. Call connect() first.")
+
+        if self._tools_cache is None:
+            tools_response = await self.session.list_tools()
+            self._tools_cache = [
+                {
+                    "name": t.name,
+                    "description": t.description,
+                    "input_schema": t.inputSchema,
+                }
+                for t in tools_response.tools
+            ]
+
+        messages = [
+            {
+                "role": "user",
+                "content": (
+                    "You are a documentation assistant. "
+                    "Use the available MCP tools to search and read docs in order "
+                    "to answer the question. You can use multiple tools and think through "
+                    "your response step by step. Always reference the files you used.\n\n"
+                    f"User question: {user_query}"
+                ),
+            }
+        ]
+
+        tools = self._tools_cache
+        max_iterations = 10  # Prevent infinite loops
+        iteration = 0
+
+        while iteration < max_iterations:
+            iteration += 1
+            
+            # Call the LLM
+            response = self.anthropic.messages.create(
+                model="claude-3-haiku-20240307",
+                max_tokens=2500,  # Increased token limit for longer responses
+                messages=messages,
+                tools=tools,
+            )
+
+            # Add assistant's response to conversation
+            messages.append({
+                "role": "assistant",
+                "content": response.content,
+            })
+
+            # Check if there are any tool calls to execute
+            tool_calls = [content for content in response.content if content.type == "tool_use"]
+            
+            if not tool_calls:
+                # No more tool calls - we're done
+                text_content = [content.text for content in response.content if content.type == "text"]
+                return "\n".join(text_content) if text_content else "[no text response from model]"
+
+            # Execute all tool calls in this round
+            tool_results = []
+            for tool_call in tool_calls:
+                try:
+                    tool_name = tool_call.name
+                    tool_args = tool_call.input
+                    
+                    # Call the MCP tool
+                    result = await self.session.call_tool(tool_name, tool_args)
+                    
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": tool_call.id,
+                        "content": result.content,
+                    })
+                except Exception as e:
+                    # Handle tool errors gracefully
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": tool_call.id,
+                        "content": f"Error calling tool {tool_call.name}: {str(e)}",
+                        "is_error": True,
+                    })
+
+            # Add tool results to conversation
+            messages.append({
+                "role": "user",
+                "content": tool_results,
+            })
+
+        # If we hit max iterations, return what we have so far
+        text_content = []
+        for message in messages:
+            if message["role"] == "assistant":
+                for content in message["content"]:
+                    if hasattr(content, 'type') and content.type == "text":
+                        text_content.append(content.text)
+                    elif isinstance(content, dict) and content.get("type") == "text":
+                        text_content.append(content.get("text", ""))
+
+        return "\n".join(text_content) if text_content else "[reached max iterations without final response]"
+
+
+# Thread-local storage for client instances
+import threading
+_thread_local = threading.local()
+
+
+def answer_sync(user_query: str) -> str:
+    """
+    Synchronous wrapper so Gradio can call into our async flow easily.
+    Creates a new client for each request to avoid event loop conflicts.
+    """
+    import concurrent.futures
+    
+    def run_in_new_loop():
+        # Create a new event loop in this thread
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(_answer_async(user_query))
+        finally:
+            loop.close()
+    
+    # Run in a separate thread to avoid conflicts with Gradio's event loop
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future = executor.submit(run_in_new_loop)
+        return future.result()
+
+
+async def _answer_async(user_query: str) -> str:
+    """
+    Create a fresh client for each request to avoid event loop issues.
+    """
+    client = DocsNavigatorClient()
+    try:
+        await client.connect("src/server/server.py")
+        return await client.answer(user_query)
+    finally:
+        await client.close()

src/server/__init__.py

@@ -0,0 +1,4 @@
+# MCP Module
+from .server import mcp
+
+__all__ = ["mcp"]

src/server/server.py

@@ -0,0 +1,1241 @@
+# server_docs.py
+from __future__ import annotations
+from pathlib import Path
+from typing import List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
+from document_intelligence import DocumentIntelligence
+
+# Import PDF processing library
+try:
+    import PyPDF2
+    PDF_SUPPORT = True
+except ImportError:
+    PDF_SUPPORT = False
+    print("Warning: PyPDF2 not installed. PDF support disabled.")
+
+# Name your server – this is what clients see
+mcp = FastMCP("DocsNavigator")
+
+DOCS_ROOT = Path(__file__).parent.parent.parent / "docs"
+doc_intel = DocumentIntelligence(DOCS_ROOT)
+
+
+def _iter_docs() -> list[Path]:
+    exts = {".md", ".txt", ".rst"}
+    if PDF_SUPPORT:
+        exts.add(".pdf")
+    return [
+        p for p in DOCS_ROOT.rglob("*")
+        if p.is_file() and p.suffix.lower() in exts
+    ]
+
+
+def _read_file(path: Path) -> str:
+    if path.suffix.lower() == ".pdf":
+        return _read_pdf_file(path)
+    else:
+        return path.read_text(encoding="utf-8", errors="ignore")
+
+
+def _read_pdf_file(path: Path) -> str:
+    """Extract text from PDF file."""
+    if not PDF_SUPPORT:
+        return f"PDF support not available. Install PyPDF2 to read {path.name}"
+    
+    try:
+        text = ""
+        with open(path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            
+            for page_num, page in enumerate(pdf_reader.pages):
+                try:
+                    page_text = page.extract_text()
+                    if page_text:
+                        text += f"\n--- Page {page_num + 1} ---\n{page_text}\n"
+                except Exception as e:
+                    text += f"\n--- Page {page_num + 1} (Error reading: {str(e)}) ---\n"
+                    
+        return text if text.strip() else f"No text could be extracted from {path.name}"
+        
+    except Exception as e:
+        return f"Error reading PDF {path.name}: {str(e)}"
+
+
+def _extract_hierarchical_sections(content: str) -> List[Dict[str, str]]:
+    """Extract sections including their subsections for better content access."""
+    lines = content.split('\n')
+    headers = []
+    
+    # Identify all headers
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped.startswith('#'):
+            level = len(stripped) - len(stripped.lstrip('#'))
+            title = stripped.lstrip('#').strip()
+            headers.append({
+                'title': stripped,
+                'clean_title': title,
+                'level': level,
+                'line_index': i
+            })
+    
+    if not headers:
+        return [{'title': 'Document Content', 'content': content.strip()}]
+    
+    hierarchical_sections = []
+    
+    # Extract content for each header including subsections
+    for i, header in enumerate(headers):
+        start_line = header['line_index']
+        
+        # Find content that belongs to this section (including subsections)
+        end_line = len(lines)
+        for j in range(i + 1, len(headers)):
+            next_header = headers[j]
+            # Only stop at headers of the same or higher level (lower number)
+            if next_header['level'] <= header['level']:
+                end_line = next_header['line_index']
+                break
+        
+        # Extract all content for this section (header + content + subsections)
+        section_lines = lines[start_line:end_line]
+        section_content = '\n'.join(section_lines).strip()
+        
+        # Remove the header line itself from content for cleaner output
+        if section_content.startswith('#'):
+            content_lines = section_content.split('\n')[1:]
+            clean_content = '\n'.join(content_lines).strip()
+        else:
+            clean_content = section_content
+        
+        hierarchical_sections.append({
+            'title': header['title'],
+            'content': clean_content,
+            'level': header['level'],
+            'includes_subsections': any(h['level'] > header['level'] for h in headers[i+1:] if h['line_index'] < end_line)
+        })
+    
+    return hierarchical_sections
+
+
+def _extract_sections(content: str) -> List[Dict[str, str]]:
+    """Extract sections from markdown content based on headers with proper hierarchy."""
+    lines = content.split('\n')
+    headers = []
+    
+    # First pass: identify all headers with their positions
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped.startswith('#'):
+            level = len(stripped) - len(stripped.lstrip('#'))
+            title = stripped.lstrip('#').strip()
+            headers.append({
+                'title': stripped,
+                'clean_title': title,
+                'level': level,
+                'line_index': i
+            })
+    
+    if not headers:
+        return [{'title': 'Document Content', 'content': content.strip()}]
+    
+    sections = []
+    
+    # Second pass: extract content for each header
+    for i, header in enumerate(headers):
+        start_line = header['line_index'] + 1
+        
+        # Find the end of this section (next header of same or higher level)
+        end_line = len(lines)
+        for j in range(i + 1, len(headers)):
+            next_header = headers[j]
+            if next_header['level'] <= header['level']:
+                end_line = next_header['line_index']
+                break
+        
+        # Extract content for this section
+        section_lines = lines[start_line:end_line]
+        section_content = '\n'.join(section_lines).strip()
+        
+        sections.append({
+            'title': header['title'],
+            'content': section_content,
+            'level': header['level']
+        })
+    
+    return sections
+
+
+def _extract_headers(content: str) -> List[Dict[str, Any]]:
+    """Extract header hierarchy from markdown content."""
+    headers = []
+    lines = content.split('\n')
+    
+    for line_num, line in enumerate(lines, 1):
+        stripped = line.strip()
+        if stripped.startswith('#'):
+            level = len(stripped) - len(stripped.lstrip('#'))
+            title = stripped.lstrip('#').strip()
+            headers.append({
+                'level': level,
+                'title': title,
+                'line': line_num
+            })
+    
+    return headers
+
+
+def _create_outline(headers: List[Dict[str, Any]]) -> List[str]:
+    """Create a hierarchical outline from headers."""
+    outline = []
+    for header in headers:
+        indent = "  " * (header['level'] - 1)
+        outline.append(f"{indent}- {header['title']}")
+    return outline
+
+
+def _count_code_blocks(content: str) -> int:
+    """Count code blocks in markdown content."""
+    return content.count('```')
+
+
+def _extract_links(content: str) -> List[str]:
+    """Extract links from markdown content."""
+    import re
+    # Match markdown links [text](url) and bare URLs
+    link_pattern = r'\[([^\]]+)\]\(([^)]+)\)|https?://[^\s\])]+'
+    matches = re.findall(link_pattern, content)
+    links = []
+    for match in matches:
+        if isinstance(match, tuple) and match[1]:
+            links.append(match[1])  # URL from [text](url)
+        elif isinstance(match, str):
+            links.append(match)  # Bare URL
+    return links
+
+
+def _generate_overview_summary(content: str, sections: List[Dict[str, str]]) -> str:
+    """Generate a concise overview summary."""
+    if not sections:
+        # If no sections, summarize the whole content
+        words = content.split()[:100]  # First 100 words
+        return ' '.join(words) + "..." if len(content.split()) > 100 else ' '.join(words)
+    
+    summary_parts = []
+    
+    # Process all meaningful sections (skip empty ones)
+    for section in sections:
+        title = section['title'].lstrip('#').strip()
+        section_content = section['content'].strip()
+        
+        # Skip empty sections
+        if not section_content:
+            continue
+            
+        # For overview, take first 50 words of each section
+        content_words = section_content.split()[:50]
+        section_summary = ' '.join(content_words)
+        if len(section['content'].split()) > 50:
+            section_summary += "..."
+            
+        summary_parts.append(f"**{title}**: {section_summary}")
+        
+        # Limit to 5 sections for overview to avoid too much text
+        if len(summary_parts) >= 5:
+            break
+    
+    # If we still have no content, fall back to first 100 words
+    if not summary_parts:
+        words = content.split()[:100]
+        return ' '.join(words) + "..." if len(content.split()) > 100 else ' '.join(words)
+    
+    return '\n\n'.join(summary_parts)
+
+
+def _extract_key_points(content: str, sections: List[Dict[str, str]]) -> str:
+    """Extract key points from content."""
+    key_points = []
+    
+    # Look for bullet points and numbered lists in sections
+    for section in sections:
+        section_content = section['content']
+        lines = section_content.split('\n')
+        
+        for line in lines:
+            stripped = line.strip()
+            if (stripped.startswith('- ') or 
+                stripped.startswith('* ') or 
+                stripped.startswith('+ ') or
+                (stripped and len(stripped) > 0 and stripped[0].isdigit() and '. ' in stripped)):
+                # Clean up the bullet point
+                clean_point = stripped.lstrip('- *+0123456789. ').strip()
+                if clean_point:
+                    key_points.append(f"• {clean_point}")
+    
+    if key_points:
+        return '\n'.join(key_points[:15])  # Top 15 points
+    
+    # Fallback: extract sentences that contain key indicators from all content
+    sentences = content.replace('\n', ' ').split('.')
+    important_sentences = []
+    keywords = ['important', 'note', 'warning', 'key', 'must', 'should', 'required', 'avoid', 'best', 'practice']
+    
+    for sentence in sentences:
+        sentence = sentence.strip()
+        if sentence and any(keyword in sentence.lower() for keyword in keywords):
+            important_sentences.append(f"• {sentence}.")
+    
+    return '\n'.join(important_sentences[:8]) if important_sentences else "No specific key points identified."
+
+
+def _generate_detailed_summary(content: str, sections: List[Dict[str, str]]) -> str:
+    """Generate a detailed summary with all sections."""
+    if not sections:
+        return content[:1500] + "..." if len(content) > 1500 else content
+    
+    detailed_parts = []
+    
+    for section in sections:
+        title = section['title'].lstrip('#').strip()
+        section_content = section['content'].strip()
+        
+        # Skip empty sections
+        if not section_content:
+            continue
+            
+        # For detailed summary, include more content
+        content_preview = section_content[:400]
+        if len(section_content) > 400:
+            content_preview += "..."
+            
+        detailed_parts.append(f"## {title}\n{content_preview}")
+    
+    # If no sections with content, return truncated full content
+    if not detailed_parts:
+        return content[:1500] + "..." if len(content) > 1500 else content
+    
+    return '\n\n'.join(detailed_parts)
+
+
+def _extract_technical_details(content: str, sections: List[Dict[str, str]]) -> str:
+    """Extract technical details like code, configurations, and specifications."""
+    technical_parts = []
+    
+    # Extract code blocks
+    import re
+    code_blocks = re.findall(r'```[\s\S]*?```', content)
+    if code_blocks:
+        technical_parts.append("**Code Examples:**")
+        for i, block in enumerate(code_blocks[:3], 1):
+            technical_parts.append(f"Block {i}: {block[:100]}..." if len(block) > 100 else block)
+    
+    # Extract technical terms (words in backticks)
+    tech_terms = re.findall(r'`([^`]+)`', content)
+    if tech_terms:
+        unique_terms = list(set(tech_terms))[:10]
+        technical_parts.append(f"**Technical Terms:** {', '.join(unique_terms)}")
+    
+    # Look for configuration or specification patterns
+    config_lines = []
+    lines = content.split('\n')
+    for line in lines:
+        if ('config' in line.lower() or 
+            'setting' in line.lower() or 
+            '=' in line or 
+            ':' in line and not line.strip().startswith('#')):
+            config_lines.append(line.strip())
+    
+    if config_lines:
+        technical_parts.append("**Configurations/Settings:**")
+        technical_parts.extend(config_lines[:5])
+    
+    return '\n\n'.join(technical_parts) if technical_parts else "No specific technical details identified."
+
+
+def _generate_brief_summary(content: str) -> str:
+    """Generate a very brief summary (1-2 sentences)."""
+    words = content.split()
+    if len(words) <= 30:
+        return content
+    
+    # Take first sentence or first 30 words
+    sentences = content.split('.')
+    first_sentence = sentences[0].strip() + '.' if sentences else ''
+    
+    if len(first_sentence.split()) <= 30:
+        return first_sentence
+    else:
+        return ' '.join(words[:30]) + "..."
+
+
+@mcp.resource("docs://list")
+def list_docs_resource() -> list[str]:
+    """
+    Resource that returns a simple list of available doc paths.
+    """
+    return [str(p.relative_to(DOCS_ROOT)) for p in _iter_docs()]
+
+
+@mcp.resource("docs://{relative_path}")
+def read_doc(relative_path: str) -> str:
+    """
+    Read a specific doc by relative path (e.g. 'getting-started.md').
+    """
+    path = (DOCS_ROOT / relative_path).resolve()
+    if not path.exists() or not path.is_file():
+        return f"Document not found: {relative_path}"
+    if DOCS_ROOT not in path.parents and DOCS_ROOT != path.parent:
+        return "Access denied: path escapes docs root."
+    return _read_file(path)
+
+
+@mcp.tool()
+def list_docs() -> List[str]:
+    """
+    List available documentation files relative to the docs/ folder.
+    """
+    return [str(p.relative_to(DOCS_ROOT)) for p in _iter_docs()]
+
+
+@mcp.tool()
+def search_docs(query: str, max_results: int = 10) -> List[Dict[str, str]]:
+    """
+    Improved full-text search over docs with better matching.
+
+    Args:
+        query: Search query string.
+        max_results: Max number of matches to return.
+    Returns:
+        List of {path, snippet} matches.
+    """
+    import re
+    
+    query_lower = query.lower()
+    query_words = query_lower.split()
+    results: list[dict[str, str]] = []
+
+    for path in _iter_docs():
+        text = _read_file(path)
+        text_lower = text.lower()
+        
+        # Score based on how many query words are found
+        matches = []
+        
+        # First, try exact phrase match (highest score)
+        if query_lower in text_lower:
+            idx = text_lower.find(query_lower)
+            start = max(0, idx - 80)
+            end = min(len(text), idx + 80)
+            snippet = text[start:end].replace("\n", " ")
+            matches.append({
+                "score": 100,
+                "snippet": snippet,
+                "match_type": "exact_phrase"
+            })
+        
+        # Then try to find sentences containing most query words
+        sentences = re.split(r'[.!?]+|\n\n+', text)
+        for sentence in sentences:
+            sentence_lower = sentence.lower()
+            word_matches = sum(1 for word in query_words if word in sentence_lower)
+            
+            if word_matches >= max(1, len(query_words) * 0.6):  # At least 60% of words
+                # Calculate score based on word matches and total words
+                score = (word_matches / len(query_words)) * 80
+                if len(sentence.strip()) > 20:  # Prefer longer, more informative sentences
+                    snippet = sentence.strip()[:160] + "..." if len(sentence.strip()) > 160 else sentence.strip()
+                    matches.append({
+                        "score": score,
+                        "snippet": snippet,
+                        "match_type": f"words_{word_matches}/{len(query_words)}"
+                    })
+        
+        # Add the best matches for this document
+        if matches:
+            # Sort by score and take the best match
+            best_match = max(matches, key=lambda x: x["score"])
+            results.append({
+                "path": str(path.relative_to(DOCS_ROOT)),
+                "snippet": best_match["snippet"],
+                "score": str(best_match["score"]),
+                "match_type": best_match["match_type"]
+            })
+
+    # Sort results by score (highest first) and limit
+    results.sort(key=lambda x: x["score"], reverse=True)
+    return results[:max_results]
+
+
+@mcp.tool()
+def extract_section(relative_path: str, section_title: str, include_subsections: bool = True) -> Dict[str, Any]:
+    """
+    Extract a specific section from a document.
+    
+    Args:
+        relative_path: Path to the document relative to docs/ folder
+        section_title: Title of the section to extract (case-insensitive, partial matches allowed)
+        include_subsections: Whether to include subsections in the extracted content
+    Returns:
+        Dictionary with section content and metadata
+    """
+    path = (DOCS_ROOT / relative_path).resolve()
+    if not path.exists() or not path.is_file():
+        return {"error": f"Document not found: {relative_path}"}
+    if DOCS_ROOT not in path.parents and DOCS_ROOT != path.parent:
+        return {"error": "Access denied: path escapes docs root."}
+    
+    content = _read_file(path)
+    
+    # Use hierarchical extraction if including subsections, otherwise flat extraction
+    if include_subsections:
+        sections = _extract_hierarchical_sections(content)
+    else:
+        sections = _extract_sections(content)
+    
+    # Find matching section (case-insensitive, partial match)
+    section_title_lower = section_title.lower()
+    matching_sections = []
+    
+    for section in sections:
+        section_title_clean = section['title'].lstrip('#').strip().lower()
+        if section_title_lower in section_title_clean or section_title_clean in section_title_lower:
+            matching_sections.append(section)
+    
+    if not matching_sections:
+        # List available sections for user reference
+        available_sections = [s['title'].lstrip('#').strip() for s in sections if s['content'].strip()]
+        return {
+            "error": f"Section '{section_title}' not found",
+            "available_sections": available_sections[:10],  # Limit to first 10 for readability
+            "total_sections": str(len(available_sections))
+        }
+    
+    if len(matching_sections) == 1:
+        section = matching_sections[0]
+        result = {
+            "document": relative_path,
+            "section_title": section['title'].lstrip('#').strip(),
+            "content": section['content'].strip(),
+            "word_count": str(len(section['content'].split())),
+            "match_type": "single",
+            "extraction_mode": "hierarchical" if include_subsections else "flat"
+        }
+        
+        # Add metadata about subsections if available
+        if 'includes_subsections' in section:
+            result["includes_subsections"] = section['includes_subsections']
+        if 'level' in section:
+            result["header_level"] = section['level']
+            
+        return result
+    else:
+        # Multiple matches - return all
+        results = []
+        for section in matching_sections:
+            section_info = {
+                "section_title": section['title'].lstrip('#').strip(),
+                "content": section['content'].strip(),
+                "word_count": str(len(section['content'].split()))
+            }
+            if 'level' in section:
+                section_info["header_level"] = section['level']
+            if 'includes_subsections' in section:
+                section_info["includes_subsections"] = section['includes_subsections']
+            results.append(section_info)
+        
+        return {
+            "document": relative_path,
+            "match_type": "multiple",
+            "matching_sections": results,
+            "total_matches": str(len(results)),
+            "extraction_mode": "hierarchical" if include_subsections else "flat"
+        }
+
+
+@mcp.tool()
+def summarize_document(relative_path: str, summary_type: str = "overview") -> Dict[str, str]:
+    """
+    Generate a smart summary of a specific document.
+    
+    Args:
+        relative_path: Path to the document relative to docs/ folder
+        summary_type: Type of summary - 'overview', 'key_points', 'detailed', or 'technical'
+    Returns:
+        Dictionary with document info and structured summary
+    """
+    path = (DOCS_ROOT / relative_path).resolve()
+    if not path.exists() or not path.is_file():
+        return {"error": f"Document not found: {relative_path}"}
+    if DOCS_ROOT not in path.parents and DOCS_ROOT != path.parent:
+        return {"error": "Access denied: path escapes docs root."}
+    
+    content = _read_file(path)
+    word_count = len(content.split())
+    
+    # Extract key sections based on markdown headers
+    sections = _extract_sections(content)
+    
+    # Generate summary based on type
+    if summary_type == "key_points":
+        summary = _extract_key_points(content, sections)
+    elif summary_type == "detailed":
+        summary = _generate_detailed_summary(content, sections)
+    elif summary_type == "technical":
+        summary = _extract_technical_details(content, sections)
+    else:  # overview
+        summary = _generate_overview_summary(content, sections)
+    
+    return {
+        "document": relative_path,
+        "word_count": str(word_count),
+        "sections": str(len(sections)),
+        "summary_type": summary_type,
+        "summary": summary
+    }
+
+
+@mcp.tool()
+def analyze_document_structure(relative_path: str) -> Dict[str, Any]:
+    """
+    Analyze the structure and metadata of a document.
+    
+    Args:
+        relative_path: Path to the document relative to docs/ folder
+    Returns:
+        Dictionary with structural analysis
+    """
+    path = (DOCS_ROOT / relative_path).resolve()
+    if not path.exists() or not path.is_file():
+        return {"error": f"Document not found: {relative_path}"}
+    
+    content = _read_file(path)
+    
+    # Extract headers and create outline
+    headers = _extract_headers(content)
+    sections = _extract_sections(content)
+    
+    # Basic statistics
+    lines = content.split('\n')
+    words = content.split()
+    
+    # Find code blocks and links
+    code_blocks = _count_code_blocks(content)
+    links = _extract_links(content)
+    
+    return {
+        "document": relative_path,
+        "statistics": {
+            "lines": len(lines),
+            "words": len(words),
+            "characters": len(content),
+            "sections": str(len(sections)),
+            "code_blocks": code_blocks,
+            "links": len(links)
+        },
+        "structure": {
+            "headers": headers,
+            "outline": _create_outline(headers)
+        },
+        "content_analysis": {
+            "has_tables": "| " in content,
+            "has_images": "![" in content,
+            "has_code": "```" in content or "    " in content,
+            "external_links": [link for link in links if link.startswith(('http', 'https'))]
+        }
+    }
+
+
+@mcp.tool()
+def generate_doc_overview() -> Dict[str, Any]:
+    """
+    Generate a comprehensive overview of the entire documentation set.
+    
+    Returns:
+        Dictionary with overall documentation analysis
+    """
+    docs = _iter_docs()
+    overview = {
+        "total_documents": str(len(docs)),
+        "documents_by_type": {},
+        "total_content": {"words": 0, "lines": 0, "characters": 0},
+        "structure_analysis": {"sections": 0, "code_blocks": 0},
+        "document_summaries": []
+    }
+    
+    for path in docs:
+        content = _read_file(path)
+        ext = path.suffix.lower()
+        rel_path = str(path.relative_to(DOCS_ROOT))
+        
+        # Count by type
+        overview["documents_by_type"][ext] = overview["documents_by_type"].get(ext, 0) + 1
+        
+        # Aggregate statistics
+        words = len(content.split())
+        lines = len(content.split('\n'))
+        chars = len(content)
+        
+        overview["total_content"]["words"] += words
+        overview["total_content"]["lines"] += lines
+        overview["total_content"]["characters"] += chars
+        
+        # Structure analysis
+        sections = len(_extract_sections(content))
+        code_blocks = _count_code_blocks(content)
+        
+        overview["structure_analysis"]["sections"] += sections
+        overview["structure_analysis"]["code_blocks"] += code_blocks
+        
+        # Brief summary for each doc
+        brief_summary = _generate_brief_summary(content)
+        overview["document_summaries"].append({
+            "path": rel_path,
+            "words": words,
+            "sections": sections,
+            "brief_summary": brief_summary
+        })
+    
+    return overview
+
+
+@mcp.tool()
+def semantic_search(query: str, max_results: int = 5) -> List[Dict[str, Any]]:
+    """
+    Perform semantic search across documents using keyword matching and relevance scoring.
+    
+    Args:
+        query: Search query
+        max_results: Maximum number of results to return
+    Returns:
+        List of documents with relevance scores and context
+    """
+    query_words = set(query.lower().split())
+    results = []
+    
+    for path in _iter_docs():
+        content = _read_file(path)
+        content_lower = content.lower()
+        
+        # Calculate relevance score
+        score = 0
+        context_snippets = []
+        
+        for word in query_words:
+            word_count = content_lower.count(word)
+            score += word_count * len(word)  # Longer words get higher weight
+            
+            # Find context for each query word
+            word_positions = []
+            start = 0
+            while True:
+                pos = content_lower.find(word, start)
+                if pos == -1:
+                    break
+                word_positions.append(pos)
+                start = pos + 1
+            
+            # Get context snippets around found words
+            for pos in word_positions[:2]:  # Max 2 snippets per word
+                snippet_start = max(0, pos - 60)
+                snippet_end = min(len(content), pos + 60)
+                snippet = content[snippet_start:snippet_end].replace('\n', ' ')
+                context_snippets.append(snippet)
+        
+        if score > 0:
+            # Normalize score by document length
+            normalized_score = score / len(content.split())
+            
+            results.append({
+                'path': str(path.relative_to(DOCS_ROOT)),
+                'relevance_score': normalized_score,
+                'context_snippets': context_snippets[:3],  # Max 3 snippets
+                'word_count': len(content.split())
+            })
+    
+    # Sort by relevance score
+    results.sort(key=lambda x: x['relevance_score'], reverse=True)
+    return results[:max_results]
+
+
+@mcp.tool()
+def compare_documents(doc1_path: str, doc2_path: str) -> Dict[str, Any]:
+    """
+    Compare two documents and identify similarities and differences.
+    
+    Args:
+        doc1_path: Path to first document
+        doc2_path: Path to second document
+    Returns:
+        Comparison analysis
+    """
+    path1 = (DOCS_ROOT / doc1_path).resolve()
+    path2 = (DOCS_ROOT / doc2_path).resolve()
+    
+    if not path1.exists() or not path2.exists():
+        return {"error": "One or both documents not found"}
+    
+    content1 = _read_file(path1)
+    content2 = _read_file(path2)
+    
+    # Basic statistics comparison
+    stats1 = {
+        "words": len(content1.split()),
+        "lines": len(content1.split('\n')),
+        "characters": len(content1)
+    }
+    stats2 = {
+        "words": len(content2.split()),
+        "lines": len(content2.split('\n')),
+        "characters": len(content2)
+    }
+    
+    # Find common and unique words
+    words1 = set(word.lower().strip('.,!?;:') for word in content1.split())
+    words2 = set(word.lower().strip('.,!?;:') for word in content2.split())
+    
+    common_words = words1.intersection(words2)
+    unique_to_doc1 = words1 - words2
+    unique_to_doc2 = words2 - words1
+    
+    # Extract headers for structure comparison
+    headers1 = [h['title'] for h in _extract_headers(content1)]
+    headers2 = [h['title'] for h in _extract_headers(content2)]
+    
+    return {
+        "document1": doc1_path,
+        "document2": doc2_path,
+        "statistics": {
+            "doc1": stats1,
+            "doc2": stats2,
+            "size_ratio": stats1["words"] / stats2["words"] if stats2["words"] > 0 else float('inf')
+        },
+        "content_similarity": {
+            "common_words_count": len(common_words),
+            "unique_to_doc1_count": len(unique_to_doc1),
+            "unique_to_doc2_count": len(unique_to_doc2),
+            "similarity_ratio": len(common_words) / len(words1.union(words2)) if len(words1.union(words2)) > 0 else 0
+        },
+        "structure_comparison": {
+            "doc1_headers": headers1,
+            "doc2_headers": headers2,
+            "common_headers": list(set(headers1).intersection(set(headers2))),
+            "unique_headers_doc1": list(set(headers1) - set(headers2)),
+            "unique_headers_doc2": list(set(headers2) - set(headers1))
+        },
+        "sample_unique_words": {
+            "doc1": list(unique_to_doc1)[:10],
+            "doc2": list(unique_to_doc2)[:10]
+        }
+    }
+
+
+@mcp.tool()
+def extract_definitions(relative_path: str) -> Dict[str, Any]:
+    """
+    Extract definitions, terms, and explanations from a document.
+    
+    Args:
+        relative_path: Path to the document
+    Returns:
+        Extracted definitions and terms
+    """
+    path = (DOCS_ROOT / relative_path).resolve()
+    if not path.exists():
+        return {"error": f"Document not found: {relative_path}"}
+    
+    content = _read_file(path)
+    definitions = []
+    
+    # Look for definition patterns
+    import re
+    
+    # Pattern 1: "Term: Definition" or "Term - Definition"
+    definition_patterns = [
+        r'^([A-Z][^:\-\n]+):\s*(.+)$',  # Term: Definition
+        r'^([A-Z][^:\-\n]+)\s*-\s*(.+)$',  # Term - Definition
+        r'\*\*([^*]+)\*\*:\s*([^\n]+)',  # **Term**: Definition
+        r'`([^`]+)`:\s*([^\n]+)'  # `Term`: Definition
+    ]
+    
+    for pattern in definition_patterns:
+        matches = re.findall(pattern, content, re.MULTILINE)
+        for match in matches:
+            term, definition = match
+            definitions.append({
+                "term": term.strip(),
+                "definition": definition.strip(),
+                "type": "explicit"
+            })
+    
+    # Look for glossary sections
+    sections = _extract_sections(content)
+    glossary_terms = []
+    
+    for section in sections:
+        if any(keyword in section['title'].lower() for keyword in ['glossary', 'definition', 'terminology', 'terms']):
+            lines = section['content'].split('\n')
+            for line in lines:
+                if ':' in line or '-' in line:
+                    parts = line.split(':') if ':' in line else line.split('-')
+                    if len(parts) == 2:
+                        glossary_terms.append({
+                            "term": parts[0].strip(),
+                            "definition": parts[1].strip(),
+                            "type": "glossary"
+                        })
+    
+    # Extract technical terms (words in backticks)
+    tech_terms = re.findall(r'`([^`]+)`', content)
+    tech_terms_unique = list(set(tech_terms))
+    
+    return {
+        "document": relative_path,
+        "definitions": definitions,
+        "glossary_terms": glossary_terms,
+        "technical_terms": tech_terms_unique,
+        "total_definitions": str(len(definitions) + len(glossary_terms)),
+        "definition_density": (len(definitions) + len(glossary_terms)) / len(content.split()) if content.split() else 0
+    }
+
+
+@mcp.tool()
+def generate_table_of_contents(relative_path: str = None) -> Dict[str, Any]:
+    """
+    Generate a table of contents for a specific document or all documents.
+    
+    Args:
+        relative_path: Path to specific document, or None for all documents
+    Returns:
+        Table of contents structure
+    """
+    if relative_path:
+        # Single document TOC
+        path = (DOCS_ROOT / relative_path).resolve()
+        if not path.exists():
+            return {"error": f"Document not found: {relative_path}"}
+        
+        content = _read_file(path)
+        headers = _extract_headers(content)
+        
+        return {
+            "document": relative_path,
+            "table_of_contents": _create_outline(headers),
+            "header_count": len(headers),
+            "max_depth": max([h['level'] for h in headers]) if headers else 0
+        }
+    else:
+        # All documents TOC
+        all_toc = {}
+        for path in _iter_docs():
+            content = _read_file(path)
+            headers = _extract_headers(content)
+            rel_path = str(path.relative_to(DOCS_ROOT))
+            
+            all_toc[rel_path] = {
+                "outline": _create_outline(headers),
+                "header_count": len(headers),
+                "max_depth": max([h['level'] for h in headers]) if headers else 0
+            }
+        
+        return {
+            "type": "complete_documentation_toc",
+            "documents": all_toc,
+            "total_documents": str(len(all_toc))
+        }
+
+
+@mcp.tool()
+def intelligent_summarize(relative_path: str, summary_type: str = "medium", focus_keywords: str = None) -> Dict[str, Any]:
+    """
+    Generate an intelligent summary using advanced text analysis.
+    
+    Args:
+        relative_path: Path to the document
+        summary_type: "short", "medium", or "long"
+        focus_keywords: Optional comma-separated keywords to focus on
+    Returns:
+        Intelligent summary with analysis
+    """
+    path = (DOCS_ROOT / relative_path).resolve()
+    if not path.exists():
+        return {"error": f"Document not found: {relative_path}"}
+    
+    try:
+        content = _read_file(path)
+        
+        # Use document intelligence for smart summary
+        summary_result = doc_intel.generate_smart_summary(content, summary_type)
+        
+        # Add key concepts
+        key_concepts = doc_intel.extract_key_concepts(content)
+        
+        # Add readability analysis
+        readability = doc_intel.analyze_readability(content)
+        
+        # If focus keywords provided, highlight relevant sections
+        focused_content = None
+        if focus_keywords:
+            keywords = [k.strip() for k in focus_keywords.split(',')]
+            # Find sections that contain the keywords
+            sections = _extract_sections(content)
+            relevant_sections = []
+            for section in sections:
+                if section['content'].strip() and any(keyword.lower() in section['content'].lower() for keyword in keywords):
+                    relevant_sections.append(section['title'].lstrip('#').strip())
+            focused_content = relevant_sections
+        
+        return {
+            "document": relative_path,
+            "summary": summary_result,
+            "key_concepts": key_concepts[:10],
+            "readability": readability,
+            "focused_sections": focused_content,
+            "analysis_method": "advanced_intelligence"
+        }
+    except Exception as e:
+        return {
+            "error": f"Failed to analyze document: {str(e)}",
+            "document": relative_path,
+            "fallback_available": True
+        }
+
+
+@mcp.tool()
+def extract_qa_pairs(relative_path: str = None) -> Dict[str, Any]:
+    """
+    Extract question-answer pairs from documents for FAQ generation.
+    
+    Args:
+        relative_path: Specific document path, or None for all documents
+    Returns:
+        Extracted Q&A pairs
+    """
+    if relative_path:
+        path = (DOCS_ROOT / relative_path).resolve()
+        if not path.exists():
+            return {"error": f"Document not found: {relative_path}"}
+        
+        content = _read_file(path)
+        qa_pairs = doc_intel.extract_questions_and_answers(content)
+        
+        return {
+            "document": relative_path,
+            "qa_pairs": qa_pairs,
+            "total_pairs": str(len(qa_pairs))
+        }
+    else:
+        # Extract from all documents
+        all_qa_pairs = {}
+        total_pairs = 0
+        
+        for path in _iter_docs():
+            content = _read_file(path)
+            qa_pairs = doc_intel.extract_questions_and_answers(content)
+            if qa_pairs:
+                rel_path = str(path.relative_to(DOCS_ROOT))
+                all_qa_pairs[rel_path] = qa_pairs
+                total_pairs += len(qa_pairs)
+        
+        return {
+            "type": "complete_documentation_qa",
+            "qa_by_document": all_qa_pairs,
+            "total_pairs": str(total_pairs)
+        }
+
+
+@mcp.tool()
+def find_related_documents(query: str, max_results: int = 3) -> List[Dict[str, Any]]:
+    """
+    Find documents most related to a query using advanced similarity scoring.
+    
+    Args:
+        query: Search query or topic
+        max_results: Maximum number of related documents to return
+    Returns:
+        List of related documents with scores and explanations
+    """
+    all_docs = list(_iter_docs())
+    related = doc_intel.find_related_content(query, all_docs, max_results)
+    
+    return {
+        "query": query,
+        "related_documents": related,
+        "total_analyzed": len(all_docs),
+        "method": "tf-idf_similarity"
+    }
+
+
+@mcp.tool()
+def analyze_document_gaps() -> Dict[str, Any]:
+    """
+    Analyze the documentation set to identify potential gaps or areas needing improvement.
+    
+    Returns:
+        Analysis of documentation completeness and suggestions
+    """
+    all_docs = list(_iter_docs())
+    analysis = {
+        "total_documents": len(all_docs),
+        "coverage_analysis": {},
+        "recommendations": [],
+        "content_quality": {},
+        "structure_issues": []
+    }
+    
+    # Analyze each document
+    total_words = 0
+    short_docs = []
+    long_docs = []
+    low_readability_docs = []
+    missing_sections = []
+    
+    common_sections = ['introduction', 'overview', 'getting started', 'configuration', 'examples', 'troubleshooting']
+    section_coverage = {section: 0 for section in common_sections}
+    
+    for path in all_docs:
+        content = _read_file(path)
+        rel_path = str(path.relative_to(DOCS_ROOT))
+        
+        # Word count analysis
+        word_count = len(content.split())
+        total_words += word_count
+        
+        if word_count < 100:
+            short_docs.append(rel_path)
+        elif word_count > 3000:
+            long_docs.append(rel_path)
+        
+        # Readability analysis
+        readability = doc_intel.analyze_readability(content)
+        if readability.get('flesch_score', 50) < 30:
+            low_readability_docs.append(rel_path)
+        
+        # Section coverage analysis
+        headers = [h['title'].lower() for h in _extract_headers(content)]
+        doc_sections = []
+        for section in common_sections:
+            if any(section in header for header in headers):
+                section_coverage[section] += 1
+                doc_sections.append(section)
+        
+        missing = [s for s in common_sections if s not in doc_sections]
+        if missing:
+            missing_sections.append({"document": rel_path, "missing": missing})
+    
+    # Generate recommendations
+    if short_docs:
+        analysis["recommendations"].append(f"Consider expanding these short documents: {', '.join(short_docs[:3])}")
+    
+    if low_readability_docs:
+        analysis["recommendations"].append(f"Improve readability of: {', '.join(low_readability_docs[:3])}")
+    
+    # Find least covered sections
+    least_covered = min(section_coverage.values())
+    missing_section_types = [section for section, count in section_coverage.items() if count <= least_covered]
+    if missing_section_types:
+        analysis["recommendations"].append(f"Consider adding {', '.join(missing_section_types)} sections to more documents")
+    
+    analysis["coverage_analysis"] = {
+        "average_words_per_doc": total_words / len(all_docs) if all_docs else 0,
+        "short_documents": short_docs,
+        "long_documents": long_docs,
+        "section_coverage": section_coverage
+    }
+    
+    analysis["content_quality"] = {
+        "low_readability": low_readability_docs,
+        "missing_common_sections": missing_sections
+    }
+    
+    return analysis
+
+
+@mcp.tool()
+def generate_documentation_index() -> Dict[str, Any]:
+    """
+    Generate a comprehensive searchable index of all documentation content.
+    
+    Returns:
+        Searchable index with topics, concepts, and cross-references
+    """
+    index = {
+        "concepts": {},  # concept -> [documents]
+        "topics": {},    # topic -> documents
+        "cross_references": {},  # document -> related documents
+        "metadata": {}
+    }
+    
+    all_docs = list(_iter_docs())
+    
+    # Build concept index
+    all_concepts = {}
+    
+    for path in all_docs:
+        content = _read_file(path)
+        rel_path = str(path.relative_to(DOCS_ROOT))
+        
+        # Extract concepts from this document
+        concepts = doc_intel.extract_key_concepts(content, min_frequency=1)
+        
+        # Add to global concept index
+        for concept_info in concepts:
+            concept = concept_info['concept']
+            if concept not in all_concepts:
+                all_concepts[concept] = []
+            all_concepts[concept].append({
+                "document": rel_path,
+                "frequency": concept_info['frequency'],
+                "type": concept_info['type']
+            })
+        
+        # Find cross-references (documents with similar concepts)
+        related_docs = doc_intel.find_related_content(
+            ' '.join([c['concept'] for c in concepts[:5]]), 
+            all_docs, 
+            max_results=3
+        )
+        index["cross_references"][rel_path] = [doc['path'] for doc in related_docs if doc['path'] != rel_path]
+        
+        # Document metadata
+        headers = _extract_headers(content)
+        readability = doc_intel.analyze_readability(content)
+        
+        index["metadata"][rel_path] = {
+            "word_count": len(content.split()),
+            "sections": len(headers),
+            "readability_score": readability.get('flesch_score', 0),
+            "main_topics": [c['concept'] for c in concepts[:5]]
+        }
+    
+    # Filter concepts that appear in multiple documents (more valuable for index)
+    index["concepts"] = {
+        concept: docs for concept, docs in all_concepts.items() 
+        if len(docs) > 1 or any(d['frequency'] > 2 for d in docs)
+    }
+    
+    # Create topic clusters
+    topic_clusters = {}
+    for concept, docs in index["concepts"].items():
+        if len(docs) >= 2:  # Concept appears in multiple docs
+            topic_clusters[concept] = [doc['document'] for doc in docs]
+    
+    index["topics"] = topic_clusters
+    
+    return {
+        "index": index,
+        "statistics": {
+            "total_concepts": len(index["concepts"]),
+            "total_topics": len(index["topics"]),
+            "total_documents": len(all_docs),
+            "avg_cross_references": sum(len(refs) for refs in index["cross_references"].values()) / len(index["cross_references"]) if index["cross_references"] else 0
+        }
+    }
+
+
+if __name__ == "__main__":
+    # stdio transport keeps it compatible with the official client pattern
+    mcp.run(transport="stdio")

src/ui/__init__.py

@@ -0,0 +1 @@
+# UI module

src/ui/app.py

@@ -0,0 +1,122 @@
+# app_gradio.py
+import gradio as gr
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
+from src.agent.client import answer_sync
+
+
+def chat_fn(message: str, history: list[dict]):
+    """Enhanced chat function with better error handling and user feedback"""
+    try:
+        if not message.strip():
+            return "Please enter a question about the documentation."
+        
+        reply = answer_sync(message)
+        return reply
+    except Exception as e:
+        return f"⚠️ I encountered an error while processing your question: {str(e)}\n\nPlease try again or rephrase your question."
+
+
+def main():
+    """Main entry point for the application when run via uv."""
+    print("🚀 Starting Docs Navigator MCP...")
+    print("📚 AI-Powered Documentation Assistant")
+    print("🌐 The app will be available at: http://127.0.0.1:7862")
+    print("💡 Ask questions about your documentation!")
+    print("-" * 50)
+    
+    demo.launch(
+        server_name="127.0.0.1",
+        server_port=7862,
+        show_error=True,
+        share=False
+    )
+
+
+# Professional theme configuration
+professional_theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="slate",
+    neutral_hue="gray",
+    font=[
+        gr.themes.GoogleFont("Inter"),
+        "ui-sans-serif", 
+        "system-ui", 
+        "sans-serif"
+    ]
+).set(
+    body_background_fill="*neutral_50",
+    panel_background_fill="white",
+    button_primary_background_fill="*primary_600",
+    button_primary_background_fill_hover="*primary_700",
+    input_background_fill="white"
+)
+
+# Custom CSS for enhanced styling
+custom_css = """
+.gradio-container {
+    max-width: 1000px !important;
+    margin: 0 auto !important;
+}
+
+.chat-interface {
+    border-radius: 12px !important;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1) !important;
+}
+
+.message {
+    border-radius: 8px !important;
+    margin: 6px 0 !important;
+}
+
+/* Enhanced input styling */
+.input-container textarea {
+    border-radius: 8px !important;
+    border: 2px solid #e5e7eb !important;
+    transition: all 0.2s ease !important;
+}
+
+.input-container textarea:focus {
+    border-color: #3b82f6 !important;
+    box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1) !important;
+}
+"""
+
+demo = gr.ChatInterface(
+    fn=chat_fn,
+    type="messages",
+    title="📚 Docs Navigator MCP",
+    description="🤖 **AI-Powered Documentation Assistant**\n\nAsk questions about your documentation and get intelligent, contextual answers. Powered by Claude AI and Model Context Protocol.",
+    theme=professional_theme,
+    css=custom_css,
+    chatbot=gr.Chatbot(
+        height=500,
+        show_label=False,
+        type="messages",
+        avatar_images=(
+            "https://api.dicebear.com/7.x/thumbs/svg?seed=user&backgroundColor=3b82f6",
+            "https://api.dicebear.com/7.x/bottts/svg?seed=docs&backgroundColor=1e40af"
+        )
+    ),
+    textbox=gr.Textbox(
+        placeholder="💭 Ask me anything about your documentation...",
+        container=False,
+        scale=7
+    ),
+    examples=[
+        "🚀 How do I get started with this project?",
+        "⚙️ What configuration options are available?", 
+        "🔧 How do I troubleshoot connection issues?",
+        "📖 Tell me about the setup process",
+        "💡 What does the overview documentation explain?",
+        "📄 What information is in the PDF documents?"
+    ]
+)
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        show_error=True
+    )

src/ui/enhanced.py

@@ -0,0 +1,304 @@
+# app_gradio_enhanced.py
+import gradio as gr
+from client_agent import answer_sync
+
+
+def chat_fn(message: str, history: list[dict]):
+    """Enhanced chat function with better error handling"""
+    try:
+        reply = answer_sync(message)
+        return reply
+    except Exception as e:
+        return f"⚠️ Error: {str(e)}"
+
+
+# Custom CSS for professional styling
+custom_css = """
+/* Main container styling */
+.gradio-container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+}
+
+/* Header styling */
+.header-text {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    text-align: center;
+    font-weight: bold;
+    margin-bottom: 1rem;
+}
+
+/* Chat message styling */
+.message-wrap {
+    border-radius: 12px !important;
+    margin: 8px 0 !important;
+    padding: 12px 16px !important;
+}
+
+.user-message {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    color: white !important;
+}
+
+.bot-message {
+    background: #f8f9fa !important;
+    border-left: 4px solid #667eea !important;
+}
+
+/* Input styling */
+.input-container {
+    border-radius: 25px !important;
+    border: 2px solid #e9ecef !important;
+    transition: all 0.3s ease !important;
+}
+
+.input-container:focus-within {
+    border-color: #667eea !important;
+    box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1) !important;
+}
+
+/* Button styling */
+.submit-btn {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    border: none !important;
+    border-radius: 20px !important;
+    padding: 10px 20px !important;
+    font-weight: 600 !important;
+    transition: all 0.3s ease !important;
+}
+
+.submit-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 4px 12px rgba(102, 126, 234, 0.3) !important;
+}
+
+/* Status indicators */
+.status-indicator {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 12px;
+    border-radius: 20px;
+    font-size: 14px;
+    font-weight: 500;
+}
+
+.status-online {
+    background: #d4edda;
+    color: #155724;
+    border: 1px solid #c3e6cb;
+}
+
+/* Loading animation */
+@keyframes pulse {
+    0% { opacity: 1; }
+    50% { opacity: 0.5; }
+    100% { opacity: 1; }
+}
+
+.loading {
+    animation: pulse 1.5s infinite;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .gradio-container {
+        padding: 10px !important;
+    }
+    
+    .message-wrap {
+        margin: 4px 0 !important;
+        padding: 8px 12px !important;
+    }
+}
+
+/* Dark mode support */
+.dark .bot-message {
+    background: #2d3748 !important;
+    color: #e2e8f0 !important;
+    border-left-color: #667eea !important;
+}
+
+.dark .input-container {
+    background: #2d3748 !important;
+    border-color: #4a5568 !important;
+    color: #e2e8f0 !important;
+}
+"""
+
+
+def create_enhanced_interface():
+    """Create an enhanced Gradio interface with professional styling"""
+    
+    with gr.Blocks(
+        css=custom_css,
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="purple",
+            neutral_hue="slate",
+            font=[
+                gr.themes.GoogleFont("Inter"),
+                "ui-sans-serif", 
+                "system-ui", 
+                "sans-serif"
+            ]
+        ),
+        title="📚 Docs Navigator - AI-Powered Documentation Assistant",
+        analytics_enabled=False
+    ) as interface:
+        
+        # Header section
+        with gr.Row():
+            gr.Markdown(
+                """
+                # 📚 Docs Navigator MCP
+                ### AI-Powered Documentation Assistant
+                
+                Ask questions about your documentation and get intelligent, contextual answers powered by Claude and MCP.
+                """,
+                elem_classes=["header-text"]
+            )
+        
+        # Status indicator
+        with gr.Row():
+            gr.HTML(
+                """
+                <div class="status-indicator status-online">
+                    <span>🟢</span>
+                    <span>MCP Server Connected</span>
+                </div>
+                """,
+                visible=True
+            )
+        
+        # Main chat interface
+        chat = gr.ChatInterface(
+            fn=chat_fn,
+            type="messages",
+            chatbot=gr.Chatbot(
+                height=500,
+                show_label=False,
+                container=True,
+                bubble_full_width=False,
+                avatar_images=(
+                    "https://api.dicebear.com/7.x/thumbs/svg?seed=user&backgroundColor=667eea",
+                    "https://api.dicebear.com/7.x/bottts/svg?seed=bot&backgroundColor=764ba2"
+                )
+            ),
+            textbox=gr.Textbox(
+                placeholder="Ask me anything about your documentation... 💭",
+                container=False,
+                scale=7,
+                elem_classes=["input-container"]
+            ),
+            submit_btn=gr.Button(
+                "Send 🚀", 
+                variant="primary",
+                elem_classes=["submit-btn"]
+            ),
+            retry_btn=gr.Button("🔄 Retry", variant="secondary"),
+            undo_btn=gr.Button("↩️ Undo", variant="secondary"),
+            clear_btn=gr.Button("🗑️ Clear", variant="secondary"),
+            examples=[
+                "How do I set up AuroraAI?",
+                "What are the troubleshooting steps for connection issues?",
+                "Tell me about the configuration options",
+                "What does the overview documentation say?",
+                "How do I get started with this project?"
+            ]
+        )
+        
+        # Footer section
+        with gr.Row():
+            gr.Markdown(
+                """
+                ---
+                <div style="text-align: center; color: #6c757d; font-size: 14px; margin-top: 20px;">
+                    <p>
+                        🔧 Powered by <strong>Model Context Protocol (MCP)</strong> | 
+                        🤖 <strong>Claude AI</strong> | 
+                        🎨 <strong>Gradio</strong>
+                    </p>
+                    <p style="font-size: 12px; margin-top: 10px;">
+                        💡 Tip: Ask specific questions about your documentation for the best results!
+                    </p>
+                </div>
+                """,
+                elem_classes=["footer"]
+            )
+    
+    return interface
+
+
+# Create the demo with different styling options
+def create_minimal_interface():
+    """Create a minimal, clean interface"""
+    return gr.ChatInterface(
+        fn=chat_fn,
+        type="messages",
+        title="📚 Docs Navigator",
+        description="Clean, minimal documentation assistant",
+        theme=gr.themes.Monochrome(),
+        chatbot=gr.Chatbot(height=400, show_label=False),
+        textbox=gr.Textbox(placeholder="Ask about your docs...", container=False),
+        examples=["Setup guide", "Troubleshooting", "Configuration"]
+    )
+
+
+def create_corporate_interface():
+    """Create a corporate/professional interface"""
+    corporate_theme = gr.themes.Default(
+        primary_hue="slate",
+        secondary_hue="blue",
+        neutral_hue="gray"
+    ).set(
+        body_background_fill="white",
+        panel_background_fill="*neutral_50",
+        button_primary_background_fill="*primary_600"
+    )
+    
+    return gr.ChatInterface(
+        fn=chat_fn,
+        type="messages",
+        title="Documentation Assistant",
+        description="Enterprise AI Documentation System",
+        theme=corporate_theme,
+        chatbot=gr.Chatbot(
+            height=450, 
+            show_label=False,
+            bubble_full_width=False
+        ),
+        textbox=gr.Textbox(
+            placeholder="Enter your documentation question...",
+            container=False
+        )
+    )
+
+
+if __name__ == "__main__":
+    import sys
+    
+    # Choose interface style based on command line argument
+    style = sys.argv[1] if len(sys.argv) > 1 else "enhanced"
+    
+    if style == "minimal":
+        demo = create_minimal_interface()
+    elif style == "corporate":
+        demo = create_corporate_interface()
+    else:  # enhanced (default)
+        demo = create_enhanced_interface()
+    
+    # Launch with professional settings
+    demo.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        quiet=False,
+        favicon_path=None,  # You can add a custom favicon here
+        ssl_verify=False,
+        show_tips=True
+    )

src/ui/showcase.py

@@ -0,0 +1,402 @@
+# gradio_ui_showcase.py
+"""
+Showcase different Gradio UI/UX options for the Docs Navigator
+Run with: python gradio_ui_showcase.py [style_name]
+
+Available styles:
+- modern: Modern, clean design with animations
+- dark: Dark theme professional interface  
+- minimal: Minimal, distraction-free design
+- corporate: Enterprise/business-focused styling
+- glassmorphism: Modern glass-effect design
+"""
+
+import gradio as gr
+from client_agent import answer_sync
+import sys
+
+
+def chat_fn(message: str, history: list[dict]):
+    """Enhanced chat function"""
+    try:
+        if not message.strip():
+            return "Please enter a question about the documentation."
+        reply = answer_sync(message)
+        return reply
+    except Exception as e:
+        return f"⚠️ Error: {str(e)}"
+
+
+def create_modern_interface():
+    """Modern, animated interface with gradient backgrounds"""
+    modern_css = """
+    @import url('https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap');
+    
+    .gradio-container {
+        font-family: 'Poppins', sans-serif !important;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+        min-height: 100vh !important;
+    }
+    
+    .main-wrap {
+        background: rgba(255, 255, 255, 0.95) !important;
+        backdrop-filter: blur(10px) !important;
+        border-radius: 20px !important;
+        margin: 20px !important;
+        padding: 30px !important;
+        box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25) !important;
+    }
+    
+    .title {
+        background: linear-gradient(135deg, #667eea, #764ba2) !important;
+        -webkit-background-clip: text !important;
+        -webkit-text-fill-color: transparent !important;
+        text-align: center !important;
+        font-size: 2.5rem !important;
+        font-weight: 700 !important;
+        margin-bottom: 1rem !important;
+    }
+    
+    .chat-message {
+        animation: slideIn 0.5s ease-out !important;
+        margin: 10px 0 !important;
+    }
+    
+    @keyframes slideIn {
+        from { opacity: 0; transform: translateY(20px); }
+        to { opacity: 1; transform: translateY(0); }
+    }
+    
+    .input-wrap {
+        border-radius: 25px !important;
+        background: white !important;
+        box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1) !important;
+        border: none !important;
+    }
+    
+    .send-button {
+        background: linear-gradient(135deg, #667eea, #764ba2) !important;
+        border: none !important;
+        border-radius: 50% !important;
+        width: 50px !important;
+        height: 50px !important;
+        transition: all 0.3s ease !important;
+    }
+    
+    .send-button:hover {
+        transform: scale(1.1) !important;
+        box-shadow: 0 10px 20px rgba(102, 126, 234, 0.4) !important;
+    }
+    """
+    
+    return gr.ChatInterface(
+        fn=chat_fn,
+        type="messages",
+        title="✨ Docs Navigator AI",
+        description="**Modern AI Documentation Assistant** - Powered by cutting-edge AI technology",
+        css=modern_css,
+        theme=gr.themes.Soft(),
+        chatbot=gr.Chatbot(height=450, show_label=False),
+        examples=["🚀 Quick Start Guide", "⚙️ Configuration", "🔍 Advanced Features"]
+    )
+
+
+def create_dark_interface():
+    """Professional dark theme interface"""
+    dark_css = """
+    .gradio-container {
+        background: #0f172a !important;
+        color: #e2e8f0 !important;
+    }
+    
+    .main-wrap, .panel {
+        background: #1e293b !important;
+        border: 1px solid #334155 !important;
+        border-radius: 12px !important;
+    }
+    
+    .chatbot {
+        background: #1e293b !important;
+        border: 1px solid #334155 !important;
+    }
+    
+    .message-wrap {
+        background: #334155 !important;
+        border-radius: 8px !important;
+        margin: 8px !important;
+        padding: 12px !important;
+    }
+    
+    .user-message {
+        background: linear-gradient(135deg, #3b82f6, #1d4ed8) !important;
+        color: white !important;
+    }
+    
+    .input-container textarea {
+        background: #334155 !important;
+        border: 1px solid #475569 !important;
+        color: #e2e8f0 !important;
+        border-radius: 8px !important;
+    }
+    
+    .input-container textarea:focus {
+        border-color: #3b82f6 !important;
+        box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.2) !important;
+    }
+    """
+    
+    return gr.ChatInterface(
+        fn=chat_fn,
+        type="messages",
+        title="🌙 Docs Navigator - Dark Mode",
+        description="**Professional Dark Theme** - Easy on the eyes, powerful AI assistance",
+        css=dark_css,
+        theme=gr.themes.Monochrome().set(
+            body_background_fill="#0f172a",
+            panel_background_fill="#1e293b"
+        ),
+        chatbot=gr.Chatbot(height=450, show_label=False),
+        examples=["📚 Documentation Overview", "🛠️ Setup Instructions", "❓ FAQ"]
+    )
+
+
+def create_minimal_interface():
+    """Ultra-minimal, distraction-free interface"""
+    minimal_css = """
+    .gradio-container {
+        max-width: 800px !important;
+        margin: 0 auto !important;
+        padding: 20px !important;
+    }
+    
+    * {
+        border-radius: 4px !important;
+    }
+    
+    .title {
+        font-size: 1.5rem !important;
+        font-weight: 400 !important;
+        color: #374151 !important;
+        text-align: center !important;
+        margin-bottom: 2rem !important;
+    }
+    
+    .chatbot {
+        border: 1px solid #e5e7eb !important;
+        box-shadow: none !important;
+    }
+    
+    .input-container {
+        border: 1px solid #d1d5db !important;
+        background: white !important;
+    }
+    """
+    
+    return gr.ChatInterface(
+        fn=chat_fn,
+        type="messages",
+        title="Docs Navigator",
+        description="Simple documentation assistant",
+        css=minimal_css,
+        theme=gr.themes.Base(),
+        chatbot=gr.Chatbot(height=400, show_label=False),
+        textbox=gr.Textbox(placeholder="Ask about docs...", container=False),
+        examples=["Setup", "Config", "Help"]
+    )
+
+
+def create_corporate_interface():
+    """Enterprise/business-focused styling"""
+    corporate_css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif !important;
+        background: #f8fafc !important;
+    }
+    
+    .main-wrap {
+        background: white !important;
+        border: 1px solid #e2e8f0 !important;
+        border-radius: 8px !important;
+        padding: 24px !important;
+        margin: 16px !important;
+        box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1) !important;
+    }
+    
+    .title {
+        color: #1a202c !important;
+        font-size: 1.875rem !important;
+        font-weight: 600 !important;
+        text-align: center !important;
+        margin-bottom: 0.5rem !important;
+    }
+    
+    .description {
+        color: #4a5568 !important;
+        text-align: center !important;
+        margin-bottom: 2rem !important;
+    }
+    
+    .chatbot {
+        border: 1px solid #e2e8f0 !important;
+        border-radius: 6px !important;
+        background: #ffffff !important;
+    }
+    
+    .input-container {
+        border: 1px solid #cbd5e0 !important;
+        border-radius: 6px !important;
+        background: white !important;
+    }
+    
+    .submit-button {
+        background: #3182ce !important;
+        color: white !important;
+        border: none !important;
+        border-radius: 6px !important;
+        font-weight: 500 !important;
+        padding: 8px 16px !important;
+    }
+    
+    .submit-button:hover {
+        background: #2c5aa0 !important;
+    }
+    """
+    
+    return gr.ChatInterface(
+        fn=chat_fn,
+        type="messages",
+        title="Enterprise Documentation Assistant",
+        description="Professional AI-powered documentation system for enterprise environments",
+        css=corporate_css,
+        theme=gr.themes.Default().set(
+            primary_hue="blue",
+            secondary_hue="slate",
+            neutral_hue="gray"
+        ),
+        chatbot=gr.Chatbot(height=450, show_label=False),
+        examples=[
+            "System Documentation",
+            "API Reference",
+            "Implementation Guide",
+            "Security Protocols"
+        ]
+    )
+
+
+def create_glassmorphism_interface():
+    """Modern glass-effect design"""
+    glass_css = """
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+    
+    body {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+        min-height: 100vh !important;
+    }
+    
+    .gradio-container {
+        font-family: 'Inter', sans-serif !important;
+        background: transparent !important;
+    }
+    
+    .main-wrap {
+        background: rgba(255, 255, 255, 0.1) !important;
+        backdrop-filter: blur(20px) !important;
+        border: 1px solid rgba(255, 255, 255, 0.2) !important;
+        border-radius: 20px !important;
+        margin: 20px !important;
+        padding: 30px !important;
+        box-shadow: 
+            0 8px 32px 0 rgba(31, 38, 135, 0.37),
+            inset 0 1px 1px 0 rgba(255, 255, 255, 0.3) !important;
+    }
+    
+    .title {
+        color: white !important;
+        text-shadow: 0 2px 4px rgba(0, 0, 0, 0.1) !important;
+        font-size: 2.25rem !important;
+        font-weight: 600 !important;
+        text-align: center !important;
+        margin-bottom: 1rem !important;
+    }
+    
+    .description {
+        color: rgba(255, 255, 255, 0.9) !important;
+        text-align: center !important;
+        font-size: 1.1rem !important;
+        margin-bottom: 2rem !important;
+    }
+    
+    .chatbot, .panel {
+        background: rgba(255, 255, 255, 0.15) !important;
+        backdrop-filter: blur(10px) !important;
+        border: 1px solid rgba(255, 255, 255, 0.2) !important;
+        border-radius: 15px !important;
+    }
+    
+    .input-container {
+        background: rgba(255, 255, 255, 0.2) !important;
+        backdrop-filter: blur(10px) !important;
+        border: 1px solid rgba(255, 255, 255, 0.3) !important;
+        border-radius: 12px !important;
+    }
+    
+    .input-container textarea {
+        background: transparent !important;
+        color: white !important;
+        border: none !important;
+    }
+    
+    .input-container textarea::placeholder {
+        color: rgba(255, 255, 255, 0.7) !important;
+    }
+    
+    .message-wrap {
+        background: rgba(255, 255, 255, 0.1) !important;
+        backdrop-filter: blur(5px) !important;
+        border-radius: 10px !important;
+        margin: 8px !important;
+        padding: 12px !important;
+        border: 1px solid rgba(255, 255, 255, 0.1) !important;
+    }
+    
+    .user-message {
+        background: rgba(59, 130, 246, 0.3) !important;
+        color: white !important;
+    }
+    """
+    
+    return gr.ChatInterface(
+        fn=chat_fn,
+        type="messages",
+        title="🔮 Docs Navigator Glass",
+        description="Experience the future of documentation with glassmorphism design",
+        css=glass_css,
+        theme=gr.themes.Glass(),
+        chatbot=gr.Chatbot(height=450, show_label=False),
+        examples=["✨ Modern Features", "🎨 Design System", "🔧 Advanced Config"]
+    )
+
+
+if __name__ == "__main__":
+    # Get style from command line or default to modern
+    style = sys.argv[1] if len(sys.argv) > 1 else "modern"
+    
+    interfaces = {
+        "modern": create_modern_interface,
+        "dark": create_dark_interface,
+        "minimal": create_minimal_interface,
+        "corporate": create_corporate_interface,
+        "glassmorphism": create_glassmorphism_interface
+    }
+    
+    if style not in interfaces:
+        print(f"Available styles: {', '.join(interfaces.keys())}")
+        style = "modern"
+    
+    print(f"🎨 Launching {style} interface...")
+    demo = interfaces[style]()
+    demo.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        show_error=True
+    )