embracing langgraph; addapted LLMFactory, Args.LLMInterface, IAgent, Toolbox and agents.py; simplified graph: removed math and encryption agents while promoting the reasoner

agents.py

@@ -1,82 +1,104 @@
 from args import Args
 from itf_agent import IAgent
+from llm_factory import AgentPreset
+from toolbox import Toolbox
+
+
+PRIMARY_AGENT_PRESET = AgentPreset(Args.primary_llm_interface, Args.primary_model,
+    temperature = None, max_tokens = 2048, repeat_penalty = None)
+SECONDARY_AGENT_PRESET = AgentPreset(Args.primary_llm_interface, Args.secondary_model,
+    temperature = None, max_tokens = 2048, repeat_penalty = None)
+VISION_AGENT_PRESET = AgentPreset(Args.vlm_interface, Args.vision_model,
+    temperature = None, max_tokens = 2048, repeat_penalty = None)
 
 
 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)
+    def __init__(self):
+        super().__init__("01_manager.txt", PRIMARY_AGENT_PRESET)
 
 
 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)
+    def __init__(self):
+        super().__init__("02_auditor.txt", PRIMARY_AGENT_PRESET)
 
 
 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)
+    def __init__(self):
+        super().__init__("04_summarizer.txt", PRIMARY_AGENT_PRESET)
 
 
 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)
+    def __init__(self):
+        super().__init__("03_solver.txt", PRIMARY_AGENT_PRESET)
 
 
 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)
-
-
-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 __init__(self):
+        toolbox = Toolbox.web_search
+        tools = [
+            toolbox.duckduckgo_text_search,
+            toolbox.duckduckgo_images_search,
+            toolbox.duckduckgo_videos_search
+            ]
+        super().__init__("05_researcher.txt", PRIMARY_AGENT_PRESET, tools)
 
 
-class MathExpert(IAgent):
+class Reasoner(IAgent):
     """
-    Performs mathematical calculations and solves numerical problems
+    Performs logical reasoning, inference, and step-by-step problem-solving
     """
-    def __init__(self, temperature, max_tokens):
-        super().__init__(temperature, max_tokens, "07_math_expert.txt", Args.primary_llm_interface)
-
-
-class Reasoner(IAgent):
+    def __init__(self):
+        math_toolbox = Toolbox.math
+        encryption_toolbox = Toolbox.encryption
+        tools = [
+            math_toolbox.symbolic_calc,
+            math_toolbox.unit_converter,
+            encryption_toolbox.ascii_decode,
+            encryption_toolbox.ascii_encode,
+            encryption_toolbox.base64_decode,
+            encryption_toolbox.base64_encode,
+            encryption_toolbox.caesar_cipher_decode,
+            encryption_toolbox.caesar_cipher_encode,
+            encryption_toolbox.caesar_cipher_brute_force,
+            encryption_toolbox.reverse_string
+            ]
+        super().__init__("08_reasoner.txt", PRIMARY_AGENT_PRESET, tools)
+
+
+class OutputGuard(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)
+    def __init__(self):
+        super().__init__("11_output_guard.txt", SECONDARY_AGENT_PRESET)
 
 
 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)
+    def __init__(self):
+        super().__init__("09_image_handler.txt", VISION_AGENT_PRESET)
 
 
 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)
+    def __init__(self):
+        super().__init__("10_video_handler.txt", VISION_AGENT_PRESET)

args.py

@@ -5,18 +5,19 @@ from logger import Logger
 
 
 class LLMInterface(Enum):
-    HUGGINGFACE = "HuggingFace"
-    OPENAILIKE = "OpenAILike"
     OPENAI = "OpenAI"
+    HUGGINGFACE = "HuggingFace"
     # Add your own if you like (then adjust the LLMFactory)
 
 
 class Args:
     LOGGER = Logger.set_logger()
-    primary_llm_interface=LLMInterface.OPENAILIKE
+    primary_llm_interface=LLMInterface.OPENAI
     # secondary_llm_interface=LLMInterface.HUGGINGFACE
     vlm_interface=LLMInterface.HUGGINGFACE
