Ajout tools de recherche et structuration agent

.env-example

@@ -1,6 +0,0 @@
-# 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 

.gitignore

@@ -0,0 +1,115 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+.env
+.venv
+env.bak/
+venv.bak/
+.python-version
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+pytest-*.xml
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Logs
+*.log
+logs/
+log/
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.DS_Store
+.project
+.pydevproject
+.settings/
+.vs/
+*.sublime-project
+*.sublime-workspace
+
+# Database
+*.db
+*.rdb
+*.sqlite
+*.sqlite3
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# macOS specific
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+._*
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# AI/model files
+*.h5
+*.pb
+*.onnx
+*.tflite
+*.pt
+*.pth
+*.weights
+
+# Temporary files
+tmp/
+temp/
+.tmp
+*.tmp

agent.py

@@ -1,18 +1,18 @@
 import os
 import logging
-from typing import List, Optional, Dict, Any
+from typing import List, Dict, Any, Tuple
+from langchain.tools import BaseTool
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from langchain_huggingface import HuggingFaceEndpoint
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import tools_condition, ToolNode
 
-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
+#, AudioToTextTool, SpreadsheetParserTool, StringUtilitiesTool 
 
-from tools import WebSearchTool, WebContentTool, CurrentDateTool, JsonParserTool, CalculatorTool
 import config
 
 # Configuration du logging
@@ -23,61 +23,30 @@ logging.basicConfig(
 )
 logger = logging.getLogger("Agent")
 
-class AdvancedAgent:
+class LangGraphAgent:
     """
-    Agent avancé utilisant LangChain et des outils personnalisés
-    pour répondre aux questions de manière plus intelligente.
+    Agent avancé utilisant LangGraph et le modèle Qwen3-30B-A3B
     """
     
