Upload app.py with huggingface_hub

app.py

@@ -38,139 +38,135 @@ GLOBAL_REGIONS = [
 # HuggingFace Token for all providers
 HF_TOKEN = os.getenv('HF_TOKEN', '')
 
-# HuggingFace Inference API using linked DeepSeek models
+# Initialize InferenceClient instances for DeepSeek models
+inference_clients = []
+if HF_TOKEN:
+    try:
+        # Primary DeepSeek-V3.2-Exp client
+        primary_client = InferenceClient(
+            model="deepseek-ai/DeepSeek-V3.2-Exp",
+            token=HF_TOKEN
+        )
+        inference_clients.append({
+            "name": "deepseek-v3.2-exp",
+            "client": primary_client,
+            "model": "deepseek-ai/DeepSeek-V3.2-Exp"
+        })
+        
+        # Secondary DeepSeek-V3-Base client
+        secondary_client = InferenceClient(
+            model="deepseek-ai/DeepSeek-V3-Base", 
+            token=HF_TOKEN
+        )
+        inference_clients.append({
+            "name": "deepseek-v3-base",
+            "client": secondary_client,
+            "model": "deepseek-ai/DeepSeek-V3-Base"
+        })
+        
+        # Fallback client (same as primary)
+        fallback_client = InferenceClient(
+            model="deepseek-ai/DeepSeek-V3.2-Exp",
+            token=HF_TOKEN
+        )
+        inference_clients.append({
+            "name": "deepseek-fallback",
+            "client": fallback_client,
+            "model": "deepseek-ai/DeepSeek-V3.2-Exp"
+        })
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize InferenceClient: {e}")
+
+# Legacy API_PROVIDERS for compatibility (now using InferenceClient)
 API_PROVIDERS = [
     {
         "name": "deepseek-v3.2-exp",
-        "base_url": "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-V3.2-Exp",
-        "headers": {
-            "Authorization": f"Bearer {HF_TOKEN}",
-            "Content-Type": "application/json"
-        },
-        "provider": "hf_inference",
+        "provider": "hf_inference_client",
         "model": "deepseek-ai/DeepSeek-V3.2-Exp"
     },
     {
         "name": "deepseek-v3-base", 
-        "base_url": "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-V3-Base",
-        "headers": {
-            "Authorization": f"Bearer {HF_TOKEN}",
-            "Content-Type": "application/json"
-        },
-        "provider": "hf_inference",
+        "provider": "hf_inference_client",
         "model": "deepseek-ai/DeepSeek-V3-Base"
     },
     {
         "name": "deepseek-fallback",
-        "base_url": "https://api-inference.huggingface.co/models/deepseek-ai/DeepSeek-V3.2-Exp",
-        "headers": {
-            "Authorization": f"Bearer {HF_TOKEN}",
-            "Content-Type": "application/json"
-        },
-        "provider": "hf_inference",
+        "provider": "hf_inference_client",
         "model": "deepseek-ai/DeepSeek-V3.2-Exp"
     }
 ]
 
 def get_next_provider():
-    """Get the next available API provider for failover"""
+    """Get the next available InferenceClient for failover"""
     global current_provider_index
-    provider = API_PROVIDERS[current_provider_index]
-    current_provider_index = (current_provider_index + 1) % len(API_PROVIDERS)
-    return provider
+    if not inference_clients:
+        return None
+    client_info = inference_clients[current_provider_index]
+    current_provider_index = (current_provider_index + 1) % len(inference_clients)
+    return client_info
 
-def call_deepseek_api(messages: List[Dict], provider: Dict, max_retries: int = 3) -> Optional[str]:
-    """Call DeepSeek API via HuggingFace Inference API"""
-    try:
-        # Convert messages to HF Inference API format
-        conversation = ""
-        for msg in messages:
-            if msg["role"] == "system":
-                conversation += f"System: {msg['content']}\n\n"
-            elif msg["role"] == "user":
-                conversation += f"User: {msg['content']}\n\n"
-            elif msg["role"] == "assistant":
-                conversation += f"Assistant: {msg['content']}\n\n"
-        
-        conversation += "Assistant: "
+def call_deepseek_api(messages: List[Dict], client_info: Dict, max_retries: int = 3) -> Optional[str]:
+    """Call DeepSeek API via HuggingFace InferenceClient"""
+    if not client_info:
+        return None
         
-        payload = {
-            "inputs": conversation,
-            "parameters": {
-                "max_new_tokens": 1024,
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "do_sample": True,
-                "return_full_text": False
-            },
-            "options": {
-                "wait_for_model": True,
-                "use_cache": False
-            }
-        }
+    try:
+        client = client_info["client"]
         
-        response = requests.post(
-            provider['base_url'],
-            headers=provider["headers"],
-            json=payload,
-            timeout=60
+        # Use InferenceClient.chat_completion method
+        response = client.chat_completion(
+            messages=messages,
+            max_tokens=1024,
+            temperature=0.7,
+            top_p=0.9,
+            stream=False
         )
         
-        if response.status_code == 200:
-            result = response.json()
-            
-            # Handle HuggingFace Inference API response format
-            if isinstance(result, list) and len(result) > 0:
-                content = result[0].get("generated_text", "")
-                logger.info(f"✅ Success with provider: {provider['name']} ({provider['provider']})")
-                return content.strip()
-            elif isinstance(result, dict) and "generated_text" in result:
-                content = result["generated_text"]
-                logger.info(f"✅ Success with provider: {provider['name']} ({provider['provider']})")
-                return content.strip()
-            else:
-                logger.warning(f"⚠️ Unexpected response format from {provider['name']}: {result}")
-                return None
-            
-        elif response.status_code == 429:
-            logger.warning(f"💸 Rate limit reached for {provider['name']}, switching to next provider...")
-            return None
-        elif response.status_code == 503:
-            logger.warning(f"⏳ Model loading for {provider['name']}, waiting 15 seconds...")
-            time.sleep(15)  # Wait longer for model to load
-            return None
+        # Extract content from response
+        if hasattr(response, 'choices') and len(response.choices) > 0:
+            content = response.choices[0].message.content
+            logger.info(f"✅ Success with InferenceClient: {client_info['name']} ({client_info['model']})")
+            return content.strip()
         else:
-            logger.warning(f"⚠️ API error from {provider['name']}: {response.status_code} - {response.text}")
+            logger.warning(f"⚠️ Unexpected response format from {client_info['name']}: {response}")
             return None
             
-    except requests.exceptions.Timeout:
-        logger.warning(f"⏰ Timeout with provider: {provider['name']}")
-        return None
-    except requests.exceptions.RequestException as e:
-        logger.warning(f"🔌 Connection error with {provider['name']}: {str(e)}")
-        return None
     except Exception as e:
-        logger.error(f"❌ Unexpected error with {provider['name']}: {str(e)}")
+        error_msg = str(e).lower()
+        if "rate limit" in error_msg or "429" in error_msg:
+            logger.warning(f"💸 Rate limit reached for {client_info['name']}, switching to next provider...")
+        elif "503" in error_msg or "service unavailable" in error_msg:
+            logger.warning(f"⏳ Model loading for {client_info['name']}, waiting...")
+            time.sleep(10)  # Wait for model to load
+        else:
+            logger.warning(f"⚠️ API error from {client_info['name']}: {str(e)}")
         return None
 
 def call_deepseek_with_failover(messages: List[Dict]) -> str:
-    """Call DeepSeek-V3.2-Exp with automatic provider failover"""
-    providers_tried = []
+    """Call DeepSeek-V3.2-Exp with automatic InferenceClient failover"""
+    if not inference_clients:
+        return "InferenceClient not initialized. Please check HF_TOKEN configuration."
     
-    # Try all providers until one succeeds
-    for attempt in range(len(API_PROVIDERS)):
-        provider = get_next_provider()
-        providers_tried.append(provider['name'])
+    clients_tried = []
+    
+    # Try all clients until one succeeds
+    for attempt in range(len(inference_clients)):
+        client_info = get_next_provider()
+        if not client_info:
+            continue
+            
+        clients_tried.append(client_info['name'])
         
-        logger.info(f"🔄 Trying provider: {provider['name']} (attempt {attempt + 1}/{len(API_PROVIDERS)})")
+        logger.info(f"🔄 Trying InferenceClient: {client_info['name']} (attempt {attempt + 1}/{len(inference_clients)})")
         
-        result = call_deepseek_api(messages, provider)
+        result = call_deepseek_api(messages, client_info)
         if result:
             return result
     
-    # If all providers failed
-    logger.error(f"❌ All providers failed: {', '.join(providers_tried)}")
-    return f"I apologize, but all API providers ({', '.join(providers_tried)}) are currently unavailable. Please try again in a moment."
+    # If all clients failed
+    logger.error(f"❌ All InferenceClients failed: {', '.join(clients_tried)}")
+    return f"I apologize, but all API providers ({', '.join(clients_tried)}) are currently unavailable. Please try again in a moment."
 
 def format_response(text):
     """Clean and format the model response"""
@@ -302,7 +298,7 @@ Provide comprehensive analysis with specific numerical values for all calculated
         "year": year,
         "analysis_timestamp": datetime.now().isoformat(),
         "model": MODEL_NAME,
-        "providers": [p["name"] for p in API_PROVIDERS]
+        "providers": [c["name"] for c in inference_clients]
     }
     
     # Extract metrics from model response
@@ -358,8 +354,8 @@ def status():
         'model': MODEL_NAME,
         'version': AEGIS_VERSION,
         'regions': len(GLOBAL_REGIONS),
-        'providers': [p["name"] for p in API_PROVIDERS],
-        'current_provider': API_PROVIDERS[current_provider_index]["name"],
+        'providers': [c["name"] for c in inference_clients],
+        'current_provider': inference_clients[current_provider_index]["name"] if inference_clients else "none",
         'api_ready': True
     })
 