-    model_name="Qwen/Qwen2.5-Coder-32B-Instruct"
+    primary_model="qwen2.5-qwq-35b-eureka-cubed-abliterated-uncensored"
+    secondary_model="qwen2.5-7b-instruct-1m"
+    vision_model="gemma-3-27b-it"
     api_base="http://127.0.0.1:1234/v1"  # LM Studio local endpoint
-    api_key="api_key"
+    api_key=None
     token = ""  # Not needed when using OpenAILike API

design.puml

@@ -28,22 +28,6 @@ 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
 ]
@@ -68,18 +52,10 @@ 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

design.yaml

@@ -21,7 +21,7 @@ nodes:
   status: NOT_IMPLEMENTED
 
 - name: solver
-  connections: [manager, researcher, encryption_expert, math_expert, reasoner, image_handler, video_handler]
+  connections: [manager, researcher, reasoner, image_handler, video_handler]
   description: Central problem-solving node that coordinates with specialized experts based on task requirements
   status: NOT_IMPLEMENTED
 
@@ -30,26 +30,6 @@ nodes:
   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

graph.py

@@ -1,7 +1,9 @@
-from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.messages import AnyMessage, BaseMessage, AIMessage, HumanMessage
 from langgraph.graph import START, END, StateGraph
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
 
-from typing import Any, Dict, List, Literal, Optional, TypedDict
+from typing import Annotated, Any, Dict, List, Literal, Optional, TypedDict
 import logging
 from pathlib import Path
 
@@ -11,7 +13,8 @@ from args import Args
 class State(TypedDict):
     """State class for the agent graph."""
     initial_query: str
-    messages: List[Dict[str, Any]]
+    # messages: List[Dict[str, Any]]
+    messages: Annotated[list[AnyMessage], add_messages]
     nr_interactions: int
     final_response: Optional[str]
 
@@ -55,34 +58,6 @@ class Nodes:
         # 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
@@ -117,26 +92,10 @@ class Edges:
         # TODO: To implement...
         pass
 
-    def solver_edge(self, state: State) -> Literal["manager", "researcher", "encryption_expert", "math_expert", "reasoner", "image_handler", "video_handler"]:
+    def solver_edge(self, state: State) -> Literal["manager", "researcher", "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

@@ -22,10 +22,6 @@ class GraphBuilder:
         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)
@@ -34,8 +30,6 @@ class GraphBuilder:
         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")
@@ -51,21 +45,7 @@ class GraphBuilder:
             "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"
+                "manager": "manager", "researcher": "researcher", "reasoner": "reasoner", "image_handler": "image_handler", "video_handler": "video_handler"
             }
         )
         

itf_agent.py

@@ -1,32 +1,33 @@
-from llama_index.core.tools import FunctionTool
-from llama_index.core.workflow import Context
+from langchain_core.messages import BaseMessage, SystemMessage
 
 import logging
 import os
 import re
 from typing import List
 
-from args import Args, LLMInterface
-from llm_factory import LLMFactory
-from llama_index.core.agent.workflow import AgentWorkflow
+from args import Args
+from llm_factory import LLMFactory, AgentPreset
 
 
 class IAgent():
-    def __init__(self, temperature, max_tokens, sys_prompt_filename, llm_itf: LLMInterface):
+    def __init__(self, sys_prompt_filename, agent_preset: AgentPreset, tools: List = [], parallel_tool_calls=False):
         self.name = self._format_name(sys_prompt_filename)
-        self.temperature, self.max_tokens = temperature, max_tokens
+        self.interface = agent_preset.get_interface()
+
         # Load the system prompt from a 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()
-        # Initialize the tool agents
-        self.tools = self.setup_tools()
-        self.slaves: List[IAgent] = self.setup_slaves()
-        # Define the LLM and agent
-        self.llm = LLMFactory.create(llm_itf, self.system_prompt, temperature, max_tokens)
-        self.agent = self._setup_agent()
-        self.ctx = Context(self.agent)
+
+        # Define LLM
+        llm = LLMFactory.create(agent_preset)
+
+        # Add tools
+        if tools:
+            self.model = llm.bind_tools(tools, parallel_tool_calls=parallel_tool_calls)
+        else:
+            self.model = llm
 
     @staticmethod
     def _format_name(sys_prompt_filename: str) -> str:
@@ -36,55 +37,6 @@ class IAgent():
         cleaned_name = re.sub(r'^[^a-zA-Z]+', '', name_without_ext)
         return cleaned_name
     
