Added logger; Optimized query flow; Fixed DuckDuckGo tools; Tweaked system prompts.

.gitignore

@@ -57,6 +57,7 @@ venv.bak/
 # IDE related
 .idea/
 .vscode/
+.github/
 *.swp
 *.swo
 
@@ -66,6 +67,5 @@ venv.bak/
 # Rejected by git
 *.png
 
-# Other files
-_to_ignore/
-.github/
+# Log files
+logs/

alfred.py

@@ -2,24 +2,27 @@ from langgraph.graph import START, END, StateGraph
 from langgraph.graph.state import CompiledStateGraph
 
 from typing import Dict, Any, TypedDict, Literal, Optional
-import asyncio
+import logging
+import datetime
+from pathlib import Path
 
+from args import Args
 from management import Manager, Assistant
 
 
 # Maximum number of interactions between Assistant and Manager
 MAX_INTERACTIONS = 5
 # Maximum depth of recursion for Manager
-MAX_DEPTH = 3
+MAX_DEPTH = 2
 # For both Assistant and Manager:
 TEMPERATURE = 0.7
-MAX_TOKENS = 100
+MAX_TOKENS = 2000
 
 
 class State(TypedDict):
     """State for the agent graph."""
     initial_query: str
-    current_message: str
+    current_message: Optional[str]
     nr_interactions: int
     final_response: Optional[str]
 
@@ -44,7 +47,11 @@ class GraphBuilder:
         
         Uses the existing Assistant implementation.
         """
-        response = await self.assistant_agent.query(state["current_message"])
+        if state["current_message"] is None:
+            # First time, just forward the query to the manager
+            response = state["initial_query"]
+        else:
+            response = await self.assistant_agent.query(state["current_message"])
         
         # Check if this is a final answer
         if self.final_answer_hint in response:
@@ -62,6 +69,9 @@ class GraphBuilder:
         
         Uses the existing Manager implementation.
         """
+        if state["current_message"] is None:
+            raise ValueError("manager_node called with no current_message in state")
+
         response = await self.manager_agent.query(state["current_message"])
         
         state["current_message"] = response
@@ -107,6 +117,9 @@ class GraphBuilder:
             "manager": If the Assistant has decided to continue the conversation
             "final_answer": If the Assistant has decided to provide a final answer
         """
+        if state["current_message"] is None:
+            raise ValueError("should_continue conditional edge was reached with no current_message in state")
+
         message = state["current_message"]
         
         if state["nr_interactions"] >= MAX_INTERACTIONS or self.final_answer_hint in message:
@@ -146,6 +159,9 @@ class Alfred:
 
     def __init__(self):
         print("Agent initialized.")
+
+        Args.LOGGER = self.set_logger()
+
         self.graph_builder = GraphBuilder()
         self.agent_graph = self.graph_builder.build_agent_graph()
 
@@ -169,7 +185,7 @@ class Alfred:
         """
         initial_state: State = {
             "initial_query": query,
-            "current_message": query,
+            "current_message": None,
             "nr_interactions": 0,
             "final_response": None
         }
@@ -177,3 +193,37 @@ class Alfred:
 
         result = await self.agent_graph.ainvoke(initial_state)
         return result
+    
+    def set_logger(self) -> logging.Logger:
+        """
+        Configure and return a logger with a file handler that writes to logs/<current date-time>.txt
+        
+        Returns:
+            logging.Logger: Configured logger instance
+        """
+        # Create logger
+        logger = logging.getLogger("Alfred")
+        logger.setLevel(logging.INFO)
+        
+        # Create formatter
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        
+        # Create logs directory if it doesn't exist
+        logs_dir = Path('logs')
+        logs_dir.mkdir(exist_ok=True)
+        
+        # Generate log filename with current date-time
+        current_time = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        log_filename = f"{current_time}.txt"
+        log_filepath = logs_dir / log_filename
+        
+        # Create file handler
+        file_handler = logging.FileHandler(log_filepath)
+        file_handler.setLevel(logging.INFO)
+        file_handler.setFormatter(formatter)
+        
+        # Add handler to logger
+        logger.addHandler(file_handler)
+        
+        logger.info(f"Logging started at {current_time}")
+        return logger

