New approach: langgraph only

agent_builder.py

@@ -1,321 +0,0 @@
-from pathlib import Path
-import yaml
-from typing import Dict, List, Any
-
-
-class AgentBuilder:
-    @staticmethod
-    def initialize(agent_name: str):
-        """Create agent folder and an empty 'yaml' file
-
-        Args:
-            agent_name: Name of the agent to create
-        """
-        # Create base agents directory if it doesn't exist
-        agents_base_dir = Path("agents")
-        agents_base_dir.mkdir(exist_ok=True)
-
-        # Create agent-specific directory
-        agent_dir = agents_base_dir / agent_name
-        agent_dir.mkdir(exist_ok=True)
-
-        # Create YAML file with initial content
-        yaml_file = agent_dir / f"design.yaml"
-
-        # Initial YAML content with nodes list and example node
-        initial_content = {
-            "nodes": [
-                {
-                    "name": "START",
-                    "connections": ["example_node"],
-                    "description": "This is the mandatory initial node `START` !"
-                },
-                {
-                    "name": "example_node",
-                    "connections": [],
-                    "description": "This is an example node"
-                }
-            ]
-        }
-
-        # Write the YAML content to the file
-        with open(yaml_file, "w") as f:
-            yaml.dump(initial_content, f, default_flow_style=False, sort_keys=False)
-
-    @classmethod
-    def setup(cls, agent_name: str):
-        """Create the graph and the test python files as well as a 'puml' diagram
-
-        Args:
-            agent_name: Name of the agent to set up
-        """
-        design_data = cls._validate_design(agent_name)
-
-        cls._create_graph_file(agent_name, design_data)
-        cls._create_test_file(agent_name)
-        cls._create_puml_file(agent_name, design_data)
-
-    @classmethod
-    def _validate_design(cls, agent_name: str) -> Dict[str, List[Dict[str, Any]]]:
-        """Validate the design.yaml file structure
-
-        Args:
-            agent_name: Name of the agent to validate
-
-        Returns:
-            The parsed design data if valid
-
-        Raises:
-            ValueError: If design file is invalid or missing required elements
-        """
-        yaml_path = Path(f"agents/{agent_name}/design.yaml")
-
-        if not yaml_path.exists():
-            raise ValueError(f"Design file not found at {yaml_path}")
-
-        with open(yaml_path, 'r') as f:
-            design_data = yaml.safe_load(f)
-
-        # Check if nodes list exists
-        if not design_data or 'nodes' not in design_data or not isinstance(design_data['nodes'], list):
-            raise ValueError("Design file must contain a 'nodes' list")
-            
-        # Check if START node is defined
-        start_node_exists = any(node.get('name') == "START" for node in design_data['nodes'])
-        if not start_node_exists:
-            raise ValueError("Design file must contain a 'START' node")
-
-        # Validate each node
-        for i, node in enumerate(design_data['nodes']):
-            if not isinstance(node, dict):
-                raise ValueError(f"Node at index {i} must be a dictionary")
-
-            if 'name' not in node:
-                raise ValueError(f"Node at index {i} is missing a 'name' field")
-
-            if 'description' not in node:
-                raise ValueError(f"Node '{node.get('name', f'at index {i}')}' is missing a 'description' field")
-
-            if 'connections' not in node or not isinstance(node['connections'], list):
-                raise ValueError(f"Node '{node.get('name')}' must have a 'connections' list")
-
-        return design_data
-
-    @classmethod
-    def _create_graph_file(cls, agent_name: str, design_data: Dict[str, List[Dict[str, Any]]]):
-        """Create the graph.py file with the necessary classes
-
-        Args:
-            agent_name: Name of the agent
-            design_data: The validated design data
-        """
-        nodes = design_data['nodes']
-
-        # Prepare node methods and conditional edge methods
-        node_methods = []
-        edge_methods = []
-
-        # Generate node method for each node
-        for node in nodes:
-            node_name = node['name']
-            node_desc = node['description']
-
-            node_method = f'''
-    def {node_name}_node(self, state):
-        """
-        {node_desc}
-        """
-        # TODO: To implement...
-        pass
-'''
-            if node_name != "START":
-                node_methods.append(node_method)
-
-            # Check if this node has more than one connection (needs conditional edge)
-            if len(node['connections']) > 1:
-                connections_str = ", ".join([f'"{conn}"' for conn in node['connections']])
-                edge_method = f'''
-    def {node_name}_edge(self, state):
-        """
-        Conditional edge for {node_name} node.
-        Returns one of: {connections_str}
-        """
-        # TODO: To implement...
-        pass
-'''
-                edge_methods.append(edge_method)
-
-        # Build the file content
-        file_content = f'''from typing import Dict, Any
-from langgraph.graph import StateGraph, END, START
-from langgraph.graph.state import CompiledStateGraph
-
-
-class State:
-    """
-    State class for the agent graph.
-    """
-    # TODO: Define state structure
-    pass
-
-
-class Nodes:
-    """
-    Collection of node functions for the agent graph.
-    """
-{"".join(node_methods)}
-
-
-class Edges:
-    """
-    Collection of conditional edge functions for the agent graph.
-    """
-{"".join(edge_methods)}
-
-
-class GraphBuilder:
-    def __init__(self):
-        """
-        Initializes the GraphBuilder.
-        """
-        self.nodes = Nodes()
-        self.edges = Edges()
-        # TODO: Implement the desired constructor.
-        pass
-        
-    def build_agent_graph(self) -> CompiledStateGraph:
-        """Build and return the agent graph."""
-        graph = StateGraph(State)
-        
-        # Add all nodes
-{cls._generate_add_nodes_code(nodes)}
-        
-        # Add edges
-{cls._generate_regular_edges_code(nodes)}
-{cls._generate_conditional_edges_code(nodes)}        
-        return graph.compile()
-'''
-        # Write to file
-        graph_file_path = Path(f"agents/{agent_name}/graph.py")
-        with open(graph_file_path, 'w') as f:
-            f.write(file_content)
-
-    @staticmethod
-    def _generate_add_nodes_code(nodes):
-        """Generate code for adding nodes to the graph"""
-        code_lines = []
-        for node in nodes:
-            if node["name"] != "START":
-                code_lines.append(f'        graph.add_node("{node["name"]}", self.nodes.{node["name"]}_node)')
-        return "\n".join(code_lines)
-
-    @staticmethod
-    def _generate_conditional_edges_code(nodes):
-        """Generate code for adding conditional edges to the graph"""
-        code_lines = []
-        for node in nodes:
-            if len(node['connections']) > 1:
-                destinations = ", ".join([f'{conn}: {conn}' if conn in ["START", "END"] else f'"{conn}": "{conn}"' for conn in node['connections']])
-                code_lines.append(f'''        graph.add_conditional_edges(
-            "{node["name"]}",
-            self.edges.{node["name"]}_edge,
-            {{
-                {destinations}
-            }}
-        )''')
-        return "\n".join(code_lines) if code_lines else ""
-
-    @staticmethod
-    def _generate_regular_edges_code(nodes):
-        """Generate code for adding regular edges to the graph"""
-        code_lines = []
-        for node in nodes:
-            if len(node['connections']) == 1:
-                start_key = node["name"] if node["name"] in ["START", "END"] else f'"{node["name"]}"'
-                end_key = node["connections"][0] if node["connections"][0] in ["START", "END"] else f'"{node["connections"][0]}"'
-                code_lines.append(f'        graph.add_edge({start_key}, {end_key})')
-        return "\n".join(code_lines) if code_lines else ""
-
-    @staticmethod
-    def _create_test_file(agent_name: str):
-        """Create the test.py file
-
-        Args:
-            agent_name: Name of the agent
-        """
-        test_file_content = f'''# Test file for {agent_name} agent
-from graph import GraphBuilder
-
-def test_agent():
-    """
-    Test the {agent_name} agent functionality.
-    """
-    # Create the graph
-    builder = GraphBuilder()
-    graph = builder.build_agent_graph()
-    
-    # TODO: Add test code here
-    print("Testing {agent_name} agent...")
-    
-    # Example test
-    # result = graph.invoke({{"input": "Test input"}})
-    # print(f"Result: {{result}}")
-
-if __name__ == "__main__":
-    test_agent()
-'''
-
-        # Write to file
-        test_file_path = Path(f"agents/{agent_name}/test.py")
-        with open(test_file_path, 'w') as f:
-            f.write(test_file_content)
-
-    @staticmethod
-    def _create_puml_file(agent_name: str, design_data: Dict[str, List[Dict[str, Any]]]):
-        """Create the design.puml file for diagram visualization
-
-        Args:
-            agent_name: Name of the agent
-            design_data: The validated design data
-        """
-        nodes = design_data['nodes']
-
-        # Start the PlantUML content
-        puml_content = f'''@startuml {agent_name}
-!define NOT_IMPLEMENTED_NODE_COLOR #IndianRed
-!define IMPLEMENTED_NODE_COLOR #Gold
-!define TESTED_NODE_COLOR #LawnGreen
-!define TERMINAL_NODE_COLOR #DodgerBlue
-
-'''
-
-        # Add node descriptions
-        for node in nodes:
-            puml_content += f'node {node["name"]} {node["status"]}_NODE_COLOR[\n  {node["description"]}\n]\n\n'
-        puml_content += f'node END TERMINAL_NODE_COLOR[\n  This is the final Node !\n]\n\n'
-
-        # Add connections
-        for node in nodes:
-            node_name = node["name"]
-            for connection in node["connections"]:
-                if connection == "END":
-                    puml_content += f'{node_name} --> END\n'
-                else:
-                    puml_content += f'{node_name} --> {connection}\n'
-
-        # End the PlantUML content
-        puml_content += '\n@enduml'
-
-        # Write to file
-        puml_file_path = Path(f"agents/{agent_name}/design.puml")
-        with open(puml_file_path, 'w') as f:
-            f.write(puml_content)
-
-    @staticmethod
-    def validate(agent_name: str):
-        pass
-
-
-if __name__ == "__main__":
-    # AgentBuilder.initialize("universal_solver")
-    AgentBuilder.setup("universal_solver")

agent_builder_template/design_puml.txt

@@ -1,15 +0,0 @@
-@startuml universal_solver
-!define NOT_IMPLEMENTED_NODE_COLOR #IndianRed
-!define IMPLEMENTED_NODE_COLOR #Gold
-!define TESTED_NODE_COLOR #LawnGreen
-!define TERMINAL_NODE_COLOR #DodgerBlue
-
->>>>>NODES<<<<<
-
-node END TERMINAL_NODE_COLOR[
-  This is the final Node !
-]
-
->>>>>EDGES<<<<<
-
-@enduml

agent_builder_template/design_yaml.txt

@@ -1,11 +0,0 @@
-nodes:
-- name: START
-  connections:
-  - example_node
-  description: This is the mandatory initial node `START` !
-  status: TERMINAL
-
-- name: example_node
-  connections: [END]
-  description: This is an example node
-  status: NOT_IMPLEMENTED

agent_builder_template/graph.txt

@@ -1,21 +0,0 @@
-class State:
-    """
-    State class for the agent graph.
-    """
-    # TODO: Define state structure
-    pass
-
-
-class Nodes:
-    """
-    Collection of node functions for the agent graph.
-    """
-    >>>>>NODE_METHODS<<<<<
-
-
-
-class Edges:
-    """
-    Collection of conditional edge functions for the agent graph.
-    """
-    >>>>>CONDITIONAL_EDGE_METHODS<<<<<

agent_builder_template/graph_builder.txt

@@ -1,24 +0,0 @@
-from typing import Dict, Any
-from langgraph.graph import StateGraph, END, START
-from langgraph.graph.state import CompiledStateGraph
-
-
-class GraphBuilder:
-    def __init__(self):
-        """
-        Initializes the GraphBuilder.
-        """
-        self.nodes = Nodes()
-        self.edges = Edges()
-        # TODO: Implement the desired constructor.
-        pass
-        
-    def build_agent_graph(self) -> CompiledStateGraph:
-        """Build and return the agent graph."""
-        graph = StateGraph(State)
-        
-        >>>>>NODES<<<<<
-        
-        >>>>>EDGES<<<<<
-        
-        return graph.compile()

agent_builder_template/test.txt

@@ -1,2 +0,0 @@
-from graph import State, Nodes, Edges
-from graph_builder import GraphBuilder

solver.py → agents.py

@@ -1,110 +1,82 @@
-from llama_index.core.tools import FunctionTool
+from args import Args
+from itf_agent import IAgent
 
-from typing import List
 
-from itf_agent import IAgent
-from toolbox import Toolbox
-from args import Args
+class Manager(IAgent):
+    """
+    Orchestrates the workflow by delegating tasks to specialized nodes and integrating their outputs
+    """
+    def __init__(self, temperature, max_tokens):
+        super().__init__(temperature, max_tokens, "01_manager.txt", Args.primary_llm_interface)
+
+
+class Auditor(IAgent):
+    """
+    Reviews manager's outputs for accuracy, safety, and quality
+    """
+    def __init__(self, temperature, max_tokens):
+        super().__init__(temperature, max_tokens, "02_auditor.txt", Args.primary_llm_interface)
 
 
 class Summarizer(IAgent):
+    """
+    Generates concise summaries of conversations or passages.
+    """
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "04_summarizer.txt", Args.primary_llm_interface)
 
 
+class Solver(IAgent):
+    """
+    Central problem-solving node that coordinates with specialized experts based on task requirements
+    """
+    def __init__(self, temperature, max_tokens):
+        super().__init__(temperature, max_tokens, "03_solver.txt", Args.primary_llm_interface)
+
+
 class Researcher(IAgent):
+    """
+    Retrieves and synthesizes information from various sources to answer knowledge-based questions
+    """
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "05_researcher.txt", Args.primary_llm_interface)
 
-    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):
+    """
+    Handles encryption/decryption tasks and encoding/decoding operations
+    """
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "06_encryption_expert.txt", Args.primary_llm_interface)
 
-    def setup_tools(self) -> List[FunctionTool]:
-        return [
-                Toolbox.encryption.ascii_encode,
-                Toolbox.encryption.ascii_decode,
-                Toolbox.encryption.base64_encode,
-                Toolbox.encryption.base64_decode,
-                Toolbox.encryption.caesar_cipher_encode,
-                Toolbox.encryption.caesar_cipher_decode,
-                Toolbox.encryption.caesar_cipher_brute_force,
-                Toolbox.encryption.reverse_string,
-                Toolbox.math.unit_converter
-            ]
-
-    def setup_slaves(self) -> List:
-        reasoner = Reasoner(self.temperature, self.max_tokens)
-        return [reasoner]
-
 
 class MathExpert(IAgent):
+    """
+    Performs mathematical calculations and solves numerical problems
+    """
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "07_math_expert.txt", Args.primary_llm_interface)
 
-    def setup_tools(self) -> List[FunctionTool]:
-        return [
-            Toolbox.math.symbolic_calc,
-            Toolbox.math.unit_converter,
-            ]
-
-    def setup_slaves(self) -> List:
-        reasoner = Reasoner(self.temperature, self.max_tokens)
-        return [reasoner]
-
 
 class Reasoner(IAgent):
+    """
+    Performs logical reasoning, inference, and step-by-step problem-solving
+    """
     def __init__(self, temperature, max_tokens):
         super().__init__(temperature, max_tokens, "08_reasoner.txt", Args.primary_llm_interface)
 
 
 class ImageHandler(IAgent):
+    """
+    Processes, analyzes, and generates information related to images
+    """
     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):
+    """
+    Processes, analyzes, and generates information related to videos
+    """
     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):
-        super().__init__(temperature, max_tokens, "03_solver.txt", Args.primary_llm_interface)
-
-    def setup_slaves(self) -> List:
-        summarizer = Summarizer(self.temperature, self.max_tokens)
-        researcher = Researcher(self.temperature, self.max_tokens)
-        encryption_expert = EncryptionExpert(self.temperature, self.max_tokens)
-        math_expert = MathExpert(self.temperature, self.max_tokens)
-        reasoner = Reasoner(self.temperature, self.max_tokens)
-        image_handler = ImageHandler(self.temperature, self.max_tokens)
-        video_handler = VideoHandler(self.temperature, self.max_tokens)
-
-        return [
-            summarizer,
-            researcher,
-            encryption_expert,
-            math_expert,
-            reasoner,
-            image_handler,
-            video_handler
-            ]
-
-
-# if __name__ == "__main__":
-#     pass

agents/universal_solver/design.puml

@@ -1,32 +0,0 @@
-@startuml universal_solver
-!define NOT_IMPLEMENTED_NODE_COLOR #IndianRed
-!define IMPLEMENTED_NODE_COLOR #Gold
-!define TESTED_NODE_COLOR #LawnGreen
-!define TERMINAL_NODE_COLOR #DodgerBlue
-
-node START TERMINAL_NODE_COLOR[
-  This is the mandatory initial node `START` !
-]
-
-node example_node_1 NOT_IMPLEMENTED_NODE_COLOR[
-  This is an example node
-]
-
-node example_node_2 IMPLEMENTED_NODE_COLOR[
-  This is another example node
-]
-
-node example_node_3 TESTED_NODE_COLOR[
-  This is yet another example node
-]
-
-node END TERMINAL_NODE_COLOR[
-  This is the final Node !
-]
-
-START --> example_node_1
-example_node_1 --> example_node_2
-example_node_2 --> example_node_3
-example_node_3 --> END
-
-@enduml

agents/universal_solver/design.yaml

@@ -1,21 +0,0 @@
-nodes:
-- name: START
-  connections:
-  - example_node_1
-  description: This is the mandatory initial node `START` !
-  status: TERMINAL
-
-- name: example_node_1
-  connections: [example_node_2]
-  description: This is an example node
-  status: NOT_IMPLEMENTED
-
-- name: example_node_2
-  connections: [example_node_3]
-  description: This is another example node
-  status: IMPLEMENTED
-
-- name: example_node_3
-  connections: [END]
-  description: This is yet another example node
-  status: TESTED

agents/universal_solver/graph.py

@@ -1,74 +0,0 @@
-from typing import Dict, Any
-from langgraph.graph import StateGraph, END, START
-from langgraph.graph.state import CompiledStateGraph
-
-
-class State:
-    """
-    State class for the agent graph.
-    """
-    # TODO: Define state structure
-    pass
-
-
-class Nodes:
-    """
-    Collection of node functions for the agent graph.
-    """
-
-    def example_node_1_node(self, state):
-        """
-        This is an example node
-        """
-        # TODO: To implement...
-        pass
-
-    def example_node_2_node(self, state):
-        """
-        This is another example node
-        """
-        # TODO: To implement...
-        pass
-
-    def example_node_3_node(self, state):
-        """
-        This is yet another example node
-        """
-        # TODO: To implement...
-        pass
-
-
-
-class Edges:
-    """
-    Collection of conditional edge functions for the agent graph.
-    """
-
-
-
-class GraphBuilder:
-    def __init__(self):
-        """
-        Initializes the GraphBuilder.
-        """
-        self.nodes = Nodes()
-        self.edges = Edges()
-        # TODO: Implement the desired constructor.
-        pass
-        
-    def build_agent_graph(self) -> CompiledStateGraph:
-        """Build and return the agent graph."""
-        graph = StateGraph(State)
-        
-        # Add all nodes
-        graph.add_node("example_node_1", self.nodes.example_node_1_node)
-        graph.add_node("example_node_2", self.nodes.example_node_2_node)
-        graph.add_node("example_node_3", self.nodes.example_node_3_node)
-        
-        # Add edges
-        graph.add_edge(START, "example_node_1")
-        graph.add_edge("example_node_1", "example_node_2")
-        graph.add_edge("example_node_2", "example_node_3")
-        graph.add_edge("example_node_3", END)
-        
-        return graph.compile()

agents/universal_solver/test.py

@@ -1,20 +0,0 @@
-# Test file for universal_solver agent
-from graph import GraphBuilder
-
-def test_agent():
-    """
-    Test the universal_solver agent functionality.
-    """
-    # Create the graph
-    builder = GraphBuilder()
-    graph = builder.build_agent_graph()
-    
-    # TODO: Add test code here
-    print("Testing universal_solver agent...")
-    
-    # Example test
-    # result = graph.invoke({"input": "Test input"})
-    # print(f"Result: {result}")
-
-if __name__ == "__main__":
-    test_agent()

alfred.py

@@ -1,13 +1,8 @@
-from langgraph.graph import START, END, StateGraph
-from langgraph.graph.state import CompiledStateGraph
-
-from typing import Dict, Any, TypedDict, Literal, Optional
-import logging
-import datetime
-from pathlib import Path
+from typing import Dict, Any
 
 from args import Args
-from management import Manager, Assistant
+from graph import State
+from graph_builder import GraphBuilder
 
 
 # Maximum number of interactions between Assistant and Manager
@@ -19,173 +14,11 @@ TEMPERATURE = 0.7
 MAX_TOKENS = 2000
 
 
-class State(TypedDict):
-    """State for the agent graph."""
-    initial_query: str
-    current_message: Optional[str]
-    nr_interactions: int
-    final_response: Optional[str]
-
-
-class GraphBuilder:
-    def __init__(self):
-        """
-        Initializes the GraphBuilder.
-        """
-        self.assistant_agent = Assistant(TEMPERATURE, MAX_TOKENS)
-        self.manager_agent = Manager(TEMPERATURE, MAX_TOKENS, MAX_DEPTH)
-        self.final_answer_hint = "Final answer:"
-
-    def clear_chat_history(self):
-        self.assistant_agent.clear_context()
-        self.manager_agent.clear_context()
-
-    async def assistant_node(self, state: State) -> State:
-        """
-        Assistant agent that evaluates the query and decides whether to give a final answer
-        or continue the conversation with the Manager.
-
-        Uses the existing Assistant implementation.
-        """
-        if Args.LOGGER is None:
-            raise RuntimeError("LOGGER must be defined before running the assistant_node.")
-
-        Args.LOGGER.log(logging.INFO, "********** assistant_node **********")
-
-        if state["current_message"] is None:
-            # First time, just forward the query to the manager
-            response = state["initial_query"]
-        else:
-            assistent_input = f"This is the initial user query:\n\n{state["initial_query"]}\n\nThe manager provided the following answer:\n\n{state["current_message"]}\n"
-            response = await self.assistant_agent.query(assistent_input)
-
-        # Check if this is a final answer
-        if self.final_answer_hint in response:
-            # Extract the text after final answer hint
-            final_response = response.split(self.final_answer_hint)[-1]
-            final_response = final_response.strip()
-            state["final_response"] = final_response
-
-        state["current_message"] = response
-        state["nr_interactions"] += 1
-
-        return state
-
-    async def manager_node(self, state: State) -> State:
-        """
-        Manager agent that handles the queries from the Assistant and provides responses.
-        
-        Uses the existing Manager implementation.
-        """
-        if Args.LOGGER is None:
-            raise RuntimeError("LOGGER must be defined before running the manager_node.")
-
-        Args.LOGGER.log(logging.INFO, "********** manager_node **********")
-
-        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
-
-        return state
-
-    async def final_answer_node(self, state: State) -> State:
-        """
-        Final answer node that formats and returns the final response.
-        
-        If there's already a final answer in the state, it uses that.
-        Otherwise, it asks the assistant to formulate a final answer.
-        """
-        if Args.LOGGER is None:
-            raise RuntimeError("LOGGER must be defined before running the final_answer_node.")
-
-        Args.LOGGER.log(logging.INFO, "********** final_answer_node **********")
-
-        # If we already have a final answer, use it
-        final_response = state.get("final_response")
-        if final_response is not None:
-            Args.LOGGER.log(logging.INFO, f"==========\nFinal response:\n{final_response}\n==========")
-            return state
-        
-        # Otherwise, have the assistant formulate a final answer
-        prompt = f"Based on the conversation so far, provide a final answer to the original query:\n\n{state['initial_query']}"
-        state["current_message"] = prompt
-        response = await self.assistant_agent.query(prompt)
-        
-        # Format the response
-        if self.final_answer_hint not in response:
-            Args.LOGGER.log(logging.WARNING, f"Final_answer_hint '{self.final_answer_hint}' not in response !")
-            response = f"{self.final_answer_hint}{response}"
-        
-        # Extract the text after final answer hint
-        final_response = response.split(self.final_answer_hint)[-1]
-        final_response = final_response.strip()
-        state["final_response"] = final_response
-        Args.LOGGER.log(logging.INFO, f"==========\nFinal response:\n{final_response}\n==========")
-        
-        return state
-
-    def should_continue(self, state: State) -> Literal["manager", "final_answer"]:
-        """
-        Decides whether to continue to the Manager or to provide a final answer.
-        
-        Returns:
-            "manager": If the Assistant has decided to continue the conversation
-            "final_answer": If the Assistant has decided to provide a final answer
-        """
-        if Args.LOGGER is None:
-            raise RuntimeError("LOGGER must be defined before running the should_continue edge.")
-
-        Args.LOGGER.log(logging.INFO, "++++++++++ should_continue edge ++++++++++")
-
-        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:
-            Args.LOGGER.log(logging.INFO, "++++++++++ should_continue edge decision: final_answer ++++++++++")
-            return "final_answer"
-        Args.LOGGER.log(logging.INFO, "++++++++++ should_continue edge decision: manager ++++++++++")
-        return "manager"
-
-    def build_agent_graph(self) -> CompiledStateGraph:
-        """Build and return the agent graph."""
-        graph = StateGraph(State)
-
-        # Add the nodes with sync wrappers
-        graph.add_node("assistant", self.assistant_node)
-        graph.add_node("manager", self.manager_node)
-        graph.add_node("final_answer", self.final_answer_node)
-
-        # Add the edges
-        graph.add_edge(START, "assistant")
-
-        graph.add_conditional_edges(
-            "assistant",
-            self.should_continue,
-            {
-                "manager": "manager",
-                "final_answer": "final_answer"
-            }
-        )
-
-        graph.add_edge("manager", "assistant")
-
-        graph.add_edge("final_answer", END)
-
-        return graph.compile()
-
-
 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()
 
@@ -200,54 +33,19 @@ class Alfred:
     async def process_query(self, query: str) -> Dict[str, Any]:
         """
         Process a query through the agent graph.
-        
+
         Args:
             query: The initial query to process
-        
+
         Returns:
             The final state of the graph execution
         """
         initial_state: State = {
             "initial_query": query,
-            "current_message": None,
+            "messages": [],
             "nr_interactions": 0,
             "final_response": None
         }
-        self.graph_builder.clear_chat_history()
 
         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 with UTF-8 encoding to handle all Unicode characters
-        file_handler = logging.FileHandler(log_filepath, encoding='utf-8')
-        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,7 +1,7 @@
 
 from enum import Enum
-from logging import Logger
-from typing import Optional
+
+from logger import Logger
 
 
 class LLMInterface(Enum):
@@ -12,7 +12,7 @@ class LLMInterface(Enum):
 
 
 class Args:
-    LOGGER: Optional[Logger] = None
+    LOGGER = Logger.set_logger()
     primary_llm_interface=LLMInterface.OPENAILIKE
     # secondary_llm_interface=LLMInterface.HUGGINGFACE
     vlm_interface=LLMInterface.HUGGINGFACE

design.puml

