Deploy Enhanced Gemini Multi-API Service

app.py

@@ -1,449 +1,365 @@
 #!/usr/bin/env python3
 """
-Enhanced Gemini Multi-API - Full Application for HuggingFace Space
-Complete API compatibility and Gemini functionality
+Enhanced Gemini Multi-API - Anthropic Compatible API Service
+Provides Google Gemini models through Anthropic-compatible interface
 """
 
 import os
 import json
+import time
+import uuid
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Union
+from dataclasses import dataclass
+from flask import Flask, request, jsonify
+import google.generativeai as genai
+from google.generativeai.types import HarmCategory, HarmBlockThreshold
 import requests
-from typing import List, Dict, Any, Optional
-import gradio as gr
 
-# Initialize API keys from environment
+# Initialize Flask app
+app = Flask(__name__)
+
+# API Configuration
 GEMINI_API_KEY = os.environ.get('GEMINI_API_KEY', '')
-BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
+DEFAULT_MODEL = "gemini-1.5-flash"
+MAX_TOKENS = 4096
+DEFAULT_TEMPERATURE = 0.7
+
+# Initialize Gemini
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+    gemini_model = genai.GenerativeModel(DEFAULT_MODEL)
+else:
+    gemini_model = None
+
+# API Configuration
+API_VERSION = "v1"
+BASE_PATH = f"/{API_VERSION}"
+
+# Available Models
+MODELS = {
+    "claude-3-sonnet-20240229": "gemini-1.5-pro",
+    "claude-3-haiku-20240307": "gemini-1.5-flash",
+    "claude-3-5-sonnet-20241022": "gemini-1.5-pro",
+    "claude-3-5-haiku-20241022": "gemini-1.5-flash",
+    "gemini-1.5-pro": "gemini-1.5-pro",
+    "gemini-1.5-flash": "gemini-1.5-flash",
+    "gemini-1.5-pro-002": "gemini-1.5-pro-002",
+    "gemini-1.5-flash-8b": "gemini-1.5-flash-8b",
+    "gemini-2.0-flash-exp": "gemini-2.0-flash-exp"
+}
 
-class GeminiAPI:
-    """Gemini API client for Enhanced Multi-API functionality"""
+@dataclass
+class Message:
+    role: str
+    content: str
+
+class AnthropicCompatibleAPI:
+    """Anthropic API compatible wrapper for Gemini models"""
     
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-        self.base_url = BASE_URL
-        
-    def _make_request(self, endpoint: str, data: dict) -> dict:
-        """Make API request to Gemini"""
-        url = f"{self.base_url}/{endpoint}?key={self.api_key}"
-        headers = {
-            'Content-Type': 'application/json',
-            'User-Agent': 'Enhanced-Gemini-Multi-API/1.0'
-        }
+    def __init__(self, gemini_api_key: str):
+        if not gemini_api_key:
+            raise ValueError("GEMINI_API_KEY is required")
         
-        try:
-            response = requests.post(url, headers=headers, json=data, timeout=30)
-            response.raise_for_status()
-            return response.json()
-        except requests.exceptions.RequestException as e:
-            return {"error": str(e)}
+        genai.configure(api_key=gemini_api_key)
+        self.api_key = gemini_api_key
     
-    def chat_completion(self, model: str, messages: List[Dict], **kwargs) -> Dict:
-        """Chat completion compatible with OpenAI/Anthropic format"""
+    def chat_completion(self, messages: List[Dict], model: str = DEFAULT_MODEL, **kwargs) -> Dict:
+        """OpenAI/Anthropic compatible chat completion"""
         
-        # Extract system and user messages
-        system_message = ""
-        user_messages = []
+        # Map Anthropic model names to Gemini models
+        gemini_model_name = self._map_model(model)
         
-        for msg in messages:
-            if msg.get('role') == 'system':
-                system_message = msg.get('content', '')
-            elif msg.get('role') == 'user':
-                user_messages.append(msg.get('content', ''))
+        # Extract parameters
+        max_tokens = kwargs.get('max_tokens', MAX_TOKENS)
+        temperature = kwargs.get('temperature', DEFAULT_TEMPERATURE)
+        stop_sequences = kwargs.get('stop_sequences', [])
         
-        user_input = user_messages[-1] if user_messages else ""
+        # Build system prompt and user content
+        system_prompt = ""
+        conversation_messages = []
         