args.py

@@ -1,5 +1,7 @@
 
 from enum import Enum
+from logging import Logger
+from typing import Optional
 
 
 class LLMInterface(Enum):
@@ -10,6 +12,7 @@ class LLMInterface(Enum):
 
 
 class Args:
+    LOGGER: Optional[Logger] = None
     primary_llm_interface=LLMInterface.OPENAILIKE
     # secondary_llm_interface=LLMInterface.HUGGINGFACE
     vlm_interface=LLMInterface.HUGGINGFACE

diagrams/architecture.puml

@@ -92,7 +92,11 @@ component "LlamaIndex Flow" as LlamaIndexFlow CANVAS_COLOR {
     node WebSearch TOOLBOX_WEBSEARCH_COLOR [
     <b>WebSearch</b>
     ----
-    duck_duck_go_tools
+    duckduckgo_text_search
+    ____
+    duckduckgo_images_search
+    ____
+    duckduckgo_videos_search
     ]
     node Encryption TOOLBOX_ENCRYPTION_COLOR [
     <b>Encryption</b>

itf_agent.py

@@ -1,19 +1,23 @@
+from llama_index.core.tools import FunctionTool
 from llama_index.core.workflow import Context
 
+import logging
 import os
+import re
 from typing import List
 
-from args import LLMInterface
+from args import Args, LLMInterface
 from llm_factory import LLMFactory
 from llama_index.core.agent.workflow import AgentWorkflow
 
 
 class IAgent():
-    def __init__(self, temperature, max_tokens, sys_prompt_file, llm_itf: LLMInterface):
-        print(f"Agent initialized using {sys_prompt_file} prompt file.")
+    def __init__(self, temperature, max_tokens, sys_prompt_filename, llm_itf: LLMInterface):
+        print(f"Agent initialized using {sys_prompt_filename} prompt file.")
+        self.name = self._format_name(sys_prompt_filename)
         self.temperature, self.max_tokens = temperature, max_tokens
         # Load the system prompt from a file
-        system_prompt_path = os.path.join(os.getcwd(), "system_prompts", sys_prompt_file)
+        system_prompt_path = os.path.join(os.getcwd(), "system_prompts", sys_prompt_filename)
         self.system_prompt = ""
         with open(system_prompt_path, "r") as file:
             self.system_prompt = file.read().strip()
@@ -24,8 +28,16 @@ class IAgent():
         self.llm = LLMFactory.create(llm_itf, self.system_prompt, temperature, max_tokens)
         self.agent = self._setup_agent()
         self.ctx = Context(self.agent)
+
+    @staticmethod
+    def _format_name(sys_prompt_filename: str) -> str:
+        # Remove file extension
+        name_without_ext = os.path.splitext(sys_prompt_filename)[0]
+        # Remove numbers and special characters from the beginning
+        cleaned_name = re.sub(r'^[^a-zA-Z]+', '', name_without_ext)
+        return cleaned_name
     
-    def setup_tools(self) -> List:
+    def setup_tools(self) -> List[FunctionTool]:
         """
         Set up the tools for this agent.
         
@@ -60,7 +72,12 @@ class IAgent():
         # Create tools from slaves: each tool calls slave.query(question) asynchronously
         slave_tools = []
         for slave in self.slaves:
-            slave_tools.append(slave.query)
+            slave_tool = FunctionTool.from_defaults(
+                name=f"call_{slave.name}",
+                description=f"Calls agent {slave.name} with a given query.",
+                fn=slave.query
+            )
+            slave_tools.append(slave_tool)
 
         self.tools.extend(slave_tools)
 
@@ -88,11 +105,19 @@ class IAgent():
         Returns:
             str: The response from the agent as a string.
         """
+        if Args.LOGGER is None:
+            raise RuntimeError("LOGGER must be defined before querying the agent.")
+
+        separator = "=============================="
+        Args.LOGGER.log(logging.INFO, f"\n{separator}\nAgent '{self.name}' has been queried !\nINPUT:\n{question}\n")
+
         if has_context:
             response = await self.agent.run(question, ctx=self.ctx)
         else:
             response = await self.agent.run(question)
         response = str(response)
+
+        Args.LOGGER.log(logging.INFO, f"\nAgent '{self.name}' produced OUTPUT:\n{response}\n{separator}\n")
         return response
 
     def clear_context(self):

management.py

@@ -18,6 +18,9 @@ class Manager(IAgent):
         self.max_depth = max_depth
         self.current_depth = 0
 
+        # We track the current query to forward it to the team when needed.
+        self.current_query = ""
+
         self.solver = Solver(temperature, max_tokens)
         self.summarizer = Summarizer(temperature, max_tokens)
 
@@ -32,9 +35,18 @@ class Manager(IAgent):
                 name="require_solution",
                 description="Request direct solutions for specific tasks. Use when a task is simple enough to be solved directly.",
                 fn=self.require_solution
+            ),
+            FunctionTool.from_defaults(
+                name="forward_query",
+                description="Request direct solutions for the current query. Use as a first attempt and to make the team aware of the task's context.",
+                fn=self.forward_query
             )
         ]
 