@@ -384,24 +380,31 @@ def chat():
             logger.warning("Empty message provided in chat request")
             return jsonify({'error': 'No message provided'}), 400
         
-        # Check if HF_TOKEN is available (only token needed for HuggingFace Inference API)
+        # Check if HF_TOKEN is available and InferenceClients are initialized
         if not HF_TOKEN or len(HF_TOKEN) < 10:
             logger.error("HF_TOKEN not configured or invalid!")
             return jsonify({
                 'error': 'HuggingFace token not configured. Please set HF_TOKEN in Space Settings > Secrets.',
                 'provider_status': 'HF_TOKEN missing'
             }), 500
+            
+        if not inference_clients:
+            logger.error("InferenceClients not initialized!")
+            return jsonify({
+                'error': 'InferenceClients not initialized. Please check HF_TOKEN configuration.',
+                'provider_status': 'InferenceClients not initialized'
+            }), 500
         
         # Generate response using AEGIS Multi-Domain System with DeepSeek-V3.2-Exp
         logger.info("Generating AEGIS analysis...")
         response = analyze_with_aegis_conductor(message, analysis_type)
         
-        if not response or response.startswith("I apologize, but all API providers"):
-            logger.error("All API providers failed or returned empty response")
+        if not response or response.startswith("I apologize, but all API providers") or response.startswith("InferenceClient not initialized"):
+            logger.error("All InferenceClients failed or returned empty response")
             return jsonify({
-                'error': 'All API providers are currently unavailable. Please check your API keys and try again.',
+                'error': 'All API providers are currently unavailable. Please check your HF_TOKEN and try again.',
                 'response': response,
-                'provider_status': 'All providers failed'
+                'provider_status': 'All InferenceClients failed'
             }), 503
         
         logger.info(f"Successfully generated response of length: {len(response)}")