-    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):
+    def __init__(self, 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
+        self.llm = HuggingFaceEndpoint(
+            endpoint_url=f"https://api-inference.huggingface.co/models/{config.MODEL_NAME}",
+            huggingfacehub_api_token=config.HUGGINGFACE_API_KEY,
         )
         
         # 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()
+        # Créer le graphe d'exécution
+        self.workflow = self._create_workflow()
     
-    def _setup_tools(self) -> List:
+    def _setup_tools(self) -> List[BaseTool]:
         """Configure et retourne les outils disponibles pour l'agent"""
         tools = []
         
@@ -86,47 +55,51 @@ class AdvancedAgent:
             tools.append(WebSearchTool())
             tools.append(WebContentTool())
             
-        if config.ENABLE_CALCULATOR:
-            tools.append(CalculatorTool())
+        # if config.ENABLE_AUDIO_TO_TEXT:
+        #     tools.append(AudioToTextTool())
             
-        if config.ENABLE_DATE_TOOL:
-            tools.append(CurrentDateTool())
-        
-        # Toujours ajouter l'outil JSON parser
-        tools.append(JsonParserTool())
+        # if config.ENABLE_SPREADSHEET_PARSER:
+        #     tools.append(SpreadsheetParserTool())
+            
+        # if config.ENABLE_STRING_UTILITIES:
+        #     tools.append(StringUtilitiesTool())
         
         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"""
+    def _create_workflow(self) -> StateGraph:
+        """Crée le graphe d'exécution de l'agent"""
         
         # Définir le prompt
-        prompt = [
-            SystemMessage(content=self.system_message),
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", config.DEFAULT_SYSTEM_MESSAGE),
             MessagesPlaceholder(variable_name="chat_history"),
-            HumanMessage(content="{input}"),
+            ("human", "{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"
+        # Définir les nodes
+        def assistant(state: MessagesState):
+            return {"messages": [self.llm.invoke(state["messages"])]}
+        
+        # Créer le graphe
+        builder = StateGraph(MessagesState)
+        
+        # Ajouter les nodes
+        builder.add_node("assistant", assistant)
+        builder.add_node("tools", ToolNode(self.tools))
+        
+        # Ajouter les edges
+        builder.add_edge(START, "assistant")
+        builder.add_conditional_edges(
+            "assistant",
+            tools_condition,
         )
+        builder.add_edge("tools", "assistant")
         
-        return agent_executor
+        # Compiler le graphe
+        return builder.compile()
     
     def __call__(self, question: str) -> str:
         """
@@ -144,45 +117,17 @@ class AdvancedAgent:
         try:
             logger.info(f"Question reçue: {question[:50]}...")
             
-            # Exécuter l'agent
-            response = self.agent.invoke({"input": question})
+            # Exécuter le workflow
+            result = self.workflow.invoke({
+                "messages": [HumanMessage(content=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
+            # Extraire la réponse finale
+            final_message = result["messages"][-1].content
+            if "FINAL ANSWER:" in final_message:
+                return final_message.split("FINAL ANSWER:")[1].strip()
+            return final_message
             
         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:] 
+            return f"Désolé, une erreur s'est produite: {str(e)}" 

app.py

@@ -6,7 +6,7 @@ import pandas as pd
 from dotenv import load_dotenv
 
 # Importer notre agent avancé
-from agent import AdvancedAgent
+from agent import LangGraphAgent
 import config
 
 # Charger les variables d'environnement
@@ -23,7 +23,7 @@ def initialize_agent():
     global agent
     if agent is None:
         try:
-            agent = AdvancedAgent(verbose=False)
+            agent = LangGraphAgent(verbose=False)
             return True
         except Exception as e:
             print(f"Erreur lors de l'initialisation de l'agent: {e}")

config.py

@@ -7,9 +7,9 @@ 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
+# Configuration du modèle
+MODEL_NAME = "Qwen/Qwen3-30B-A3B"
+HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY", "")
 
 # Configurations diverses
 MAX_TOKENS = 4096
@@ -18,13 +18,13 @@ RETRY_ATTEMPTS = 3
 
 # Configuration des outils
 ENABLE_WEB_SEARCH = True
-ENABLE_CALCULATOR = True
-ENABLE_DATE_TOOL = True
+ENABLE_AUDIO_TO_TEXT = False
+ENABLE_SPREADSHEET_PARSER = False
+ENABLE_STRING_UTILITIES = False
 
 # 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. """
+DEFAULT_SYSTEM_MESSAGE = """You are a helpful assistant tasked with answering questions using a set of tools. 
+Now, 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.
+Your answer should only start with "FINAL ANSWER: ", then follows with the answer. """

requirements.txt

@@ -1,8 +1,14 @@
 gradio
+gradio[oauth]
 requests
 langchain
-langchain-openai
+langchain-community
 langchain-core
+langchain-huggingface
+langgraph
 python-dotenv
 bs4
-pandas
+pandas
+openpyxl
+pydub
+huggingface-hub

tools/__init__.py

@@ -1,10 +1,12 @@
-from tools.web_tools import WebSearchTool, WebContentTool
-from tools.utils import CurrentDateTool, JsonParserTool, CalculatorTool
+from .web_tools import WebSearchTool, WebContentTool
+# from .audio_tools import AudioToTextTool
+# from .spreadsheet_tools import SpreadsheetParserTool
+# from .string_tools import StringUtilitiesTool
 
 __all__ = [
-    "WebSearchTool",
-    "WebContentTool",
-    "CurrentDateTool",
-    "JsonParserTool",
-    "CalculatorTool"
-] 
+    'WebSearchTool',
+    'WebContentTool',
+    # 'AudioToTextTool',
+    # 'SpreadsheetParserTool',
+    # 'StringUtilitiesTool'
+]

tools/audio_tools.py

@@ -0,0 +1,47 @@
+import os
+from typing import Optional
+from langchain.tools import BaseTool
+import requests
+from pydub import AudioSegment
+import tempfile
+
+class AudioToTextTool(BaseTool):
+    name = "audio_to_text"
+    description = "Convertit un fichier audio en texte en utilisant l'API Hugging Face"
+    
+    def _run(self, audio_path: str) -> str:
+        """Convertit un fichier audio en texte"""
+        try:
+            # Vérifier si le fichier existe
+            if not os.path.exists(audio_path):
+                return f"Erreur: Le fichier {audio_path} n'existe pas"
+            
+            # Convertir le fichier audio en format WAV si nécessaire
+            audio = AudioSegment.from_file(audio_path)
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+                audio.export(temp_file.name, format="wav")
+                temp_path = temp_file.name
+            
+            # Appeler l'API Hugging Face pour la transcription
+            API_URL = "https://api-inference.huggingface.co/models/facebook/wav2vec2-large-960h-lv60-self"
+            headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_API_KEY')}"}
+            
+            with open(temp_path, "rb") as f:
+                data = f.read()
+            
+            response = requests.post(API_URL, headers=headers, data=data)
+            
+            # Nettoyer le fichier temporaire
+            os.unlink(temp_path)
+            
+            if response.status_code != 200:
+                return f"Erreur lors de la transcription: {response.text}"
+            
+            return response.json().get("text", "Aucun texte transcrit")
+            
+        except Exception as e:
+            return f"Erreur lors de la conversion audio en texte: {str(e)}"
+    
+    async def _arun(self, audio_path: str) -> str:
+        """Version asynchrone de l'outil"""
+        return self._run(audio_path) 

tools/spreadsheet_tools.py

@@ -0,0 +1,43 @@
+import pandas as pd
+from typing import List, Dict, Any
+from langchain.tools import BaseTool
+
+class SpreadsheetParserTool(BaseTool):
+    name = "spreadsheet_parser"
+    description = "Analyse un fichier Excel et extrait des informations spécifiques"
+    
+    def _run(self, file_path: str, query: str) -> str:
+        """Analyse un fichier Excel et répond à une requête spécifique"""
+        try:
+            # Lire le fichier Excel
+            df = pd.read_excel(file_path)
+            
+            # Analyser la requête pour déterminer l'action à effectuer
+            if "somme" in query.lower() or "total" in query.lower():
+                # Trouver les colonnes numériques
+                numeric_cols = df.select_dtypes(include=['number']).columns
+                if len(numeric_cols) > 0:
+                    return f"Somme des colonnes numériques:\n{df[numeric_cols].sum().to_string()}"
+                else:
+                    return "Aucune colonne numérique trouvée dans le fichier"
+            
+            elif "moyenne" in query.lower() or "average" in query.lower():
+                numeric_cols = df.select_dtypes(include=['number']).columns
+                if len(numeric_cols) > 0:
+                    return f"Moyenne des colonnes numériques:\n{df[numeric_cols].mean().to_string()}"
+                else:
+                    return "Aucune colonne numérique trouvée dans le fichier"
+            
+            elif "premières lignes" in query.lower() or "first rows" in query.lower():
+                return f"Premières lignes du fichier:\n{df.head().to_string()}"
+            
+            else:
+                # Par défaut, retourner un résumé du fichier
+                return f"Résumé du fichier:\nNombre de lignes: {len(df)}\nColonnes: {', '.join(df.columns)}\nTypes de données:\n{df.dtypes.to_string()}"
+                
+        except Exception as e:
+            return f"Erreur lors de l'analyse du fichier Excel: {str(e)}"
+    
+    async def _arun(self, file_path: str, query: str) -> str:
+        """Version asynchrone de l'outil"""
+        return self._run(file_path, query) 

tools/string_tools.py

@@ -0,0 +1,35 @@
+from typing import List, Dict, Any
+from langchain.tools import BaseTool
+
+class StringUtilitiesTool(BaseTool):
+    name = "string_utilities"
+    description = "Fournit des utilitaires pour manipuler les chaînes de caractères"
+    
+    def _run(self, text: str, operation: str) -> str:
+        """Effectue une opération sur une chaîne de caractères"""
+        try:
+            if operation == "reverse":
+                return text[::-1]
+            elif operation == "uppercase":
+                return text.upper()
+            elif operation == "lowercase":
+                return text.lower()
+            elif operation == "capitalize":
+                return text.capitalize()
+            elif operation == "title":
+                return text.title()
+            elif operation == "strip":
+                return text.strip()
+            elif operation == "split":
+                return str(text.split())
+            elif operation == "join":
+                return " ".join(text.split())
+            else:
+                return f"Opération non supportée: {operation}. Opérations disponibles: reverse, uppercase, lowercase, capitalize, title, strip, split, join"
+                
+        except Exception as e:
+            return f"Erreur lors de la manipulation de la chaîne: {str(e)}"
+    
+    async def _arun(self, text: str, operation: str) -> str:
+        """Version asynchrone de l'outil"""
+        return self._run(text, operation) 

tools/web_tools.py

@@ -1,61 +1,30 @@
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain.tools import BaseTool
+from typing import Optional, Type
 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"
+    name: str = "web_search"
+    description: str = "Recherche des informations sur le web à partir d'un terme de recherche"
+    args_schema: Optional[Type] = None
     
     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
-            
+            search_tool = DuckDuckGoSearchRun()
+            return search_tool.run(query)
         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"
+    name: str = "fetch_web_content"
+    description: str = "Récupère le contenu d'une page web à partir d'une URL"
+    args_schema: Optional[Type] = None
     
     def _run(self, url: str) -> str:
         """Récupère et nettoie le contenu d'une page web"""
@@ -63,7 +32,7 @@ class WebContentTool(BaseTool):
             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)
+            response = requests.get(url, headers=headers, timeout=10)
             
             if response.status_code != 200:
                 return f"Erreur lors de la récupération du contenu: {response.status_code}"
@@ -94,5 +63,4 @@ class WebContentTool(BaseTool):
     
     async def _arun(self, url: str) -> str:
         """Version asynchrone de l'outil"""
-        # Implémentation asynchrone si nécessaire
         return self._run(url)