+    async def query(self, question: str, has_context=True) -> str:
+        self.current_query = question
+        return await super().query(question, has_context)
+
     async def require_break_up(self, tasks: List[str], try_solving = False) -> str:
         """
         Break down complex tasks into simpler subtasks recursively up to max_depth.
@@ -78,7 +90,7 @@ class Manager(IAgent):
         Returns:
             Summarized report of solutions for all tasks
         """
-        print(f"-> require_solution tool used (input: {tasks}) !")
+        print(f"-> require_solution tool used with input: {tasks} !")
         if not tasks:
             return "Error: No tasks provided to solve. Please provide at least one task."
         
@@ -90,3 +102,6 @@ class Manager(IAgent):
 
         report = await self.summarizer.query(observation.strip())
         return report
+
+    async def forward_query(self) -> str:
+        return await self.require_solution([self.current_query])

solver.py

@@ -1,3 +1,5 @@
+from llama_index.core.tools import FunctionTool
+
 from typing import List
 
 from itf_agent import IAgent
@@ -14,15 +16,19 @@ class Researcher(IAgent):
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "05_researcher.txt", Args.primary_llm_interface)
 
-    def setup_tools(self) -> List:
-        return Toolbox.web_search.duck_duck_go_tools
+    def setup_tools(self) -> List[FunctionTool]:
+        return [
+                Toolbox.web_search.duckduckgo_text_search,
+                Toolbox.web_search.duckduckgo_images_search,
+                Toolbox.web_search.duckduckgo_videos_search
+            ]
 
 
 class EncryptionExpert(IAgent):
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "06_encryption_expert.txt", Args.primary_llm_interface)
 
-    def setup_tools(self) -> List:
+    def setup_tools(self) -> List[FunctionTool]:
         return [
                 Toolbox.encryption.ascii_encode,
                 Toolbox.encryption.ascii_decode,
@@ -44,7 +50,7 @@ class MathExpert(IAgent):
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "07_math_expert.txt", Args.primary_llm_interface)
 
-    def setup_tools(self) -> List:
+    def setup_tools(self) -> List[FunctionTool]:
         return [
             Toolbox.math.symbolic_calc,
             Toolbox.math.unit_converter,
@@ -64,11 +70,17 @@ class ImageHandler(IAgent):
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "09_image_handler.txt", Args.vlm_interface)
 
+    async def query(self, question: str, has_context=True) -> str:
+        return "Image Handler is not available due to maintainance !"
+
 
 class VideoHandler(IAgent):
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "10_video_handler.txt", Args.vlm_interface)
 
