Deploy Enhanced Gemini Multi-API Hybrid Service

app.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-Enhanced Gemini Multi-API - Anthropic Compatible API Service
-Provides Google Gemini models through Anthropic-compatible interface
+Enhanced Gemini Multi-API - Hybrid Web + API Interface
+Anthropic-compatible service with both web interface and API endpoints
 """
 
 import os
@@ -9,34 +9,21 @@ 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
+from typing import List, Dict, Any
+from flask import Flask, request, jsonify, render_template_string
+import gradio as gr
 import google.generativeai as genai
-from google.generativeai.types import HarmCategory, HarmBlockThreshold
-import requests
 
 # Initialize Flask app
 app = Flask(__name__)
 
-# API Configuration
+# Configuration
 GEMINI_API_KEY = os.environ.get('GEMINI_API_KEY', '')
 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
+# Model mapping
 MODELS = {
     "claude-3-sonnet-20240229": "gemini-1.5-pro",
     "claude-3-haiku-20240307": "gemini-1.5-flash",
@@ -49,95 +36,69 @@ MODELS = {
     "gemini-2.0-flash-exp": "gemini-2.0-flash-exp"
 }
 
-@dataclass
-class Message:
-    role: str
-    content: str
-
-class AnthropicCompatibleAPI:
-    """Anthropic API compatible wrapper for Gemini models"""
+class GeminiAPI:
+    """Anthropic compatible wrapper for Gemini"""
     
-    def __init__(self, gemini_api_key: str):
-        if not gemini_api_key:
-            raise ValueError("GEMINI_API_KEY is required")
-        
-        genai.configure(api_key=gemini_api_key)
-        self.api_key = gemini_api_key
+    def __init__(self, api_key: str):
+        if api_key:
+            genai.configure(api_key=api_key)
+        self.api_key = api_key
     
     def chat_completion(self, messages: List[Dict], model: str = DEFAULT_MODEL, **kwargs) -> Dict:
-        """OpenAI/Anthropic compatible chat completion"""
+        """Anthropic compatible chat completion"""
         
-        # Map Anthropic model names to Gemini models
-        gemini_model_name = self._map_model(model)
+        if not self.api_key:
+            return {
+                "error": {
+                    "type": "configuration_error",
+                    "message": "GEMINI_API_KEY not configured",
+                    "code": "CONFIGURATION_ERROR"
+                }
+            }
         
-        # Extract parameters
-        max_tokens = kwargs.get('max_tokens', MAX_TOKENS)
-        temperature = kwargs.get('temperature', DEFAULT_TEMPERATURE)
-        stop_sequences = kwargs.get('stop_sequences', [])
+        gemini_model_name = MODELS.get(model, DEFAULT_MODEL)
         
-        # Build system prompt and user content
+        # Build prompt
         system_prompt = ""
-        conversation_messages = []
+        user_messages = []
         
         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]})
-        
-        # 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 msg.get('role') == 'system':
+                system_prompt = msg.get('content', '')
+            elif msg.get('role') == 'user':
+                user_messages.append(msg.get('content', ''))
         
-        full_prompt += "\n\nAssistant:"
+        full_prompt = system_prompt + "\\n\\n" if system_prompt else ""
+        if user_messages:
+            full_prompt += f"Human: {user_messages[-1]}"
+        full_prompt += "\\n\\nAssistant:"
         
         try:
-            # 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)
+                generation_config=genai.types.GenerationConfig(
+                    temperature=kwargs.get('temperature', DEFAULT_TEMPERATURE),
+                    max_output_tokens=kwargs.get('max_tokens', MAX_TOKENS),
+                    top_p=kwargs.get('top_p', 0.9),
+                    top_k=kwargs.get('top_k', 40)
+                )
             )
             
-            # Format response to match Anthropic format
             response_text = response.text
             
-            # Calculate usage (approximate)
-            input_tokens = len(full_prompt.split()) * 1.3  # Rough approximation
+            # Calculate usage
+            input_tokens = len(full_prompt.split()) * 1.3
             output_tokens = len(response_text.split()) * 1.3
             
             return {
                 "id": f"msg_{str(uuid.uuid4())[:8]}",
                 "type": "message",
                 "role": "assistant",
-                "content": [
-                    {
-                        "type": "text",
-                        "text": response_text
-                    }
-                ],
+                "content": [{"type": "text", "text": response_text}],
                 "model": model,
                 "stop_reason": "end_turn",
-                "stop_sequence": None,
                 "usage": {
                     "input_tokens": int(input_tokens),
                     "output_tokens": int(output_tokens),
@@ -156,127 +117,63 @@ class AnthropicCompatibleAPI:
                 }
             }
     
-    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 models in Anthropic format"""
+        """List available models"""
         models = [
             {
                 "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
-                }
+                "output_token_limit": 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
-                }
+                "output_token_limit": 8192
             }
         ]