-    def setup_tools(self) -> List[FunctionTool]:
-        """
-        Set up the tools for this agent.
-        
-        Override this method in subclasses to define custom tools.
-        By default, returns an empty list.
-        
-        Returns:
-            List: A list of tools this agent can use
-        """
-        return []
-    
-    def setup_slaves(self) -> List:
-        """
-        Set up the slave agents for this agent.
-        
-        Override this method in subclasses to define custom sub-agents.
-        By default, returns an empty list.
-        
-        Returns:
-            List: A list of slave agents this agent can use
-        """
-        return []
-    
-    def _setup_agent(self) -> AgentWorkflow:
-        """
-        Initializes and returns an agent workflow based on the presence of tools and slaves.
-        If both `self.tools` and `self.slaves` are empty, it sets up a default agent using the provided language model (`self.llm`).
-        Otherwise, it creates an agent workflow using the combined list of tools and slaves with the language model.
-        Returns:
-            AgentWorkflow: An instance of the agent workflow configured with the appropriate tools and language model.
-        """
-        # Create tools from slaves: each tool calls slave.query(question) asynchronously
-        slave_tools = []
-        for slave in self.slaves:
-            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)
-
-        return AgentWorkflow.from_tools_or_functions(
-        self.tools,
-        llm=self.llm
-        )
-
     def get_system_prompt(self) -> str:
         """
         Retrieves the system prompt.
@@ -94,7 +46,7 @@ class IAgent():
         """
         return self.system_prompt
 