@@ -0,0 +1,87 @@
+@startuml alfred
+!define NOT_IMPLEMENTED_NODE_COLOR #IndianRed
+!define IMPLEMENTED_NODE_COLOR #Gold
+!define TESTED_NODE_COLOR #LawnGreen
+!define TERMINAL_NODE_COLOR #DodgerBlue
+
+node START TERMINAL_NODE_COLOR[
+  START
+]
+
+node manager NOT_IMPLEMENTED_NODE_COLOR[
+  manager
+]
+
+node final_answer NOT_IMPLEMENTED_NODE_COLOR[
+  final_answer
+]
+
+node auditor NOT_IMPLEMENTED_NODE_COLOR[
+  auditor
+]
+
+node solver NOT_IMPLEMENTED_NODE_COLOR[
+  solver
+]
+
+node researcher NOT_IMPLEMENTED_NODE_COLOR[
+  researcher
+]
+
+node encryption_expert NOT_IMPLEMENTED_NODE_COLOR[
+  encryption_expert
+]
+
+node encryption_advisor NOT_IMPLEMENTED_NODE_COLOR[
+  encryption_advisor
+]
+
+node math_expert NOT_IMPLEMENTED_NODE_COLOR[
+  math_expert
+]
+
+node math_advisor NOT_IMPLEMENTED_NODE_COLOR[
+  math_advisor
+]
+
+node reasoner NOT_IMPLEMENTED_NODE_COLOR[
+  reasoner
+]
+
+node image_handler NOT_IMPLEMENTED_NODE_COLOR[
+  image_handler
+]
+
+node video_handler NOT_IMPLEMENTED_NODE_COLOR[
+  video_handler
+]
+
+node END TERMINAL_NODE_COLOR[
+  END
+]
+
+START --> manager
+manager --> solver
+manager --> auditor
+manager --> final_answer
+final_answer --> END
+auditor --> manager
+solver --> manager
+solver --> researcher
+solver --> encryption_expert
+solver --> math_expert
+solver --> reasoner
+solver --> image_handler
+solver --> video_handler
+researcher --> solver
+encryption_expert --> solver
+encryption_expert --> encryption_advisor
+encryption_advisor --> encryption_expert
+math_expert --> solver
+math_expert --> math_advisor
+math_advisor --> math_expert
+reasoner --> solver
+image_handler --> solver
+video_handler --> solver
+
+@enduml

design.yaml

@@ -0,0 +1,66 @@
+nodes:
+- name: START
+  connections:
+  - manager
+  description: This is the mandatory initial node `START` !
+  status: TERMINAL
+
+- name: manager
+  connections: [solver, auditor, final_answer]
+  description: Orchestrates the workflow by delegating tasks to specialized nodes and integrating their outputs
+  status: NOT_IMPLEMENTED
+
+- name: final_answer
+  connections: [END]
+  description: Formats and delivers the final response to the user
+  status: NOT_IMPLEMENTED
+
+- name: auditor
+  connections: [manager]
+  description: Reviews manager's outputs for accuracy, safety, and quality
+  status: NOT_IMPLEMENTED
+
+- name: solver
+  connections: [manager, researcher, encryption_expert, math_expert, reasoner, image_handler, video_handler]
+  description: Central problem-solving node that coordinates with specialized experts based on task requirements
+  status: NOT_IMPLEMENTED
+
+- name: researcher
+  connections: [solver]
+  description: Retrieves and synthesizes information from various sources to answer knowledge-based questions
+  status: NOT_IMPLEMENTED
+
+- name: encryption_expert
+  connections: [solver, encryption_advisor]
+  description: Handles encryption/decryption tasks and encoding/decoding operations
+  status: NOT_IMPLEMENTED
+
+- name: encryption_advisor
+  connections: [encryption_expert]
+  description: Provides specialized guidance on complex encryption problems to the encryption expert
+  status: NOT_IMPLEMENTED
+
+- name: math_expert
+  connections: [solver, math_advisor]
+  description: Performs mathematical calculations and solves numerical problems
+  status: NOT_IMPLEMENTED
+
+- name: math_advisor
+  connections: [math_expert]
+  description: Provides specialized guidance on complex mathematical problems to the math expert
+  status: NOT_IMPLEMENTED
+
+- name: reasoner
+  connections: [solver]
+  description: Performs logical reasoning, inference, and step-by-step problem-solving
+  status: NOT_IMPLEMENTED
+
+- name: image_handler
+  connections: [solver]
+  description: Processes, analyzes, and generates information related to images
+  status: NOT_IMPLEMENTED
+
+- name: video_handler
+  connections: [solver]
+  description: Processes, analyzes, and generates information related to videos
+  status: NOT_IMPLEMENTED

diagrams/architecture.puml

@@ -1,147 +0,0 @@
-@startuml Architecture Diagram
-
-' Define color variables
-!define CANVAS_COLOR #FAEBD7
-!define DEFAULT_NODE_COLOR #Gold
-!define TODO_COLOR #FireBrick
-!define ARROW_COLOR #666666
-!define BORDER_COLOR #999999
-!define TOOLBOX_MATH_COLOR #LightBlue
-!define TOOLBOX_WEBSEARCH_COLOR #LightGreen
-!define TOOLBOX_ENCRYPTION_COLOR #PaleVioletRed
-!define POWERS_ARROW_COLOR #4285F4
-!define TRIGGER_ARROW_COLOR #OrangeRed
-!define FINAL_ANSWER_COLOR #Orange
-
-' Style settings
-skinparam handwritten true
-skinparam backgroundColor white
-skinparam componentStyle uml2
-skinparam defaultFontName Arial
-skinparam arrowColor ARROW_COLOR
-skinparam componentBorderColor BORDER_COLOR
-skinparam component {
-  BackgroundColor DEFAULT_NODE_COLOR
-}
-
-' Custom style for toolbox functions
-skinparam label {
-  FontSize 10
-  FontColor black
-}
-
-' Components
-package "app.py" {
-  [UI] as UI
-  [Application] as Application
-}
-
-package "alfred.py" {
-  [Alfred] as Alfred
-  [GraphBuilder] as GraphBuilder
-}
-
-package "management.py" {
-  [Assistant] as Assistant
-  [Manager] as Manager
-}
-
-' Relationships
-UI -d-> Application
-Application -d-> Alfred
-Alfred -d-> GraphBuilder
-GraphBuilder -d-> Assistant
-GraphBuilder -d-> Manager
-
-' LangGraph Flow and LlamaIndex Flow positioning
-component "LangGraph Flow" as LangGraphFlow CANVAS_COLOR {
-  [Query] as Query
-  [Assistant Node] as AssistantNode
-  [Manager Node] as ManagerNode
-  [<b>Final Answer</b>] as FinalAnswer FINAL_ANSWER_COLOR
-  
-  Query -r-> AssistantNode
-  AssistantNode -r-> ManagerNode : requests
-  ManagerNode -l-> AssistantNode : solution
-  ManagerNode -d-> break_up_recursion
-  break_up_recursion -u-> ManagerNode
-  AssistantNode -d-> FinalAnswer : problem solved
-}
-
-' Position LlamaIndex Flow with solver.py and toolbox.py - more compact
-component "LlamaIndex Flow" as LlamaIndexFlow CANVAS_COLOR {
-  package "solver.py" {
-    [Solver] as Solver TODO_COLOR
-    [Summarizer] as Summarizer
-    [Researcher] as Researcher TODO_COLOR
-    [EncryptionExpert] as EncryptionExpert TODO_COLOR
-    [MathExpert] as MathExpert TODO_COLOR
-    [Reasoner] as Reasoner TODO_COLOR
-    [ImageHandler] as ImageHandler TODO_COLOR
-    [VideoHandler] as VideoHandler TODO_COLOR
-  }
-  
-  package "toolbox.py" {
-    node Math TOOLBOX_MATH_COLOR [
-    <b>Math</b>
-    ----
-    symbolic_calc
-    ____
-    unit_converter
-    ]
-    node WebSearch TOOLBOX_WEBSEARCH_COLOR [
-    <b>WebSearch</b>
-    ----
-    duckduckgo_text_search
-    ____
-    duckduckgo_images_search
-    ____
-    duckduckgo_videos_search
-    ]
-    node Encryption TOOLBOX_ENCRYPTION_COLOR [
-    <b>Encryption</b>
-    ----
-    <font color=FireBrick><b>ascii_encode/decode</b></font>
-    ____
-    <font color=FireBrick><b>chr_to_int/int_to_chr</b></font>
-    ____
-    base64_encode/decode
-    ____
-    caesar_cipher_encode/decode/<font color=FireBrick><b>brute_force</b></font>
-    ____
-    reverse_string
-    ]
-  }
-
-  Solver -r-> Summarizer
-  Solver -d-> Researcher
-  Solver -d-> EncryptionExpert
-  Solver -d-> MathExpert
-  Solver -d-> Reasoner
-  Solver -d-> ImageHandler
-  Solver -d-> VideoHandler
-  
-  Researcher -d-> WebSearch
-  MathExpert -d-> Math
-  EncryptionExpert -d-> Encryption
-}
-
-' Adjust the label position to avoid overlap
-GraphBuilder -d-> LangGraphFlow : builds
-
-' Curved connections from Manager to Solver/Summarizer
-Manager -d-> Solver
-Manager -d-> Summarizer
-
-' Bidirectional connection between ManagerNode and Solver
-ManagerNode -r-> Solver : requests
-Solver -l-> ManagerNode : provides solution
-
-' Agents powering the Nodes (dashed, blue color)
-Assistant -[POWERS_ARROW_COLOR,dashed]d-> AssistantNode : powers
-Manager -[POWERS_ARROW_COLOR,dashed]d-> ManagerNode : powers
-
-' Adding a direct connection from Alfred to Query
-Alfred -[TRIGGER_ARROW_COLOR]d..> Query
-
-@enduml

