Update app.py

app.py

@@ -74,6 +74,7 @@ COHERE_API_KEY = os.environ.get("COHERE_API_KEY", "")
 HF_API_KEY = os.environ.get("HF_API_KEY", "")
 TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY", "")
 GOOGLEAI_API_KEY = os.environ.get("GOOGLEAI_API_KEY", "")
+ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
 
 # Print application startup message with timestamp
 current_time = time.strftime("%Y-%m-%d %H:%M:%S")
@@ -353,6 +354,25 @@ GOOGLEAI_MODELS = {
     "gemini-2.5-pro": 2000000,
 }
 
+# ANTHROPIC MODELS
+ANTHROPIC_MODELS = {
+    "claude-3-7-sonnet-20250219": 128000,  # Claude 3.7 Sonnet
+    "claude-3-5-sonnet-20241022": 200000,  # Claude 3.5 Sonnet
+    "claude-3-5-haiku-20240307": 200000,   # Claude 3.5 Haiku
+    "claude-3-opus-20240229": 200000,      # Claude 3 Opus
+    "claude-3-haiku-20240307": 200000,     # Claude 3 Haiku
+    "claude-3-sonnet-20240229": 200000,    # Claude 3 Sonnet
+}
+
+# Add Anthropic to the vision models list
+VISION_MODELS["Anthropic"] = [
+    "claude-3-7-sonnet-20250219",
+    "claude-3-5-sonnet-20241022", 
+    "claude-3-opus-20240229", 
+    "claude-3-sonnet-20240229",
+    "claude-3-5-haiku-20240307",
+    "claude-3-haiku-20240307"
+]
 
 # Add all models with "vl", "vision", "visual" in their name to HF vision models
 for model_name in list(HUGGINGFACE_MODELS.keys()):
@@ -681,6 +701,95 @@ def update_model_info(provider, model_name):
 # API HANDLERS
 # ==========================================================
 
+def call_anthropic_api(payload, api_key_override=None):
+    """Make a call to Anthropic API with error handling"""
+    try:
+        # Try to import Anthropic
+        try:
+            import anthropic
+            from anthropic import Anthropic
+        except ImportError:
+            raise ImportError("Anthropic package not installed. Install it with: pip install anthropic")
+            
+        api_key = api_key_override if api_key_override else os.environ.get("ANTHROPIC_API_KEY", "")
+        if not api_key:
+            raise ValueError("Anthropic API key is required")
+            
+        client = Anthropic(api_key=api_key)
+        
+        # Extract parameters from payload
+        model = payload.get("model", "claude-3-5-sonnet-20241022")
+        messages = payload.get("messages", [])
+        temperature = payload.get("temperature", 0.7)
+        max_tokens = payload.get("max_tokens", 1000)
+        
+        # Format messages for Anthropic
+        # Find system message if any
+        system_prompt = None
+        chat_messages = []
+        
+        for msg in messages:
+            if msg["role"] == "system":
+                system_prompt = msg["content"]
+            else:
+                # Format content
+                if isinstance(msg["content"], list):
+                    # Handle multimodal content (images)
+                    anthropic_content = []
+                    for item in msg["content"]:
+                        if item["type"] == "text":
+                            anthropic_content.append({
+                                "type": "text",
+                                "text": item["text"]
+                            })
+                        elif item["type"] == "image_url":
+                            # Extract base64 from data URL if present
+                            image_url = item["image_url"]["url"]
+                            if image_url.startswith("data:"):
+                                # Extract media type and base64 data
+                                parts = image_url.split(",", 1)
+                                media_type = parts[0].split(":")[1].split(";")[0]
+                                base64_data = parts[1]
+                                
+                                anthropic_content.append({
+                                    "type": "image",
+                                    "source": {
+                                        "type": "base64",
+                                        "media_type": media_type,
+                                        "data": base64_data
+                                    }
+                                })
+                            else:
+                                # URL not supported by Anthropic yet
+                                anthropic_content.append({
+                                    "type": "text",
+                                    "text": f"[Image URL: {image_url}]"
+                                })
+                    chat_messages.append({
+                        "role": msg["role"],
+                        "content": anthropic_content
+                    })
+                else:
+                    # Simple text content
+                    chat_messages.append({
+                        "role": msg["role"],
+                        "content": msg["content"]
+                    })
+        
+        # Make request to Anthropic
+        response = client.messages.create(
+            model=model,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            system=system_prompt,
+            messages=chat_messages
+        )
+        
+        return response
+    except Exception as e:
+        logger.error(f"Anthropic API error: {str(e)}")
+        raise e
+    
 def call_openrouter_api(payload, api_key_override=None):
     """Make a call to OpenRouter API with error handling"""
     try:
@@ -894,6 +1003,16 @@ def extract_ai_response(result, provider):
         elif provider == "OpenAI":
             if hasattr(result, "choices") and len(result.choices) > 0:
                 return result.choices[0].message.content
+            
+        elif provider == "Anthropic":
+            if hasattr(result, "content"):
+                # Combine text from all content blocks
+                full_text = ""
+                for block in result.content:
+                    if block.type == "text":
+                        full_text += block.text
+                return full_text
+            return "No content returned from Anthropic"
                 
         elif provider == "HuggingFace":
             return result.get("generated_text", "")
@@ -1462,6 +1581,44 @@ def ask_ai(message, history, provider, model_choice, temperature, max_tokens, to
                     {"role": "user", "content": message},
                     {"role": "assistant", "content": error_message}
                 ]
+            
+        elif provider == "Anthropic":
+            # Get model ID from registry
+            model_id, _ = get_model_info(provider, model_choice)
+            if not model_id:
+                error_message = f"Error: Model '{model_choice}' not found in Anthropic"
+                return history + [
+                    {"role": "user", "content": message},
+                    {"role": "assistant", "content": error_message}
+                ]
+                
+            # Build Anthropic payload
+            payload = {
+                "model": model_id,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            # Call Anthropic API
+            logger.info(f"Sending request to Anthropic model: {model_id}")
+            
+            try:
+                response = call_anthropic_api(payload, api_key_override)
+                
+                # Extract response
+                ai_response = extract_ai_response(response, provider)
+                return history + [
+                    {"role": "user", "content": message},
+                    {"role": "assistant", "content": ai_response}
+                ]
+            except Exception as e:
+                error_message = f"Anthropic API Error: {str(e)}"
+                logger.error(error_message)
+                return history + [
+                    {"role": "user", "content": message},
+                    {"role": "assistant", "content": error_message}
+                ]
                 
         elif provider == "OpenAI":
             # Process OpenAI similarly as above...
@@ -1886,7 +2043,7 @@ def create_app():
         gr.Markdown("""
         # 🤖 CrispChat
         
-        Chat with AI models from multiple providers: OpenRouter, OpenAI, HuggingFace, Groq, Cohere, Together, OVH, Cerebras, and Google AI.
+        Chat with AI models from multiple providers: OpenRouter, OpenAI, HuggingFace, Groq, Cohere, Together, Anthropic, and Google AI.
         """)
         
         with gr.Row():
@@ -1946,9 +2103,9 @@ def create_app():
                 with gr.Group(elem_classes="provider-selection"):
                     gr.Markdown("### Provider Selection")
                     
-                    # Provider selection
+                    # Provider selection - removed OVH and Cerebras, added Anthropic
                     provider_choice = gr.Radio(
-                        choices=["OpenRouter", "OpenAI", "HuggingFace", "Groq", "Cohere", "Together", "OVH", "Cerebras", "GoogleAI"],
+                        choices=["OpenRouter", "OpenAI", "HuggingFace", "Groq", "Cohere", "Together", "Anthropic", "GoogleAI"],
                         value="OpenRouter",
                         label="AI Provider"
                     )
@@ -1999,6 +2156,14 @@ def create_app():
                             value=TOGETHER_API_KEY if TOGETHER_API_KEY else ""
                         )
                         