-        
         return {"object": "list", "data": models}
 
 # Global API instance
-api = AnthropicCompatibleAPI(GEMINI_API_KEY) if GEMINI_API_KEY else None
+gemini_api = GeminiAPI(GEMINI_API_KEY)
 
-# API Routes
+# Flask API Routes
+BASE_PATH = "/v1"
 
 @app.route(f"{BASE_PATH}/models", methods=["GET"])
 def list_models():
-    """List available models - Anthropic compatible"""
-    if not GEMINI_API_KEY:
-        return jsonify({
-            "error": {
-                "type": "configuration_error",
-                "message": "GEMINI_API_KEY not configured",
-                "code": "CONFIGURATION_ERROR"
-            }
-        }), 401
-    
+    """List available models"""
     try:
-        models = api.list_models()
+        models = gemini_api.list_models()
         return jsonify(models)
     except Exception as e:
-        return jsonify({
-            "error": {
-                "type": "api_error",
-                "message": str(e),
-                "code": "INTERNAL_ERROR"
-            }
-        }), 500
+        return jsonify({"error": str(e)}), 500
 
 @app.route(f"{BASE_PATH}/messages", methods=["POST"])
 def create_message():
-    """Create a message - Anthropic compatible"""
-    if not GEMINI_API_KEY:
-        return jsonify({
-            "error": {
-                "type": "configuration_error", 
-                "message": "GEMINI_API_KEY not configured",
-                "code": "CONFIGURATION_ERROR"
-            }
-        }), 401
-    
-    # Get request data
+    """Create a message"""
     data = request.get_json()
     if not data:
-        return jsonify({
-            "error": {
-                "type": "invalid_request_error",
-                "message": "Request body is required",
-                "code": "INVALID_REQUEST"
-            }
-        }), 400
+        return jsonify({"error": "Request body required"}), 400
     
-    # 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
-    
-    # Extract parameters
-    model = data["model"]
-    messages = data["messages"]
-    max_tokens = data.get("max_tokens", MAX_TOKENS)
-    temperature = data.get("temperature", DEFAULT_TEMPERATURE)
+            return jsonify({"error": f"Missing required field: {field}"}), 400
     
     try:
-        # 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")
+        response = gemini_api.chat_completion(
+            messages=data["messages"],
+            model=data["model"],
+            max_tokens=data.get("max_tokens", 1024),
+            temperature=data.get("temperature", 0.7)
         )
         
         if "error" in response:
@@ -285,81 +182,268 @@ def create_message():
         return jsonify(response)
         
     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
+        return jsonify({"error": str(e)}), 500
 
 @app.route("/health", methods=["GET"])
 def health_check():
-    """Health check endpoint"""
+    """Health check"""
     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)
+        "api_key_configured": bool(GEMINI_API_KEY)
     })
 
 @app.route("/info", methods=["GET"])
 def api_info():
