add model factory

.env.example

@@ -1,6 +1,10 @@
+MODEL_PROVIDER=huggingface
+
 # Hugging Face Hub token (required)
 # Create one at https://huggingface.co/settings/tokens
 HUGGING_FACE_HUB_TOKEN=your_token_here
+HUGGING_FACE_INFERENCE_ENDPOINT_URL=https://xxxxxxxxxxx.us-east-1.aws.endpoints.huggingface.cloud
+HUGGING_FACE_MODEL_NAME=google/gemma-3-12b-it
 
 OPENAI_API_KEY=sk-proj-xxxx
 

.gitignore

@@ -1,3 +1,7 @@
+.env
+data/best_model_for_results.json
+data/final_leaderboards.json
+
 # Logs
 logs
 *.log
@@ -8,6 +12,8 @@ pnpm-debug.log*
 lerna-debug.log*
 
 __pycache__
+**/*/__pycache__
+src/__pycache__
 *.pyc
 
 client/node_modules
@@ -37,7 +43,4 @@ server/data/leaderboards_results.json
 server/data/leaderboards_runtime.json
 
 cache/
-server/cache
-.env
-data/best_model_for_results.json
-data/final_leaderboards.json
+server/cache

endpoint-scripts/mount-endpoint.py

@@ -0,0 +1,22 @@
+from huggingface_hub import create_inference_endpoint
+ 
+endpoint = create_inference_endpoint(
+    "vllm-meta-llama-3-8b-instruct",
+    repository="meta-llama/Meta-Llama-3-8B-Instruct",
+    framework="pytorch",
+    task="custom",
+    accelerator="gpu",
+    vendor="aws",
+    region="us-east-1",
+    type="protected",
+    instance_type="g5.2xlarge",
+    instance_size="medium",
+    custom_image={
+        "health_route": "/health",
+        "env": { "MAX_MODEL_LEN": "8192" },
+        "url": "philschmi/vllm-hf-inference-endpoints",
+    },
+)
+ 
+endpoint.wait()
+print(endpoint.status)

poetry.lock

@@ -1495,13 +1495,13 @@ files = [
 
 [[package]]
 name = "openai"
-version = "1.66.3"
+version = "1.66.5"
 description = "The official Python library for the openai API"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "openai-1.66.3-py3-none-any.whl", hash = "sha256:a427c920f727711877ab17c11b95f1230b27767ba7a01e5b66102945141ceca9"},
-    {file = "openai-1.66.3.tar.gz", hash = "sha256:8dde3aebe2d081258d4159c4cb27bdc13b5bb3f7ea2201d9bd940b9a89faf0c9"},
+    {file = "openai-1.66.5-py3-none-any.whl", hash = "sha256:74be528175f8389f67675830c51a15bd51e874425c86d3de6153bf70ed6c2884"},
+    {file = "openai-1.66.5.tar.gz", hash = "sha256:f61b8fac29490ca8fdc6d996aa6926c18dbe5639536f8c40219c40db05511b11"},
 ]
 
 [package.dependencies]

src/agents/fact_checker/fact_checker_agent.py

@@ -1,3 +0,0 @@
-"""
-Agent management for the agent leaderboard parser fact checker.
-"""

src/agents/model_factory.py

@@ -0,0 +1,114 @@
+import os
+import traceback
+
+def get_temperature():
+    """
+    Récupère la température depuis la variable d'environnement ou utilise une valeur par défaut.
+    
+    Returns:
+        La température à utiliser pour les modèles (float entre 0 et 1)
+    """
+    try:
+        temp_str = os.environ.get("MODEL_TEMPERATURE", "0.2")
+        temp = float(temp_str)
+        # Limiter la température entre 0 et 1
+        temp = max(0.0, min(1.0, temp))
+        return temp
+    except ValueError:
+        print(f"AVERTISSEMENT: La valeur MODEL_TEMPERATURE '{temp_str}' n'est pas un nombre valide. Utilisation de la valeur par défaut 0.2.")
+        return 0.2
+
+def get_hf_model():
+    """
+    Initialise et retourne un modèle Hugging Face via un endpoint personnalisé.
+    
+    Returns:
+        Le modèle configuré ou None en cas d'erreur
+    """
+    hf_endpoint_url = os.environ.get("HUGGING_FACE_INFERENCE_ENDPOINT_URL")
+    hf_token = os.environ.get("HUGGING_FACE_HUB_TOKEN")
+    hf_model_name = os.environ.get("HUGGING_FACE_MODEL_NAME", "google/gemma-3-12b-it")
+    temperature = get_temperature()
+    
+    # Vérifier que les variables d'environnement sont définies
+    if not hf_endpoint_url or not hf_token:
+        print("ERREUR: HUGGING_FACE_INFERENCE_ENDPOINT_URL ou HUGGING_FACE_HUB_TOKEN non configuré.")
+        return None
+    
+    print(f"Utilisation du modèle {hf_model_name} via endpoint personnalisé: {hf_endpoint_url}")
+    print(f"Température configurée: {temperature}")
+    
+    try:
+        # Utiliser OpenAIServerModel qui est plus adapté pour les endpoints d'inférence
+        from smolagents import OpenAIServerModel
+        
+        model = OpenAIServerModel(
+            model_id=hf_model_name,
+            api_base=hf_endpoint_url,
+            api_key=hf_token,
+            temperature=temperature
+        )
+        
+        print("Modèle OpenAIServerModel initialisé avec succès!")
+        return model
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        print(f"ERREUR lors de l'initialisation de OpenAIServerModel: {e}")
+        print(f"Traceback complet: {error_trace}")
+        return None
+
+def get_openai_model():
+    """
+    Initialise et retourne un modèle OpenAI GPT-4o.
+    
+    Returns:
+        Le modèle configuré ou None en cas d'erreur
+    """
+    openai_api_key = os.environ.get("OPENAI_API_KEY")
+    temperature = get_temperature()
+    
+    if not openai_api_key:
+        print("ERREUR: OPENAI_API_KEY non configuré.")
+        return None
+    
+    try:
+        # Configuration pour OpenAI
+        from smolagents import LiteLLMModel
+        
+        print("Utilisation du modèle OpenAI GPT-4o")
+        print(f"Température configurée: {temperature}")
+        
+        return LiteLLMModel(
+            "gpt-4o",
+            temperature=temperature,
+            api_key=openai_api_key
+        )
+    except Exception as e:
+        error_trace = traceback.format_exc()
+        print(f"ERREUR lors de l'initialisation de LiteLLMModel: {e}")
+        print(f"Traceback complet: {error_trace}")
+        return None
+
+def get_model():
+    """
+    Retourne le modèle à utiliser en fonction de MODEL_PROVIDER.
+    
+    Returns:
+        Un modèle configuré ou None en cas d'erreur
+    """
+    # Récupérer le modèle à utiliser depuis les variables d'environnement
+    model_provider = os.environ.get("MODEL_PROVIDER", "openai").lower()
+    
+    if model_provider == "huggingface":
+        model = get_hf_model()
+        if model:
+            return model
+        print("Passage à OpenAI suite à l'erreur.")
+        model_provider = "openai"
+    
+    if model_provider == "openai":
+        return get_openai_model()
+    
+    # Si on arrive ici, c'est que MODEL_PROVIDER n'est ni huggingface ni openai
+    print(f"ERREUR: MODEL_PROVIDER '{model_provider}' non reconnu. Utiliser 'huggingface' ou 'openai'")
+    return None 

src/agents/{parser/parser_agent.py → parser_agent.py}

@@ -1,9 +1,13 @@
 """
 Agent management for the leaderboard parser.
 """
+import os
 import datetime
+import json
+import requests
 from smolagents import CodeAgent
-from smolagents.cli import load_model
+from smolagents.models import HfApiModel
+from src.agents.model_factory import get_model as get_default_model
 
 from src.agents.browser import save_screenshot
 from src.agents.tools import (
@@ -20,38 +24,46 @@ from src.agents.tools import (
 )
 
 
+def load_model(model_type, model_id):
+    """
+    Load a model by its type and ID.
+    
+    Args:
+        model_type: The type of model to load
+        model_id: The ID of the model
+        
+    Returns:
+        The loaded model
+    """
+    if model_type == "HfApiModel":
+        return HfApiModel(model_id=model_id)
+    elif model_type == "LiteLLMModel":
+        from smolagents import LiteLLMModel
+        return LiteLLMModel(model_id)
+    else:
+        raise ValueError(f"Unknown model type: {model_type}")
+
+
 def initialize_agent(model):
     """
-    Initialize the CodeAgent with the specified model.
+    Initialize an agent with the given model.
     
     Args:
-        model: The LLM model to use for the agent
+        model: The model to use for the agent
         
     Returns:
-        A configured CodeAgent instance
+        The initialized agent
     """
     return CodeAgent(
         tools=[go_back, map_clickable_elements, validate_json_results, close_popups, search_item_ctrl_f, extract_table_data, find_leaderboard_elements, copy_link_from_element, find_model_links, click_at_coordinates],
         model=model,
-        additional_authorized_imports=["selenium", "helium", "time", "json", "re"],
+        additional_authorized_imports=["selenium", "helium", "time", "json", "re", "src.agents.browser"],
         step_callbacks=[save_screenshot],
         max_steps=25,
         verbosity_level=2,
     )
 
 
-def get_default_model():
-    """
-    Get the default model for the agent.
-    
-    Returns:
-        A configured model instance
-    """
-    model_type = "LiteLLMModel"
-    model_id = "gpt-4o"
-    return load_model(model_type, model_id)
-
-
 # Instructions for the agent
 leaderboard_instructions = """
 Your task is to extract the three BEST models from the leaderboard. It is crucial that you identify the models that are at the top of the ranking, not just any three models present on the page.
@@ -285,6 +297,15 @@ def process_leaderboard(url, model, index, uid=None, additional_rules=None):
     now = datetime.datetime.now()
     parsed_at = now.isoformat()
     
+    # Vérifier si le modèle est None
+    if model is None:
+        return {
+            "results": None,
+            "parsing_status": "error",
+            "parsing_message": "Model initialization failed - check HUGGING_FACE_INFERENCE_ENDPOINT_URL and HUGGING_FACE_HUB_TOKEN",
+            "parsed_at": parsed_at
+        }
+    
     initialize_driver()
     
     agent = initialize_agent(model)

src/leaderboard_processor.py

@@ -3,7 +3,7 @@ Leaderboard processing.
 """
 import datetime
 import os
-from src.agents.parser.parser_agent import process_leaderboard
+from src.agents.parser_agent import process_leaderboard
 from src.file_utils import create_category_slug, split_combined_id
 
 

src/processor.py

@@ -16,7 +16,7 @@ from src.file_utils import create_category_slug, split_combined_id, create_combi
 from src.file_utils import load_and_validate_results, validate_leaderboard_result
 from src.hub_utils import upload_to_hub, download_from_hub
 from src.leaderboard_processor import process_single_leaderboard
-from src.agents.parser.parser_agent import get_default_model
+from src.agents.parser_agent import get_default_model
 from src.agents.browser import cleanup_browser
 
 # Configure logger