-        # Prepare Gemini request
-        request_data = {
-            "contents": [{
-                "parts": [{"text": f"{system_message}\n\nUser: {user_input}"}]
-            }],
-            "generationConfig": {
-                "temperature": kwargs.get('temperature', 0.7),
-                "maxOutputTokens": kwargs.get('max_tokens', 1024),
-                "topP": kwargs.get('top_p', 0.9),
-                "topK": kwargs.get('top_k', 40)
-            }
-        }
+        for msg in messages:
+            role = msg.get('role', '')
+            content = msg.get('content', '')
+            
+            if role == 'system':
+                system_prompt += content + "\n"
+            else:
+                conversation_messages.append({"role": role, "parts": [content]})
         
-        endpoint = f"models/{model}:generateContent"
-        response = self._make_request(endpoint, request_data)
+        # Create Gemini prompt
+        full_prompt = system_prompt.strip() if system_prompt else ""
+        if conversation_messages:
+            last_message = conversation_messages[-1]['parts'][0]
+            if full_prompt:
+                full_prompt += f"\n\nHuman: {last_message}"
+            else:
+                full_prompt = last_message
         
-        if "error" in response:
-            return {"error": response["error"]}
+        full_prompt += "\n\nAssistant:"
         
-        # Format response to match OpenAI/Anthropic format
         try:
-            content = response.get('candidates', [{}])[0].get('content', {}).get('parts', [{}])[0].get('text', '')
+            # Generate response using Gemini
+            model_instance = genai.GenerativeModel(gemini_model_name)
+            
+            generation_config = {
+                'temperature': temperature,
+                'max_output_tokens': max_tokens,
+                'top_p': kwargs.get('top_p', 0.9),
+                'top_k': kwargs.get('top_k', 40)
+            }
+            
+            if stop_sequences:
+                generation_config['stop_sequences'] = stop_sequences
+            
+            response = model_instance.generate_content(
+                full_prompt,
+                generation_config=genai.types.GenerationConfig(**generation_config)
+            )
+            
+            # Format response to match Anthropic format
+            response_text = response.text
+            
+            # Calculate usage (approximate)
+            input_tokens = len(full_prompt.split()) * 1.3  # Rough approximation
+            output_tokens = len(response_text.split()) * 1.3
             
             return {
-                "choices": [{
-                    "message": {
-                        "content": content,
-                        "role": "assistant"
-                    },
-                    "finish_reason": "stop"
-                }],
+                "id": f"msg_{str(uuid.uuid4())[:8]}",
+                "type": "message",
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": response_text
+                    }
+                ],
                 "model": model,
+                "stop_reason": "end_turn",
+                "stop_sequence": None,
                 "usage": {
-                    "prompt_tokens": response.get('usageMetadata', {}).get('promptTokenCount', 0),
-                    "completion_tokens": response.get('usageMetadata', {}).get('candidatesTokenCount', 0),
-                    "total_tokens": response.get('usageMetadata', {}).get('totalTokenCount', 0)
+                    "input_tokens": int(input_tokens),
+                    "output_tokens": int(output_tokens),
+                    "cache_creation_input_tokens": 0,
+                    "cache_read_input_tokens": 0
+                },
+                "created_at": int(time.time())
+            }
+            
+        except Exception as e:
+            return {
+                "error": {
+                    "type": "api_error",
+                    "message": str(e),
+                    "code": "INTERNAL_ERROR"
                 }
             }
-        except (KeyError, IndexError) as e:
-            return {"error": f"Response parsing error: {str(e)}"}
+    
+    def _map_model(self, model: str) -> str:
+        """Map model names to Gemini equivalents"""
+        return MODELS.get(model, DEFAULT_MODEL)
     
     def list_models(self) -> Dict:
-        """List available Gemini models"""
+        """List available models in Anthropic format"""
         models = [
-            "gemini-1.5-pro",
-            "gemini-1.5-pro-002", 
-            "gemini-1.5-flash",
-            "gemini-1.5-flash-8b",
-            "gemini-2.0-flash-exp"
+            {
+                "id": "claude-3-sonnet-20240229",
+                "object": "model",
+                "created": 1710364800,
+                "owned_by": "google-gemini",
+                "name": "claude-3-sonnet-20240229",
+                "display_name": "Gemini 1.5 Pro (Claude Compatible)",
+                "description": "Anthropic-compatible access to Gemini 1.5 Pro",
+                "input_token_limit": 2000000,
+                "output_token_limit": 8192,
+                "top_provider": {
+                    "context_length": 2000000,
+                    "max_completion_tokens": 8192
+                }
+            },
+            {
+                "id": "claude-3-haiku-20240307",
+                "object": "model",
+                "created": 1710364800,
+                "owned_by": "google-gemini",
+                "name": "claude-3-haiku-20240307",
+                "display_name": "Gemini 1.5 Flash (Claude Compatible)",
+                "description": "Anthropic-compatible access to Gemini 1.5 Flash",
+                "input_token_limit": 2000000,
+                "output_token_limit": 8192,
+                "top_provider": {
+                    "context_length": 2000000,
+                    "max_completion_tokens": 8192
+                }
+            }
         ]
         
-        return {
-            "data": [
-                {
-                    "id": model,
-                    "object": "model",
-                    "created": 2024,
-                    "owned_by": "google"
-                }
-                for model in models
-            ]
-        }
+        return {"object": "list", "data": models}
 
-# Global API client
-api_client = None
+# Global API instance
+api = AnthropicCompatibleAPI(GEMINI_API_KEY) if GEMINI_API_KEY else None
 
-def get_api_client():
-    """Get or initialize API client"""
-    global api_client
-    if not api_client and GEMINI_API_KEY:
-        api_client = GeminiAPI(GEMINI_API_KEY)
-    return api_client
-
-def chat_with_gemini(message, history, model, temperature, max_tokens):
-    """Enhanced chat interface with Gemini"""
-    global api_client
-    
-    if not GEMINI_API_KEY:
-        return "❌ Error: GEMINI_API_KEY not configured. Please set the API key in Space secrets."
-    
-    client = get_api_client()
-    if not client:
-        return "❌ Error: Failed to initialize API client."
-    
-    # Format messages for API
-    messages = []
-    if history:
-        for user_msg, assistant_msg in history:
-            messages.append({"role": "user", "content": user_msg})
-            messages.append({"role": "assistant", "content": assistant_msg})
-    messages.append({"role": "user", "content": message})
-    
-    # Make API call
-    response = client.chat_completion(
-        model=model,
-        messages=messages,
-        temperature=temperature,
-        max_tokens=max_tokens
-    )
-    
-    if "error" in response:
-        return f"❌ Error: {response['error']}"
-    
-    try:
-        content = response["choices"][0]["message"]["content"]
-        usage = response.get("usage", {})
-        tokens_used = usage.get("total_tokens", 0)
-        
-        return f"{content}\n\n---\n💬 **Tokens Used**: {tokens_used}"
-    except (KeyError, IndexError):
-        return "❌ Error: Unable to parse API response"
+# API Routes
 
-def openai_compatible_chat(messages, model, temperature, max_tokens):
-    """OpenAI/Anthropic compatible chat interface"""
+@app.route(f"{BASE_PATH}/models", methods=["GET"])
+def list_models():
+    """List available models - Anthropic compatible"""
     if not GEMINI_API_KEY:
-        return {"error": "GEMINI_API_KEY not configured"}
-    
-    client = get_api_client()
-    if not client:
-        return {"error": "Failed to initialize API client"}
-    
-    response = client.chat_completion(
-        model=model,
-        messages=messages,
-        temperature=temperature,
-        max_tokens=max_tokens
-    )
-    
-    return response
-
-def get_available_models():
-    """Get list of available models"""
-    client = get_api_client()
-    if not client:
-        return ["Error: API client not initialized"]
+        return jsonify({
+            "error": {
+                "type": "configuration_error",
+                "message": "GEMINI_API_KEY not configured",
+                "code": "CONFIGURATION_ERROR"
+            }
+        }), 401
     
     try:
-        models_response = client.list_models()
-        return [model["id"] for model in models_response.get("data", [])]
+        models = api.list_models()
+        return jsonify(models)
     except Exception as e:
-        return [f"Error: {str(e)}"]
+        return jsonify({
+            "error": {
+                "type": "api_error",
+                "message": str(e),
+                "code": "INTERNAL_ERROR"
+            }
+        }), 500
 