+    async def query(self, question: str, has_context=True) -> str:
+        return "Video Handler is not available due to maintainance !"
+
 
 class Solver(IAgent):
     def __init__(self, temperature, max_tokens):

system_prompts/01_assistant.txt

@@ -7,4 +7,13 @@ VERY IMPORTANT - QUERY RESOLUTION PROTOCOL:
 4. When you have gathered enough information to provide a final answer, format your response as such:
   "Final answer: [your concise answer]"
 - Your final answer will be evaluated by exact comparison with the correct answer, therefore it must be precise, accurate, and contain no redundant words.
-- Include "Final answer:" string in your response only when you are confident you have the correct solution, or when you are prompted to wrap up an answer.
+- Include "Final answer:" string in your response only when you are confident you have the correct solution, or when you are prompted to wrap up an answer.
+
+Response length:
+    - **Keep It Brief, But Clear**: Provide direct and efficient responses with minimal explanation. 
+    Offer slightly more detail than a single word but avoid unnecessary elaboration. 
+    Only include additional context when strictly relevant.
+    - For your final answer be extreme precision is paramount ! It will be evaluated by exact comparison with the correct answer, 
+    therefore it must be precise, accurate, and contain no redundant words, otherwise it will be considered wrong, even if the information provided is correct.
+
+/no_think

system_prompts/02_manager.txt

@@ -14,6 +14,7 @@ AVAILABLE TOOLS:
    - Optional parameter try_solving (default: False) attempts to solve tasks at maximum depth
    - Returns a summarized report of the task breakdown
    - Use when a task appears too complex to be solved directly
+   - WARNING: This tool is expensive ! Do not overuse it.
 
 2. require_solution(tasks: List[str]) -> str
    - Use to request direct solutions for specific tasks
@@ -21,10 +22,20 @@ AVAILABLE TOOLS:
    - Returns a summarized report of solutions for all tasks
    - Use when tasks are simple enough to be solved directly
 
+3. forward_query() -> str
+   - Use to request direct solutions for the current query
+   - Returns a summarized solution for the current query
+   - Use as a first attempt and to make the team aware of the task's context
+
+
+MANDATORY REQUIREMENT: NEVER TRY TO SOLVE PROBLEMS YOURSELF! THAT MIGHT LEAD TO HALLUCINATIONS! USE `require_solution` (OR `forward_query`) INSTEAD!
+YOUR TEAM HAS ACCESS TO A WIDE VARIETY OF TOOLS INCLUDING DECRIPRION, WEB SEARCH, MATH TOOLS, IMAGE AND VIDEO HANDLERS AND EVEN A REASONING ENGINE !
+IN MANY CASES, HOWEVER, YOU MAY RECEIVE HALLUCINATED ANSWERS, SO YOU MUST BE SCEPTIC AND VERIFY ! 
+
 
 SUGGESTED EXECUTION FRAMEWORK:
-1. Evaluate the complexity of the task.
-2.1. If it is straightforward, request the solution from your team.
+1. Use `forward_query` to make the team aware of the full context and get a direct solution.
+2.1. If the solution is corect, wrap up your answer.
 2.2. Otherwise break it up into sub-tasks. It is best to aim for 3 to 5 sub-tasks.
     Note: You must do an initial effort here. Do not just request the break up of an unprocessed task.
 3. Reflect on the sub-tasks you just created. Evaluate whether they are still too complex and require further distillation, 
@@ -37,10 +48,11 @@ NOTE: When using the tools for steps 4 and 5, make sure to provide a clear descr
 OVERCOMING CHALLENGES:
 Sometimes, you might face uncommon tasks, where the suggested execution framework is not very applicable.
 Examples: a cryptic message, a task where obtaining the required information is blocked by another task...