+                        # Add Anthropic API key
+                        anthropic_api_key = gr.Textbox(
+                            placeholder="Enter Anthropic API key",
+                            label="Anthropic API Key",
+                            type="password",
+                            value=os.environ.get("ANTHROPIC_API_KEY", "")
+                        )
+                        
                         googleai_api_key = gr.Textbox(
                             placeholder="Enter Google AI API key",
                             label="Google AI API Key",
@@ -2059,25 +2224,18 @@ def create_app():
                     
                     together_model = gr.Dropdown(
                         choices=list(TOGETHER_MODELS.keys()),
-                        value="meta-llama/Llama-3.1-8B-Instruct" if "meta-llama/Llama-3.1-8B-Instruct" in TOGETHER_MODELS else None,
+                        value="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo" if "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo" in TOGETHER_MODELS else None,
                         label="Together Model",
                         elem_id="together-model-choice",
                         visible=False
                     )
                     
-                    ovh_model = gr.Dropdown(
-                        choices=list(OVH_MODELS.keys()),
-                        value="ovh/llama-3.1-8b-instruct" if "ovh/llama-3.1-8b-instruct" in OVH_MODELS else None,
-                        label="OVH Model",
-                        elem_id="ovh-model-choice",
-                        visible=False
-                    )
-                    
-                    cerebras_model = gr.Dropdown(
-                        choices=list(CEREBRAS_MODELS.keys()),
-                        value="cerebras/llama-3.1-8b" if "cerebras/llama-3.1-8b" in CEREBRAS_MODELS else None,
-                        label="Cerebras Model",
-                        elem_id="cerebras-model-choice",
+                    # Add Anthropic model dropdown
+                    anthropic_model = gr.Dropdown(
+                        choices=list(ANTHROPIC_MODELS.keys()),
+                        value="claude-3-5-sonnet-20241022" if "claude-3-5-sonnet-20241022" in ANTHROPIC_MODELS else None,
+                        label="Anthropic Model",
+                        elem_id="anthropic-model-choice",
                         visible=False
                     )
                     
@@ -2253,8 +2411,7 @@ def create_app():
             - **Groq**: High-performance inference, requires API key
             - **Cohere**: Specialized in language understanding, requires API key
             - **Together**: Access to high-quality open models, requires API key
-            - **OVH**: Free beta access to several models
-            - **Cerebras**: Free tier available with 8K context limit
+            - **Anthropic**: Claude models with strong reasoning capabilities, requires API key
             - **GoogleAI**: Google's Gemini models, requires API key
             
             ## Advanced Parameters
@@ -2267,7 +2424,7 @@ def create_app():
         # Add a footer with version info
         footer_md = gr.Markdown("""
         ---
-        ### CrispChat v1.1
+        ### CrispChat v1.2
         Built with ❤️ using Gradio and multiple AI provider APIs | Context sizes shown next to model names
         """)
         
@@ -2281,12 +2438,11 @@ def create_app():
                 groq_model: gr.update(visible=(provider == "Groq")),
                 cohere_model: gr.update(visible=(provider == "Cohere")),
                 together_model: gr.update(visible=(provider == "Together")),
-                ovh_model: gr.update(visible=(provider == "OVH")),
-                cerebras_model: gr.update(visible=(provider == "Cerebras")),
+                anthropic_model: gr.update(visible=(provider == "Anthropic")),
                 googleai_model: gr.update(visible=(provider == "GoogleAI"))
             }
             
-        def update_context_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model):
+        def update_context_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, anthropic_model, googleai_model):
             """Update context display based on selected provider and model"""
             if provider == "OpenRouter":
                 return update_context_display(provider, openrouter_model)
@@ -2300,15 +2456,13 @@ def create_app():
                 return update_context_display(provider, cohere_model)
             elif provider == "Together":
                 return update_context_display(provider, together_model)
-            elif provider == "OVH":
-                return update_context_display(provider, ovh_model)
-            elif provider == "Cerebras":
-                return update_context_display(provider, cerebras_model)
+            elif provider == "Anthropic":
+                return update_context_display(provider, anthropic_model)
             elif provider == "GoogleAI":
                 return update_context_display(provider, googleai_model)
             return "Unknown"
             
-        def update_model_info_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model):
+        def update_model_info_for_provider(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, anthropic_model, googleai_model):
             """Update model info based on selected provider and model"""
             if provider == "OpenRouter":
                 return update_model_info(provider, openrouter_model)
@@ -2322,10 +2476,8 @@ def create_app():
                 return update_model_info(provider, cohere_model)
             elif provider == "Together":
                 return update_model_info(provider, together_model)
