DAGent

Description

DAGent offers an opinionated Python library for the swift creation of AI agents with minimal overhead. The core concept revolves around structuring AI agent logic into a workflow, visualized as a Directed Acyclic Graph (DAG). Each Python function within the agent is treated as a node in this graph.

Agentic behavior is achieved by employing Large Language Models (LLMs) to infer which function to execute next. This inference process is managed by a "Decision Node," which acts as the central point for LLM-driven decision-making. Tools, which are essentially Python functions, can be integrated into the agent. It is highly recommended to provide clear docstrings and type annotations for these functions to assist the LLM in understanding their purpose and parameters, especially for more complex tools.

The library distinguishes between `FunctionNode` and `DecisionNode`. A `FunctionNode` executes a Python function, and when attached to a `DecisionNode`, it can be treated as a tool that an LLM can select. The `DecisionNode` is where the LLM chooses from a set of available functions. The `.compile()` method automatically generates and saves tool descriptions in JSON format under a `Tool_JSON` folder, which can be manually edited if the agent's reliability needs improvement. The `prev_output` parameter is crucial for passing data between functions in the workflow, requiring it to be present in the function signature. For handling unexpected parameters, adding `**kwargs` to function signatures is advised.

DAGent supports the use of various LLM models for inference and tool description generation. Users can specify the desired model when calling LLM functions or when compiling `DecisionNode` instances, allowing flexibility in choosing models like those from Groq or Ollama. The library facilitates dynamic parameter overriding for function nodes, enabling fine-tuning of agent behavior during execution. Feedback on the library can be provided through a dedicated form.

DAGent's Core Features

• Build AI agents using existing Python code

• Structure agent logic as Directed Acyclic Graphs (DAGs)

• LLM-driven function selection via Decision Nodes

• Functions treated as tools for LLMs

• Automatic generation of tool descriptions (JSON)

• Support for multiple LLM models (e.g., Groq, Ollama)

• Pass data between functions using `prev_output` parameter

• Dynamic parameter overriding for function nodes

• Includes example quickstart agent

Getting Started with DAGent

1. 1

   Install: pip install dagent or rye add dagent

2. 2

   Configure: Ensure your API key (e.g., OPENAI_API_KEY) is available

3. 3

   Develop: Define Python functions to act as nodes

4. 4

   Integrate: Use DecisionNode to allow LLMs to select functions

5. 5

   Compile: Run `.compile()` to generate tool descriptions

6. 6

   Execute: Run your agent workflow

DAGent's Use Cases

• Automated Task Execution
• Data Analysis Agents
• Code Generation Assistants
• Workflow Automation
• Custom AI Tool Integration
• LLM-powered Scripting

FAQ from DAGent

• What is DAGent?

  DAGent is a Python library that allows developers to build AI agents quickly by structuring their logic into Directed Acyclic Graphs (DAGs) and leveraging LLMs for decision-making.

• How does DAGent structure AI agents?

  DAGent structures AI agents into workflows where each Python function is a node in a Directed Acyclic Graph (DAG). An LLM, through a Decision Node, infers which function to execute next.

• Can I use my existing Python code with DAGent?

  Yes, DAGent is designed to build AI agents with your existing Python code. Functions can be treated as tools that the LLM can utilize.

• What is a Decision Node in DAGent?

  A Decision Node is a component in DAGent where an LLM selects which function (tool) to run from a given set of options.

• How are tool descriptions generated in DAGent?

  Tool descriptions are automatically generated and saved in JSON format under a `Tool_JSON` folder when you call the `.compile()` method on a DecisionNode.

• How do I pass data between functions in DAGent?

  Data can be passed between functions by including the `prev_output` parameter in the function signature. This parameter receives the return value from the preceding function.

• Does DAGent support different LLM models?

  Yes, DAGent supports using different LLM models for inference and tool description generation. You can specify the model when calling LLM functions or compiling DecisionNodes.

• How can I override function parameters in DAGent?

  Function arguments can be overridden at any time by setting the `user_params` attribute on the function node, merging kwargs with priority to the user.

• What should I do if my agent is unreliable?

  If the agent is unreliable, you can try editing the generated tool descriptions in the `Tool_JSON` folder or run the compile method with `force_load=True`.

• What are the installation options for DAGent?

  You can install DAGent using pip with `pip install dagent` or using rye with `rye add dagent`.