-In that case, think about your task like solving a puzzle. Use appropriate actions in order to drive progress.
+You may still try `forward_query` at first to see if the team can handle the query directly, but if that doesn't 
+yield satisfactory results, think of your task like solving a puzzle. Use appropriate actions in order to drive progress.
 For example:
-1. You may craft tasks (such as "Decipher the following message <the cryptic message>"), and call `require_solution` tool.
-2. When the solution is provided:
+- You may craft tasks (such as "Decipher the following message <the cryptic message>"), and call `require_solution` tool.
+- When the solution is provided:
     - if there are no more blockers: you can apply the suggested execution framework on the deciphered message to solve the hidden query
     - else: craft additional tasks to deal with the blockers.
 NOTE: It is advised to use reflection for the tasks (or for the approach in general) to evaluate its dificulty.

system_prompts/03_solver.txt

@@ -1,5 +1,13 @@
 You are an elite problem-solving engine optimized for resolving complex challenges through systematic analysis and creative solution generation.
 
+YOU MUST ADHERE TO THE FOLLOWING RULES OF CONDUCT:
+- **Truth is Paramount! Eliminate Fabrications, Especially in Code!**: Hallucinations are not allowed!
+    1. **Verify Ruthlessly**: Cross-reference everything with reliable sources for accuracy. For code, confirm function/library existence and syntax.
+    2. **Uncertain? Admit It!**: Explicitly state uncertainty and the reason. Examples: "Uncertain if 'X' exists in 'Y'.", "Can't verify syntax.", "According to [source], [claim], but this is contested.".
+    3. **Scrutinize Relentlessly**: Review all outputs for errors. In code, check for undefined variables, non-existent methods, and syntax errors.
+    4. **Falsehood Detected? Retract Immediately!**: Correct if possible.
+    - **Ground Responses in Evidence!**: Use verifiable facts, not conjecture. Distinguish opinion from fact. Do not present unverifiable claims as truth. For code, rely on official documentation and best practices.
+
 COGNITIVE ARCHITECTURE:
 - Analytical decomposition of multifaceted problems
 - Parallel evaluation of solution pathways
@@ -20,7 +28,7 @@ AVAILABLE SPECIALIZED AGENTS:
 You have access to these specialized sub-agents that you can query for specific tasks:
 
 1. Summarizer: For condensing complex information
-2. Researcher: For web searches and finding current information
+2. Researcher: For web searches and finding current information. It uses DuckDuckGoSearchToolSpec().
 3. EncryptionExpert: For encryption/decryption tasks
 4. MathExpert: For mathematical calculations and conversions
 5. Reasoner: For logical reasoning and analysis

system_prompts/05_researcher.txt

@@ -3,11 +3,15 @@ You are a specialized search agent with the capability to search the web for cur
 Your goal is to provide accurate, up-to-date information from the web in response to user queries.
 
 AVAILABLE TOOLS:
-- DuckDuckGo search tools: Allow you to perform web searches to find current information
+- Web Search Tools:
+    - duckduckgo_text_search: Search the web for text content based on keywords
+    - duckduckgo_images_search: Search the web for images based on keywords
+    - duckduckgo_videos_search: Search the web for videos based on keywords
 
 When responding to questions:
 - Determine if the query requires searching the web for current information
-- Use the DuckDuckGo search tool to find relevant information
+- Select the appropriate search tool based on the content type needed (text, images, or videos)
+- Use clear, specific keywords for your search
 - Summarize and synthesize the information you find from search results
 - Always cite your sources by mentioning where the information came from
 - If the search results don't provide useful information, acknowledge this and explain why
@@ -27,6 +31,4 @@ When reformulating searches:
 - Add qualifiers like "latest," "recent," "explained," or "overview" as appropriate
 - Consider searching for specific time periods if date-sensitive information is needed
 
-Only use the search tool when appropriate. For simple questions or queries not requiring web information, respond directly without using the tool.
-
 Be persistent in your search efforts. Your goal is to provide the most accurate and helpful information possible to the user.

toolbox.py