-            elif provider == "OVH":
-                return update_model_info(provider, ovh_model)
-            elif provider == "Cerebras":
-                return update_model_info(provider, cerebras_model)
+            elif provider == "Anthropic":
+                return update_model_info(provider, anthropic_model)
             elif provider == "GoogleAI":
                 return update_model_info(provider, googleai_model)
             return "<p>Model information not available</p>"
@@ -2432,35 +2584,18 @@ def create_app():
                 default_model = "meta-llama/Llama-3.1-8B-Instruct" if "meta-llama/Llama-3.1-8B-Instruct" in all_models else all_models[0] if all_models else None
                 return gr.update(choices=all_models, value=default_model)
                 
-        def search_ovh_models(search_term):
-            """Filter OVH models based on search term"""
-            all_models = list(OVH_MODELS.keys())
-            if not search_term:
-                default_model = "ovh/llama-3.1-8b-instruct" if "ovh/llama-3.1-8b-instruct" in all_models else all_models[0] if all_models else None
-                return gr.update(choices=all_models, value=default_model)
-                
-            filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
-            
-            if filtered_models:
-                return gr.update(choices=filtered_models, value=filtered_models[0])
-            else:
-                default_model = "ovh/llama-3.1-8b-instruct" if "ovh/llama-3.1-8b-instruct" in all_models else all_models[0] if all_models else None
-                return gr.update(choices=all_models, value=default_model)
-                
-        def search_cerebras_models(search_term):
-            """Filter Cerebras models based on search term"""
-            all_models = list(CEREBRAS_MODELS.keys())
+        def search_anthropic_models(search_term):
+            """Filter Anthropic models based on search term"""
+            all_models = list(ANTHROPIC_MODELS.keys())
             if not search_term:
-                default_model = "cerebras/llama-3.1-8b" if "cerebras/llama-3.1-8b" in all_models else all_models[0] if all_models else None
-                return gr.update(choices=all_models, value=default_model)
+                return gr.update(choices=all_models, value="claude-3-5-sonnet-20241022" if "claude-3-5-sonnet-20241022" in all_models else all_models[0] if all_models else None)
                 
             filtered_models = [model for model in all_models if search_term.lower() in model.lower()]
             
             if filtered_models:
                 return gr.update(choices=filtered_models, value=filtered_models[0])
             else:
-                default_model = "cerebras/llama-3.1-8b" if "cerebras/llama-3.1-8b" in all_models else all_models[0] if all_models else None
-                return gr.update(choices=all_models, value=default_model)
+                return gr.update(choices=all_models, value="claude-3-5-sonnet-20241022" if "claude-3-5-sonnet-20241022" in all_models else all_models[0] if all_models else None)
                 
         def search_googleai_models(search_term):
             """Filter GoogleAI models based on search term"""
@@ -2478,26 +2613,25 @@ def create_app():
                 return gr.update(choices=all_models, value=default_model)
 
             
-        def get_current_model(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model):
+        def get_current_model(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, 
+                            together_model, anthropic_model, googleai_model):
             """Get the currently selected model based on provider"""
             if provider == "OpenRouter":
-                return openrouter_model if openrouter_model else OPENROUTER_ALL_MODELS[0][0] if OPENROUTER_ALL_MODELS else None
+                return openrouter_model
             elif provider == "OpenAI":
-                return openai_model if openai_model else "gpt-3.5-turbo" if "gpt-3.5-turbo" in OPENAI_MODELS else None
+                return openai_model
             elif provider == "HuggingFace":
-                return hf_model if hf_model else "mistralai/Mistral-7B-Instruct-v0.3" if "mistralai/Mistral-7B-Instruct-v0.3" in HUGGINGFACE_MODELS else None
+                return hf_model
             elif provider == "Groq":
-                return groq_model if groq_model else "llama-3.1-8b-instant" if "llama-3.1-8b-instant" in GROQ_MODELS else None
+                return groq_model
             elif provider == "Cohere":
-                return cohere_model if cohere_model else "command-r-plus" if "command-r-plus" in COHERE_MODELS else None
+                return cohere_model
             elif provider == "Together":