-    async def query(self, question: str, has_context = True) -> str:
+    def query(self, messages: List[BaseMessage]) -> BaseMessage:
         """
         Asynchronously queries the agent with a given question and returns the response.
 
@@ -110,25 +62,9 @@ class IAgent():
         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)
+        system_prompt = self.get_system_prompt()
+        conversation = [SystemMessage(content=system_prompt)] + messages
+        response = self.model.invoke(conversation)
 
         Args.LOGGER.log(logging.INFO, f"\nAgent '{self.name}' produced OUTPUT:\n{response}\n{separator}\n")
         return response
-
-    def clear_context(self):
-        """
-        Clears the current context of the agent, resetting any conversation history.
-        This is useful when starting a new conversation or when the context needs to be refreshed.
-        """
-        if self.ctx is not None:
-            self.ctx = Context(self.agent)
-
-        if not self.slaves:
-            return
-
-        for slave in self.slaves:
-            slave.clear_context()

llm_factory.py

@@ -1,71 +1,127 @@
-from llama_index.llms.openai_like import OpenAILike
-from llama_index.llms.openai import OpenAI
-from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langchain_openai import ChatOpenAI
+
+from typing import Optional
 
 from args import LLMInterface, Args
 
 
+class AgentPreset:
+    def __init__(self, interface: LLMInterface, model_name: str, temperature: Optional[float] = None, 
+                 max_tokens: Optional[int] = None, repeat_penalty: Optional[float] = None):
+        """
+        Initialize an AgentPreset with LLM configuration parameters.
+        
+        Args:
+            interface: The model interface to use (e.g., OPENAI, HUGGINGFACE)
+            model_name: Name of the model to use
+            temperature: Controls randomness in responses (0.0-1.0)
+            max_tokens: Maximum number of tokens to generate in response
+            repeat_penalty: Penalty for token repetition
+        """
+        self.interface = interface
+        self.model_name = model_name
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.repeat_penalty = repeat_penalty
+    
+    def get_interface(self) -> LLMInterface:
+        """
+        Get the model interface.
+        
+        Returns:
+            LLMInterface: The interface used for this agent.
+        """
+        return self.interface
+    
+    def get_model_name(self) -> str:
+        """
+        Get the model name.
+        
+        Returns:
+            str: The name of the model.
+        """
+        return self.model_name
+    
+    def get_temperature(self) -> float:
+        """
+        Get the temperature setting.
+        
+        Returns:
+            float: The temperature value controlling randomness.
+        """
+        return self.temperature
+    
+    def get_max_tokens(self) -> int:
+        """
+        Get the maximum tokens setting.
+        
+        Returns:
+            int: The maximum number of tokens for generation.
+        """
+        return self.max_tokens
+    
+    def get_repeat_penalty(self) -> float:
+        """
+        Get the repeat penalty setting.
+        
+        Returns:
+            float: The penalty value for token repetition.
+        """
+        return self.repeat_penalty
+
+
 class LLMFactory():
 
     @classmethod
-    def create(cls, interface: LLMInterface, system_prompt, temperature = None, max_tokens = None):
-        if interface == LLMInterface.OPENAILIKE:
-            return cls._openailike_create(system_prompt, temperature, max_tokens)
-        elif interface == LLMInterface.OPENAI:
-            return cls._openai_create(system_prompt, temperature, max_tokens)
+    def create(cls, agent_preset: AgentPreset):
+        interface = agent_preset.get_interface()
+
+        if interface == LLMInterface.OPENAI:
+            model = cls._create_openai_model(agent_preset)
         elif interface == LLMInterface.HUGGINGFACE:
-            return cls._hf_create(system_prompt, temperature, max_tokens)
+            model = cls._create_huggingface_model(agent_preset)
         else:
             raise ValueError(f"Interface '{interface}' is not supported !")
+        
+        return model
 
     @staticmethod
-    def _openailike_create(system_prompt, temperature=None, max_tokens=None):
-        kwargs = {
-            "model": Args.model_name,
-            "api_base": Args.api_base,
-            "api_key": Args.api_key,
-            "system_prompt": system_prompt,
-        }
+    def _create_openai_model(agent_preset: AgentPreset):
+        model_name = agent_preset.get_model_name()
+        temperature = agent_preset.get_temperature()
+        max_tokens = agent_preset.get_max_tokens()
+        repeat_penalty = agent_preset.get_repeat_penalty()
 
-        if temperature is not None:
-            kwargs["temperature"] = temperature
-
-        if max_tokens is not None:
-            kwargs["max_tokens"] = max_tokens
-
-        llm = OpenAILike(**kwargs)
-        return llm
-
-    @staticmethod
-    def _openai_create(system_prompt, temperature = None, max_tokens = None):
         kwargs = {
-            "model": Args.model_name,
+            "model": model_name,
+            "base_url": Args.api_base,
             "api_key": Args.api_key,
-            "system_prompt": system_prompt,
+            "temperature": temperature,
+            "max_completion_tokens": max_tokens,
+            # "presence_penalty": repeat_penalty,
+            "frequency_penalty": repeat_penalty
         }
 
-        if temperature is not None:
-            kwargs["temperature"] = temperature
+        model = ChatOpenAI(**kwargs)
 
-        if max_tokens is not None:
-            kwargs["max_tokens"] = max_tokens
-
-        llm = OpenAI(**kwargs)
-        return llm
+        return model
 
     @staticmethod
-    def _hf_create(system_prompt, temperature = None, max_tokens = None):
+    def _create_huggingface_model(agent_preset: AgentPreset):
+        model_name = agent_preset.get_model_name()
+        temperature = agent_preset.get_temperature()
+        max_tokens = agent_preset.get_max_tokens()
+        repeat_penalty = agent_preset.get_repeat_penalty()
+
         kwargs = {
-            "model_name": Args.model_name,
-            "system_prompt": system_prompt,
-            "token": Args.token,
+            "model": model_name,
+            "temperature": temperature,
+            "max_new_tokens": max_tokens,
+            "repetition_penalty": repeat_penalty
         }
 
-        if temperature is not None:
-            kwargs["temperature"] = temperature
-
-        if max_tokens is not None:
-            kwargs["max_tokens"] = max_tokens
+        llm = HuggingFaceEndpoint(**kwargs)
+        model = ChatHuggingFace(llm=llm)
 
-        llm = HuggingFaceInferenceAPI(**kwargs)
-        return llm
+        return model

requirements.txt

@@ -10,4 +10,8 @@ llama-index-embeddings-huggingface
 llama-index-llms-openai
 llama-index-llms-openai-like
 llama-index-tools-duckduckgo
+langchain
+langchain_openai
+langchain_huggingface
+langchain-core>=0.3.11
 pint

system_prompts/11_output_guard.txt

@@ -0,0 +1,9 @@
+Act as a guard for a powerful reasoning model, but with many flaws. It can answer the questions very smart, but it is prone to glitch or output Chinese words out of nowhere sometimes.
+
+Your role is to detect any issues with the output and correct it (for example, translate the Chinese, remove the glitched repetitive tokens, etc.)
+
+If there is a thinking block, remove it ! Only output the response !
+
+If there is no issue with the response, you will just output it word for word. Otherwise, you will output the corrected version.
+
+Do not output anything else. Do not offer explanations or any other redundant words.

test.py

@@ -109,82 +109,6 @@ class TestAlfredAgent(unittest.TestCase):
         # 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.
@@ -266,7 +190,7 @@ class TestAlfredAgent(unittest.TestCase):
         """
         Test the conditional edge for solver node.
         
