agent v_1

All the common features are present
Video/audio/image analysis
Code analysis
Websearch/wikipedia search

.gitignore

@@ -0,0 +1,2 @@
+.env
+__pycache__

agent/agent.py

@@ -0,0 +1,97 @@
+from smolagents import Tool, tool
+import os
+import asyncio
+
+from Final_Assignment_Template.agent.ressources_getter import save_file, \
+    get_prompt_with_file_content, extract_text_from_file, convert_excel_to_text, delete_tmp_files
+from get_question.hf_api import get_file_by_task_id
+from Final_Assignment_Template.agent.agent_websearch import create_wikipedia_agent
+from Final_Assignment_Template.agent.agent_multimedia import create_multimedia_agent
+from Final_Assignment_Template.agent.agent_code import create_code_analyzer_agent
+from smolagents import ToolCallingAgent, LiteLLMModel
+from dotenv import load_dotenv
+
+load_dotenv()
+
+agent_wikipedia = create_wikipedia_agent()
+agent_multimedia = create_multimedia_agent()
+agent_code = create_code_analyzer_agent()
+
+class WikipediaAgentTool(Tool):
+    name = "WikipediaAgentTool"
+    description = "Delegates tasks to the WebSearch agent."
+    inputs = {"query": {"type": "string", "description": "Search query for Wikipedia or Web search."}}
+    output_type = "string"
+    def forward(self, query: str) -> str:
+        return agent_wikipedia.run(query)
+
+class MediaAgentTool(Tool):
+    name = "MediaAgentTool"
+    description = """Delegates tasks to the Media agent. It can search for videos on YouTube to download them localy.
+    It can also analyze local video,image and music content."""
+    inputs = {"query": {"type": "string", "description": "Search query with a Youtube url or query with the file path."}}
+    output_type = "string"
+
+    def forward(self, query: str) -> str:
+        # Utilise l'agent vidéo pour rechercher sur YouTube
+        return agent_multimedia.run(query)
+
+
+class CodeAgentTool(Tool):
+    name = "CodeAgentTool"
+    description = """Delegates tasks to the Code agent. It can execute Python code and return the output."""
+    inputs = {"query": {"type": "string", "description": "Query with file path of the code."}}
+    output_type = "string"
+
+    def forward(self, query: str) -> str:
+        # Utilise l'agent code pour exécuter du code Python
+        return agent_code.run(query)
+
+
+
+gemini_flash_manager_model = LiteLLMModel(model_id="gemini/gemini-2.5-flash", api_key=os.getenv("GOOGLE_API_KEY"))
+
+
+manager_agent = ToolCallingAgent(
+    tools=[WikipediaAgentTool(),MediaAgentTool(),CodeAgentTool(),extract_text_from_file,convert_excel_to_text,delete_tmp_files], # Les agents workers sont des outils pour le manager
+    model=gemini_flash_manager_model,
+    name="ManagerAgent",
+    description=(
+        "Je suis un agent manager. Mon rôle est de comprendre les requêtes complexes, "
+        "de les décomposer en tâches plus petites et de déléguer ces tâches "
+        "aux agents spécialisés (WikiAgent) pour obtenir la meilleure réponse. "
+        "Je coordonne leurs actions et synthétise les résultats."
+        "Après avoir répondu à la requête, je supprime les fichiers temporaires téléchargés pour économiser de l'espace disque."
+        "Si tu ne trouve pas une réponse satisfaisante sous 5 étapes ou que tu n'as pas les outils pour y répondre, renvoie une chaine de caractères vide."
+    )
+)
+
+# Pour interagir avec l'agent manager
+async def run_multi_agent_system(prompt: str):
+    print(f"\nRequête au Manager : {prompt}")
+    return manager_agent.run(prompt)
+
+
+class BasicAgent:
+    task_id:str
+    file_content_type:str
+    agent = manager_agent
+    def __init__(self):
+        print("BasicAgent initialized.")
+    def __call__(self, question: str, task_id :str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        file_bytes,file_name=get_file_by_task_id(task_id)
+        print(file_name)
+        file_path = save_file(file_bytes,file_name)
+        prompt = get_prompt_with_file_content(question,file_path)
+        answer = asyncio.run(run_multi_agent_system(prompt))
+        print(f"Agent returning fixed answer: {answer}")
+        return answer
+
+
+# if __name__ == "__main__":
+#     agent = BasicAgent()
+#     question = "Review the chess position provided in the image. It is black's turn. Provide the correct next move for black which guarantees a win. Please provide your response in algebraic notation."
+#     task_id = "cca530fc-4052-43b2-b130-b30968d8aa44"
+#     response = agent(question,task_id)
+#     print(response)

agent/agent_code.py

@@ -0,0 +1,45 @@
+import os
+
+from dotenv import load_dotenv
+from smolagents import CodeAgent, LiteLLMModel, tool
+
+load_dotenv()  # Charge les variables d'environnement
+llm_model = LiteLLMModel(model_id="mistral/codestral-latest", api_key=os.getenv("MISTRAL_API_KEY"))
+
+
+def create_code_analyzer_agent():
+    """
+    Crée un agent simple pour exécuter du code et obtenir sa sortie.
+
+    Returns:
+        CodeAgent: Agent configuré pour l'exécution de code
+    """
+    # Initialiser le modèle Mistral Codestral
+    model = LiteLLMModel(
+        model_id="mistral/codestral-latest",
+        temperature=0.1,  # Déterministe pour l'exécution
+        max_tokens=2000,
+    )
+
+    # Instructions système simples et directes
+    system_prompt = """
+Tu es un exécuteur de code Python. Ton rôle est simple : exécuter le code fourni et donner sa sortie finale.
+
+Quand on te donne du code à analyser :
+1. Exécute directement le code Python
+2. Capture toute la sortie (print, résultats, etc.)
+3. Retourne la sortie finale
+
+Sois concis et direct dans tes réponses. Concentre-toi uniquement sur l'exécution et le résultat.
+"""
+
+    code_analyzer_agent = CodeAgent(
+        model=model,
+        tools=[],
+        description=system_prompt,
+        max_steps=3,  # Peu d'étapes nécessaires
+    )
+
+    return code_analyzer_agent
+
+

agent/agent_multimedia.py

@@ -0,0 +1,108 @@
+# Fonction pour lire et encoder une image en base64
+import base64
+import os
+from pathlib import Path
+
+import yt_dlp
+from dotenv import load_dotenv
+from smolagents import tool, ToolCallingAgent, LiteLLMModel
+import google.generativeai as genai
+from ressources_getter import DOWNLOAD_FOLDER, delete_tmp_files, create_download_folder_if_not_exist
+import mimetypes
+
+
+load_dotenv()
+
+
+@tool
+def download_video_youtube(url : str)-> str | None:
+    """
+    Télécharge une vidéo YouTube dans un dossier local.
+    Args:
+        url (str): URL de la vidéo YouTube
+    Returns:
+        file_path (str): Chemin du fichier téléchargé ou None en cas d'erreur
+    """
+    try:
+        # Créer le dossier de téléchargement s'il n'existe pas
+        create_download_folder_if_not_exist()
+        file_path = f'{DOWNLOAD_FOLDER}/tmp_video.mp4'
+        # Configuration pour yt-dlp
+        ydl_opts = {
+            'outtmpl': file_path,  # Format du nom de fichier
+            'format': 'best[height<=720]',  # Qualité maximale 720p (ajustable)
+            'noplaylist': True,  # Télécharger seulement la vidéo, pas la playlist
+        }
+
+        # Télécharger la vidéo
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            print(f"Téléchargement de: {url}")
+            ydl.download([url])
+            print("Téléchargement terminé avec succès!")
+            return file_path
+
+    except Exception as e:
+        print(f"Erreur lors du téléchargement: {str(e)}")
+        return None
+
+
+@tool
+def analyze_media_content(media_path: str, user_prompt: str) -> str:
+    """
+    Analyse le contenu du média en utilisant Gemini 2.5 Flash via le SDK Google Generative AI.
+    (Ce n'est pas LiteLLM qui fait l'appel multimodal ici, mais le SDK direct pour gérer les parties vidéo).
+    Args:
+        media_path (str): Chemin du fichier local à analyser.
+        user_prompt (str): Requête de l'utilisateur pour guider l'analyse.
+    Returns:
+        str: Résultat de l'analyse du fichier.
+    """
+    try:
+
+
+        with open(media_path, "rb") as file:
+            file_bytes = file.read()
+            encoded_video = base64.b64encode(file_bytes).decode('utf-8')
+
+        # Déterminer le type MIME du fichier
+        mime_type, encoding = mimetypes.guess_type(media_path)
+
+        file_part = {
+            "inline_data": {
+                "mime_type": mime_type,
+                "data": encoded_video
+            }
+        }
+        genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))  # Assure que l'API Key est configurée
+        model = genai.GenerativeModel('gemini-2.5-flash') # Utilise le modèle directement via le SDK
+        response = model.generate_content([user_prompt, file_part])
+        return response.text
+
+    except Exception as e:
+        return f"Erreur lors de l'analyse de la vidéo : {e}"
+
+
+def create_multimedia_agent():
+    """
+    Crée un agent multimédia capable de télécharger et d'analyser des vidéos YouTube.
+    Il peut également analyser des fichiers multimédias locaux (vidéos, images, musique).
+    Returns:
+        BasicAgent: Instance de l'agent multimédia.
+    """
+    gemini_flash_vlm_model = LiteLLMModel(model_id="gemini/gemini-2.5-flash", api_key=os.getenv("GOOGLE_API_KEY"))
+
+    system_prompt = """Tu es un expert en analyse de vidéo,image et fichier son. Ton rôle est d'analyser les fichiers fournies en utilisant les outils à ta disposition.
+    Lorsque tu reçois un lien d'une vidéo youtube, utilise la fonction 'download_video_youtube' pour télécharger la vidéo.
+    Si tu as un fichier video,image ou son local, utilise la fonction 'analyze_media_content' pour analyser le contenu.
+    Utilise tes outils pour répondre aux questions de l'utilisateur concernant le contenu du fichier.
+    Fait bien attention à supprimer les fichiers temporaires téléchargées après analyse pour économiser de l'espace disque.
+    Fournis un réponse concise et sans points ou virgules.
+    """
+
+    # Crée l'agent en lui passant l'instance de LiteLLMModel
+    video_agent = ToolCallingAgent(
+        model=gemini_flash_vlm_model, # Passe l'instance LiteLLMModel ici
+        tools=[analyze_media_content, download_video_youtube,delete_tmp_files], # Liste des outils que l'agent peut utiliser
+        description=system_prompt,
+    )
+    return video_agent

