xyizko-Fix

xyizko - Syntax and AgentCalls Fixes

app4.py

@@ -0,0 +1,862 @@
+# /////////////////////////////////////////////
+# Xyizko - MCH Hackathon 2025 Skeleton
+# x.com/xyizko
+# /////////////////////////////////////////////
+
+# --- Imports Section ---
+
+import datetime
+
+import gradio as gr
+
+# Try importing SmolAgents with proper error handling
+try:
+    from smolagents import CodeAgent, HfApiModel
+    SMOLAGENTS_AVAILABLE = True
+except ImportError:
+    SMOLAGENTS_AVAILABLE = False
+    print("⚠️ SmolAgents not available, using direct HF API")
+
+# Fallback to HuggingFace Hub
+from huggingface_hub import InferenceClient
+
+# --- Demo UI Component Functions ---
+
+# App Introduction Function (UPDATED with MCP info)
+
+
+def app_intro():
+    intro_text = """
+    # Xyizko - MCP Hackathon 2025 Submission - Smart Contract Analyzer
+    1. This gradio app serves as a skeleton for the MCP Hackathon 2025 project.
+    2. As components are developed they will be added to this app.
+    3. https://huggingface.co/Agents-MCP-Hackathon - Official Hackathon Announcement
+
+    # App Description
+    **AI-Powered Smart Contract Security Analysis Platform**
+    1. This tool leverages AI to analyze smart contracts for vulnerabilities, 
+    anti-patterns, and security issues. Upload your contract code and get comprehensive 
+    security analysis powered by Hugging Face models.
+    2. https://github.com/RareSkills/Buggy-ERC-20 - Test Buggy ERC-20 Contracts Source
+    """
+
+    ai_system_info = f"""
+    ## 🤖 AI Analysis System
+    **SmolAgents Status**: {'✅ Available' if SMOLAGENTS_AVAILABLE else '❌ Not Available - Using Direct HF API'}
+    
+    ### What Our AI System Does:
+    
+    #### 🧠 **Intelligent Code Analysis**
+    {'- SmolAgents CodeAgent for specialized code analysis' if SMOLAGENTS_AVAILABLE else '- Direct HuggingFace Inference API calls'}
+    - Multi-step security vulnerability detection
+    - Risk assessment and scoring
+    - Code quality evaluation
+    - Actionable security recommendations
+    
+    #### 🎯 **Analysis Capabilities**
+    1. **Security Vulnerability Detection**: Identifies reentrancy, overflow, access control issues
+    2. **Risk Assessment**: Intelligent risk scoring and prioritization
+    3. **Code Quality Analysis**: Best practices and optimization evaluation
+    4. **Pattern Recognition**: Detects anti-patterns and security smells
+    5. **Actionable Recommendations**: Generates specific improvement suggestions
+    
+    #### 🚀 **System Features**
+    - **Reliable**: Robust error handling with fallback mechanisms
+    - **Flexible**: Works with various HuggingFace models
+    - **Comprehensive**: Multi-dimensional analysis approach
+    - **Practical**: Provides actionable, implementable recommendations
+    """
+
+    # NEW MCP Integration Info
+    mcp_integration_info = """
+    ## 🔌 Model Context Protocol (MCP) Integration
+    
+    **🚀 This app is now MCP-enabled!** AI assistants like Claude can use it as a specialized security tool.
+    
+    ### 🛠️ Available MCP Tool:
+    
+    #### 🛡️ `analyze_smart_contract`
+    - **Purpose**: Complete smart contract security analysis
+    - **Features**: Security vulnerabilities + Risk scoring + Code quality assessment
+    - **AI-Powered**: Uses HuggingFace models with intelligent rule-based fallback
+    - **Input**: Just paste your Solidity contract code
+    - **Output**: Comprehensive security report with actionable recommendations
+    - **Reliability**: Always works - even without API tokens (fallback analysis)
+    
+    ### 🤖 How AI Assistants Use This:
+    
+    **Claude Desktop Integration:**
+    ```json
+    {
+      "mcpServers": {
+        "smart-contract-analyzer": {
+          "command": "npx",
+          "args": ["-y", "@modelcontextprotocol/server-gradio", "YOUR_HF_SPACE_URL"]
+        }
+      }
+    }
+    ```
+    
+    **Example AI Conversation:**
+    ```
+    User: "Analyze this smart contract for security issues: [paste contract]"
+    
+    Claude: [Uses analyze_smart_contract tool] 
+    "I've analyzed your contract and found 3 critical vulnerabilities..."
+    ```
+    
+    ### ✨ Key Benefits:
+    - **One-Click Security**: AI assistants can instantly analyze any contract
+    - **Always Available**: Hosted on reliable HuggingFace infrastructure  
+    - **No Setup Required**: AI assistants connect directly to your public space
+    - **Professional Reports**: Detailed analysis with specific remediation steps
+    """
+
+    part3 = """
+    ## Development Progress 
+    > Changelog - Fri Jun  6 08:14:02 PM UTC 2025
+    1. ✅ Implement robust AI analysis system
+    2. ✅ SmolAgents integration with proper error handling
+    3. ✅ Direct HF API fallback for maximum compatibility
+    4. ✅ Enhanced analysis with multiple approaches
+    5. ✅ Comprehensive security assessment capabilities
+    6. ✅ **NEW: Model Context Protocol (MCP) Integration**
+    7. ✅ **NEW: Single powerful MCP tool for AI assistants**
+    8. ✅ **NEW: Lightweight deployment (no transformers/torch dependencies)**
+    9. ✅ **NEW: Proper Gradio MCP server setup with mcp_server=True**
+
+    ### About Author
+    1. X - https://x.com/xyizko 
+    2. Project Acknowledgements - https://x.com/Gradio/status/1930951866935910753
+    """
+
+    gr.Markdown(intro_text)
+    gr.Markdown(ai_system_info)
+    gr.Markdown(mcp_integration_info)
+    gr.Markdown(
+        value="""  
+        ```mermaid  
+        flowchart LR
+            A[Smart Contract Code] -->|Upload/MCP| B{AI Analysis System}
+            B -->|SmolAgents Available| C[CodeAgent Analysis]
+            B -->|Fallback| D[Direct HF API]
+            C --> E[Multi-Step Analysis]
+            D --> E
+            E --> F[Security Assessment]
+            E --> G[Risk Scoring]
+            E --> H[Quality Review]
+            F --> I[Comprehensive Report]
+            G --> I
+            H --> I
+            I --> J[Gradio UI Output]
+            I --> K[MCP Tool Response]
+            K --> L[AI Assistant Integration]
+            J --> M[Downloadable Analysis]
+        ```  
+        """)
+    gr.Markdown(part3)
+
+# --- Existing Analysis Functions (Unchanged) ---
+
+
+def create_smart_contract_analyzer(hf_token, model_name):
+    """Create AI analyzer using SmolAgents or direct HF API"""
+    if SMOLAGENTS_AVAILABLE:
+        try:
+            model = HfApiModel(model_id=model_name, token=hf_token)
+            agent = CodeAgent(tools=[], model=model)
+            return {"type": "smolagent", "instance": agent, "model": model_name}
+        except Exception as e:
+            print(f"SmolAgents creation failed: {e}")
+
+    try:
+        client = InferenceClient(token=hf_token)
+        test_response = client.text_generation(
+            prompt="Test prompt",
+            model=model_name,
+            max_new_tokens=5
+        )
+        return {"type": "direct_api", "instance": client, "model": model_name}
+    except Exception as e:
+        raise Exception(f"Failed to create AI analyzer: {str(e)}")
+
+
+def run_ai_analysis(analyzer, contract_code, analysis_type):
+    """Run AI analysis using available method"""
+    prompts = {
+        "security": f"""Analyze this Solidity smart contract for security vulnerabilities:
+
+```solidity
+{contract_code[:3000]}
+```
+
+Identify:
+1. Security vulnerabilities (reentrancy, overflow, access control)
+2. Risk level for each issue (Critical/High/Medium/Low)
+3. Specific remediation steps
+
+Be concise and practical.""",
+
+        "risk": f"""Assess the risk level of this smart contract (scale 1-10):
+
+```solidity
+{contract_code[:3000]}
+```
+
+Provide:
+1. Overall risk score (1-10)
+2. Main risk factors
+3. Top 3 recommendations
+
+Be specific and actionable.""",
+
+        "quality": f"""Review the code quality of this smart contract:
+
+```solidity
+{contract_code[:3000]}
+```
+
+Evaluate:
+1. Solidity best practices
+2. Gas optimization opportunities
+3. Code organization
+
+Provide specific improvement suggestions."""
+    }
+
+    prompt = prompts.get(analysis_type, prompts["security"])
+
+    try:
+        if analyzer["type"] == "smolagent":
+            result = analyzer["instance"].run(prompt)
+            return str(result)
+        else:
+            response = analyzer["instance"].text_generation(
+                prompt=prompt,
+                model=analyzer["model"],
+                max_new_tokens=600,
+                temperature=0.5,
+                do_sample=True
+            )
+
+            if isinstance(response, str):
+                return response.strip()
+            elif hasattr(response, 'generated_text'):
+                return response.generated_text.strip()
+            else:
+                return str(response)
+
+    except Exception as e:
+        error_msg = str(e).lower()
+        if "not found" in error_msg or "404" in error_msg:
+            return f"❌ Model '{analyzer.get('model', 'unknown')}' not found. Try: microsoft/DialoGPT-medium"
+        elif "unauthorized" in error_msg or "403" in error_msg:
+            return "❌ Invalid API token or insufficient permissions"
+        elif "rate limit" in error_msg:
+            return "❌ Rate limit exceeded. Please wait and try again"
+        else:
+            return f"❌ Analysis failed: {str(e)}"
+
+
+def enhanced_fallback_analysis(content, analysis_type):
+    """Comprehensive fallback analysis when AI fails"""
+    lines = content.splitlines()
+    functions = content.count('function')
+
+    if analysis_type == "security":
+        vulnerabilities = []
+        risk_score = 0
+
+        if 'call.value' in content or '.call(' in content:
+            vulnerabilities.append(
+                "🔴 **CRITICAL**: Potential reentrancy vulnerability (call.value/.call usage)")
+            risk_score += 4
+
+        if 'tx.origin' in content:
+            vulnerabilities.append(
+                "🟡 **MEDIUM**: Authentication bypass risk (tx.origin usage)")
+            risk_score += 2
+
+        if 'block.timestamp' in content or 'now' in content:
+            vulnerabilities.append("🟡 **MEDIUM**: Timestamp manipulation risk")
+            risk_score += 1
+
+        if not any(word in content.lower() for word in ['require', 'assert', 'revert']):
+            vulnerabilities.append("🟠 **HIGH**: Missing input validation")
+            risk_score += 3
+
+        if 'selfdestruct' in content:
+            vulnerabilities.append(
+                "🔴 **CRITICAL**: Contract can be destroyed (selfdestruct)")
+            risk_score += 4
+
+        if 'delegatecall' in content:
+            vulnerabilities.append("🟠 **HIGH**: Dangerous delegate call usage")
+            risk_score += 3
+
+        if functions > 20:
+            vulnerabilities.append(
+                "🟡 **MEDIUM**: High complexity (many functions)")
+            risk_score += 1
+
+        return f"""**Security Analysis Results:**
+
+**Vulnerabilities Found:** {len(vulnerabilities)}
+**Risk Score:** {min(risk_score, 10)}/10
+
+{chr(10).join(vulnerabilities) if vulnerabilities else "✅ No major vulnerabilities detected in static analysis"}
+
+**Recommendations:**
+- Implement reentrancy guards for external calls
+- Use msg.sender instead of tx.origin
+- Add comprehensive input validation
+- Consider formal verification for critical functions"""
+
+    elif analysis_type == "risk":
+        risk_factors = []
+        score = 0
+
+        if 'call.value' in content:
+            score += 3
+            risk_factors.append("External call risks")
+        if len(lines) > 500:
+            score += 1
+            risk_factors.append("Large codebase")
+        if functions > 15:
+            score += 1
+            risk_factors.append("High complexity")
+        if 'owner' in content.lower():
+            score += 1
+            risk_factors.append("Centralized control")
+        if content.count('mapping') > 5:
+            score += 1
+            risk_factors.append("Complex state")
+
+        risk_level = "Critical" if score >= 6 else "High" if score >= 4 else "Medium" if score >= 2 else "Low"
+
+        return f"""**Risk Assessment:**
+
+**Overall Risk Score:** {score}/10
+**Risk Level:** {risk_level}
+
+**Risk Factors:**
+{chr(10).join([f"- {factor}" for factor in risk_factors]) if risk_factors else "- Minimal risk factors identified"}
+
+**Priority Actions:**
+1. {"Immediate security review required" if score >= 4 else "Standard review recommended"}
+2. {"Implement emergency pause mechanism" if score >= 6 else "Add comprehensive testing"}
+3. {"Consider professional audit" if score >= 3 else "Document all functions"}"""
+
+    elif analysis_type == "quality":
+        quality_issues = []
+        score = 100
+
+        if content.count('pragma') == 0:
+            quality_issues.append("❌ Missing pragma statement (-10 points)")
+            score -= 10
+
+        if content.count('//') < functions / 2:
+            quality_issues.append("⚠️ Insufficient documentation (-15 points)")
+            score -= 15
+
+        if len(lines) > 1000:
+            quality_issues.append(
+                "⚠️ Contract too large, consider splitting (-10 points)")
+            score -= 10
+
+        if 'TODO' in content or 'FIXME' in content:
+            quality_issues.append(
+                "⚠️ Unfinished code markers found (-5 points)")
+            score -= 5
+
+        if not any(modifier in content for modifier in ['public', 'private', 'internal', 'external']):
+            quality_issues.append(
+                "❌ Missing function visibility specifiers (-20 points)")
+            score -= 20
+
+        return f"""**Code Quality Assessment:**
+
+**Quality Score:** {max(score, 0)}/100
+
+**Issues Found:**
+{chr(10).join(quality_issues) if quality_issues else "✅ No major quality issues detected"}
+
+**Improvement Suggestions:**
+- Add comprehensive NatSpec documentation
+- Implement consistent naming conventions
+- Use latest Solidity version with appropriate pragma
+- Add function visibility specifiers
+- Consider gas optimization patterns"""
+
+# --- MCP Tool Function ---
+
+
+def analyze_smart_contract(contract_code: str, hf_token: str = "", hf_model: str = "microsoft/DialoGPT-medium"):
+    """
+    MCP Tool: Comprehensive smart contract security analysis
+
+    This function will be automatically exposed as an MCP tool when mcp_server=True
+
+    Args:
+        contract_code: Solidity smart contract source code
+        hf_token: Optional HuggingFace API token for AI analysis
+        hf_model: HuggingFace model name (default: microsoft/DialoGPT-medium)
+
+    Returns:
+        Complete security analysis report with vulnerabilities, risk assessment, and recommendations
+    """
+    try:
+        # Initialize analyzer if token provided
+        analyzer = None
+        analysis_method = "Enhanced Rule-Based Fallback"
+
+        if hf_token.strip():
+            try:
+                analyzer = create_smart_contract_analyzer(hf_token, hf_model)
+                analysis_method = f"AI-Powered ({analyzer['type']})"
+            except Exception as e:
+                # Continue with fallback analysis
+                analysis_method = f"Rule-Based Fallback (AI failed: {str(e)[:50]}...)"
+
+        # Perform comprehensive analysis
+        if analyzer:
+            # Try AI analysis first
+            security_result = run_ai_analysis(
+                analyzer, contract_code, "security")
+            if security_result.startswith("❌"):
+                security_result = enhanced_fallback_analysis(
+                    contract_code, "security")
+
+            risk_result = run_ai_analysis(analyzer, contract_code, "risk")
+            if risk_result.startswith("❌"):
+                risk_result = enhanced_fallback_analysis(contract_code, "risk")
+
+            quality_result = run_ai_analysis(
+                analyzer, contract_code, "quality")
+            if quality_result.startswith("❌"):
+                quality_result = enhanced_fallback_analysis(
+                    contract_code, "quality")
+        else:
+            # Use enhanced fallback analysis
+            security_result = enhanced_fallback_analysis(
+                contract_code, "security")
+            risk_result = enhanced_fallback_analysis(contract_code, "risk")
+            quality_result = enhanced_fallback_analysis(
+                contract_code, "quality")
+
+        # Contract statistics
+        lines = contract_code.splitlines()
+        function_count = contract_code.count('function')
+        modifier_count = contract_code.count('modifier')
+        pragma_count = contract_code.count('pragma')
+
+        # Generate comprehensive report
+        report = f"""# 🛡️ Smart Contract Security Analysis Report
+
+## 📊 Analysis Overview
+**Analysis Method**: {analysis_method}
+**Model Used**: {hf_model if analyzer else 'Rule-Based Analysis Engine'}
+**Timestamp**: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}
+**Analysis Tool**: Xyizko Smart Contract Analyzer (MCP-Enabled)
+
+## 📈 Contract Metrics
+- **Lines of Code**: {len(lines)}
+- **Functions**: {function_count}
+- **Modifiers**: {modifier_count}
+- **Pragma Statements**: {pragma_count}
+- **Code Size**: {len(contract_code)} characters
+
+## 🛡️ Security Vulnerability Assessment
+{security_result}
+
+## 🎯 Risk Assessment & Scoring
+{risk_result}
+
+## 📊 Code Quality Analysis
+{quality_result}
+
+## 📋 Executive Summary & Recommendations
+
+### 🚨 Immediate Actions Required:
+- Review and address any CRITICAL or HIGH severity vulnerabilities
+- Implement recommended security improvements
+- Add missing input validations and access controls
+
+### 🔧 Development Best Practices:
+- Follow Solidity security patterns and conventions
+- Implement comprehensive testing including edge cases
+- Consider formal verification for critical functions
+
+### 🏗️ Deployment Readiness:
+- {"⚠️ NOT READY: Address critical issues before deployment" if "CRITICAL" in security_result else "✅ Ready for thorough testing and audit review"}
+- Professional security audit recommended before mainnet deployment
+- Implement emergency pause mechanisms for production contracts
+
+---
+**Analysis powered by Xyizko Smart Contract Analyzer**  
+*MCP-enabled AI tool for comprehensive smart contract security assessment*
+"""
+
+        return report
+
+    except Exception as e:
+        return f"""# ❌ Smart Contract Analysis Failed
+
+**Error**: {str(e)}
+**Timestamp**: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}
+
+## Troubleshooting:
+- Ensure contract code is valid Solidity
+- Check HuggingFace token if using AI analysis
+- Try with a different model name
+- Contact support if the issue persists
+
+---
+*Xyizko Smart Contract Analyzer - MCP Tool*
+"""
+
+# --- Smart Contract Analysis Tab (Unchanged) ---
+
+
+def upload_tab():
+    system_status = "SmolAgents + HF API" if SMOLAGENTS_AVAILABLE else "Direct HF API"
+
+    upload_description = f"""
+    # Smart Contract AI Analysis
+    > Upload your smart contract and get comprehensive AI-powered security analysis.
+    
+    **Current System**: {system_status}
+    
+    ## How it works:
+    1. **Upload**: Select your smart contract (.txt, .sol files)
+    2. **Configure**: Enter your Hugging Face API token and model
+    3. **AI Analysis**: {'SmolAgents or' if SMOLAGENTS_AVAILABLE else ''} Direct API analysis with fallback
+    4. **Download**: Get detailed analysis reports with actionable recommendations
+    """
+
+    analysis_info = """
+    ## Analysis Features
+    - **🛡️ Security Analysis**: Comprehensive vulnerability detection
+    - **🎯 Risk Assessment**: Intelligent risk scoring (1-10 scale)
+    - **📊 Code Quality Review**: Best practices evaluation
+    - **🔧 Fallback Analysis**: Robust rule-based analysis when AI fails
+    - **📝 Actionable Reports**: Specific, implementable recommendations
+    
+    ## Recommended Models
+    - **microsoft/DialoGPT-medium** (Reliable, good balance)
+    - **microsoft/DialoGPT-large** (More detailed responses)
+    - **google/flan-t5-base** (Good instruction following)
+    - **facebook/blenderbot-400M-distill** (Lightweight, fast)
+    """
+
+    def analyze_contract_ui(file, hf_token, hf_model, progress=gr.Progress()):
+        if file is None:
+            return "❌ No file uploaded.", "", gr.update(visible=False)
+
+        if not hf_token.strip():
+            return "❌ Please provide a valid Hugging Face API token.", "", gr.update(visible=False)
+
+        if not hf_model.strip():
+            return "❌ Please specify a Hugging Face model name.", "", gr.update(visible=False)
+
+        try:
+            progress(0.1, desc="📖 Reading contract file...")
+
+            # Read file content
+            if hasattr(file, 'read'):
+                content = file.read().decode("utf-8")
+            else:
+                with open(file.name, 'r', encoding='utf-8') as f:
+                    content = f.read()
+
+            # Limit content size
+            if len(content) > 10000:
+                content = content[:10000] + "\n// ... (truncated for analysis)"
+
+            progress(0.3, desc="🤖 Running comprehensive analysis...")
+
+            # Use the MCP function for consistency
+            analysis_result = analyze_smart_contract(
+                content, hf_token, hf_model)
+
+            progress(0.9, desc="💾 Creating downloadable report...")
+
+            # Create downloadable report
+            timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+            report_content = f"""# Smart Contract Security Analysis Report
+**Generated by**: Xyizko Smart Contract Analyzer
+**Date**: {datetime.datetime.now().strftime("%Y-%m-%d at %H:%M:%S")}
+
+{analysis_result}
+
+---
+*Report generated by Xyizko Smart Contract Analyzer - MCH Hackathon 2025*
+"""
+
+            progress(1.0, desc="✅ Analysis complete!")
+
+            # Create downloadable file
+            report_filename = f"contract_analysis_{timestamp}.md"
+            try:
+                with open(report_filename, 'w', encoding='utf-8') as f:
+                    f.write(report_content)
+
+                return (
+                    "✅ Analysis completed successfully!",
+                    analysis_result,
+                    gr.update(visible=True, value=report_filename)
+                )
+            except Exception:
+                return (
+                    "✅ Analysis completed! (Download creation failed)",
+                    analysis_result,
+                    gr.update(visible=False)
+                )
+
+        except Exception as e:
+            return f"❌ Analysis error: {str(e)}", "", gr.update(visible=False)
+
+    with gr.Column():
+        gr.Markdown(upload_description)
+        gr.Markdown(analysis_info)
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                file_input = gr.File(
+                    label="📁 Upload Smart Contract",
+                    file_types=[".txt", ".sol"],
+                    height=120
+                )
+                hf_token_input = gr.Textbox(
+                    label="🔑 Hugging Face API Token",
+                    placeholder="hf_xxxxxxxxxxxxxxxxxxxxxxxxx",
+                    type="password",
+                    info="Get your token from https://huggingface.co/settings/tokens"
+                )
+                hf_model_input = gr.Textbox(
+                    label="🤖 Hugging Face Model",
+                    placeholder="microsoft/DialoGPT-medium",
+                    value="microsoft/DialoGPT-medium",
+                    info="Recommended: microsoft/DialoGPT-medium (Lightweight & Reliable)"
+                )
+
+            with gr.Column(scale=1):
+                analyze_btn = gr.Button(
+                    "🚀 Start Analysis",
+                    variant="primary",
+                    size="lg",
+                    scale=2
+                )
+
+        gr.Markdown("---")
+
+        status_output = gr.Textbox(
+            label="📊 Analysis Status",
+            lines=2,
+            interactive=False,
+            show_copy_button=True
+        )
+
+        analysis_output = gr.Textbox(
+            label="📋 Analysis Results",
+            lines=20,
+            max_lines=25,
+            show_copy_button=True
+        )
+
+        download_file = gr.File(
+            label="📥 Download Analysis Report (Markdown)",
+            visible=False
+        )
+
+        analyze_btn.click(
+            fn=analyze_contract_ui,
+            inputs=[file_input, hf_token_input, hf_model_input],
+            outputs=[status_output, analysis_output, download_file]
+        )
+
+# --- MCP Integration Tab ---
+
+
+def mcp_integration_tab():
+    """Simple MCP Integration and Testing Tab"""
+
+    mcp_info = """
+    # 🔌 MCP Integration - One Powerful Tool
+    
+    This Smart Contract Analyzer provides **one comprehensive MCP tool** that AI assistants can use.
+    
+    ## 🛡️ `analyze_smart_contract` - The Complete Security Tool
+    
+    **What it does:**
+    - ✅ **Security Vulnerability Detection** (reentrancy, access control, etc.)
+    - ✅ **Risk Assessment & Scoring** (1-10 scale with detailed factors)
+    - ✅ **Code Quality Analysis** (best practices, optimization opportunities)
+    - ✅ **Actionable Recommendations** (specific steps to fix issues)
+    - ✅ **Always Works** (AI-powered with intelligent fallback)
+    
+    **Parameters:**
+    - `contract_code` (required): Your Solidity smart contract code
+    - `hf_token` (optional): HuggingFace API token for AI analysis
+    - `hf_model` (optional): Model name (default: microsoft/DialoGPT-medium)
+    
+    ## 🚀 For AI Assistants (Claude, etc.):
+    
+    **Claude Desktop Config:**
+    ```json
+    {
+      "mcpServers": {
+        "smart-contract-analyzer": {
+          "command": "npx",
+          "args": ["-y", "@modelcontextprotocol/server-gradio", "YOUR_HF_SPACE_URL"]
+        }
+      }
+    }
+    ```
+    
+    **Example Usage:**
+    ```
+    "Analyze this smart contract for security issues:
+    
+    pragma solidity ^0.8.0;
+    contract MyContract {
+        // Your contract code here
+    }"
+    ```
+    
+    **Benefits:**
+    - 🎯 **Simple**: One tool does everything
+    - 🛡️ **Reliable**: Always works (even without API tokens)
+    - 🚀 **Fast**: Lightweight dependencies
+    - 📊 **Comprehensive**: Complete security assessment
+    """
+
+    def test_mcp_tool(contract_code, hf_token, hf_model):
+        """Test the MCP tool directly"""
+        if not contract_code.strip():
+            return "❌ Please provide contract code to test the MCP tool"
+
+        try:
+            result = analyze_smart_contract(contract_code, hf_token, hf_model)
+            return result
+        except Exception as e:
+            return f"❌ MCP Tool Error: {str(e)}"
+
+    def generate_claude_config(hf_space_url):
+        """Generate Claude Desktop configuration"""
+        if not hf_space_url.strip():
+            hf_space_url = "https://your-username-smart-contract-analyzer.hf.space"
+
+        config = f'''{{\n  "mcpServers": {{\n    "smart-contract-analyzer": {{\n      "command": "npx",\n      "args": [\n        "-y", \n        "@modelcontextprotocol/server-gradio",\n        "{hf_space_url}"\n      ]\n    }}\n  }}\n}}'''
+        return config
+
+    with gr.Column():
+        gr.Markdown(mcp_info)
+
+        gr.Markdown("## 🧪 Test the MCP Tool")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                test_contract = gr.Textbox(
+                    label="📝 Contract Code",
+                    placeholder="""pragma solidity ^0.8.0;
+
+contract TestContract {
+    address owner;
+    mapping(address => uint) balances;
+    
+    function withdraw() public {
+        uint amount = balances[msg.sender];
+        (bool success, ) = msg.sender.call{value: amount}("");
+        balances[msg.sender] = 0;
+    }
+}""",
+                    lines=12
+                )
+
+                test_token = gr.Textbox(
+                    label="🔑 HF Token (Optional)",
+                    placeholder="hf_xxxxxxxxx (leave empty for rule-based analysis)",
+                    type="password"
+                )
+
+                test_model = gr.Textbox(
+                    label="🤖 Model (Optional)",
+                    placeholder="microsoft/DialoGPT-medium",
+                    value="microsoft/DialoGPT-medium"
+                )
+
+            with gr.Column(scale=1):
+                test_btn = gr.Button(
+                    "🧪 Test MCP Tool",
+                    variant="primary",
+                    size="lg"
+                )
+
+                gr.Markdown("### 📋 Generate Config")
+
+                space_url = gr.Textbox(
+                    label="🌐 Your HF Space URL",
+                    placeholder="https://your-space.hf.space"
+                )
+
+                config_btn = gr.Button(
+                    "📋 Generate Claude Config",
+                    variant="secondary"
+                )
+
+        test_output = gr.Textbox(
+            label="🔍 MCP Tool Test Results",
+            lines=25,
+            show_copy_button=True
+        )
+
+        claude_config = gr.Textbox(
+            label="📄 Claude Desktop Configuration",
+            lines=12,
+            show_copy_button=True
+        )
+
+        test_btn.click(
+            fn=test_mcp_tool,
+            inputs=[test_contract, test_token, test_model],
+            outputs=[test_output]
+        )
+
+        config_btn.click(
+            fn=generate_claude_config,
+            inputs=[space_url],
+            outputs=[claude_config]
+        )
+
+# /////////////////////////////////////////////////////////////////////////////////
+# --- Main Demo UI Function ---
+
+
+with gr.Blocks(
+    theme=gr.themes.Ocean(),
+    title="Xyizko - Smart Contract Analyzer"
+) as demo:
+
+    with gr.Tab("🏠 Introduction"):
+        app_intro()
+
+    with gr.Tab("🔍 Contract Analyzer"):
+        upload_tab()
+
+    with gr.Tab("🔌 MCP Integration"):
+        mcp_integration_tab()
+
+if __name__ == "__main__":
+    print("🌐 Starting Xyizko Smart Contract Analyzer...")
+    print("🔌 MCP Integration: ENABLED (mcp_server=True)")
+    print("🤖 AI Analysis: SmolAgents + HF API with Fallback")
+    print("⚡ Lightweight: No transformers/torch dependencies")
+    print("💡 Deploy to HuggingFace Spaces for public MCP access!")
+
+    demo.launch(
+        mcp_server=True,  # 🔑 KEY FIX: Enable MCP server
+        share=False,
+        server_name="0.0.0.0",
+        show_error=True
+    )