@@ -1,6 +1,8 @@
 from llama_index.core.tools import FunctionTool
-from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
+# from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec  # I encountered some issues... Sometimes it doesn't work !
 
+
+from duckduckgo_search import DDGS
 import pint
 import sympy as sp
 
@@ -70,8 +72,86 @@ class _MathToolbox:
     )
 
 
+class _WebSearch:
+    @staticmethod
+    def duckduckgo_text_search(keywords, max_results=5) -> list[dict[str, str]]:
+        """DuckDuckGo text search.
+
+        Args:
+            keywords: keywords for query.
+            max_results: max number of results. If None, returns results only from the first response. Defaults to 5.
+
+        Returns:
+            List of dictionaries with search results, or None if there was an error.
+
+        Raises:
+            DuckDuckGoSearchException: Base exception for duckduckgo_search errors.
+            RatelimitException: Inherits from DuckDuckGoSearchException, raised for exceeding API request rate limits.
+            TimeoutException: Inherits from DuckDuckGoSearchException, raised for API request timeouts.
+        """
+        return DDGS().text(keywords, max_results=max_results)
+
+
+    @staticmethod
+    def duckduckgo_images_search(keywords, license = None, max_results=5) -> list[dict[str, str]]:
+        """DuckDuckGo images search.
+
+        Args:
+            keywords: keywords for query.
+            license: any (All Creative Commons), Public (PublicDomain),
+                Share (Free to Share and Use), ShareCommercially (Free to Share and Use Commercially),
+                Modify (Free to Modify, Share, and Use), ModifyCommercially (Free to Modify, Share, and
+                Use Commercially). Defaults to None.
+            max_results: max number of results. If None, returns results only from the first response. Defaults to 5.
+
+        Returns:
+            List of dictionaries with images search results.
+
+        Raises:
+            DuckDuckGoSearchException: Base exception for duckduckgo_search errors.
+            RatelimitException: Inherits from DuckDuckGoSearchException, raised for exceeding API request rate limits.
+            TimeoutException: Inherits from DuckDuckGoSearchException, raised for API request timeouts.
+        """
+        return DDGS().images(keywords, license_image=license, max_results=max_results)
+
+
+    @staticmethod
+    def duckduckgo_videos_search(keywords, license = None, max_results=5) -> list[dict[str, str]]:
+        """DuckDuckGo videos search.
+
+        Args:
+            keywords: keywords for query.
+            license: creativeCommon, youtube. Defaults to None.
+            max_results: max number of results. If None, returns results only from the first response. Defaults to 5.
+
+        Returns:
+            List of dictionaries with videos search results.
+
+        Raises:
+            DuckDuckGoSearchException: Base exception for duckduckgo_search errors.
+            RatelimitException: Inherits from DuckDuckGoSearchException, raised for exceeding API request rate limits.
+            TimeoutException: Inherits from DuckDuckGoSearchException, raised for API request timeouts.
+        """
+        return DDGS().videos(keywords, license_videos=license, max_results=max_results)
+
+
 class _WebSearchToolbox:
-    duck_duck_go_tools = DuckDuckGoSearchToolSpec().to_tool_list()
+    # duckduckgo_tools = DuckDuckGoSearchToolSpec().to_tool_list()  # I encountered some issues... Sometimes it doesn't work !
+    duckduckgo_text_search = FunctionTool.from_defaults(
+        name="duckduckgo_text_search",
+        description="DuckDuckGo text search",
+        fn=_WebSearch.duckduckgo_text_search
+    )
+    duckduckgo_images_search = FunctionTool.from_defaults(
+        name="duckduckgo_images_search",
+        description="DuckDuckGo images search",
+        fn=_WebSearch.duckduckgo_images_search
+    )
+    duckduckgo_videos_search = FunctionTool.from_defaults(
+        name="duckduckgo_videos_search",
+        description="DuckDuckGo videos search",
+        fn=_WebSearch.duckduckgo_videos_search
+    )
 
 
 class _Encryption: