Update app.py

app.py

@@ -1,3 +1,5 @@
+Multi ai
+
 import gradio as gr
 import os
 from openai import OpenAI
@@ -6,7 +8,7 @@ from openai import OpenAI
 OPENROUTER_API_KEY = "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"
 
 # Available models
-MODELS = {
+TEXT_MODELS = {
     "Mistral Small": "mistralai/mistral-small-3.2-24b-instruct:free",
     "Claude 3 Haiku": "anthropic/claude-3-haiku:free",
     "Gemini Pro": "google/gemini-2.5-pro-exp-03-25",
@@ -16,10 +18,39 @@ MODELS = {
     "Llama 3": "meta-llama/llama-3-70b-instruct:free",
 }
 
+# Available image models
+IMAGE_MODELS = {
+    "Kimi Vision": "moonshotai/kimi-vl-a3b-thinking:free",
+    "Claude 3 Opus Vision": "anthropic/claude-3-opus-vision:free",
+    "Claude 3 Sonnet Vision": "anthropic/claude-3-sonnet-vision:free",
+    "Gemini Pro Vision": "google/gemini-pro-vision:free",
+    "GPT-4 Vision": "openai/gpt-4-vision:free",
+    "Llava": "llava/llava-1.6-34b-vision:free",
+}
+
+# Combined models for dropdown
+MODELS = {**TEXT_MODELS, **IMAGE_MODELS}
+
 # Initialize chat history
 history = []
 
-def chat_with_ai(message, model_name, history):
+import base64
+from PIL import Image
+import io
+
+def image_to_base64(image):
+    """Convert an image to base64 encoding"""
+    # If image is a file path
+    if isinstance(image, str):
+        with open(image, "rb") as img_file:
+            return base64.b64encode(img_file.read()).decode()
+    
+    # If image is already a PIL Image
+    buffered = io.BytesIO()
+    image.save(buffered, format="JPEG")
+    return base64.b64encode(buffered.getvalue()).decode()
+
+def chat_with_ai(message, model_name, history, image=None):
     """Chat with the selected OpenRouter model"""
     try:
         # Initialize OpenAI client with OpenRouter base URL
@@ -34,8 +65,30 @@ def chat_with_ai(message, model_name, history):
             messages.append({"role": "user", "content": human})
             messages.append({"role": "assistant", "content": assistant})
         
-        # Add the current message
-        messages.append({"role": "user", "content": message})
+        # Check if we're using an image model and have an image
+        if model_name in IMAGE_MODELS and image is not None:
+            # Convert image to base64
+            img_base64 = image_to_base64(image)
+            
+            # Add the current message with image
+            messages.append({
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": message
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{img_base64}"
+                        }
+                    }
+                ]
+            })
+        else:
+            # Add the current message (text only)
+            messages.append({"role": "user", "content": message})
         
         # Create the completion request
         completion = client.chat.completions.create(
@@ -54,14 +107,16 @@ def chat_with_ai(message, model_name, history):
         return f"Error: {str(e)}"
 
 # Create the Gradio interface
-with gr.Blocks(title="OpenRouter AI Chat Interface", css="style.css") as demo:
+with gr.Blocks(title="OpenRouter AI Multi-Modal Interface", css="style.css") as demo:
     gr.Markdown(
         """
-        # 💬 OpenRouter AI Chat Interface
+        # 🤖 OpenRouter AI Multi-Modal Interface
+        
+        Chat with multiple AI models powered by OpenRouter API - both text-only and vision models!
         
-        Chat with multiple AI models powered by OpenRouter API.
+        *Select your model type (Text or Image), choose a specific model, and start interacting!*
         
-        *Select from various large language models and start chatting!*
+        **All responses from image models will be provided in English**
         """
     )
     
@@ -69,48 +124,142 @@ with gr.Blocks(title="OpenRouter AI Chat Interface", css="style.css") as demo:
         with gr.Column(scale=4):
             # Chat interface
             chatbot = gr.Chatbot(height=500, label="Conversation")
+            
+            # Image upload (initially hidden)
+            image_input = gr.Image(type="pil", label="Upload Image for Analysis", visible=False)
+            
             msg = gr.Textbox(label="Your message", placeholder="Type your message here...")
             
             with gr.Row():
                 submit_btn = gr.Button("Send", variant="primary")
                 clear_btn = gr.Button("Clear Chat")
+                
+            # Instructions for image models
+            image_instructions = gr.Markdown(
+                """
+                ### 📷 Image Analysis Instructions
+                1. Upload an image using the panel above
+                2. Ask a question about the image
+                3. The AI will analyze the image and respond in English
+                
+                **Example prompts:**
+                - "What's in this image?"
+                - "Describe this scene in detail"
+                - "What objects can you identify?"
+                - "What's happening in this picture?"
+                """,
+                visible=False
+            )
         
         with gr.Column(scale=1):
             # Model selection
             with gr.Group():
+                model_type = gr.Radio(
+                    choices=["Text Models", "Image Models"],
+                    value="Text Models",
+                    label="Model Type",
+                    info="Choose between text-only or vision models"
+                )
+                
+                # Function to update model dropdown based on selection
+                def update_model_choices(model_type):
+                    if model_type == "Text Models":
+                        return {
+                            model_dropdown: gr.Dropdown.update(choices=list(TEXT_MODELS.keys()), value="Mistral Small"),
+                            image_input: gr.Image.update(visible=False),
+                            image_instructions: gr.Markdown.update(visible=False)
+                        }
+                    else:  # Image Models
+                        return {
+                            model_dropdown: gr.Dropdown.update(choices=list(IMAGE_MODELS.keys()), value="Kimi Vision"),
+                            image_input: gr.Image.update(visible=True),
+                            image_instructions: gr.Markdown.update(visible=True)
+                        }
+                
                 model_dropdown = gr.Dropdown(
-                    choices=list(MODELS.keys()), 
+                    choices=list(TEXT_MODELS.keys()), 
                     value="Mistral Small", 
                     label="Select AI Model",
-                    info="Choose from different language models"
+                    info="Choose from different AI models"
                 )
                 
-                gr.Markdown(
-                    """
-                    ### Available Models
-                    - **Mistral Small**: Powerful language model from Mistral AI
-                    - **Claude 3 Haiku**: Fast and efficient model from Anthropic
-                    - **Gemini Pro**: Google's advanced language model
-                    - **Qwen**: Alibaba's large language model
-                    - **Mistral 3.1**: Earlier version of Mistral's model
-                    - **Gemma**: Google's lightweight language model
-                    - **Llama 3**: Meta's large language model
-                    """
-                )
+                # Connect the radio button to update the dropdown and show/hide image components
+                model_type.change(fn=update_model_choices, inputs=model_type, outputs=[model_dropdown, image_input, image_instructions])
+                
+                with gr.Tabs():
+                    with gr.TabItem("Text Models"):
+                        gr.Markdown(
+                            """
+                            ### Available Text Models
+                            - **Mistral Small**: Powerful language model from Mistral AI
+                            - **Claude 3 Haiku**: Fast and efficient model from Anthropic
+                            - **Gemini Pro**: Google's advanced language model
+                            - **Qwen**: Alibaba's large language model
+                            - **Mistral 3.1**: Earlier version of Mistral's model
+                            - **Gemma**: Google's lightweight language model
+                            - **Llama 3**: Meta's large language model
+                            """
+                        )
+                    
+                    with gr.TabItem("Image Models"):
+                        gr.Markdown(
+                            """
+                            ### Available Image Models
+                            - **Kimi Vision**: Moonshot AI's vision-language model
+                            - **Claude 3 Opus Vision**: Anthropic's premium vision model
+                            - **Claude 3 Sonnet Vision**: Mid-tier vision model from Anthropic
+                            - **Gemini Pro Vision**: Google's multimodal vision model
+                            - **GPT-4 Vision**: OpenAI's vision-enabled GPT model
+                            - **Llava**: Open-source vision-language model
+                            
+                            *Note: All responses will be provided in English*
+                            """
+                        )
     
     # Set up the submit action
-    def respond(message, chat_history, model):
+    def respond(message, chat_history, model, image, model_type):
         if not message.strip():
             return "", chat_history
         
-        bot_message = chat_with_ai(message, model, chat_history)
-        chat_history.append((message, bot_message))
+        # Check if we need to use image
+        use_image = model_type == "Image Models" and image is not None
+        
+        # Add a note if using image model but no image uploaded
+        if model_type == "Image Models" and image is None:
+            return "", chat_history + [(message, "Please upload an image first before sending your message.")]
+        
+        # Process with or without image
+        if use_image:
+            bot_message = chat_with_ai(message, model, chat_history, image)
+            # Add a note that the response is in English
+            if not bot_message.startswith("Error:"):
+                display_message = f"{bot_message}\n\n*Response provided in English*"
+            else:
+                display_message = bot_message
+        else:
+            bot_message = chat_with_ai(message, model, chat_history)
+            display_message = bot_message
+        
+        chat_history.append((message, display_message))
         return "", chat_history
     
     # Connect the components
-    submit_btn.click(respond, [msg, chatbot, model_dropdown], [msg, chatbot])
-    msg.submit(respond, [msg, chatbot, model_dropdown], [msg, chatbot])
-    clear_btn.click(lambda: None, None, chatbot, queue=False)
+    submit_btn.click(
+        respond, 
+        [msg, chatbot, model_dropdown, image_input, model_type], 
+        [msg, chatbot]
+    )
+    msg.submit(
+        respond, 
+        [msg, chatbot, model_dropdown, image_input, model_type], 
+        [msg, chatbot]
+    )
+    
+    # Clear chat and image
+    def clear_all():
+        return None, None
+    
+    clear_btn.click(clear_all, None, [chatbot, image_input], queue=False)
 
 # For Hugging Face Spaces compatibility
 if __name__ == "__main__":