[ADD] added multi provider class and its structure part to handle it.

Gradio_UI.py

@@ -278,7 +278,11 @@ class GradioUI:
             app_content = f.read()
         model_providers_match = re.search(r"model_providers = ({[^{}]*(?:{[^{}]*}[^{}]*)*})", app_content, re.DOTALL)
         if model_providers_match:
-            model_providers = eval(model_providers_match.group(1))
+            try:
+                model_providers = eval(model_providers_match.group(1))
+            except Exception as e:
+                print(f"Error evaluating model_providers: {e}")
+                model_providers = {}
         else:
             model_providers = {}
 

app.py

@@ -1,4 +1,13 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+import os
+from enum import Enum
+import logging
+from openai import OpenAI
+from anthropic import Anthropic
+import groq
+import google.generativeai as palm
+from smolagents import HfApiModel, CodeAgent, DuckDuckGoSearchTool, load_tool, tool
 import datetime
 import requests
 import pytz
@@ -12,11 +21,15 @@ from tools.odoo_code_agent_16 import OdooCodeAgent16
 from tools.odoo_code_agent_17 import OdooCodeAgent17
 from tools.odoo_code_agent_18 import OdooCodeAgent18
 
-from dotenv import load_dotenv
 from Gradio_UI import GradioUI
-load_dotenv()
 
-import os
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+os.environ["TRANSFORMERS_OFFLINE"] = "1"
+os.environ["TORCH_MPS_FORCE_CPU"] = "1"
+
 
 # Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
@@ -56,8 +69,160 @@ odoo_code_agent_16_tool = OdooCodeAgent16(prompt_templates["system_prompt"])
 odoo_code_agent_17_tool = OdooCodeAgent17(prompt_templates["system_prompt"])
 odoo_code_agent_18_tool = OdooCodeAgent18(prompt_templates["system_prompt"])
 
+# Import tool from Hub
+image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+
+class ModelProvider(Enum):
+    QWEN = "Qwen"
+    HUGGINGFACE = "HuggingFace"
+    OPENAI = "OpenAI"
+    ANTHROPIC = "Anthropic"
+    GROQ = "Groq"
+    GOOGLE = "Google"
+    CUSTOM = "Custom"
+
+@dataclass
+class ProviderConfig:
+    model_id: str
+    api_key_env_var: Optional[str] = None
+    model_name_env_var: Optional[str] = None
+    base_url_env_var: Optional[str] = None
+    default_max_tokens: int = 1000
+    default_temperature: float = 0.5
+
+class LLMProviderManager:
+    def __init__(self):
+        self.providers_config = {
+            ModelProvider.QWEN: ProviderConfig(
+                model_id="Qwen/Qwen2.5-Coder-32B-Instruct"
+            ),
+            ModelProvider.HUGGINGFACE: ProviderConfig(
+                model_id="https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud"
+            ),
+            ModelProvider.OPENAI: ProviderConfig(
+                model_id="gpt-4",
+                api_key_env_var="OPENAI_API_KEY",
+                model_name_env_var="OPENAI_MODEL_NAME",
+                base_url_env_var="OPENAI_BASE_URL"
+            ),
+            ModelProvider.ANTHROPIC: ProviderConfig(
+                model_id="claude-v1",
+                api_key_env_var="ANTHROPIC_API_KEY",
+                model_name_env_var="ANTHROPIC_MODEL_NAME",
+                base_url_env_var="ANTHROPIC_BASE_URL"
+            ),
+            ModelProvider.GROQ: ProviderConfig(
+                model_id="mixtral-8x7b-32768",
+                api_key_env_var="GROQ_API_KEY",
+                model_name_env_var="GROQ_MODEL_NAME",
+                base_url_env_var="GROQ_BASE_URL"
+            ),
+            ModelProvider.GOOGLE: ProviderConfig(
+                model_id="gemini-pro",
+                api_key_env_var="GOOGLE_API_KEY",
+                model_name_env_var="GOOGLE_MODEL_NAME",
+                base_url_env_var="GOOGLE_BASE_URL"
+            ),
+            ModelProvider.CUSTOM: ProviderConfig(
+                model_id=None,
+                base_url_env_var="CUSTOM_BASE_URL"
+            )
+        }
+
+    def _get_api_key(self, provider: ModelProvider, custom_api_key: Optional[str] = None) -> Optional[str]:
+        config = self.providers_config[provider]
+        if custom_api_key:
+            return custom_api_key
+        return os.environ.get(config.api_key_env_var) if config.api_key_env_var else None
+
+    def _get_base_url(self, provider: ModelProvider) -> Optional[str]:
+        config = self.providers_config[provider]
+        return os.environ.get(config.base_url_env_var) if config.base_url_env_var else None
+
+    def _get_model_name(self, provider: ModelProvider) -> str:
+        config = self.providers_config[provider]
+        if config.model_name_env_var:
+            return os.environ.get(config.model_name_env_var, config.model_id)
+        return config.model_id
+
+    def initialize_provider(
+        self,
+        provider: ModelProvider,
+        custom_api_key: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None
+    ) -> Any:
+        """Initialize a specific LLM provider with given configuration."""
+        try:
+            config = self.providers_config[provider]
+            api_key = self._get_api_key(provider, custom_api_key)
+            base_url = self._get_base_url(provider)
+            
+            if provider in [ModelProvider.QWEN, ModelProvider.HUGGINGFACE, ModelProvider.CUSTOM]:
+                return self._initialize_hf_model(config, api_key, base_url, max_tokens, temperature)
+            
+            provider_initializers = {
+                ModelProvider.OPENAI: self._initialize_openai,
+                ModelProvider.ANTHROPIC: self._initialize_anthropic,
+                ModelProvider.GROQ: self._initialize_groq,
+                ModelProvider.GOOGLE: self._initialize_google
+            }
+            
+            initializer = provider_initializers.get(provider)
+            if not initializer:
+                raise ValueError(f"Unsupported provider: {provider}")
+
+            if provider == ModelProvider.GOOGLE:
+                client = initializer(api_key, base_url)
+                return client
+            else:
+                return initializer(api_key, base_url)
+
+        except Exception as e:
+            logger.error(f"Error initializing provider {provider}: {str(e)}")
+            raise
+
+    def _initialize_hf_model(
+        self,
+        config: ProviderConfig,
+        api_key: Optional[str],
+        base_url: Optional[str],
+        max_tokens: Optional[int],
+        temperature: Optional[float]
+    ) -> HfApiModel:
+        model_kwargs = {
+            "max_tokens": max_tokens or config.default_max_tokens,
+            "temperature": temperature or config.default_temperature,
+            "model_id": config.model_id,
+            "custom_role_conversions": None
+        }
+        
+        if api_key:
+            model_kwargs["api_key"] = api_key
+        if base_url:
+            model_kwargs["url"] = base_url
+            
+        return HfApiModel(**model_kwargs)
+
+    def _initialize_openai(self, api_key: str, base_url: Optional[str]) -> OpenAI:
+        kwargs = {"api_key": api_key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        return OpenAI(**kwargs)
+
+    def _initialize_anthropic(self, api_key: str, base_url: Optional[str]) -> Anthropic:
+        kwargs = {"api_key": api_key}
+        if base_url:
+            kwargs["base_url"] = base_url
+        return Anthropic(**kwargs)
+
+    def _initialize_groq(self, api_key: str, _: Optional[str]) -> groq.Groq:
+        return groq.Groq(api_key=api_key)
+
+    def _initialize_google(self, api_key: str, _: Optional[str]) -> Any:
+        palm.configure(api_key=api_key)
+        return palm
 
-# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
 model_providers = {
     "Qwen": {
         "model_id": "Qwen/Qwen2.5-Coder-32B-Instruct",
@@ -69,74 +234,87 @@ model_providers = {
     },
     "OpenAI": {
         "model_id": "gpt-4",
-        "api_key_env_var": "OPENAI_API_KEY"
+        "api_key_env_var": "OPENAI_API_KEY",
+        "model_name_env_var": "OPENAI_MODEL_NAME",
+        "base_url_env_var": "OPENAI_BASE_URL"
     },
     "Anthropic": {
         "model_id": "claude-v1",
-        "api_key_env_var": "ANTHROPIC_API_KEY"
+        "api_key_env_var": "ANTHROPIC_API_KEY",
+        "model_name_env_var": "ANTHROPIC_MODEL_NAME",
+        "base_url_env_var": "ANTHROPIC_BASE_URL"
     },
     "Groq": {
         "model_id": "mixtral-8x7b-32768",
-        "api_key_env_var": "GROQ_API_KEY"
+        "api_key_env_var": "GROQ_API_KEY",
+        "model_name_env_var": "GROQ_MODEL_NAME",
+        "base_url_env_var": "GROQ_BASE_URL"
     },
     "Google": {
         "model_id": "gemini-pro",
-        "api_key_env_var": "GOOGLE_API_KEY"
+        "api_key_env_var": "GOOGLE_API_KEY",
+        "model_name_env_var": "GOOGLE_MODEL_NAME",
+        "base_url_env_var": "GOOGLE_BASE_URL"
     },
     "Custom": {
         "model_id": None,
-        "api_key_env_var": None
+        "api_key_env_var": None,
+        "base_url_env_var": "CUSTOM_BASE_URL"
     }
 }
 
+def launch_gradio_ui(additional_args: Optional[Dict[str, Any]] = None):
+    """Launch the Gradio UI with the specified LLM provider configuration."""
+    if additional_args is None:
+        additional_args = {}
 
-# Import tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+    def generate_google_content(prompt: str, model: palm.GenerativeModel):
+        """Helper function to generate content using the Google provider."""
+        try:
+            response = model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            logger.error(f"Google Palm API error: {str(e)}")
+            return f"Error generating text with Google Palm: {str(e)}"
 
+    provider_name = additional_args.get("selected_provider", "HuggingFace")
+    max_steps = int(additional_args.get("max_steps", 6))
+    max_tokens = int(additional_args.get("max_tokens", 1000))
+    temperature = float(additional_args.get("temperature", 0.5))
 
+    try:
+        provider = ModelProvider(provider_name)
+        provider_manager = LLMProviderManager()
+        
+        custom_api_key = additional_args.get(f"{provider_name}_api_key")
+        model = provider_manager.initialize_provider(
+            provider=provider,
+            custom_api_key=custom_api_key,
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
 
-def launch_gradio_ui(additional_args=None):
-    global selected_provider
-    global model
-    #global agent # Declare agent as global
+        agent = CodeAgent(
+            model=generate_google_content if provider == ModelProvider.GOOGLE else model,
+            tools=[
+                final_answer, visit_webpage, web_search, image_generation_tool, get_current_time_in_timezone,
+                job_search_tool,
+                odoo_documentation_search_tool, odoo_code_agent_16_tool,
+                odoo_code_agent_17_tool, odoo_code_agent_18_tool
+            ],
+            max_steps=max_steps,
+            verbosity_level=1,
+            grammar=None,
+            planning_interval=None,
+            name=None,
+            description=None,
+            prompt_templates=prompt_templates
+        )
 
-    if additional_args:
-        selected_provider = additional_args.get("selected_provider", "HuggingFace")
-        max_steps = int(additional_args.get("max_steps", 6))
-        max_tokens = int(additional_args.get("max_tokens", 1000))
-    else:
-        selected_provider = "HuggingFace"
-        max_steps = 6
-        max_tokens = 1000
+        GradioUI(agent).launch()
 
-    model_id = model_providers[selected_provider]["model_id"]
-    api_key_env_var = model_providers[selected_provider]["api_key_env_var"]
-    api_key = additional_args.get(f"{selected_provider}_api_key") if additional_args else None
+    except Exception as e:
+        logger.error(f"Error launching Gradio UI: {str(e)}")
+        raise
 
-    model_kwargs = {
-        "max_tokens": max_tokens,
-        "temperature": 0.5,
-        "model_id": model_id,
-        "custom_role_conversions": None,
-    }
-    if model_providers[selected_provider]["api_key_env_var"]:
-        model_kwargs["api_key"] = api_key if api_key else os.environ.get(api_key_env_var)
-
-    model = HfApiModel(**model_kwargs)
-
-    agent = CodeAgent(
-        model=model,
-        tools=[final_answer, visit_webpage, web_search, image_generation_tool, get_current_time_in_timezone, job_search_tool, odoo_documentation_search_tool, odoo_code_agent_16_tool, odoo_code_agent_17_tool, odoo_code_agent_18_tool],
-        max_steps=max_steps,
-        verbosity_level=1,
-        grammar=None,
-        planning_interval=None,
-        name=None,
-        description=None,
-        prompt_templates=prompt_templates
-    )
-
-    GradioUI(agent).launch()
-
-# Remove the direct call to launch_gradio_ui()
 launch_gradio_ui()

requirements.txt

@@ -1,4 +1,3 @@
-markdownify
 smolagents
 requests
 duckduckgo_search
@@ -10,3 +9,7 @@ transformers
 torch
 sentence-transformers
 numpy==1.23.5
+openai
+anthropic
+groq
+google-generativeai