-        This edge should return one of: "manager", "researcher", "encryption_expert", "math_expert", "reasoner", "image_handler", "video_handler"
+        This edge should return one of: "manager", "researcher", "reasoner", "image_handler", "video_handler"
         """
         # Create an instance of Edges class
         edges = Edges()
@@ -280,48 +204,8 @@ class TestAlfredAgent(unittest.TestCase):
         
         # 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"
+        assert result in ["manager", "researcher", "reasoner", "image_handler", "video_handler"], 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.

toolbox.py

@@ -1,6 +1,3 @@
-from llama_index.core.tools import FunctionTool
-
-
 from duckduckgo_search import DDGS
 import pint
 import sympy as sp
@@ -58,19 +55,6 @@ class _Math:
             return f"Error in unit conversion: {str(e)}"
 
 
-class _MathToolbox:
-    symbolic_calc = FunctionTool.from_defaults(
-        name="symbolic_calc",
-        description="Evaluates complex mathematical expressions using SymPy",
-        fn=_Math.symbolic_calc
-    )
-    unit_converter = FunctionTool.from_defaults(
-        name="unit_converter",
-        description="Converts values between different units of measurement",
-        fn=_Math.unit_converter
-    )
-
-
 class _WebSearch:
     @staticmethod
     def duckduckgo_text_search(keywords, max_results=5) -> list[dict[str, str]]:
@@ -134,24 +118,6 @@ class _WebSearch:
         return DDGS().videos(keywords, license_videos=license, max_results=max_results)
 
 
-class _WebSearchToolbox:
-    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:
     
     @staticmethod
@@ -312,50 +278,7 @@ class _Encryption:
         return reversed_text
 
 
-class _EncryptionToolbox:
-    ascii_encode = FunctionTool.from_defaults(
-        name="ascii_encode",
-        description="Convert each character in a string to its ASCII value",
-        fn=_Encryption.ascii_encode
-    )
-    ascii_decode = FunctionTool.from_defaults(
-        name="ascii_decode",
-        description="Convert space-separated ASCII values back to characters",
-        fn=_Encryption.ascii_decode
-    )
-    base64_encode = FunctionTool.from_defaults(
-        name="base64_encode",
-        description="Encode a string to base64",
-        fn=_Encryption.base64_encode
-    )
-    base64_decode = FunctionTool.from_defaults(
-        name="base64_decode",
-        description="Decode a base64 string to plain text",
-        fn=_Encryption.base64_decode
-    )
-    caesar_cipher_encode = FunctionTool.from_defaults(
-        name="caesar_cipher_encode",
-        description="Encode a string using Caesar cipher with specified shift",
-        fn=_Encryption.caesar_cipher_encode
-    )
-    caesar_cipher_decode = FunctionTool.from_defaults(
-        name="caesar_cipher_decode",
-        description="Decode a Caesar cipher string with specified shift",
-        fn=_Encryption.caesar_cipher_decode
-    )
-    caesar_cipher_brute_force = FunctionTool.from_defaults(
-        name="caesar_cipher_brute_force",
-        description="Try all 26 possible shifts to decode a Caesar cipher text",
-        fn=_Encryption.caesar_cipher_brute_force
-    )
-    reverse_string = FunctionTool.from_defaults(
-        name="reverse_string",
-        description="Reverse a string",
-        fn=_Encryption.reverse_string
-    )
-
-
 class Toolbox:
-    math = _MathToolbox()
-    web_search = _WebSearchToolbox()
-    encryption = _EncryptionToolbox()
+    math = _Math()
+    web_search = _WebSearch()
+    encryption = _Encryption()