-                return together_model if together_model else "meta-llama/Llama-3.1-8B-Instruct" if "meta-llama/Llama-3.1-8B-Instruct" in TOGETHER_MODELS else None
-            elif provider == "OVH":
-                return ovh_model if ovh_model else "ovh/llama-3.1-8b-instruct" if "ovh/llama-3.1-8b-instruct" in OVH_MODELS else None
-            elif provider == "Cerebras":
-                return cerebras_model if cerebras_model else "cerebras/llama-3.1-8b" if "cerebras/llama-3.1-8b" in CEREBRAS_MODELS else None
+                return together_model
+            elif provider == "Anthropic":
+                return anthropic_model
             elif provider == "GoogleAI":
-                return googleai_model if googleai_model else "gemini-1.5-pro" if "gemini-1.5-pro" in GOOGLEAI_MODELS else None
+                return googleai_model
             return None
         
         
@@ -2519,29 +2653,28 @@ def create_app():
                 groq_model,
                 cohere_model,
                 together_model,
-                ovh_model,
-                cerebras_model,
+                anthropic_model,
                 googleai_model
             ]
         ).then(
             fn=update_context_for_provider,
-            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model],
+            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, anthropic_model, googleai_model],
             outputs=context_display
         ).then(
             fn=update_model_info_for_provider,
-            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model],
+            inputs=[provider_choice, openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, anthropic_model, googleai_model],
             outputs=model_info_display
         ).then(
             fn=lambda provider, model: update_vision_indicator(
                 provider, 
-                get_current_model(provider, model, None, None, None, None, None, None, None, None)
+                get_current_model(provider, model, None, None, None, None, None, None, None)
             ),
             inputs=[provider_choice, openrouter_model],
             outputs=is_vision_indicator
         ).then(
             fn=lambda provider, model: update_image_upload_visibility(
                 provider, 
-                get_current_model(provider, model, None, None, None, None, None, None, None, None)
+                get_current_model(provider, model, None, None, None, None, None, None, None)
             ),
             inputs=[provider_choice, openrouter_model],
             outputs=image_upload_container
@@ -2556,14 +2689,13 @@ def create_app():
                 search_groq_models(search) if provider == "Groq" else gr.update(),
                 search_cohere_models(search) if provider == "Cohere" else gr.update(),
                 search_together_models(search) if provider == "Together" else gr.update(),
-                search_ovh_models(search) if provider == "OVH" else gr.update(),
-                search_cerebras_models(search) if provider == "Cerebras" else gr.update(),
+                search_anthropic_models(search) if provider == "Anthropic" else gr.update(),
                 search_googleai_models(search) if provider == "GoogleAI" else gr.update()
             ],
             inputs=[provider_choice, model_search],
             outputs=[
                 openrouter_model, openai_model, hf_model, groq_model, 
-                cohere_model, together_model, ovh_model, cerebras_model, googleai_model
+                cohere_model, together_model, anthropic_model, googleai_model
             ]
         )
         
@@ -2676,39 +2808,21 @@ def create_app():
             outputs=image_upload_container
         )
         