@@ -411,9 +414,10 @@ def chat():
             'timestamp': time.time(),
             'model': f"AEGIS BIO LAB {AEGIS_VERSION} CONDUCTOR (DeepSeek-V3.2-Exp)",
             'analysis_type': analysis_type,
-            'provider': f"{API_PROVIDERS[current_provider_index]['name']} ({API_PROVIDERS[current_provider_index]['provider']})",
-            'hf_inference': True,
-            'hf_token_configured': bool(HF_TOKEN and len(HF_TOKEN) > 10)
+            'provider': f"{inference_clients[current_provider_index]['name'] if inference_clients else 'none'} (InferenceClient)",
+            'hf_inference_client': True,
+            'hf_token_configured': bool(HF_TOKEN and len(HF_TOKEN) > 10),
+            'clients_initialized': len(inference_clients)
         })
         
     except Exception as e:
@@ -475,23 +479,23 @@ def diagnostic():
         </div>
         
         <div class="status good">
-            <strong>Note:</strong> Only HF_TOKEN is required - all providers use HuggingFace Inference API
+            <strong>Note:</strong> Using HuggingFace InferenceClient - only HF_TOKEN required
         </div>
         
         <div class="status good">
             <strong>Model:</strong> {MODEL_NAME}
         </div>
         