-def test_api_connection():
-    """Test API connection"""
+@app.route(f"{BASE_PATH}/messages", methods=["POST"])
+def create_message():
+    """Create a message - Anthropic compatible"""
     if not GEMINI_API_KEY:
-        return "❌ GEMINI_API_KEY not configured"
-    
-    client = get_api_client()
-    if not client:
-        return "❌ Failed to initialize API client"
+        return jsonify({
+            "error": {
+                "type": "configuration_error", 
+                "message": "GEMINI_API_KEY not configured",
+                "code": "CONFIGURATION_ERROR"
+            }
+        }), 401
     
-    # Simple test request
-    test_messages = [{"role": "user", "content": "Hello, test connection"}]
-    response = client.chat_completion("gemini-1.5-flash", test_messages)
+    # Get request data
+    data = request.get_json()
+    if not data:
+        return jsonify({
+            "error": {
+                "type": "invalid_request_error",
+                "message": "Request body is required",
+                "code": "INVALID_REQUEST"
+            }
+        }), 400
     
-    if "error" in response:
-        return f"❌ API Test Failed: {response['error']}"
-    else:
-        return "✅ API Connection Successful! Ready for Enhanced Gemini Multi-API functionality."
-
-def get_models_api():
-    """API endpoint for getting models"""
-    if not GEMINI_API_KEY:
-        return {"error": "GEMINI_API_KEY not configured"}
+    # Validate required fields
+    required_fields = ["model", "messages"]
+    for field in required_fields:
+        if field not in data:
+            return jsonify({
+                "error": {
+                    "type": "invalid_request_error",
+                    "message": f"Missing required field: {field}",
+                    "code": "INVALID_REQUEST"
+                }
+            }), 400
     
-    client = get_api_client()
-    if not client:
-        return {"error": "Failed to initialize API client"}
+    # Extract parameters
+    model = data["model"]
+    messages = data["messages"]
+    max_tokens = data.get("max_tokens", MAX_TOKENS)
+    temperature = data.get("temperature", DEFAULT_TEMPERATURE)
     
     try:
-        return client.list_models()
-    except Exception as e:
-        return {"error": str(e)}
-
-def create_interface():
-    """Create the full Enhanced Gemini Multi-API interface"""
-    
-    # Available models
-    models = get_available_models()
-    
-    with gr.Blocks(
-        title="Enhanced Gemini Multi-API",
-        theme=gr.themes.Soft(),
-        show_error=True,
-        server_name="0.0.0.0",
-        server_port=7860
-    ) as demo:
-        
-        # Header
-        gr.HTML("""
-        <div style="text-align: center; padding: 2rem; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 15px; margin-bottom: 2rem;">
-            <h1>🚀 Enhanced Gemini Multi-API</h1>
-            <p>OpenAI/Anthropic Compatible • Gemini Models • Full API Features</p>
-            <p><strong>Status:</strong> All Issues Resolved! Ready for Production!</p>
-        </div>
-        """)
-        
-        # API Status Tab
-        with gr.Tab("🔧 API Status"):
-            gr.HTML("<h3>🔧 API Configuration & Testing</h3>")
-            
-            with gr.Row():
-                test_btn = gr.Button("🧪 Test API Connection", variant="primary")
-                models_btn = gr.Button("📋 Get Models", variant="secondary")
-            
-            status_output = gr.Textbox(
-                label="API Status", 
-                lines=5,
-                interactive=False
-            )
-            
-            models_output = gr.Textbox(
-                label="Available Models", 
-                lines=5,
-                interactive=False
-            )
-        
-        # Chat Interface Tab
-        with gr.Tab("💬 Chat Interface"):
-            gr.HTML("<h3>💬 Enhanced Chat with Gemini Models</h3>")
-            
-            with gr.Row():
-                model_dropdown = gr.Dropdown(
-                    choices=models,
-                    value=models[0] if models else "gemini-1.5-flash",
-                    label="🧠 Model",
-                    info="Select Gemini model for chat"
-                )
-                
-                temp_slider = gr.Slider(
-                    minimum=0.0,
-                    maximum=2.0,
-                    value=0.7,
-                    step=0.1,
-                    label="🌡️ Temperature",
-                    info="Controls randomness in responses"
-                )
-                
-                max_tokens_slider = gr.Slider(
-                    minimum=256,
-                    maximum=4096,
-                    value=1024,
-                    step=256,
-                    label="📝 Max Tokens",
-                    info="Maximum response length"
-                )
-            
-            chatbot = gr.Chatbot(height=400, label="Chat")
-            
-            with gr.Row():
-                msg = gr.Textbox(
-                    label="💭 Your Message",
-                    placeholder="Enter your message here...",
-                    lines=2
-                )
-            
-            with gr.Row():
-                send_btn = gr.Button("🚀 Send", variant="primary")
-                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-        
-        # API Testing Tab
-        with gr.Tab("🧪 API Testing"):
-            gr.HTML("<h3>🧪 OpenAI/Anthropic Compatible API Testing</h3>")
-            
-            model_dropdown_test = gr.Dropdown(
-                choices=models,
-                value=models[0] if models else "gemini-1.5-flash",
-                label="🧠 Model"
-            )
-            
-            temp_slider_test = gr.Slider(
-                minimum=0.0,
-                maximum=2.0,
-                value=0.7,
-                step=0.1,
-                label="🌡️ Temperature"
-            )
-            
-            max_tokens_slider_test = gr.Slider(
-                minimum=256,
-                maximum=4096,
-                value=1024,
-                step=256,
-                label="📝 Max Tokens"
-            )
-            
-            messages_input = gr.Textbox(
-                label="💭 Messages (JSON format)",
-                placeholder='[{"role": "user", "content": "Hello!"}]',
-                lines=6
-            )
-            
-            api_test_btn = gr.Button("🚀 Test API", variant="primary")
-            api_response_output = gr.Textbox(
-                label="📤 API Response", 
-                lines=10,
-                interactive=False
-            )
-        
-        # Models Information Tab
-        with gr.Tab("📋 Models Info"):
-            gr.HTML("<h3>📋 Available Gemini Models</h3>")
-            
-            gr.HTML("""
-            <div style="background: #f8f9fa; padding: 1.5rem; border-radius: 10px; margin-bottom: 1rem;">
-                <h4>🤖 Available Models:</h4>
-                <ul>
-                    <li><strong>gemini-1.5-pro</strong> - Advanced reasoning and complex tasks</li>
-                    <li><strong>gemini-1.5-pro-002</strong> - Latest pro version with improvements</li>
-                    <li><strong>gemini-1.5-flash</strong> - Fast, efficient for most use cases</li>
-                    <li><strong>gemini-1.5-flash-8b</strong> - Ultra-fast for simple tasks</li>
-                    <li><strong>gemini-2.0-flash-exp</strong> - Experimental latest model</li>
-                </ul>
-            </div>
-            """)
-            
-            models_btn2 = gr.Button("🔄 Refresh Models List")
-            models_info_output = gr.Textbox(
-                label="Models Information", 
-                lines=8,
-                interactive=False
-            )
-        
-        # Documentation Tab
-        with gr.Tab("📚 Documentation"):
-            gr.HTML("""
-            <div style="background: #e8f5e8; padding: 1.5rem; border-radius: 10px; border-left: 4px solid #28a745;">
-                <h4>📚 Enhanced Gemini Multi-API Documentation</h4>
-                <p><strong>Features:</strong></p>
-                <ul>
-                    <li>✅ <strong>OpenAI Compatible:</strong> Works with OpenAI SDKs and APIs</li>
-                    <li>✅ <strong>Anthropic Compatible:</strong> Compatible with Anthropic API format</li>
-                    <li>✅ <strong>Full Gemini Suite:</strong> All Gemini models available</li>
-                    <li>✅ <strong>Chat Interface:</strong> Interactive chat with history</li>
-                    <li>✅ <strong>API Testing:</strong> Direct API testing and debugging</li>
-                    <li>✅ <strong>Model Management:</strong> Dynamic model selection</li>
-                </ul>
-                
-                <p><strong>API Key:</strong> Configure GEMINI_API_KEY in Space secrets</p>
-                <p><strong>Updated:</strong> 2025-11-14 04:14:57</p>
-            </div>
-            """)
-        
-        # Event handlers
-        test_btn.click(test_api_connection, outputs=[status_output])
-        models_btn.click(get_available_models, outputs=[models_output])
-        models_btn2.click(get_available_models, outputs=[models_info_output])
-        
-        # Chat interface events
-        def user(user_message, history):
-            return "", history + [(user_message, None)]
-        
-        def bot(history, model, temperature, max_tokens):
-            if not history:
-                return history
-            
-            user_message, _ = history[-1]
-            bot_message = chat_with_gemini(user_message, history[:-1], model, temperature, max_tokens)
-            history[-1] = (user_message, bot_message)
-            return history
-        
-        msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
-            bot, [chatbot, model_dropdown, temp_slider, max_tokens_slider], [chatbot]
+        # Call Gemini through our API wrapper
+        response = api.chat_completion(
+            messages=messages,
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            stop_sequences=data.get("stop_sequences"),
+            top_p=data.get("top_p"),
+            top_k=data.get("top_k")
         )
         
