ajout system prompt

agent.py

@@ -10,12 +10,12 @@ from langchain_huggingface import HuggingFaceEndpoint
 from langgraph.graph import START, StateGraph, MessagesState
 from langgraph.prebuilt import tools_condition, ToolNode
 
-from tools import WebSearchTool, WebContentTool
+from tools import WebSearchTool, WebContentTool, WikipediaSearchTool
 #, AudioToTextTool, SpreadsheetParserTool, StringUtilitiesTool 
 
 import config
 
-# Configuration du logging
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
@@ -25,16 +25,16 @@ logger = logging.getLogger("Agent")
 
 class LangGraphAgent:
     """
-    Agent avancé utilisant LangGraph et le modèle Qwen3-30B-A3B
+    Advanced agent using LangGraph and the Qwen3-30B-A3B model
     """
     
     def __init__(self, verbose: bool = True):
         """
-        Initialise l'agent avec ses outils et sa configuration.
+        Initialize the agent with its tools and configuration.
         """
         self.verbose = verbose
         
-        # Initialisation du modèle
+        # Initialize the model
         self.llm = HuggingFaceEndpoint(
             repo_id="Qwen/Qwen2.5-Coder-32B-Instruct",
             huggingfacehub_api_token=config.HUGGINGFACE_API_KEY,
@@ -42,21 +42,24 @@ class LangGraphAgent:
             temperature = config.TEMPERATURE
         )
         
-        # Charger les outils
+        # Load tools
         self.tools = self._setup_tools()
         
-        # Créer le graphe d'exécution
+        # Create the execution graph
         self.workflow = self._create_workflow()
     
     def _setup_tools(self) -> List[BaseTool]:
-        """Configure et retourne les outils disponibles pour l'agent"""
+        """Configure and return the available tools for the agent"""
         tools = []
         
-        # Ajouter les outils selon la configuration
+        # Add tools according to configuration
         if config.ENABLE_WEB_SEARCH:
             tools.append(WebSearchTool())
             tools.append(WebContentTool())
             
+        if config.ENABLE_WIKIPEDIA_SEARCH:
+            tools.append(WikipediaSearchTool())
+            
         # if config.ENABLE_AUDIO_TO_TEXT:
         #     tools.append(AudioToTextTool())
             
@@ -66,13 +69,13 @@ class LangGraphAgent:
         # if config.ENABLE_STRING_UTILITIES:
         #     tools.append(StringUtilitiesTool())
         
-        logger.info(f"Agent initialisé avec {len(tools)} outils")
+        logger.info(f"Agent initialized with {len(tools)} tools")
         return tools
     
     def _create_workflow(self) -> StateGraph:
-        """Crée le graphe d'exécution de l'agent"""
+        """Create the agent's execution graph"""
         
-        # Définir le prompt
+        # Define the prompt
         prompt = ChatPromptTemplate.from_messages([
             ("system", config.DEFAULT_SYSTEM_MESSAGE),
             MessagesPlaceholder(variable_name="chat_history"),
@@ -80,9 +83,9 @@ class LangGraphAgent:
             MessagesPlaceholder(variable_name="agent_scratchpad"),
         ])
         
-        # Définir les nodes
+        # Define the nodes
         def assistant(state: MessagesState):
-            # Utiliser le prompt pour formater les messages
+            # Use the prompt to format messages
             messages = prompt.format_messages(
                 chat_history=state["messages"][:-1],
                 input=state["messages"][-1].content,
@@ -90,14 +93,14 @@ class LangGraphAgent:
             )
             return {"messages": [self.llm.invoke(messages)]}
         
-        # Créer le graphe
+        # Create the graph
         builder = StateGraph(MessagesState)
         
-        # Ajouter les nodes
+        # Add nodes
         builder.add_node("assistant", assistant)
         builder.add_node("tools", ToolNode(self.tools))
         
-        # Ajouter les edges
+        # Add edges
         builder.add_edge(START, "assistant")
         builder.add_conditional_edges(
             "assistant",
@@ -105,60 +108,59 @@ class LangGraphAgent:
         )
         builder.add_edge("tools", "assistant")
         
-        # Compiler le graphe
+        # Compile the graph
         return builder.compile()
     
     def __call__(self, question: str) -> str:
         """
-        Répond à une question en utilisant l'agent.
+        Answer a question using the agent.
         
         Args:
-            question: La question à laquelle répondre
+            question: The question to answer
             
         Returns:
-            La réponse de l'agent
+            The agent's answer
         """
         if not question.strip():
-            return "Veuillez poser une question."
+            return "Please ask a question."
             
         try:
-            logger.info(f"Question reçue: {question[:50]}...")
+            logger.info(f"Question received: {question[:50]}...")
             
-            # Exécuter le workflow
+            # Execute the workflow
             result = self.workflow.invoke({
                 "messages": [HumanMessage(content=question)]
             })
             
-            # Extraire la réponse finale
+            # Extract the final answer
             final_message = result["messages"][-1].content
-            if "FINAL ANSWER:" in final_message:
-                return final_message.split("FINAL ANSWER:")[1].strip()
+            # 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)}" 
+            logger.error(f"Error processing the question: {str(e)}")
+            return f"Sorry, an error occurred: {str(e)}" 
 
 if __name__ == "__main__":
-    # Créer une instance de l'agent
+    # Create an instance of the agent
     agent = LangGraphAgent(verbose=True)
     
-    # Question à tester
+    # Question to test
     question = "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia."
     
-    # Obtenir la réponse
+    # Get the answer
     response = agent(question)
     
-    # Afficher la réponse
+    # Display the answer
     print("\nQuestion:", question)
-    print("\nRéponse:", response) 
+    print("\nAnswer:", response) 
 