diagrams/diagram.puml

@@ -1,87 +0,0 @@
-@startuml
-
-!include style.puml
-
-' left to right direction
-
-' Hide the class indicators (C)
-hide circle
-hide empty members
-
-' Agent Definitions (Use class notation for agents with tools as fields)
-
-
-class "Assistant" as Assistant <<M>> {
-}
-
-class "Manager" as Manager <<M>> {
-    - Solver() {trivial task}
-    - Manager() {complex task}
-}
-
-class "Solver" as Solver {
-    - Researcher()
-    - EncryptionExpert()
-    - MathExpert()
-    - Reasoner()
-    - ImageHandler()
-    - VideoHandler()
-}
-
-class "Researcher" as Researcher {
-    + DuckDuckGoSearchToolSpec
-}
-
-class "EncryptionExpert" as EncryptionExpert {
-    + ASCII Encode
-    + ASCII Decode
-    + ChrToInt Encode
-    + ChrToInt Decode
-    + Base64 Encode
-    + Base64 Decode
-    + Caesar Cipher Encode
-    + Caesar Cipher Decode
-    + Caesar Cipher Brute Force
-    + Reverse String
-    - MathExpert()
-    - Reasoner()
-}
-
-class "MathExpert" as MathExpert {
-    + Symbolic Math Calculator
-    + Unit Converter
-    - Reasoner()
-}
-
-class "Reasoner" as Reasoner {
-}
-
-class "ImageHandler" as ImageHandler {
-}
-
-class "VideoHandler" as VideoHandler {
-}
-
-' Agent-to-Agent Connections
-Query --> Assistant
-Assistant --> Manager : request
-Manager --> Assistant : solution
-Assistant --> Final_Answer : problem solved
-
-Manager ..> Manager : complex task
-Manager ..> Solver : trivial task
-Solver ..> Manager : solution
-
-Solver .. Researcher : query
-Solver .. EncryptionExpert : query
-Solver .. MathExpert : query
-Solver .. Reasoner : query
-Solver .. ImageHandler : query
-Solver .. VideoHandler : query
-
-EncryptionExpert .. MathExpert : query
-EncryptionExpert .. Reasoner : query
-MathExpert .. Reasoner : query
-
-
-@enduml

diagrams/style.puml

@@ -1,7 +0,0 @@
-skinparam class {
-    BackgroundColor #E0F7FA
-    BorderColor #D84315
-    FontColor #E65100
-    FontStyle bold
-    HeaderBackgroundColor #FFE0B2
-}

graph.py

@@ -0,0 +1,142 @@
+from langchain_core.messages import AIMessage, HumanMessage
+from langgraph.graph import START, END, StateGraph
+
+from typing import Any, Dict, List, Literal, Optional, TypedDict
+import logging
+from pathlib import Path
+
+from args import Args
+
+
+class State(TypedDict):
+    """State class for the agent graph."""
+    initial_query: str
+    messages: List[Dict[str, Any]]
+    nr_interactions: int
+    final_response: Optional[str]
+
+
+class Nodes:
+    """
+    Collection of node functions for the agent graph.
+    """
+    def manager_node(self, state: State) -> State:
+        """
+        Orchestrates the workflow by delegating tasks to specialized nodes and integrating their outputs
+        """
+        # TODO: To implement...
+        pass
+
+    def final_answer_node(self, state: State) -> State:
+        """
+        Formats and delivers the final response to the user
+        """
+        # TODO: To implement...
+        pass
+
+    def auditor_node(self, state: State) -> State:
+        """
+        Reviews manager's outputs for accuracy, safety, and quality
+        """
+        # TODO: To implement...
+        pass
+
+    def solver_node(self, state: State) -> State:
+        """
+        Central problem-solving node that coordinates with specialized experts based on task requirements
+        """
+        # TODO: To implement...
+        pass
+
+    def researcher_node(self, state: State) -> State:
+        """
+        Retrieves and synthesizes information from various sources to answer knowledge-based questions
+        """
+        # TODO: To implement...
+        pass
+
+    def encryption_expert_node(self, state: State) -> State:
+        """
+        Handles encryption/decryption tasks and encoding/decoding operations
+        """
+        # TODO: To implement...
+        pass
+
+    def encryption_advisor_node(self, state: State) -> State:
+        """
+        Provides specialized guidance on complex encryption problems to the encryption expert
+        """
+        # TODO: To implement...
+        pass
+
+    def math_expert_node(self, state: State) -> State:
+        """
+        Performs mathematical calculations and solves numerical problems
+        """
+        # TODO: To implement...
+        pass
+
+    def math_advisor_node(self, state: State) -> State:
+        """
+        Provides specialized guidance on complex mathematical problems to the math expert
+        """
+        # TODO: To implement...
+        pass
+
+    def reasoner_node(self, state: State) -> State:
+        """
+        Performs logical reasoning, inference, and step-by-step problem-solving
+        """
+        # TODO: To implement...
+        pass
+
+    def image_handler_node(self, state: State) -> State:
+        """
+        Processes, analyzes, and generates information related to images
+        """
+        # TODO: To implement...
+        pass
+
+    def video_handler_node(self, state: State) -> State:
+        """
+        Processes, analyzes, and generates information related to videos
+        """
+        # TODO: To implement...
+        pass
+
+
+class Edges:
+    """
+    Collection of conditional edge functions for the agent graph.
+    """
+    def manager_edge(self, state: State) -> Literal["solver", "auditor", "final_answer"]:
+        """
+        Conditional edge for manager node.
+        Returns one of: "solver", "auditor", "final_answer"
+        """
+        # TODO: To implement...
+        pass
+
+    def solver_edge(self, state: State) -> Literal["manager", "researcher", "encryption_expert", "math_expert", "reasoner", "image_handler", "video_handler"]:
+        """
+        Conditional edge for solver node.
+        Returns one of: "manager", "researcher", "encryption_expert", "math_expert", "reasoner", "image_handler", "video_handler"
+        """
+        # TODO: To implement...
+        pass
+
+    def encryption_expert_edge(self, state: State) -> Literal["solver", "encryption_advisor"]:
+        """
+        Conditional edge for encryption_expert node.
+        Returns one of: "solver", "encryption_advisor"
+        """
+        # TODO: To implement...
+        pass
+
+    def math_expert_edge(self, state: State) -> Literal["solver", "math_advisor"]:
+        """
+        Conditional edge for math_expert node.
+        Returns one of: "solver", "math_advisor"
+        """
+        # TODO: To implement...
+        pass

