Parallel ReACT Agent module

`ParallelReACTAgent`

Bases: Program

ReACT agent as a directed acyclic graph that choose at each step one or more tool to use.

The agent will decide at each cycle whether to continue reasoning or to finish.

The difference with DSPy or AdalFlow implementation is that each node in the DAG is a separate module with its own trainable variables, yielding better optimization (specific for each step/tool). Which makes it more memory intensive, but since ReACT are anyway limited to a small set of tools/functions, its ok.

Note: Each function MUST return a JSON object dict and be asynchrounous

Example:

import synalinks
import asyncio

class Query(synalinks.DataModel):
    query: str = synalinks.Field(
        description="The user query",
    )

class FinalAnswer(synalinks.DataModel):
    answer: float = synalinks.Field(
        description="The correct final answer",
    )

async def main():

    async def calculate(expression: str):
        """Calculate the result of a mathematical expression.

        Args:
            expression (str): The mathematical expression to calculate, such as
                '2 + 2'. The expression can contain numbers, operators (+, -, *, /),
                parentheses, and spaces.
        """
        if not all(char in "0123456789+-*/(). " for char in expression):
            return {
                "result": None,
                "log": "Error: invalid characters in expression",
            }
        try:
            # Evaluate the mathematical expression safely
            result = round(float(eval(expression, {"__builtins__": None}, {})), 2)
            return {
                "result": result,
                "log": "Successfully executed",
            }
        except Exception as e:
            return {
                "result": None,
                "log": f"Error: {e}",
            }

    language_model = synalinks.LanguageModel(model="ollama/mistral")

    x0 = synalinks.Input(data_model=Query)
    x1 = await synalinks.ParallelReACTAgent(
        data_model=FinalAnswer,
        language_model=language_model,
        functions=[calculate],
        max_iterations=3,
    )(x0)

    program = synalinks.Program(
        inputs=x0,
        outputs=x1,
        name="math_agent",
        description="A math agent that can use a calculator",
    )

if __name__ == "__main__":
    asyncio.run(main())

References

ReAct: Synergizing Reasoning and Acting in Language Models

Parameters:

Name	Type	Description	Default
`schema`	`dict`	The JSON schema to use for the final answer. If not provided, it will use the `output_data_model` argument.	`None`
`data_model`	`DataModel \| JsonDataModel \| SymbolicDataModel`	Optional. The data model to use for the final answer. If None provided, the Agent will return a ChatMessage-like data model.	`None`
`functions`	`list`	A list of Python functions for the agent to choose from.	`None`
`question`	`str`	Optional. The question to branch on actions at each step.	`None`
`continue_question`	`str`	Optional. The question for the continue-finish branch.	`None`
`language_model`	`LanguageModel`	The language model to use, if provided it will ignore `decision_language_model` and `action_language_model` argument.	`None`
`decision_language_model`	`LanguageModel`	The language model used for decision-making.	`None`
`action_language_model`	`LanguageModel`	The language model used for actions.	`None`
`prompt_template`	`str`	Optional. The jinja2 prompt template to use (See `Generator`).	`None`
`examples`	`list`	A default list of examples for decision-making (See `Decision`).	`None`
`instructions`	`list`	A default list of instructions for decision-making (See `Decision`).	`None`
`continue_instructions`	`list`	A default list of instructions for the continue-finish branch due to parallel tool calling.	`None`
`use_inputs_schema`	`bool`	Optional. Whether or not use the inputs schema in the decision prompt (Default to False) (see `Decision`).	`False`
`use_outputs_schema`	`bool`	Optional. Whether or not use the outputs schema in the decision prompt (Default to False) (see `Decision`).	`False`
`return_inputs_with_trajectory`	`bool`	Optional. Whether or not to concatenate the inputs along with the agent trajectory to the outputs (Default to False).	`False`
`return_inputs_only`	`bool`	Optional. Whether or not to concatenate the inputs to the outputs (Default to False).	`False`
`max_iterations`	`int`	The maximum number of steps to perform.	`5`
`name`	`str`	Optional. The name of the module.	`None`
`description`	`str`	Optional. The description of the module.	`None`
`trainable`	`bool`	Whether the module's variables should be trainable.	`True`