-        send_btn.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
-            bot, [chatbot, model_dropdown, temp_slider, max_tokens_slider], [chatbot]
-        )
+        if "error" in response:
+            return jsonify(response), 500
         
-        clear_btn.click(lambda: None, outputs=[chatbot], queue=False)
+        return jsonify(response)
         
-        # API testing events
-        api_test_btn.click(
-            lambda model, temp, max_tokens, messages: json.dumps(
-                openai_compatible_chat(json.loads(messages), model, temp, max_tokens),
-                indent=2
-            ),
-            [model_dropdown_test, temp_slider_test, max_tokens_slider_test, messages_input],
-            [api_response_output]
-        )
-    
-    return demo
+    except Exception as e:
+        return jsonify({
+            "error": {
+                "type": "api_error",
+                "message": str(e),
+                "code": "INTERNAL_ERROR"
+            }
+        }), 500
+
+@app.route(f"{BASE_PATH}/completions", methods=["POST"])
+def create_completion():
+    """Create completion - OpenAI compatible fallback"""
+    return create_message()  # Same implementation
+
+@app.route("/health", methods=["GET"])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        "status": "healthy",
+        "service": "Enhanced Gemini Multi-API",
+        "version": "1.0.0",
+        "timestamp": datetime.now().isoformat(),
+        "api_key_configured": bool(GEMINI_API_KEY),
+        "available_models": len(MODELS)
+    })
+
+@app.route("/info", methods=["GET"])
+def api_info():
+    """API information endpoint"""
+    return jsonify({
+        "service": "Enhanced Gemini Multi-API",
+        "description": "Google Gemini models through Anthropic-compatible interface",
+        "version": "1.0.0",
+        "endpoints": {
+            "list_models": f"{BASE_PATH}/models",
+            "create_message": f"{BASE_PATH}/messages",
+            "create_completion": f"{BASE_PATH}/completions",
+            "health": "/health",
+            "info": "/info"
+        },
+        "supported_models": list(MODELS.keys()),
+        "documentation": "https://docs.anthropic.com/claude/reference",
+        "api_key_required": True
+    })
+
+@app.errorhandler(404)
+def not_found(error):
+    return jsonify({
+        "error": {
+            "type": "not_found_error",
+            "message": "Endpoint not found",
+            "code": "NOT_FOUND"
+        }
+    }), 404
+
+@app.errorhandler(500)
+def internal_error(error):
+    return jsonify({
+        "error": {
+            "type": "api_error",
+            "message": "Internal server error",
+            "code": "INTERNAL_ERROR"
+        }
+    }), 500
 
 if __name__ == "__main__":
-    # Create and launch interface
-    demo = create_interface()
+    port = int(os.environ.get("PORT", 8080))
+    
+    if not GEMINI_API_KEY:
+        print("⚠️  WARNING: GEMINI_API_KEY not configured")
+        print("   Set GEMINI_API_KEY environment variable for full functionality")
+        print("   Without API key: Only health and info endpoints will work")
     
-    port = int(os.environ.get("PORT", 7860))
+    print(f"🚀 Enhanced Gemini Multi-API starting on port {port}")
+    print(f"📖 API Info: http://localhost:{port}/info")
+    print(f"❤️  Health Check: http://localhost:{port}/health")
+    print(f"📚 Models: POST http://localhost:{port}{BASE_PATH}/messages")
     
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=port,
-        share=False,
-        show_error=True,
-        debug=False
-    )
+    app.run(host="0.0.0.0", port=port, debug=False)