-        ovh_model.change(
-            fn=lambda model: update_context_display("OVH", model),
-            inputs=ovh_model,
-            outputs=context_display
-        ).then(
-            fn=lambda model: update_model_info("OVH", model),
-            inputs=ovh_model,
-            outputs=model_info_display
-        ).then(
-            fn=lambda model: update_vision_indicator("OVH", model),
-            inputs=ovh_model,
-            outputs=is_vision_indicator
-        ).then(
-            fn=lambda model: update_image_upload_visibility("OVH", model),
-            inputs=ovh_model,
-            outputs=image_upload_container
-        )
-        
-        cerebras_model.change(
-            fn=lambda model: update_context_display("Cerebras", model),
-            inputs=cerebras_model,
+        anthropic_model.change(
+            fn=lambda model: update_context_display("Anthropic", model),
+            inputs=anthropic_model,
             outputs=context_display
         ).then(
-            fn=lambda model: update_model_info("Cerebras", model),
-            inputs=cerebras_model,
+            fn=lambda model: update_model_info("Anthropic", model),
+            inputs=anthropic_model,
             outputs=model_info_display
         ).then(
-            fn=lambda model: update_vision_indicator("Cerebras", model),
-            inputs=cerebras_model,
+            fn=lambda model: update_vision_indicator("Anthropic", model),
+            inputs=anthropic_model,
             outputs=is_vision_indicator
         ).then(
-            fn=lambda model: update_image_upload_visibility("Cerebras", model),
-            inputs=cerebras_model,
+            fn=lambda model: update_image_upload_visibility("Anthropic", model),
+            inputs=anthropic_model,
             outputs=image_upload_container
         )
         
@@ -2744,25 +2858,24 @@ def create_app():
                 return search_cohere_models(search_term)
             elif provider == "Together":
                 return search_together_models(search_term)
-            elif provider == "OVH":
-                return search_ovh_models(search_term)
-            elif provider == "Cerebras":
-                return search_cerebras_models(search_term)
+            elif provider == "Anthropic":
+                return search_anthropic_models(search_term)
             elif provider == "GoogleAI":
                 return search_googleai_models(search_term)
             return None
         
         # Set up submission event
         def submit_message(message, history, provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, 
-                        together_model, ovh_model, cerebras_model, googleai_model, 
-                        temperature, max_tokens, top_p, frequency_penalty, presence_penalty, repetition_penalty, 
-                        top_k, min_p, seed, top_a, stream_output, response_format,
-                        images, documents, reasoning_effort, system_message, transforms, 
-                        openrouter_api_key, openai_api_key, hf_api_key, groq_api_key, cohere_api_key, together_api_key, googleai_api_key):
+                together_model, anthropic_model, googleai_model, 
+                temperature, max_tokens, top_p, frequency_penalty, presence_penalty, repetition_penalty, 
+                top_k, min_p, seed, top_a, stream_output, response_format,
+                images, documents, reasoning_effort, system_message, transforms, 
+                openrouter_api_key, openai_api_key, hf_api_key, groq_api_key, cohere_api_key, together_api_key, anthropic_api_key, googleai_api_key):
+
             """Submit message to selected provider and model"""
             # Get the currently selected model
             model_choice = get_current_model(provider, openrouter_model, openai_model, hf_model, groq_model, cohere_model, 
-                                            together_model, ovh_model, cerebras_model, googleai_model)
+                                    together_model, anthropic_model, googleai_model)
             
             # Check if model is selected
             if not model_choice:
@@ -2786,6 +2899,8 @@ def create_app():
                 api_key_override = cohere_api_key
             elif provider == "Together" and together_api_key:
                 api_key_override = together_api_key
+            elif provider == "Anthropic" and anthropic_api_key:
+                api_key_override = anthropic_api_key
             elif provider == "GoogleAI" and googleai_api_key:
                 api_key_override = googleai_api_key
             
@@ -2820,7 +2935,7 @@ def create_app():
             fn=submit_message,
             inputs=[
                 message, chatbot, provider_choice, 
-                openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model,
+                openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, anthropic_model, googleai_model,
                 temperature, max_tokens, top_p, frequency_penalty, presence_penalty, repetition_penalty, 
                 top_k, min_p, seed, top_a, stream_output, response_format,
                 images, documents, reasoning_effort, system_message, transforms,
@@ -2839,7 +2954,7 @@ def create_app():
             fn=submit_message,
             inputs=[
                 message, chatbot, provider_choice, 
-                openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, ovh_model, cerebras_model, googleai_model,
+                openrouter_model, openai_model, hf_model, groq_model, cohere_model, together_model, anthropic_model, googleai_model,
                 temperature, max_tokens, top_p, frequency_penalty, presence_penalty, repetition_penalty, 
                 top_k, min_p, seed, top_a, stream_output, response_format,
                 images, documents, reasoning_effort, system_message, transforms,
@@ -2875,6 +2990,10 @@ if __name__ == "__main__":
     if not OPENROUTER_API_KEY:
         logger.warning("WARNING: OPENROUTER_API_KEY environment variable is not set")
         missing_keys.append("OpenRouter")
+
+    if not ANTHROPIC_API_KEY:
+        logger.warning("WARNING: ANTHROPIC_API_KEY environment variable is not set")
+        missing_keys.append("Anthropic")
     
     if not OPENAI_API_KEY:
         logger.warning("WARNING: OPENAI_API_KEY environment variable is not set")