graph_builder.py

@@ -0,0 +1,78 @@
+from IPython.display import Image, display
+from langgraph.graph import StateGraph, END, START
+from langgraph.graph.state import CompiledStateGraph
+from graph import State, Nodes, Edges
+
+
+class GraphBuilder:
+    def __init__(self):
+        """
+        Initializes the GraphBuilder.
+        """
+        self.nodes = Nodes()
+        self.edges = Edges()
+        self.compiled_graph = None
+        
+    def build_agent_graph(self) -> CompiledStateGraph:
+        """Build and return the agent graph."""
+        graph = StateGraph(State)
+        
+        graph.add_node("manager", self.nodes.manager_node)
+        graph.add_node("final_answer", self.nodes.final_answer_node)
+        graph.add_node("auditor", self.nodes.auditor_node)
+        graph.add_node("solver", self.nodes.solver_node)
+        graph.add_node("researcher", self.nodes.researcher_node)
+        graph.add_node("encryption_expert", self.nodes.encryption_expert_node)
+        graph.add_node("encryption_advisor", self.nodes.encryption_advisor_node)
+        graph.add_node("math_expert", self.nodes.math_expert_node)
+        graph.add_node("math_advisor", self.nodes.math_advisor_node)
+        graph.add_node("reasoner", self.nodes.reasoner_node)
+        graph.add_node("image_handler", self.nodes.image_handler_node)
+        graph.add_node("video_handler", self.nodes.video_handler_node)
+        
+        graph.add_edge(START, "manager")
+        graph.add_edge("final_answer", END)
+        graph.add_edge("auditor", "manager")
+        graph.add_edge("researcher", "solver")
+        graph.add_edge("encryption_advisor", "encryption_expert")
+        graph.add_edge("math_advisor", "math_expert")
+        graph.add_edge("reasoner", "solver")
+        graph.add_edge("image_handler", "solver")
+        graph.add_edge("video_handler", "solver")
+
+        graph.add_conditional_edges(
+            "manager",
+            self.edges.manager_edge,
+            {
+                "solver": "solver", "auditor": "auditor", "final_answer": "final_answer"
+            }
+        )
+        graph.add_conditional_edges(
+            "solver",
+            self.edges.solver_edge,
+            {
+                "manager": "manager", "researcher": "researcher", "encryption_expert": "encryption_expert", "math_expert": "math_expert", "reasoner": "reasoner", "image_handler": "image_handler", "video_handler": "video_handler"
+            }
+        )
+        graph.add_conditional_edges(
+            "encryption_expert",
+            self.edges.encryption_expert_edge,
+            {
+                "solver": "solver", "encryption_advisor": "encryption_advisor"
+            }
+        )
+        graph.add_conditional_edges(
+            "math_expert",
+            self.edges.math_expert_edge,
+            {
+                "solver": "solver", "math_advisor": "math_advisor"
+            }
+        )
+        
+        return graph.compile()
+
+    def display_graph(self):
+        if self.compiled_graph is None:
+            raise ValueError("Graph has not been compiled yet. Call build_agent_graph() first.")
+
+        display(Image(self.compiled_graph.get_graph().draw_mermaid_png()))

logger.py

@@ -0,0 +1,40 @@
+import logging
+import datetime
+from pathlib import Path
+
+
+class Logger:
+    @staticmethod
+    def set_logger() -> 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 with UTF-8 encoding to handle all Unicode characters
+        file_handler = logging.FileHandler(log_filepath, encoding='utf-8')
+        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

management.py