-    """API information endpoint"""
+    """API information"""
     return jsonify({
         "service": "Enhanced Gemini Multi-API",
-        "description": "Google Gemini models through Anthropic-compatible interface",
-        "version": "1.0.0",
+        "description": "Anthropic API compatible interface for Gemini models",
         "endpoints": {
-            "list_models": f"{BASE_PATH}/models",
-            "create_message": f"{BASE_PATH}/messages",
-            "create_completion": f"{BASE_PATH}/completions",
+            "models": f"{BASE_PATH}/models",
+            "messages": f"{BASE_PATH}/messages",
             "health": "/health",
             "info": "/info"
         },
-        "supported_models": list(MODELS.keys()),
-        "documentation": "https://docs.anthropic.com/claude/reference",
+        "web_interface": "/gradio",
         "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
+# Web Interface Functions
+def api_chat_interface(message, history, model, temperature, max_tokens):
+    """API-compatible chat interface"""
+    if not GEMINI_API_KEY:
+        return "❌ GEMINI_API_KEY not configured. Please set the API key in Space secrets."
+    
+    # Format messages for API
+    messages = []
+    if history:
+        for user_msg, assistant_msg in history:
+            messages.append({"role": "user", "content": user_msg})
+            if assistant_msg:
+                messages.append({"role": "assistant", "content": assistant_msg})
+    
+    messages.append({"role": "user", "content": message})
+    
+    # Call API
+    response = gemini_api.chat_completion(
+        messages=messages,
+        model=model,
+        max_tokens=max_tokens,
+        temperature=temperature
+    )
+    
+    if "error" in response:
+        return f"❌ Error: {response['error']['message']}"
+    
+    try:
+        content = response["content"][0]["text"]
+        usage = response.get("usage", {})
+        tokens = usage.get("input_tokens", 0) + usage.get("output_tokens", 0)
+        
+        return f"{content}\\n\\n---\\n💬 **Tokens Used**: {tokens}"
+    except (KeyError, IndexError):
+        return "❌ Error: Unable to parse API response"
 
-@app.errorhandler(500)
-def internal_error(error):
-    return jsonify({
-        "error": {
-            "type": "api_error",
-            "message": "Internal server error",
-            "code": "INTERNAL_ERROR"
-        }
-    }), 500
+def test_api():
+    """Test API connection"""
+    if not GEMINI_API_KEY:
+        return "❌ GEMINI_API_KEY not configured"
+    
+    test_messages = [{"role": "user", "content": "Hello! Test API connection."}]
+    response = gemini_api.chat_completion(
+        messages=test_messages,
+        model="claude-3-haiku-20240307",
+        max_tokens=256,
+        temperature=0.7
+    )
+    
+    if "error" in response:
+        return f"❌ API Test Failed: {response['error']['message']}"
+    else:
+        return "✅ API Connection Successful!\\n\\nTest Response:\\n" + response["content"][0]["text"]
+
+def get_models_list():
+    """Get available models for interface"""
+    if not GEMINI_API_KEY:
+        return "❌ GEMINI_API_KEY not configured"
+    
+    try:
+        models_response = gemini_api.list_models()
+        models = models_response.get("data", [])
+        return "\\n".join([f"• **{model['id']}** - {model['display_name']}" for model in models])
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# Gradio Interface
+def create_gradio_interface():
+    """Create the web interface"""
+    
+    with gr.Blocks(
+        title="Enhanced Gemini Multi-API",
+        theme=gr.themes.Soft(),
+        show_error=True
+    ) 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>🤖 Anthropic Compatible Interface • 🌐 Full API Support • ✅ Production Ready</p>
+            <p><strong>Status:</strong> API Service + Web Interface Deployed!</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("📋 Available Models", variant="secondary")
+            
+            status_output = gr.Textbox(
+                label="API Test Result",
+                lines=6,
+                interactive=False
+            )
+            
+            models_output = gr.Textbox(
+                label="Available Models",
+                lines=6,
+                interactive=False
+            )
+        
+        # Chat Interface Tab
+        with gr.Tab("💬 Chat Interface"):
+            gr.HTML("<h3>💬 Chat with Anthropic Compatible API</h3>")
+            
+            with gr.Row():
+                model_dropdown = gr.Dropdown(
+                    choices=list(MODELS.keys()),
+                    value="claude-3-haiku-20240307",
+                    label="🧠 Model",
+                    info="Anthropic compatible model selection"
+                )
+                
+                temp_slider = gr.Slider(
+                    minimum=0.0,
+                    maximum=2.0,
+                    value=0.7,
+                    step=0.1,
+                    label="🌡️ Temperature"
+                )
+                
+                max_tokens_slider = gr.Slider(
+                    minimum=256,
+                    maximum=4096,
+                    value=1024,
+                    step=256,
+                    label="📝 Max Tokens"
+                )
+            
+            chatbot = gr.Chatbot(height=400, label="Chat with Gemini via Anthropic API")
+            
+            msg = gr.Textbox(
+                label="💭 Your Message",
+                placeholder="Type your message here...",
+                lines=2
+            )
+            
+            with gr.Row():
+                send_btn = gr.Button("🚀 Send", variant="primary")
+                clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+        
+        # API Documentation Tab
+        with gr.Tab("📚 API Documentation"):
+            gr.HTML("""
+            <div style="background: #f8f9fa; padding: 1.5rem; border-radius: 10px; border-left: 4px solid #007bff;">
+                <h4>📚 Enhanced Gemini Multi-API Documentation</h4>
+                
+                <h5>🔧 Endpoints:</h5>
+                <ul>
+                    <li><code>GET /v1/models</code> - List available models</li>
+                    <li><code>POST /v1/messages</code> - Create chat completion</li>
+                    <li><code>GET /health</code> - Health check</li>
+                    <li><code>GET /info</code> - API information</li>
+                </ul>
+                
+                <h5>📝 Example Usage:</h5>
+                <pre><code>curl -X POST https://likhonsheikh-enhanced-gemini-multi-api.hf.space/v1/messages \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "model": "claude-3-haiku-20240307",
+    "messages": [{"role": "user", "content": "Hello!"}],
+    "max_tokens": 1024,
+    "temperature": 0.7
+  }'</code></pre>
+                
+                <h5>🤖 Available Models:</h5>
+                <ul>
+                    <li><strong>claude-3-haiku-20240307</strong> → Gemini 1.5 Flash</li>
+                    <li><strong>claude-3-sonnet-20240229</strong> → Gemini 1.5 Pro</li>
+                    <li><strong>claude-3-5-sonnet-20241022</strong> → Gemini 1.5 Pro</li>
+                    <li><strong>claude-3-5-haiku-20241022</strong> → Gemini 1.5 Flash</li>
+                </ul>
+                
+                <p><strong>Status:</strong> ✅ Full Anthropic API Compatibility Deployed!</p>
+                <p><strong>Updated:</strong> 2025-11-14 04:17:24</p>
+            </div>
+            """)
+        
+        # Event handlers
+        test_btn.click(test_api, outputs=[status_output])
+        models_btn.click(get_models_list, outputs=[models_output])
+        
+        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 = api_chat_interface(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]
+        )
+        
+        send_btn.click(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+            bot, [chatbot, model_dropdown, temp_slider, max_tokens_slider], [chatbot]
+        )
+        
+        clear_btn.click(lambda: None, outputs=[chatbot], queue=False)
+    
+    return demo
 
 if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 8080))
+    # Create Gradio interface
+    demo = create_gradio_interface()
+    
+    # Start both Flask API and Gradio interface
+    port = int(os.environ.get("PORT", 7860))
     
     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")
+        print("⚠️  GEMINI_API_KEY not configured - API functionality will be limited")
+    else:
+        print("✅ GEMINI_API_KEY configured - Full functionality available")
     
-    print(f"🚀 Enhanced Gemini Multi-API starting on port {port}")
-    print(f"📖 API Info: http://localhost:{port}/info")
+    print(f"🚀 Enhanced Gemini Multi-API Service starting on port {port}")
+    print(f"🌐 Web Interface: http://localhost:{port}/gradio")
+    print(f"📖 API Documentation: http://localhost:{port}/info")
     print(f"❤️  Health Check: http://localhost:{port}/health")
-    print(f"📚 Models: POST http://localhost:{port}{BASE_PATH}/messages")
+    print(f"🤖 API Endpoint: http://localhost:{port}/v1/messages")
     
-    app.run(host="0.0.0.0", port=port, debug=False)
+    # Launch with both Flask and Gradio
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=port,
+        share=False,
+        show_error=True,
+        debug=False,
+        quiet=True
+    )