agent/agent_websearch.py

@@ -0,0 +1,199 @@
+import wikipedia
+import requests
+from bs4 import BeautifulSoup
+import pandas as pd
+from typing import List, Dict, Any, Optional
+import os
+from dotenv import load_dotenv
+from smolagents import CodeAgent, LiteLLMModel, tool, DuckDuckGoSearchTool
+import re
+from datetime import datetime
+
+# Configuration de Wikipedia en français
+wikipedia.set_lang("fr")
+
+# Initialisation de l'outil de recherche DuckDuckGo
+search_tool = DuckDuckGoSearchTool(5)
+
+load_dotenv()  # Charge les variables d'environnement
+
+@tool
+def search_internet(query: str) -> List[Dict[str, str]]:
+    """
+    Recherche des informations sur internet via DuckDuckGo.
+
+    Args:
+        query: Terme de recherche
+
+    Returns:
+        Liste de dictionnaires contenant les résultats de recherche
+    """
+    try:
+        # Utilisation de DuckDuckGoSearchTool
+        results = search_tool(query)
+        return results
+    except Exception as e:
+        return [{'error': f'Erreur lors de la recherche: {str(e)}'}]
+
+
+@tool
+def get_wikipedia_page(title: str, lang: str = "fr") -> Dict[str, Any]:
+    """
+    Récupère une page Wikipedia complète avec son contenu et ses tableaux sous forme d'un dictionnaire.
+
+    Args:
+        title: Titre de la page Wikipedia
+        lang: Langue de Wikipedia (par défaut: français)
+
+    Returns:
+        Dictionnaire contenant les informations de la page et ses tableaux
+    """
+    try:
+        wikipedia.set_lang(lang)
+        page = wikipedia.page(title)
+
+        # Récupération du HTML de la page pour extraire les tableaux
+        response = requests.get(page.url)
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Extraction des tableaux avec leurs titres
+        tables = []
+        wiki_tables = soup.find_all('table', class_='wikitable')
+
+        for i, table in enumerate(wiki_tables):
+            table_data = []
+            headers = []
+            table_title = ""
+
+            # Recherche du titre du tableau
+            # Chercher dans les éléments précédents pour trouver un titre
+            current_element = table.find_previous_sibling()
+            title_found = False
+
+            while current_element and not title_found:
+                if current_element.name in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
+                    table_title = current_element.get_text(strip=True)
+                    title_found = True
+                elif current_element.name == 'p':
+                    # Parfois le titre est dans un paragraphe juste avant
+                    text = current_element.get_text(strip=True)
+                    if len(text) < 100 and text.endswith(':'):
+                        table_title = text.rstrip(':')
+                        title_found = True
+                elif current_element.name == 'caption':
+                    # Certains tableaux ont une balise caption
+                    table_title = current_element.get_text(strip=True)
+                    title_found = True
+                current_element = current_element.find_previous_sibling()
+
+            # Vérifier si le tableau a une caption directe
+            caption = table.find('caption')
+            if caption and not table_title:
+                table_title = caption.get_text(strip=True)
+
+            # Si aucun titre trouvé, chercher dans les éléments suivants
+            if not table_title:
+                # Regarder les éléments th avec colspan ou les premiers éléments
+                first_row = table.find('tr')
+                if first_row:
+                    first_cell = first_row.find(['th', 'td'])
+                    if first_cell and first_cell.get('colspan'):
+                        potential_title = first_cell.get_text(strip=True)
+                        if len(potential_title) < 100:
+                            table_title = potential_title
+
+            # Valeur par défaut si aucun titre trouvé
+            if not table_title:
+                table_title = f"Tableau {i + 1}"
+
+            # Extraction des en-têtes
+            header_row = table.find('tr')
+            if header_row:
+                for th in header_row.find_all(['th', 'td']):
+                    headers.append(th.get_text(strip=True))
+
+            # Extraction des données
+            rows = table.find_all('tr')
+            data_rows = []
+
+            # Déterminer quelle ligne contient les données (pas les en-têtes)
+            start_row = 1 if headers else 0
+
+            for row in rows[start_row:]:
+                cells = row.find_all(['td', 'th'])
+                if cells:
+                    row_data = {}
+                    for j, cell in enumerate(cells):
+                        header = headers[j] if j < len(headers) else f'Colonne_{j + 1}'
+                        cell_text = cell.get_text(strip=True)
+                        row_data[header] = cell_text
+                    if any(row_data.values()):  # Ignorer les lignes vides
+                        data_rows.append(row_data)
+
+            tables.append({
+                'table_index': i,
+                'table_title': table_title,
+                'headers': headers,
+                'data': data_rows,
+                'row_count': len(data_rows),
+                'column_count': len(headers)
+            })
+
+        return {
+            'title': page.title,
+            'url': page.url,
+            'summary': page.summary,
+            'content': page.content,
+            'links': page.links[:20],  # Limite aux 20 premiers liens
+            'categories': page.categories[:10],  # Limite aux 10 premières catégories
+            'images': page.images[:5] if page.images else [],  # Limite aux 5 premières images
+            'tables': tables,
+            'table_count': len(tables),
+            'page_length': len(page.content),
+            'has_tables': len(tables) > 0
+        }
+    except wikipedia.exceptions.DisambiguationError as e:
+        return {
+            'error': 'Ambiguité détectée',
+            'options': e.options[:10],  # Limite aux 10 premières options
+            'type': 'disambiguation'
+        }
+    except wikipedia.exceptions.PageError:
+        return {
+            'error': f'Page "{title}" non trouvée',
+            'type': 'page_not_found'
+        }
+    except Exception as e:
+        return {
+            'error': f'Erreur: {str(e)}',
+            'type': 'general_error'
+        }
+
+
+# Configuration du modèle LiteLLM
+def create_wikipedia_agent():
+    """
+    Crée un agent Wikipedia avec tous les outils nécessaires.
+    """
+    # Initialisation du modèle (ajustez selon votre configuration)
+    model = LiteLLMModel(model_id="gemini/gemini-2.5-flash", api_key=os.getenv("GOOGLE_API_KEY"))
+
+    system_prompt = """
+    Tu es un agent de recherche d'information, tu es capable de trouver des informations sur Wikipédia ou par recherche internet.
+    Tu peux exécuter des recherches, récupérer des pages Wikipedia, extraire des tableaux.
+    Pour trouver un article, tu peux rechercher sur internet avec le plus de détails puis trouver le premier lien Wikipedia pertinent.
+    Si tu ne trouves pas d'outils spécifiques à une tâche, tu peux utiliser la recherche internet pour trouver des informations pertinentes.
+    Tu dois toujours fournir des réponses claires et concises, en citant les sources lorsque c'est possible.
+    """
+    # Création de l'agent avec les outils
+    return CodeAgent(
+        tools=[
+            search_internet,
+            get_wikipedia_page,
+            # get_featured_articles_by_year,
+            # search_wikipedia_category
+        ],
+        model=model,
+        description=system_prompt,
+        additional_authorized_imports=["wikipedia", "requests", "bs4", "pandas"]
+    )