-    # Question à tester
-    question ="In the video https://www.youtube.com/watch?v=L1vXCYZAYYM, what is the highest number of bird species to be on camera simultaneously?"
+    # Question to test
+    question = ".rewsna eht sa \"tfel\" drow eht fo etisoppo eht etirw ,ecnetnes siht dnatsrednu uoy fI"
     
     # Obtenir la réponse
     response = agent(question)
-    
     # Afficher la réponse
     print("\nQuestion:", question)
     print("\nRéponse:", response) 

config.py

@@ -16,7 +16,8 @@ TEMPERATURE = 0.7
 RETRY_ATTEMPTS = 3
 
 # Configuration des outils
-ENABLE_WEB_SEARCH = True
+ENABLE_WEB_SEARCH = False
+ENABLE_WIKIPEDIA_SEARCH = True
 ENABLE_AUDIO_TO_TEXT = False
 ENABLE_SPREADSHEET_PARSER = False
 ENABLE_STRING_UTILITIES = False

requirements.txt

@@ -12,3 +12,4 @@ pandas
 openpyxl
 pydub
 huggingface-hub
+wikipedia

tools/__init__.py

@@ -1,4 +1,4 @@
-from .web_tools import WebSearchTool, WebContentTool
+from .web_tools import WebSearchTool, WebContentTool, WikipediaSearchTool
 # from .audio_tools import AudioToTextTool
 # from .spreadsheet_tools import SpreadsheetParserTool
 # from .string_tools import StringUtilitiesTool
@@ -6,6 +6,7 @@ from .web_tools import WebSearchTool, WebContentTool
 __all__ = [
     'WebSearchTool',
     'WebContentTool',
+    'WikipediaSearchTool',
     # 'AudioToTextTool',
     # 'SpreadsheetParserTool',
     # 'StringUtilitiesTool'

tools/web_tools.py

@@ -3,31 +3,56 @@ from langchain.tools import BaseTool
 from typing import Optional, Type
 import requests
 from bs4 import BeautifulSoup
+import wikipedia
+
+
+class WikipediaSearchTool(BaseTool):
+    name: str = "wikipedia_search"
+    description: str = "Search for information on Wikipedia using a given term or subject"
+    args_schema: Optional[Type] = None
+
+    def _run(self, query: str) -> str:
+        """Synchronous Wikipedia search"""
+        try:
+            wikipedia.set_lang("en")  
+            summary = wikipedia.summary(query, sentences=3)
+            return summary
+        except wikipedia.exceptions.DisambiguationError as e:
+            return f"Ambiguity: multiple possible results for '{query}': {e.options[:5]}"
+        except wikipedia.exceptions.PageError:
+            return f"No page found for '{query}'."
+        except Exception as e:
+            return f"Error during Wikipedia search: {str(e)}"
+
+    async def _arun(self, query: str) -> str:
+        """Asynchronous Wikipedia search (fallback to sync)"""
+        return self._run(query)
+
 
 class WebSearchTool(BaseTool):
     name: str = "web_search"
-    description: str = "Recherche des informations sur le web à partir d'un terme de recherche"
+    description: str = "Search for information on the web using a search term"
     args_schema: Optional[Type] = None
     
     def _run(self, query: str) -> str:
-        """Exécute une recherche web et retourne les résultats pertinents"""
+        """Execute a web search and return relevant results"""
         try:
             search_tool = DuckDuckGoSearchRun()
             return search_tool.run(query)
         except Exception as e:
-            return f"Erreur lors de la recherche web: {str(e)}"
+            return f"Error during web search: {str(e)}"
     
     async def _arun(self, query: str) -> str:
-        """Version asynchrone de l'outil"""
+        """Asynchronous version of the tool"""
         return self._run(query)
 
 class WebContentTool(BaseTool):
     name: str = "fetch_web_content"
-    description: str = "Récupère le contenu d'une page web à partir d'une URL"
+    description: str = "Retrieve the content of a web page from a URL"
     args_schema: Optional[Type] = None
     
     def _run(self, url: str) -> str:
-        """Récupère et nettoie le contenu d'une page web"""
+        """Retrieve and clean web page content"""
         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"
@@ -35,32 +60,32 @@ class WebContentTool(BaseTool):
             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}"
+                return f"Error retrieving content: {response.status_code}"
             
-            # Extraction du contenu avec BeautifulSoup
+            # Extract content with BeautifulSoup
             soup = BeautifulSoup(response.text, 'html.parser')
             
-            # Supprimer les scripts, styles et autres éléments non pertinents
+            # Remove scripts, styles and other irrelevant elements
             for element in soup(['script', 'style', 'header', 'footer', 'nav']):
                 element.decompose()
             
-            # Extraire le texte principal
+            # Extract main text
             text = soup.get_text(separator='\n')
             
-            # Nettoyer le texte (espaces multiples, lignes vides)
+            # Clean text (multiple spaces, empty lines)
             lines = [line.strip() for line in text.split('\n') if line.strip()]
             cleaned_text = '\n'.join(lines)
             
-            # Limiter la longueur du texte retourné
+            # Limit text length
             max_length = 5000
             if len(cleaned_text) > max_length:
-                cleaned_text = cleaned_text[:max_length] + "... (contenu tronqué)"
+                cleaned_text = cleaned_text[:max_length] + "... (content truncated)"
             
             return cleaned_text
             
         except Exception as e:
-            return f"Erreur lors de la récupération du contenu web: {str(e)}"
+            return f"Error retrieving web content: {str(e)}"
     
     async def _arun(self, url: str) -> str:
-        """Version asynchrone de l'outil"""
+        """Asynchronous version of the tool"""
         return self._run(url)