-        <div class="status good">
-            <strong>Providers:</strong> {len(API_PROVIDERS)} configured
+        <div class="status {'good' if inference_clients else 'bad'}">
+            <strong>InferenceClients:</strong> {len(inference_clients)} initialized
         </div>
         
         <div class="status good">
-            <strong>Current Provider:</strong> {API_PROVIDERS[current_provider_index]['name']} ({API_PROVIDERS[current_provider_index]['provider']})
+            <strong>Current Client:</strong> {inference_clients[current_provider_index]["name"] if inference_clients else "none"}
         </div>
         
         <h2>🔧 Configuration Instructions</h2>
-        <p>Only HuggingFace Token is required (all providers use HF Inference API):</p>
+        <p>Using HuggingFace InferenceClient (only HF_TOKEN required):</p>
         <ol>
             <li>Go to your space settings</li>
             <li>Click "Variables and secrets"</li>
@@ -511,75 +515,77 @@ def clear_chat():
 
 @app.route('/provider_status', methods=['GET'])
 def provider_status():
-    """Get status of all API providers with key availability"""
+    """Get status of all InferenceClient providers"""
     provider_statuses = []
     
-    for i, provider in enumerate(API_PROVIDERS):
-        # Check if API key is available for this provider
-        # Since all providers use HuggingFace Inference API, only HF_TOKEN is needed
-        has_api_key = bool(HF_TOKEN and len(HF_TOKEN) > 10)
-        
+    for i, client_info in enumerate(inference_clients):
         status_info = {
-            "name": provider["name"],
-            "provider_type": provider["provider"],
+            "name": client_info["name"],
+            "provider_type": "hf_inference_client",
             "active": i == current_provider_index,
-            "base_url": provider["base_url"],
-            "model": provider.get("model", MODEL_NAME),
-            "has_api_key": has_api_key,
-            "key_status": "✅ Configured" if has_api_key else "❌ Missing"
+            "model": client_info.get("model", MODEL_NAME),
+            "has_api_key": bool(HF_TOKEN and len(HF_TOKEN) > 10),
+            "key_status": "✅ Configured" if HF_TOKEN and len(HF_TOKEN) > 10 else "❌ Missing"
         }
         provider_statuses.append(status_info)
     
     # Count available providers
