first commit

.env-example

@@ -0,0 +1,6 @@
+# Configurez vos clés API ici et renommez ce fichier en .env
+OPENAI_API_KEY=votre_clé_api_openai_ici
+
+# Autres configurations
+# TEMPERATURE=0.7
+# MAX_TOKENS=4096 

README.md

@@ -12,4 +12,48 @@ hf_oauth: true
 hf_oauth_expiration_minutes: 480
 ---
 
+# Agent IA avancé avec LangChain
+
+Ce projet implémente un agent IA avancé utilisant LangChain et des outils personnalisés pour répondre aux questions de manière intelligente.
+
+## Fonctionnalités
+
+- **Agent basé sur LangChain**: Utilise l'architecture d'agent de LangChain pour une réponse structurée et itérative aux questions
+- **Outils intégrés**: Recherche web, récupération de contenu web, calcul, parsing JSON, et plus
+- **Interface Gradio**: Interface utilisateur intuitive pour tester l'agent et soumettre des réponses
+- **Mémorisation des conversations**: L'agent maintient un historique des interactions
+
+## Configuration
+
+1. Clonez ce dépôt
+2. Installez les dépendances: `pip install -r requirements.txt`
+3. Copiez `.env-example` en `.env` et configurez votre clé API OpenAI
+
+## Structure du projet
+
+- `app.py`: Point d'entrée principal de l'application avec l'interface Gradio
+- `agent.py`: Implémentation de l'agent avancé avec LangChain
+- `config.py`: Configuration du projet
+- `tools/`: Dossier contenant les outils personnalisés pour l'agent
+  - `web_tools.py`: Outils pour la recherche web et la récupération de contenu
+  - `utils.py`: Outils utilitaires (date, calculatrice, parsing JSON)
+
+## Utilisation
+
+1. Lancez l'application: `python app.py`
+2. Connectez-vous avec votre compte Hugging Face
+3. Utilisez l'onglet "Test de l'agent" pour tester des questions individuelles
+4. Utilisez l'onglet "Évaluation complète" pour soumettre toutes les réponses
+
+## Personnalisation
+
+Vous pouvez personnaliser l'agent en:
+- Ajoutant de nouveaux outils dans le dossier `tools/`
+- Modifiant le message système dans `config.py`
+- Ajustant les paramètres de génération (température, etc.)
+
+---
+
+Créé pour le cours Hugging Face Agent Course - Final Assignment
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agent.py

@@ -0,0 +1,188 @@
+import os
+import logging
+from typing import List, Optional, Dict, Any
+
+from langchain.agents import AgentExecutor
+from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
+from langchain.schema import SystemMessage, HumanMessage
+from langchain.prompts import MessagesPlaceholder
+from langchain_openai import ChatOpenAI
+from langchain.memory import ConversationBufferMemory
+from langchain_core.messages import AIMessage
+from langchain.callbacks.manager import CallbackManager
+from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+
+from tools import WebSearchTool, WebContentTool, CurrentDateTool, JsonParserTool, CalculatorTool
+import config
+
+# Configuration du logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger("Agent")
+
+class AdvancedAgent:
+    """
+    Agent avancé utilisant LangChain et des outils personnalisés
+    pour répondre aux questions de manière plus intelligente.
+    """
+    
+    def __init__(self, 
+                 model_name: str = config.DEFAULT_MODEL,
+                 api_key: Optional[str] = None,
+                 temperature: float = config.TEMPERATURE,
+                 system_message: str = config.DEFAULT_SYSTEM_MESSAGE,
+                 verbose: bool = True):
+        """
+        Initialise l'agent avec ses outils et sa configuration.
+        
+        Args:
+            model_name: Nom du modèle à utiliser
+            api_key: Clé API OpenAI (prend celle de l'environnement si non spécifiée)
+            temperature: Valeur de température pour la génération de texte
+            system_message: Message système pour l'agent
+            verbose: Afficher les logs détaillés
+        """
+        self.model_name = model_name
+        self.temperature = temperature
+        self.system_message = system_message
+        self.verbose = verbose
+        
+        # Utilise la clé API fournie ou celle des variables d'environnement
+        self.api_key = api_key or config.OPENAI_API_KEY
+        if not self.api_key:
+            logger.warning("Aucune clé API OpenAI trouvée. Certaines fonctionnalités peuvent ne pas fonctionner.")
+            
+        # Initialisation du modèle
+        callback_manager = CallbackManager([StreamingStdOutCallbackHandler()]) if verbose else None
+        self.llm = ChatOpenAI(
+            model=self.model_name,
+            temperature=self.temperature,
+            api_key=self.api_key,
+            verbose=self.verbose,
+            callback_manager=callback_manager
+        )
+        
+        # Charger les outils
+        self.tools = self._setup_tools()
+        
+        # Initialiser la mémoire
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True
+        )
+        
+        # Créer l'agent
+        self.agent = self._create_agent()
+    
+    def _setup_tools(self) -> List:
+        """Configure et retourne les outils disponibles pour l'agent"""
+        tools = []
+        
+        # Ajouter les outils selon la configuration
+        if config.ENABLE_WEB_SEARCH:
+            tools.append(WebSearchTool())
+            tools.append(WebContentTool())
+            
+        if config.ENABLE_CALCULATOR:
+            tools.append(CalculatorTool())
+            
+        if config.ENABLE_DATE_TOOL:
+            tools.append(CurrentDateTool())
+        
+        # Toujours ajouter l'outil JSON parser
+        tools.append(JsonParserTool())
+        
+        logger.info(f"Agent initialisé avec {len(tools)} outils")
+        return tools
+    
+    def _create_agent(self) -> AgentExecutor:
+        """Crée et configure l'exécuteur d'agent"""
+        
+        # Définir le prompt
+        prompt = [
+            SystemMessage(content=self.system_message),
+            MessagesPlaceholder(variable_name="chat_history"),
+            HumanMessage(content="{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+        
+        # Créer l'agent
+        agent = OpenAIFunctionsAgent(
+            llm=self.llm,
+            tools=self.tools,
+            prompt=prompt
+        )
+        
+        # Créer l'exécuteur d'agent
+        agent_executor = AgentExecutor(
+            agent=agent,
+            tools=self.tools,
+            memory=self.memory,
+            verbose=self.verbose,
+            max_iterations=10,
+            early_stopping_method="generate"
+        )
+        
+        return agent_executor
+    
+    def __call__(self, question: str) -> str:
+        """
+        Répond à une question en utilisant l'agent.
+        
+        Args:
+            question: La question à laquelle répondre
+            
+        Returns:
+            La réponse de l'agent
+        """
+        if not question.strip():
+            return "Veuillez poser une question."
+            
+        try:
+            logger.info(f"Question reçue: {question[:50]}...")
+            
+            # Exécuter l'agent
+            response = self.agent.invoke({"input": question})
+            
+            # Extraire la réponse
+            answer = response.get("output", "Je n'ai pas pu générer de réponse.")
+            
+            logger.info(f"Réponse générée: {answer[:50]}...")
+            return answer
+            
+        except Exception as e:
+            logger.error(f"Erreur lors du traitement de la question: {str(e)}")
+            return f"Désolé, une erreur s'est produite: {str(e)}"
+    
+    def reset_memory(self):
+        """Réinitialise la mémoire de l'agent"""
+        self.memory.clear()
+        logger.info("Mémoire de l'agent réinitialisée")
+        
+    def get_last_interactions(self, count: int = 5) -> List[Dict[str, Any]]:
+        """
+        Retourne les dernières interactions de l'agent
+        
+        Args:
+            count: Nombre d'interactions à retourner
+            
+        Returns:
+            Liste des dernières interactions
+        """
+        history = self.memory.chat_memory.messages
+        
+        interactions = []
+        for i in range(0, len(history), 2):
+            if i + 1 < len(history):
+                human_msg = history[i].content if hasattr(history[i], 'content') else str(history[i])
+                ai_msg = history[i+1].content if hasattr(history[i+1], 'content') else str(history[i+1])
+                
+                interactions.append({
+                    "question": human_msg,
+                    "answer": ai_msg
+                })
+        
+        return interactions[-count:] 

app.py

@@ -3,23 +3,34 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from dotenv import load_dotenv
+
+# Importer notre agent avancé
+from agent import AdvancedAgent
+import config
+
+# Charger les variables d'environnement
+load_dotenv()
 
-# (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):
+DEFAULT_API_URL = config.DEFAULT_API_URL
+
+# Initialiser l'agent
+agent = None
+
+def initialize_agent():
+    """Initialise l'agent s'il n'est pas déjà initialisé"""
+    global agent
+    if agent is None:
+        try:
+            agent = AdvancedAgent(verbose=False)
+            return True
+        except Exception as e:
+            print(f"Erreur lors de l'initialisation de l'agent: {e}")
+            return False
+    return True
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
@@ -38,13 +49,15 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
+    # 1. Instantiate Agent
     try:
-        agent = BasicAgent()
+        if not initialize_agent():
+            return "Impossible d'initialiser l'agent. Vérifiez les logs pour plus d'informations.", None
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
+    
+    # In the case of an app running as a hugging Face space, this link points toward your codebase
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
 
@@ -140,9 +153,21 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         return status_message, results_df
 
 
+# Fonction pour tester l'agent sur une seule question
+def test_agent(question):
+    if not initialize_agent():
+        return "Impossible d'initialiser l'agent. Vérifiez les logs pour plus d'informations."
+    
+    try:
+        answer = agent(question)
+        return answer
+    except Exception as e:
+        return f"Erreur: {str(e)}"
+
+
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# Agent avec LangChain - Évaluation")
     gr.Markdown(
         """
         **Instructions:**
@@ -192,5 +217,8 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    # Initialiser l'agent au démarrage
+    initialize_agent()
+    
+    print("Launching Gradio Interface for Advanced Agent Evaluation...")
     demo.launch(debug=True, share=False)

config.py

@@ -0,0 +1,30 @@
+import os
+from dotenv import load_dotenv
+
+# Charger les variables d'environnement
+load_dotenv()
+
+# Configuration de l'API
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# Configuration de l'agent
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+DEFAULT_MODEL = "gpt-3.5-turbo"  # Modèle par défaut
+
+# Configurations diverses
+MAX_TOKENS = 4096
+TEMPERATURE = 0.7
+RETRY_ATTEMPTS = 3
+
+# Configuration des outils
+ENABLE_WEB_SEARCH = True
+ENABLE_CALCULATOR = True
+ENABLE_DATE_TOOL = True
+
+# Message système par défaut pour l'agent
+DEFAULT_SYSTEM_MESSAGE = """You are a general AI assistant. I will ask you a question. 
+Report your thoughts, and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. 
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. 
+If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. 
+If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. 
+If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string. """

requirements.txt

@@ -1,2 +1,8 @@
 gradio
-requests
+requests
+langchain
+langchain-openai
+langchain-core
+python-dotenv
+bs4
+pandas

tools/__init__.py

@@ -0,0 +1,10 @@
+from tools.web_tools import WebSearchTool, WebContentTool
+from tools.utils import CurrentDateTool, JsonParserTool, CalculatorTool
+
+__all__ = [
+    "WebSearchTool",
+    "WebContentTool",
+    "CurrentDateTool",
+    "JsonParserTool",
+    "CalculatorTool"
+] 

tools/web_tools.py

@@ -0,0 +1,98 @@
+import requests
+from bs4 import BeautifulSoup
+from typing import List, Dict, Any
+from langchain.tools import BaseTool
+
+class WebSearchTool(BaseTool):
+    name = "web_search"
+    description = "Recherche des informations sur le web à partir d'un terme de recherche"
+    
+    def _run(self, query: str) -> str:
+        """Exécute une recherche web et retourne les résultats pertinents"""
+        try:
+            # Cette fonction simule une recherche web
+            # Dans un cas réel, vous pourriez utiliser l'API Google ou Bing
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+            }
+            search_url = f"https://www.google.com/search?q={query.replace(' ', '+')}"
+            response = requests.get(search_url, headers=headers)
+            
+            if response.status_code != 200:
+                return f"Erreur lors de la recherche: {response.status_code}"
+            
+            # Extraction des résultats avec BeautifulSoup
+            soup = BeautifulSoup(response.text, 'html.parser')
+            search_results = []
+            
+            # Extrait les titres et descriptions des résultats
+            for result in soup.select("div.g"):
+                title_elem = result.select_one("h3")
+                if not title_elem:
+                    continue
+                
+                title = title_elem.get_text()
+                link = result.select_one("a")["href"] if result.select_one("a") else ""
+                snippet = result.select_one("div.VwiC3b")
+                description = snippet.get_text() if snippet else ""
+                
+                if title and description:
+                    search_results.append(f"Titre: {title}\nLien: {link}\nDescription: {description}\n---")
+            
+            if not search_results:
+                return "Aucun résultat trouvé pour cette recherche."
+            
+            return "\n".join(search_results[:3])  # Limite à 3 résultats
+            
+        except Exception as e:
+            return f"Erreur lors de la recherche web: {str(e)}"
+    
+    async def _arun(self, query: str) -> str:
+        """Version asynchrone de l'outil"""
+        # Implémentation asynchrone si nécessaire
+        return self._run(query)
+
+
+class WebContentTool(BaseTool):
+    name = "fetch_web_content"
+    description = "Récupère le contenu d'une page web à partir d'une URL"
+    
+    def _run(self, url: str) -> str:
+        """Récupère et nettoie le contenu d'une page web"""
+        try:
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+            }
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code != 200:
+                return f"Erreur lors de la récupération du contenu: {response.status_code}"
+            
+            # Extraction du contenu avec BeautifulSoup
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Supprimer les scripts, styles et autres éléments non pertinents
+            for element in soup(['script', 'style', 'header', 'footer', 'nav']):
+                element.decompose()
+            
+            # Extraire le texte principal
+            text = soup.get_text(separator='\n')
+            
+            # Nettoyer le texte (espaces multiples, lignes vides)
+            lines = [line.strip() for line in text.split('\n') if line.strip()]
+            cleaned_text = '\n'.join(lines)
+            
+            # Limiter la longueur du texte retourné
+            max_length = 5000
+            if len(cleaned_text) > max_length:
+                cleaned_text = cleaned_text[:max_length] + "... (contenu tronqué)"
+            
+            return cleaned_text
+            
+        except Exception as e:
+            return f"Erreur lors de la récupération du contenu web: {str(e)}"
+    
+    async def _arun(self, url: str) -> str:
+        """Version asynchrone de l'outil"""
+        # Implémentation asynchrone si nécessaire
+        return self._run(url)