Update app.py

app.py

@@ -2,12 +2,10 @@ import gradio as gr
 import os
 import json
 import logging
-from typing import Dict, Any, Optional
 import tempfile
-from pathlib import Path
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🏗️ SIMPLIFIED ARCHITECTURE FOR HUGGINGFACE SPACES
+# 🎓 ACADEMIC RESEARCH AI DEMO - SIMPLE & CLEAN
 # ══════════════════════════════════════════════════════════════════════════════
 
 try:
@@ -15,596 +13,359 @@ try:
     HF_AVAILABLE = True
 except ImportError:
     HF_AVAILABLE = False
-    print("⚠️ HuggingFace Hub not available - running in demo mode")
 
-# Configure logging
-logging.basicConfig(
-    format="%(asctime)s | %(levelname)-8s | %(message)s",
-    level=logging.INFO,
-    datefmt="%Y-%m-%d %H:%M:%S"
-)
+# Simple logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🔧 SIMPLIFIED INFERENCE ENGINE
+# 🔧 SIMPLE CLIENT SETUP (Following Official Docs)
 # ══════════════════════════════════════════════════════════════════════════════
 
-class SimpleInferenceEngine:
-    """Simplified inference engine optimized for HuggingFace Spaces."""
+def get_client():
+    """Get HuggingFace Inference Client following official documentation."""
+    api_token = os.getenv("HF_API_TOKEN")
     
-    def __init__(self):
-        self.api_token = os.getenv("HF_API_TOKEN")
-        self.client = None
-        
-        if HF_AVAILABLE and self.api_token:
-            try:
-                self.client = InferenceClient(api_key=self.api_token)
-                logger.info("✅ HuggingFace client initialized successfully")
-            except Exception as e:
-                logger.error(f"❌ Failed to initialize HF client: {e}")
-                self.client = None
-        else:
-            logger.warning("⚠️ Running in demo mode - no API client available")
+    if not HF_AVAILABLE:
+        return None, "HuggingFace Hub not installed"
     
-    def safe_call(self, func, *args, **kwargs):
-        """Execute API calls with error handling."""
-        if not self.client:
-            return {"error": "API client not available - demo mode active", "demo": True}
-        
-        try:
-            result = func(*args, **kwargs)
-            return {"data": result, "success": True}
-        except Exception as e:
-            logger.error(f"API call failed: {e}")
-            return {"error": str(e), "success": False}
+    if not api_token:
+        return None, "HF_API_TOKEN not set"
+    
+    try:
+        # Following official docs - using provider parameter
+        client = InferenceClient(
+            provider="hf-inference",
+            api_key=api_token,
+        )
+        return client, "Connected"
+    except Exception as e:
+        return None, f"Connection failed: {e}"
 
-# Global inference engine
-engine = SimpleInferenceEngine()
+# Initialize client
+CLIENT, STATUS = get_client()
+logger.info(f"Client status: {STATUS}")
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🤖 SIMPLIFIED TASK FUNCTIONS
+# 🤖 SIMPLE TASK FUNCTIONS (No Async)
 # ══════════════════════════════════════════════════════════════════════════════
 
-def process_speech_recognition(audio_data):
-    """Process audio for speech recognition."""
-    if audio_data is None:
-        return "⚠️ Please upload an audio file or record audio."
+def speech_recognition(audio_file):
+    """Speech Recognition - Following official docs exactly."""
+    if audio_file is None:
+        return "❌ Please upload an audio file"
     
-    if not engine.client:
-        return "🎤 **Demo Response:** Audio transcription would appear here.\n📝 *Configure HF_API_TOKEN for real speech recognition.*"
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
     
     try:
         # Handle audio input
-        if isinstance(audio_data, tuple):
-            sample_rate, audio_array = audio_data
+        if isinstance(audio_file, tuple):
+            # Convert numpy array to file if needed
+            sample_rate, audio_array = audio_file
             with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
                 import scipy.io.wavfile as wav
                 wav.write(tmp_file.name, sample_rate, audio_array)
                 audio_path = tmp_file.name
         else:
-            audio_path = audio_data
+            audio_path = audio_file
         
-        result = engine.safe_call(
-            engine.client.automatic_speech_recognition,
-            audio_path,
+        # Official API call from docs
+        output = CLIENT.automatic_speech_recognition(
+            audio_path, 
             model="openai/whisper-large-v3"
         )
         
-        if result.get("success"):
-            text = result["data"].get("text", "No transcription available")
-            return f"🎤 **Transcription:** {text}"
-        else:
-            return f"❌ **Error:** {result.get('error', 'Unknown error')}"
-            
+        return f"🎤 **Transcription:** {output.get('text', str(output))}"
+        
     except Exception as e:
-        return f"❌ **Processing error:** {str(e)}"
+        return f"❌ Error: {str(e)}"
 
-def process_chat(messages_json):
-    """Process chat completion."""
+def chat_completion(messages_json):
+    """Chat Completion - Following official docs exactly."""
     if not messages_json.strip():
-        return "⚠️ Please enter a valid JSON message format."
+        return "❌ Please enter valid JSON messages"
+    
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
     
     try:
         messages = json.loads(messages_json)
-        if not isinstance(messages, list) or not messages:
-            return "⚠️ Messages must be a non-empty JSON array."
-        
-        # Validate message structure
-        for msg in messages:
-            if not isinstance(msg, dict) or "role" not in msg or "content" not in msg:
-                return "⚠️ Each message must have 'role' and 'content' fields."
         
-        if not engine.client:
-            user_msg = messages[-1].get("content", "Hello")
-            return f"🤖 **Demo Response:** Thank you for your message: '{user_msg}'\n📝 *Configure HF_API_TOKEN for real chat functionality.*"
-        
-        result = engine.safe_call(
-            engine.client.chat.completions.create,
-            model="microsoft/DialoGPT-medium",
+        # Official API call from docs
+        completion = CLIENT.chat.completions.create(
+            model="meta-llama/Llama-3.2-3B-Instruct",
             messages=messages,
-            max_tokens=150
         )
         
-        if result.get("success"):
-            response = result["data"]
-            if hasattr(response, "choices") and response.choices:
-                reply = response.choices[0].message.content
-                return f"🤖 **Assistant:** {reply}"
-            else:
-                return "🤖 **Assistant:** I'm here to help! How can I assist you today?"
-        else:
-            return f"❌ **Error:** {result.get('error', 'Unknown error')}"
-            
+        return f"🤖 **Response:** {completion.choices[0].message.content}"
+        
     except json.JSONDecodeError:
-        return "⚠️ Invalid JSON format. Please check your syntax."
+        return "❌ Invalid JSON format"
     except Exception as e:
-        return f"❌ **Processing error:** {str(e)}"
+        return f"❌ Error: {str(e)}"
 
-def process_fill_mask(text):
-    """Process fill mask task."""
+def fill_mask(text):
+    """Fill Mask - Following official docs exactly."""
     if not text or "[MASK]" not in text:
-        return "⚠️ Input must contain the token `[MASK]`."
-    
-    if not engine.client:
-        # Demo response based on common patterns
-        demo_predictions = []
-        if "programming language" in text.lower():
-            demo_predictions = ["Python", "JavaScript", "Java", "C++", "Go"]
-        elif "capital" in text.lower():
-            demo_predictions = ["Paris", "London", "Tokyo", "Berlin", "Madrid"]
-        else:
-            demo_predictions = ["amazing", "powerful", "useful", "innovative", "advanced"]
-        
-        formatted_results = []
-        for i, pred in enumerate(demo_predictions, 1):
-            formatted_results.append(f"{i}. **{pred}** (demo prediction)")
-        
-        return "🎭 **Demo Predictions:**\n" + "\n".join(formatted_results) + "\n\n📝 *Configure HF_API_TOKEN for real predictions.*"
+        return "❌ Text must contain [MASK] token"
     
-    result = engine.safe_call(
-        engine.client.fill_mask,
-        text,
-        model="google-bert/bert-base-uncased"
-    )
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
     
-    if result.get("success"):
-        predictions = result["data"]
-        if isinstance(predictions, list):
-            formatted_results = []
-            for i, pred in enumerate(predictions[:5], 1):
+    try:
+        # Official API call from docs
+        result = CLIENT.fill_mask(
+            text,
+            model="google-bert/bert-base-uncased",
+        )
+        
+        if isinstance(result, list):
+            predictions = []
+            for i, pred in enumerate(result[:5], 1):
                 token = pred.get("token_str", "").strip()
                 score = pred.get("score", 0)
-                formatted_results.append(f"{i}. **{token}** (confidence: {score:.3f})")
-            return "🎭 **Top Predictions:**\n" + "\n".join(formatted_results)
+                predictions.append(f"{i}. **{token}** ({score:.3f})")
+            return "🎭 **Predictions:**\n" + "\n".join(predictions)
         else:
-            return f"🎭 **Result:** {predictions}"
-    else:
-        return f"❌ **Error:** {result.get('error', 'Unknown error')}"
+            return f"🎭 **Result:** {result}"
+            
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-def process_question_answering(question, context):
-    """Process question answering."""
+def question_answering(question, context):
+    """Question Answering - Following official docs exactly."""
     if not question or not context:
-        return "⚠️ Both question and context are required."
-    
-    if not engine.client:
-        # Simple demo logic
-        if "benefit" in question.lower() and "cloud" in context.lower():
-            return "💡 **Demo Answer:** Scalability and cost-effectiveness\n📊 **Demo Confidence:** 0.95\n\n📝 *Configure HF_API_TOKEN for real Q&A.*"
-        else:
-            return f"💡 **Demo Answer:** Based on the context, the answer relates to your question about '{question[:50]}...'\n📝 *Configure HF_API_TOKEN for real Q&A.*"
+        return "❌ Both question and context required"
     
-    result = engine.safe_call(
-        engine.client.question_answering,
-        question=question.strip(),
-        context=context.strip(),
-        model="deepset/roberta-base-squad2"
-    )
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
     
-    if result.get("success"):
-        answer_data = result["data"]
-        answer = answer_data.get("answer", "No answer found")
-        confidence = answer_data.get("score", 0)
-        return f"💡 **Answer:** {answer}\n📊 **Confidence:** {confidence:.3f}"
-    else:
-        return f"❌ **Error:** {result.get('error', 'Unknown error')}"
+    try:
+        # Official API call from docs
+        answer = CLIENT.question_answering(
+            question=question,
+            context=context,
+            model="deepset/roberta-base-squad2",
+        )
+        
+        return f"💡 **Answer:** {answer.get('answer', str(answer))}\n📊 **Score:** {answer.get('score', 'N/A')}"
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-def process_summarization(text):
-    """Process text summarization."""
+def summarization(text):
+    """Summarization - Following official docs exactly."""
     if not text or len(text.split()) < 10:
-        return "⚠️ Please provide at least 10 words to summarize."
-    
-    if not engine.client:
-        # Simple demo summarization
-        sentences = text.split('. ')
-        if len(sentences) > 2:
-            summary = sentences[0] + ". " + sentences[1] + "."
-        else:
-            summary = text[:100] + "..."
-        return f"📝 **Demo Summary:** {summary}\n\n📝 *Configure HF_API_TOKEN for real summarization.*"
+        return "❌ Please provide at least 10 words"
     
-    result = engine.safe_call(
-        engine.client.summarization,
-        text.strip(),
-        model="facebook/bart-large-cnn",
-        max_length=130,
-        min_length=30
-    )
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
     
-    if result.get("success"):
-        summary_data = result["data"]
-        if isinstance(summary_data, list) and summary_data:
-            summary = summary_data[0].get("summary_text", "No summary generated")
+    try:
+        # Official API call from docs
+        result = CLIENT.summarization(
+            text,
+            model="facebook/bart-large-cnn",
+        )
+        
+        if isinstance(result, list) and result:
+            summary = result[0].get("summary_text", str(result))
         else:
-            summary = str(summary_data)
+            summary = str(result)
+            
         return f"📝 **Summary:** {summary}"
-    else:
-        return f"❌ **Error:** {result.get('error', 'Unknown error')}"
+        
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-def process_text_generation(prompt):
-    """Process text generation."""
+def text_generation(prompt):
+    """Text Generation - Following official docs exactly."""
     if not prompt.strip():
-        return "⚠️ Prompt cannot be empty."
+        return "❌ Prompt cannot be empty"
     
-    if not engine.client:
-        # Creative demo responses
-        demo_continuations = {
-            "future": "characterized by advanced AI systems that work seamlessly with humans to solve complex global challenges.",
-            "technology": "continuing to evolve at an unprecedented pace, transforming how we work, learn, and connect.",
-            "AI": "becoming increasingly sophisticated and helpful in various domains from healthcare to education."
-        }
-        
-        continuation = None
-        for key, value in demo_continuations.items():
-            if key.lower() in prompt.lower():
-                continuation = value
-                break
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
+    
+    try:
+        # Official API call from docs
+        completion = CLIENT.chat.completions.create(
+            model="meta-llama/Llama-3.2-3B-Instruct",
+            messages=[{"role": "user", "content": prompt}],
+        )
         
-        if not continuation:
-            continuation = "filled with exciting possibilities and innovations that will benefit humanity."
+        return f"✍️ **Generated:** {completion.choices[0].message.content}"
         
-        return f"✍️ **Demo Generation:** {prompt} {continuation}\n\n📝 *Configure HF_API_TOKEN for real text generation.*"
-    
-    result = engine.safe_call(
-        engine.client.text_generation,
-        prompt.strip(),
-        model="gpt2",
-        max_new_tokens=100,
-        temperature=0.7
-    )
-    
-    if result.get("success"):
-        generated = result["data"]
-        if isinstance(generated, list) and generated:
-            text = generated[0].get("generated_text", prompt)
-        else:
-            text = str(generated)
-        return f"✍️ **Generated Text:** {text}"
-    else:
-        return f"❌ **Error:** {result.get('error', 'Unknown error')}"
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-def process_image_classification(image_path):
-    """Process image classification."""
+def image_classification(image_path):
+    """Image Classification - Following official docs exactly."""
     if image_path is None:
-        return "⚠️ Please upload an image."
-    
-    if not engine.client:
-        return "🖼️ **Demo Classification:**\n1. **Object** (85%)\n2. **Scene** (12%)\n3. **Other** (3%)\n\n📝 *Configure HF_API_TOKEN for real image classification.*"
+        return "❌ Please upload an image"
     
-    result = engine.safe_call(
-        engine.client.image_classification,
-        image_path,
-        model="google/vit-base-patch16-224"
-    )
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
     
-    if result.get("success"):
-        predictions = result["data"]
-        if isinstance(predictions, list):
-            formatted_results = []
-            for i, pred in enumerate(predictions[:5], 1):
+    try:
+        # Official API call from docs
+        output = CLIENT.image_classification(
+            image_path, 
+            model="google/vit-base-patch16-224"
+        )
+        
+        if isinstance(output, list):
+            results = []
+            for i, pred in enumerate(output[:5], 1):
                 label = pred.get("label", "Unknown")
                 score = pred.get("score", 0)
-                formatted_results.append(f"{i}. **{label}** ({score:.1%})")
-            return "🖼️ **Image Classification:**\n" + "\n".join(formatted_results)
+                results.append(f"{i}. **{label}** ({score:.1%})")
+            return "🖼️ **Classifications:**\n" + "\n".join(results)
         else:
-            return f"🖼️ **Result:** {predictions}"
-    else:
-        return f"❌ **Error:** {result.get('error', 'Unknown error')}"
+            return f"🖼️ **Result:** {output}"
+            
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
-def process_feature_extraction(text):
-    """Process feature extraction."""
+def feature_extraction(text):
+    """Feature Extraction - Following official docs exactly."""
     if not text.strip():
-        return "⚠️ Input text cannot be empty."
-    
-    if not engine.client:
-        import hashlib
-        # Generate a pseudo-embedding for demo
-        text_hash = hashlib.md5(text.encode()).hexdigest()
-        demo_values = [round(float(int(text_hash[i:i+2], 16)) / 255, 4) for i in range(0, min(len(text_hash), 10), 2)]
-        return f"🧮 **Demo Feature Vector:** Dimension: 384\n**Sample values:** {demo_values}...\n\n📝 *Configure HF_API_TOKEN for real embeddings.*"
+        return "❌ Text cannot be empty"
     
-    result = engine.safe_call(
-        engine.client.feature_extraction,
-        text.strip(),
-        model="sentence-transformers/all-MiniLM-L6-v2"
-    )
+    if CLIENT is None:
+        return f"❌ Client not available: {STATUS}"
     
-    if result.get("success"):
-        embeddings = result["data"]
-        if isinstance(embeddings, list) and embeddings:
-            dim = len(embeddings[0]) if embeddings[0] else 0
-            sample = embeddings[0][:5] if dim >= 5 else embeddings[0]
-            return f"🧮 **Feature Vector:** Dimension: {dim}\n**Sample values:** {sample}..."
+    try:
+        # Official API call from docs
+        result = CLIENT.feature_extraction(
+            text,
+            model="intfloat/multilingual-e5-large-instruct",
+        )
+        
+        if isinstance(result, list) and result:
+            dim = len(result[0]) if result[0] else 0
+            sample = result[0][:5] if dim >= 5 else result[0]
+            return f"🧮 **Embeddings:** Dimension: {dim}\n**Sample:** {sample}..."
         else:
-            return f"🧮 **Embeddings:** {str(embeddings)[:200]}..."
-    else:
-        return f"❌ **Error:** {result.get('error', 'Unknown error')}"
+            return f"🧮 **Result:** {str(result)[:200]}..."
+            
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🎨 GRADIO INTERFACE - SPACES OPTIMIZED
+# 🎨 SIMPLE GRADIO INTERFACE
 # ══════════════════════════════════════════════════════════════════════════════
 
-def create_interface():
-    """Create the main Gradio interface optimized for HuggingFace Spaces."""
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Research Demo") as demo:
     
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="🚀 AI Multi-Task Hub",
-        css="""
-        .gradio-container {
-            font-family: 'Inter', sans-serif;
-        }
-        .tab-nav button {
-            font-weight: 500;
-        }
-        """
-    ) as demo:
-        
+    gr.Markdown("""
+    # 🎓 AI Research & Academic Demo
+    ### Simple HuggingFace Inference API Implementation
+    """)
+    
+    # Status display
+    if CLIENT:
+        gr.Markdown("✅ **Status:** Connected to HuggingFace Inference API")
+    else:
+        gr.Markdown(f"❌ **Status:** {STATUS}")
         gr.Markdown("""
-        # 🚀 **AI Multi-Task Hub**
-        ### *Professional-grade AI inference across multiple domains*
-        
-        **⚡ Real-time processing** | **🔒 Secure** | **🎯 Production-ready**
+        **Setup Instructions:**
+        1. Get your API key from: https://huggingface.co/settings/tokens
+        2. Set environment variable: `HF_API_TOKEN=your_token_here`
+        3. Restart the application
         """)
+    
+    with gr.Tabs():
         
-        # Status indicator
-        if engine.client:
-            gr.Markdown("✅ **Status:** Full API functionality enabled")
-        else:
-            gr.Markdown("⚠️ **Status:** Demo mode active - configure HF_API_TOKEN for full functionality")
+        # Speech Recognition
+        with gr.TabItem("🎤 Speech Recognition"):
+            with gr.Row():
+                asr_input = gr.Audio(sources=["upload", "microphone"], type="numpy")
+                asr_output = gr.Textbox(label="Transcription", lines=3)
+            asr_btn = gr.Button("Transcribe")
+            asr_btn.click(speech_recognition, asr_input, asr_output)
         
-        with gr.Tabs():
-            
-            # 🎤 Speech Recognition Tab
-            with gr.TabItem("🎤 Speech Recognition"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        asr_input = gr.Audio(
-                            sources=["upload", "microphone"],
-                            type="numpy",
-                            label="📁 Upload or 🎙️ Record Audio"
-                        )
-                        asr_button = gr.Button("🔄 Process Audio", variant="primary")
-                    
-                    with gr.Column(scale=1):
-                        asr_output = gr.Textbox(
-                            label="📝 Transcription Result",
-                            lines=4,
-                            placeholder="Audio transcription will appear here..."
-                        )
-                
-                asr_button.click(
-                    fn=process_speech_recognition,
-                    inputs=[asr_input],
-                    outputs=[asr_output]
-                )
-            
-            # 💬 Chat Tab
-            with gr.TabItem("💬 Chat"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        chat_input = gr.Textbox(
-                            label="💭 Messages (JSON Format)",
-                            lines=5,
-                            placeholder='[{"role":"user","content":"Hello, how are you?"}]',
-                            value='[{"role":"user","content":"Hello! Tell me about artificial intelligence."}]'
-                        )
-                        chat_button = gr.Button("💬 Send Message", variant="primary")
-                        
-                        gr.Markdown("""
-                        **📝 Format Examples:**
-                        - `[{"role":"user","content":"Your message here"}]`
-                        - `[{"role":"system","content":"You are helpful"},{"role":"user","content":"Hi"}]`
-                        """)
-                    
-                    with gr.Column(scale=1):
-                        chat_output = gr.Textbox(
-                            label="🤖 AI Response",
-                            lines=6,
-                            placeholder="AI response will appear here..."
-                        )
-                
-                chat_button.click(
-                    fn=process_chat,
-                    inputs=[chat_input],
-                    outputs=[chat_output]
-                )
-            
-            # 🎭 Fill Mask Tab
-            with gr.TabItem("🎭 Fill Mask"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        mask_input = gr.Textbox(
-                            label="🎯 Text with [MASK] Token",
-                            lines=3,
-                            placeholder="The capital of France is [MASK].",
-                            value="The most popular programming language is [MASK]."
-                        )
-                        mask_button = gr.Button("🔍 Predict Mask", variant="primary")
-                    
-                    with gr.Column(scale=1):
-                        mask_output = gr.Textbox(
-                            label="🎭 Predictions",
-                            lines=6,
-                            placeholder="Mask predictions will appear here..."
-                        )
-                
-                mask_button.click(
-                    fn=process_fill_mask,
-                    inputs=[mask_input],
-                    outputs=[mask_output]
-                )
-            
-            # ❓ Question Answering Tab
-            with gr.TabItem("❓ Q&A"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        qa_question = gr.Textbox(
-                            label="❓ Question",
-                            placeholder="What is machine learning?",
-                            value="What is the main benefit of cloud computing?"
-                        )
-                        qa_context = gr.Textbox(
-                            label="📚 Context",
-                            lines=5,
-                            placeholder="Provide context for the question...",
-                            value="Cloud computing is a technology that allows users to access computing resources like servers, storage, and applications over the internet. It offers scalability, cost-effectiveness, and flexibility for businesses and individuals."
-                        )
-                        qa_button = gr.Button("🔍 Find Answer", variant="primary")
-                    
-                    with gr.Column(scale=1):
-                        qa_output = gr.Textbox(
-                            label="💡 Answer",
-                            lines=6,
-                            placeholder="Answer will appear here..."
-                        )
-                
-                qa_button.click(
-                    fn=process_question_answering,
-                    inputs=[qa_question, qa_context],
-                    outputs=[qa_output]
+        # Chat
+        with gr.TabItem("💬 Chat"):
+            with gr.Row():
+                chat_input = gr.Textbox(
+                    label="Messages (JSON)", 
+                    lines=3,
+                    value='[{"role":"user","content":"What is machine learning?"}]'
                 )
-            
-            # 📝 Summarization Tab
-            with gr.TabItem("📝 Summarization"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        sum_input = gr.Textbox(
-                            label="📄 Text to Summarize",
-                            lines=8,
-                            placeholder="Enter long text to summarize...",
-                            value="Artificial intelligence (AI) is a rapidly evolving field that encompasses machine learning, deep learning, natural language processing, and computer vision. AI systems are being deployed across various industries including healthcare, finance, transportation, and entertainment. Machine learning algorithms can analyze vast amounts of data to identify patterns and make predictions. Deep learning, a subset of machine learning, uses neural networks with multiple layers to process complex data. Natural language processing enables computers to understand and generate human language. Computer vision allows machines to interpret and analyze visual information. The applications of AI are virtually limitless, from autonomous vehicles to medical diagnosis, from recommendation systems to fraud detection."
-                        )
-                        sum_button = gr.Button("📝 Summarize", variant="primary")
-                    
-                    with gr.Column(scale=1):
-                        sum_output = gr.Textbox(
-                            label="✨ Summary",
-                            lines=6,
-                            placeholder="Summary will appear here..."
-                        )
-                
-                sum_button.click(
-                    fn=process_summarization,
-                    inputs=[sum_input],
-                    outputs=[sum_output]
+                chat_output = gr.Textbox(label="Response", lines=5)
+            chat_btn = gr.Button("Send")
+            chat_btn.click(chat_completion, chat_input, chat_output)
+        
+        # Fill Mask
+        with gr.TabItem("🎭 Fill Mask"):
+            with gr.Row():
+                mask_input = gr.Textbox(
+                    label="Text with [MASK]",
+                    value="The capital of France is [MASK]."
                 )
-            
-            # ✍️ Text Generation Tab
-            with gr.TabItem("✍️ Text Generation"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gen_input = gr.Textbox(
-                            label="✨ Creative Prompt",
-                            lines=4,
-                            placeholder="Enter your creative prompt...",
-                            value="The future of artificial intelligence will be"
-                        )
-                        gen_button = gr.Button("✍️ Generate Text", variant="primary")
-                    
-                    with gr.Column(scale=1):
-                        gen_output = gr.Textbox(
-                            label="🎨 Generated Content",
-                            lines=6,
-                            placeholder="Generated text will appear here..."
-                        )
-                
-                gen_button.click(
-                    fn=process_text_generation,
-                    inputs=[gen_input],
-                    outputs=[gen_output]
+                mask_output = gr.Textbox(label="Predictions", lines=5)
+            mask_btn = gr.Button("Predict")
+            mask_btn.click(fill_mask, mask_input, mask_output)
+        
+        # Q&A
+        with gr.TabItem("❓ Q&A"):
+            with gr.Column():
+                qa_question = gr.Textbox(label="Question", value="What is AI?")
+                qa_context = gr.Textbox(
+                    label="Context", 
+                    lines=3,
+                    value="Artificial Intelligence (AI) is the simulation of human intelligence in machines."
                 )
-            
-            # 🖼️ Image Classification Tab
-            with gr.TabItem("🖼️ Image Classification"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        img_input = gr.Image(
-                            type="filepath",
-                            label="🖼️ Upload Image"
-                        )
-                        img_button = gr.Button("🔍 Classify Image", variant="primary")
-                    
-                    with gr.Column(scale=1):
-                        img_output = gr.Textbox(
-                            label="🏷️ Classification Results",
-                            lines=6,
-                            placeholder="Image classification results will appear here..."
-                        )
-                
-                img_button.click(
-                    fn=process_image_classification,
-                    inputs=[img_input],
-                    outputs=[img_output]
+                qa_output = gr.Textbox(label="Answer", lines=3)
+            qa_btn = gr.Button("Answer")
+            qa_btn.click(question_answering, [qa_question, qa_context], qa_output)
+        
+        # Summarization
+        with gr.TabItem("📝 Summarization"):
+            with gr.Row():
+                sum_input = gr.Textbox(
+                    label="Text to Summarize",
+                    lines=5,
+                    value="Machine learning is a method of data analysis that automates analytical model building. It is a branch of artificial intelligence based on the idea that systems can learn from data, identify patterns and make decisions with minimal human intervention."
                 )
-            
-            # 🧮 Feature Extraction Tab
-            with gr.TabItem("🧮 Feature Extraction"):
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        fe_input = gr.Textbox(
-                            label="📊 Input Text",
-                            lines=4,
-                            placeholder="Enter text for feature extraction...",
-                            value="Machine learning is transforming the world."
-                        )
-                        fe_button = gr.Button("🧮 Extract Features", variant="primary")
-                    
-                    with gr.Column(scale=1):
-                        fe_output = gr.Textbox(
-                            label="🔢 Feature Vector",
-                            lines=6,
-                            placeholder="Feature vectors will appear here..."
-                        )
-                
-                fe_button.click(
-                    fn=process_feature_extraction,
-                    inputs=[fe_input],
-                    outputs=[fe_output]
+                sum_output = gr.Textbox(label="Summary", lines=3)
+            sum_btn = gr.Button("Summarize")
+            sum_btn.click(summarization, sum_input, sum_output)
+        
+        # Text Generation
+        with gr.TabItem("✍️ Text Generation"):
+            with gr.Row():
+                gen_input = gr.Textbox(
+                    label="Prompt",
+                    value="The future of AI research will be"
                 )
+                gen_output = gr.Textbox(label="Generated Text", lines=5)
+            gen_btn = gr.Button("Generate")
+            gen_btn.click(text_generation, gen_input, gen_output)
         
-        # Footer
-        gr.Markdown("""
-        ---
-        **🔧 HuggingFace Spaces Optimized** | **⚡ Async-free Architecture** | **🛡️ Robust Error Handling**
+        # Image Classification
+        with gr.TabItem("🖼️ Image Classification"):
+            with gr.Row():
+                img_input = gr.Image(type="filepath")
+                img_output = gr.Textbox(label="Classification", lines=5)
+            img_btn = gr.Button("Classify")
+            img_btn.click(image_classification, img_input, img_output)
         
-        *Set `HF_API_TOKEN` in Spaces settings for full API functionality*
-        """)
-    
-    return demo
-
-# ══════════════════════════════════════════════════════════════════════════════
-# 🚀 APPLICATION ENTRY POINT
-# ══════════════════════════════════════════════════════════════════════════════
+        # Feature Extraction
+        with gr.TabItem("🧮 Feature Extraction"):
+            with gr.Row():
+                fe_input = gr.Textbox(
+                    label="Text",
+                    value="This is a sample text for feature extraction."
+                )
+                fe_output = gr.Textbox(label="Features", lines=5)
+            fe_btn = gr.Button("Extract")
+            fe_btn.click(feature_extraction, fe_input, fe_output)
 
 if __name__ == "__main__":
-    print("🚀 Starting AI Multi-Task Hub (HuggingFace Spaces Optimized)...")
-    
-    app = create_interface()
-    app.launch(
+    demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        show_error=True,
-        inbrowser=True
-    )
-    
+        share=False
+    )