@@ -1,106 +0,0 @@
-from llama_index.core.tools import FunctionTool
-
-from typing import List
-
-from itf_agent import IAgent
-from solver import Solver, Summarizer
-from args import Args
-
-
-class Assistant(IAgent):
-    def __init__(self, temperature, max_tokens):
-        super().__init__(temperature, max_tokens, "01_assistant.txt", Args.primary_llm_interface)
-
-class Manager(IAgent):
-    def __init__(self, temperature, max_tokens, max_depth):
-        super().__init__(temperature, max_tokens, "02_manager.txt", Args.primary_llm_interface)
-
-        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)
-
-    def setup_tools(self) -> List:
-        return [
-            FunctionTool.from_defaults(
-                name="require_break_up",
-                description="Break a complex task into simpler subtasks. Use when a task needs to be divided into manageable parts.",
-                fn=self.require_break_up
-            ),
-            FunctionTool.from_defaults(
-                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.
-        
-        Args:
-            tasks: List of tasks to break down
-            try_solving: Whether to attempt solving tasks at max depth (default: False)
-            
-        Returns:
-            Summarized report of the task breakdown
-        """
-        print(f"-> require_break_up tool used (input: {tasks}) !")
-        if not tasks:
-            return "Error: No tasks provided to break up. Please provide at least one task."
-        
-        self.current_depth += 1
-
-        observation = ""
-        if self.current_depth < self.max_depth:
-            for task in tasks:
-                solution = await self.query(task, has_context=False)
-                response = f"For task:\n\n{task}\n\nThe following break up has been provided:\n\n{solution}\n\n"
-                observation += response
-        elif try_solving:
-            for task in tasks:
-                response = await self.solver.query(task)
-        else:
-            observation = "Maximum depth for `break_up` tool has been reached ! At this point, you may try to break up the task yourself or try `require_solution`."
-        
-        self.current_depth -= 1
-        report = await self.summarizer.query(observation.strip())
-        return report
-
-    async def require_solution(self, tasks: List[str]) -> str:
-        """
-        Request direct solutions for the provided tasks using the Solver.
-        
-        Args:
-            tasks: List of tasks to solve
-            
-        Returns:
-            Summarized report of solutions for all 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."
-        
-        observation = ""
-        for task in tasks:
-            solution = await self.solver.query(task)
-            observation += solution
-
-        report = await self.summarizer.query(observation.strip())
-        return report
-
-    async def forward_query(self) -> str:
-        return await self.require_solution([self.current_query])

test.py

@@ -0,0 +1,339 @@
+from graph import State, Nodes, Edges
+from graph_builder import GraphBuilder
+
+import unittest
+
+
+class TestAlfredAgent(unittest.TestCase):
+    """Test suite for the Alfred agent"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.nodes = Nodes()
+        self.edges = Edges()
+        self.builder = GraphBuilder()
+        self.graph = self.builder.build_agent_graph()
+
+    def test_manager_node(self):
+        """
+        Test the manager node functionality.
+        
+        Orchestrates the workflow by delegating tasks to specialized nodes and integrating their outputs
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'manager' node...")
+        nodes.manager_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_final_answer_node(self):
+        """
+        Test the final_answer node functionality.
+        
+        Formats and delivers the final response to the user
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'final_answer' node...")
+        nodes.final_answer_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_auditor_node(self):
+        """
+        Test the auditor node functionality.
+        
+        Reviews manager's outputs for accuracy, safety, and quality
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'auditor' node...")
+        nodes.auditor_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_solver_node(self):
+        """
+        Test the solver node functionality.
+        
+        Central problem-solving node that coordinates with specialized experts based on task requirements
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'solver' node...")
+        nodes.solver_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_researcher_node(self):
+        """
+        Test the researcher node functionality.
+        
+        Retrieves and synthesizes information from various sources to answer knowledge-based questions
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'researcher' node...")
+        nodes.researcher_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_encryption_expert_node(self):
+        """
+        Test the encryption_expert node functionality.
+        
+        Handles encryption/decryption tasks and encoding/decoding operations
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'encryption_expert' node...")
+        nodes.encryption_expert_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_encryption_advisor_node(self):
+        """
+        Test the encryption_advisor node functionality.
+        
+        Provides specialized guidance on complex encryption problems to the encryption expert
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'encryption_advisor' node...")
+        nodes.encryption_advisor_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_math_expert_node(self):
+        """
+        Test the math_expert node functionality.
+        
+        Performs mathematical calculations and solves numerical problems
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'math_expert' node...")
+        nodes.math_expert_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_math_advisor_node(self):
+        """
+        Test the math_advisor node functionality.
+        
+        Provides specialized guidance on complex mathematical problems to the math expert
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'math_advisor' node...")
+        nodes.math_advisor_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_reasoner_node(self):
+        """
+        Test the reasoner node functionality.
+        
+        Performs logical reasoning, inference, and step-by-step problem-solving
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'reasoner' node...")
+        nodes.reasoner_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_image_handler_node(self):
+        """
+        Test the image_handler node functionality.
+        
+        Processes, analyzes, and generates information related to images
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'image_handler' node...")
+        nodes.image_handler_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_video_handler_node(self):
+        """
+        Test the video_handler node functionality.
+        
+        Processes, analyzes, and generates information related to videos
+        """
+        # Create an instance of Nodes class
+        nodes = Nodes()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the node function
+        print(f"Testing 'video_handler' node...")
+        nodes.video_handler_node(test_state)
+        
+        # TODO: Add assertions to verify the state changes
+        print(f"State after node execution: {test_state}")
+
+    def test_manager_edge(self):
+        """
+        Test the conditional edge for manager node.
+        
+        This edge should return one of: "solver", "auditor", "final_answer"
+        """
+        # Create an instance of Edges class
+        edges = Edges()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the edge function
+        print(f"Testing 'manager' conditional edge...")
+        result = edges.manager_edge(test_state)
+        
+        # TODO: Add assertions to verify the result
+        print(f"Edge decision: {result}")
+        assert result in ["solver", "auditor", "final_answer"], f"Edge result '{result}' not in expected values"
+
+    def test_solver_edge(self):
+        """
+        Test the conditional edge for solver node.
+        
+        This edge should return one of: "manager", "researcher", "encryption_expert", "math_expert", "reasoner", "image_handler", "video_handler"
+        """
+        # Create an instance of Edges class
+        edges = Edges()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the edge function
+        print(f"Testing 'solver' conditional edge...")
+        result = edges.solver_edge(test_state)
+        
+        # TODO: Add assertions to verify the result
+        print(f"Edge decision: {result}")
+        assert result in ["manager", "researcher", "encryption_expert", "math_expert", "reasoner", "image_handler", "video_handler"], f"Edge result '{result}' not in expected values"
+
+    def test_encryption_expert_edge(self):
+        """
+        Test the conditional edge for encryption_expert node.
+        
+        This edge should return one of: "solver", "encryption_advisor"
+        """
+        # Create an instance of Edges class
+        edges = Edges()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the edge function
+        print(f"Testing 'encryption_expert' conditional edge...")
+        result = edges.encryption_expert_edge(test_state)
+        
+        # TODO: Add assertions to verify the result
+        print(f"Edge decision: {result}")
+        assert result in ["solver", "encryption_advisor"], f"Edge result '{result}' not in expected values"
+
+    def test_math_expert_edge(self):
+        """
+        Test the conditional edge for math_expert node.
+        
+        This edge should return one of: "solver", "math_advisor"
+        """
+        # Create an instance of Edges class
+        edges = Edges()
+        
+        # Create a test state
+        test_state = {}  # TODO: Initialize with appropriate test data
+        
+        # Test the edge function
+        print(f"Testing 'math_expert' conditional edge...")
+        result = edges.math_expert_edge(test_state)
+        
+        # TODO: Add assertions to verify the result
+        print(f"Edge decision: {result}")
+        assert result in ["solver", "math_advisor"], f"Edge result '{result}' not in expected values"
+    
+    def test_full_workflow(self):
+        """
+        Test the Alfred agent full workflow.
+        """
+        # TODO: Add test code here
+        print("Testing Alfred complete workflow...")
+        
+        # Example test
+        # result = self.graph.invoke({"input": "Test input"})
+        # self.assertIsNotNone(result)
+        # print(f"Workflow result: {result}")
+
+
+if __name__ == "__main__":
+    unittest.main()

test_agents.py

@@ -1,17 +0,0 @@
-# OUTDATED !
-from agents_stage_2 import MathAgent, MainAgent
-import asyncio
-
-def test_math_agent():
-    math_agent = MathAgent(temperature=0.7, max_tokens=100)
-    print(math_agent.get_system_prompt())
-    asyncio.run(math_agent.query("What is 345 times 281?"))
-
-def test_main_agent():
-    main_agent = MainAgent(temperature=0.7, max_tokens=100)
-    print(main_agent.get_system_prompt())
-    asyncio.run(main_agent.query("What is 345 times 281?"))
-
-if __name__ == "__main__":
-    # test_math_agent()
-    test_main_agent()

toolbox.py

@@ -1,5 +1,4 @@
 from llama_index.core.tools import FunctionTool
-# from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec  # I encountered some issues... Sometimes it doesn't work !
 
 
 from duckduckgo_search import DDGS
@@ -136,7 +135,6 @@ class _WebSearch:
 
 
 class _WebSearchToolbox:
-    # 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",