agent/get_question/hf_api.py

@@ -0,0 +1,82 @@
+import re
+
+import requests
+
+
+# (Keep Constants as is)
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+
+def get_question() :
+    questions_url = f"{DEFAULT_API_URL}/questions"
+
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+        return questions_data
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+
+def get_random_question():
+    random_question_url = f"{DEFAULT_API_URL}/random-question"
+    print(f"Fetching a random question from: {random_question_url}")
+    try:
+        response = requests.get(random_question_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        return questions_data
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching a random question: {e}")
+        return f"Error fetching a random question: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from a random question endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for a random question: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching a random question: {e}")
+        return f"An unexpected error occurred fetching a random question: {e}", None
+
+
+def get_file_by_task_id(task_id:str):
+    file_by_task_id_url = f"{DEFAULT_API_URL}/files/{task_id}"
+    print(f"Fetching a file from: {file_by_task_id_url}")
+    try:
+        response = requests.get(file_by_task_id_url, timeout=15)
+
+        response.raise_for_status()
+        content_disp = response.headers.get("Content-Disposition")
+        file_name = re.findall('filename=(.+)', content_disp)
+        questions_data = response.content
+        if not questions_data or not file_name:
+             print("No file to fetch.")
+             return "No file to fetch.", None
+        return questions_data, file_name[0].replace('"', '').strip()
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching a file: {e}")
+        return f"Error fetching a file: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from the file by task id endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for the file by task id: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching a file: {e}")
+        return f"An unexpected error occurred fetching a file: {e}", None

agent/prompts.yaml

@@ -0,0 +1,68 @@
+description: You are a GAIA benchmark AI assistant, very precise, no nonsense. Your sole purpose is to output the minimal, final answer in the format: [ANSWER]. You
+  must NEVER output explanations, intermediate steps, reasoning, or comments — only
+  the answer, strictly enclosed in `[ANSWER]`.
+rules:
+  - id: format
+    description: Control output format and token usage.
+    constraints:
+      - limit_token_used: 65536
+      - output_only_final_answer: true
+      - wrap_answer_in_brackets: true
+      - no_whitespace_outside_brackets: true
+      - no_follow_ups_justifications_clarifications: true
+  - id: numerical_answers
+    description: Guidelines for numerical answers.
+    constraints:
+      - use_digits_only: true
+      - no_commas_symbols_units_unless_required: true
+      - no_approximate_words: true
+  - id: string_answers
+    description: Guidelines for string answers.
+    constraints:
+      - omit_articles: true
+      - use_full_words: true
+      - use_text_for_numbers_if_specified: true
+      - sort_sets_lists_alphabetically_if_not_specified: true
+  - id: lists
+    description: Guidelines for list answers.
+    constraints:
+      - output_comma_separated: true
+      - no_conjunctions: true
+      - sort_alphabetically_or_numerically: true
+      - no_braces_or_brackets_unless_asked: true
+  - id: sources
+    description: Guidelines for using sources like Wikipedia or web tools.
+    constraints:
+      - extract_only_precise_fact: true
+      - ignore_unrelated_content: true
+  - id: file_analysis
+    description: Guidelines for using the run_query_with_file tool.
+    constraints:
+      - use_run_query_with_file_tool: true
+      - append_taskid_to_url: true
+      - include_exact_answer_only: true
+      - no_summarizing_excessive_quoting_or_interpreting: true
+  - id: video
+    description: Guidelines for using the relevant video tool.
+    constraints:
+      - use_relevant_video_tool: true
+      - include_exact_answer_only: true
+      - no_summarizing_excessive_quoting_or_interpreting: true
+  - id: minimalism
+    description: General minimalism guidelines.
+    constraints:
+      - no_assumptions_unless_logically_demanded: true
+      - choose_narrowest_most_literal_interpretation: true
+      - output_unknown_if_answer_not_found: true
+examples:
+  - question: What is 2 + 2?
+    answer: "[ANSWER]4"
+  - question: How many studio albums were published by Mercedes Sosa between 2000 and
+      2009 (inclusive)? Use 2022 English Wikipedia.
+    answer: "[ANSWER]3"
+  - question: Given the following group table on set S = {a, b, c, d, e}, identify
+      any subset involved in counterexamples to commutativity.
+    answer: "[ANSWER]b, e"
+  - question: How many at bats did the Yankee with the most walks in the 1977 regular
+      season have that same season?
+    answer: "[ANSWER]519"

agent/ressources_getter.py

@@ -0,0 +1,75 @@
+
+import os
+from pathlib import Path
+
+import pandas as pd
+from smolagents import tool
+
+DOWNLOAD_FOLDER = "./download"
+
+
+def create_download_folder_if_not_exist():
+    os.makedirs(DOWNLOAD_FOLDER,exist_ok=True)
+
+def save_file(binary_file,file_name:str):
+    create_download_folder_if_not_exist()
+    if binary_file is not None and file_name is not None :
+        file_path = os.path.join(DOWNLOAD_FOLDER,file_name)
+        open(file_path, 'wb').write(binary_file)
+        return file_path
+    else :
+        print("Pas de fichier")
+        return None
+
+def get_prompt_with_file_content(prompt:str,file_path:str):
+    full_prompt = prompt
+    if file_path:
+        file_extension = os.path.splitext(file_path)[1].lower()
+        print(f"--- Fichier fourni : {file_path} (Type: {file_extension}) ---")
+        full_prompt = (
+            f"{prompt}\n\n"
+            f"Voici le chemin du fichier joint : {file_path}\n"
+        )
+    return full_prompt
+
+@tool
+def extract_text_from_file(file_path: str) -> str:
+    """
+    Extrait le texte d'un fichier.
+    Ne fonctionne qu'avec les fichier texte (txt, csv, json,etc.).
+    Args:
+        file_path (str): Chemin du fichier à traiter.
+    Returns:
+        str: Contenu textuel extrait du fichier.
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return f.read()
+
+@tool
+def convert_excel_to_text(file_path: str) -> str:
+    """
+    Convertit un fichier Excel en texte brut.Ne fonctionne qu'avec les fichiers Excel (.xlsx, .xls).
+    Args:
+        file_path (str): Chemin du fichier Excel à convertir.
+    Returns:
+        str: Contenu textuel extrait du fichier Excel.
+    """
+    try:
+        df = pd.read_excel(file_path)
+        return df.to_string(index=False)
+    except Exception as e:
+        return f"Erreur lors de la conversion du fichier Excel : {e}"
+
+@tool
+def delete_tmp_files() -> None:
+    """
+    Supprime les fichiers temporaires.
+    """
+    try:
+        folder = Path(DOWNLOAD_FOLDER)
+        for file in folder.iterdir():
+            if file.is_file():
+                file.unlink()
+                print(f"Fichier temporaire supprimé : {file.name}")
+    except Exception as e:
+        print(f"Erreur lors de la suppression du fichier : {e}")

app.py

@@ -4,20 +4,12 @@ import requests
 import inspect
 import pandas as pd
 
+from Final_Assignment_Template.agent.agent import BasicAgent
+
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -80,7 +72,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            submitted_answer = agent(question_text,task_id)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:

requirements.txt

@@ -1,2 +1,17 @@
 gradio
-requests
+requests
+tools
+hf_xet
+wikipedia
+langchain_community
+langchain[google-genai]
+smolagents[toolkit]
+smolagents
+litellm
+python-dotenv
+wikipedia-api
+beautifulsoup4
+duckduckgo-search
+yt_dlp
+google-generativeai
+openpyxl