-    available_providers = sum(1 for p in provider_statuses if p["has_api_key"])
+    available_providers = len(inference_clients) if HF_TOKEN and len(HF_TOKEN) > 10 else 0
     
     return jsonify({
         "providers": provider_statuses,
-        "current_provider": API_PROVIDERS[current_provider_index]["name"],
-        "current_provider_type": API_PROVIDERS[current_provider_index]["provider"],
-        "total_providers": len(API_PROVIDERS),
+        "current_provider": inference_clients[current_provider_index]["name"] if inference_clients else "none",
+        "current_provider_type": "hf_inference_client",
+        "total_providers": len(inference_clients),
         "available_providers": available_providers,
         "model": MODEL_NAME,
         "api_keys_status": {
             "hf_token": bool(HF_TOKEN and len(HF_TOKEN) > 10),
-            "note": "Only HF_TOKEN required - all providers use HuggingFace Inference API"
+            "note": "Using HuggingFace InferenceClient - only HF_TOKEN required"
         }
     })
 
 @app.route('/switch_provider', methods=['POST'])
 def switch_provider():
-    """Manually switch to next provider"""
+    """Manually switch to next InferenceClient provider"""
     global current_provider_index
-    old_provider = API_PROVIDERS[current_provider_index]["name"]
-    old_provider_type = API_PROVIDERS[current_provider_index]["provider"]
-    current_provider_index = (current_provider_index + 1) % len(API_PROVIDERS)
-    new_provider = API_PROVIDERS[current_provider_index]["name"]
-    new_provider_type = API_PROVIDERS[current_provider_index]["provider"]
+    
+    if not inference_clients:
+        return jsonify({
+            "error": "No InferenceClients available",
+            "message": "Please check HF_TOKEN configuration"
+        }), 500
+    
+    old_client = inference_clients[current_provider_index]["name"]
+    current_provider_index = (current_provider_index + 1) % len(inference_clients)
+    new_client = inference_clients[current_provider_index]["name"]
     
     return jsonify({
-        "switched_from": f"{old_provider} ({old_provider_type})",
-        "switched_to": f"{new_provider} ({new_provider_type})",
-        "message": f"Switched from {old_provider} to {new_provider} provider",
+        "switched_from": f"{old_client} (InferenceClient)",
+        "switched_to": f"{new_client} (InferenceClient)",
+        "message": f"Switched from {old_client} to {new_client} InferenceClient",
         "model": MODEL_NAME
     })
 
 # Initialize system
 def initialize_system():
-    """Initialize AEGIS system with DeepSeek-V3.2-Exp via HuggingFace Inference"""
+    """Initialize AEGIS system with DeepSeek-V3.2-Exp via HuggingFace InferenceClient"""
     global loading_status
     
-    print("🚀 AEGIS BIO LAB 10 CONDUCTOR initializing with DeepSeek-V3.2-Exp via HuggingFace...")
+    print("🚀 AEGIS BIO LAB 10 CONDUCTOR initializing with DeepSeek-V3.2-Exp via HuggingFace InferenceClient...")
     print(f"🤗 Model: {MODEL_NAME}")
     
-    # Fix the f-string syntax error
-    provider_list = ', '.join([f"{p['name']} ({p['provider']})" for p in API_PROVIDERS])
-    print(f"📡 Available providers: {provider_list}")
+    if inference_clients:
+        client_list = ', '.join([f"{c['name']} ({c['model']})" for c in inference_clients])
+        print(f"📡 Available InferenceClients: {client_list}")
+        print(f"🔄 Automatic failover enabled across {len(inference_clients)} InferenceClients")
+    else:
+        print("❌ No InferenceClients initialized - check HF_TOKEN")
     
-    print(f"🔄 Automatic failover enabled across {len(API_PROVIDERS)} providers")
     print(f"🌍 Global analysis across {len(GLOBAL_REGIONS)} regions")
     print(f"🔑 Using HuggingFace Token: {'✅ Valid' if HF_TOKEN and len(HF_TOKEN) > 10 else '❌ Missing'}")
     
-    loading_status = f"AEGIS BIO LAB {AEGIS_VERSION} CONDUCTOR ready with DeepSeek-V3.2-Exp via HuggingFace Inference"
+    loading_status = f"AEGIS BIO LAB {AEGIS_VERSION} CONDUCTOR ready with DeepSeek-V3.2-Exp via HuggingFace InferenceClient"
     print("✅ AEGIS BIO LAB 10 CONDUCTOR ready!")
 
 if __name__ == '__main__':