Simple Agent

`Simple Agent`

The Simple Agent is the recommended starting point for building most AI solutions in NappAI. It offers a perfect balance between power and ease of use, allowing you to create conversational and automation agents that can use tools without the need for complex configurations.

This component is designed to be the backbone of your AI flows, providing essential reasoning, tool usage, and memory management capabilities.

Main Use Cases

Use the Simple Agent when your goal is to:

Build a chatbot that can answer questions using tools.
Create an assistant that executes specific tasks (e.g., sending an email, querying an API).
Orchestrate a workflow where the AI must decide which tool to use based on user input.
Quickly prototype AI solutions before moving to more complex architectures.

Configuration (Common Tab)

These are the essential parameters to define your agent’s behavior.

Parameter	Technical Description	Purpose in the Flow
`Agent Name`	A descriptive name for the agent.	Used to identify the agent, especially when exposed as a tool for a larger agent (a “supervisor”).
`Agent Description`	A clear and concise description of what the agent does.	Crucial when used as a tool. The supervisor agent will read this description to understand when to delegate a task to this sub-agent.
`User Prompt`	The template that formats the user input before being processed.	Allows adding context or structuring the user’s question. The `{input}` variable will be automatically replaced with the user’s text.
`Input`	Direct data input for the agent.	This is the main field where the user’s question is connected, usually from a `Chat Input` or another component.
`System Prompt`	The persistent instruction that defines the role, personality, rules, and objective of the agent.	Acts as the agent’s “constitution,” guiding its reasoning and ensuring consistent behavior.
`Tools`	Connection for the components the agent can use.	Connect tools here (e.g., `Web Search`, `API Request`) that you want to make available to the agent.
`Model`	Connection to the Language Model (LLM) that will power the agent’s reasoning.	This is the agent’s “cognitive engine.” Connect a component like `Gemini` or `OpenAI` here.

Configuration (Advanced Tab)

These parameters allow you to fine-tune your agent’s performance, output, and memory management.

Execution Control

Component ID: A unique identifier automatically generated for this component in your flow.
Max Iterations: Sets the maximum number of thought cycles (reasoning steps) the agent can perform in a single execution. It is a security measure to prevent infinite loops and control resource consumption.

Output

Use Structured Output: If activated, forces the agent to generate its final response in a strict JSON format defined by a schema. Essential when the agent’s output needs to be automatically processed by another system.
Stream: Allows the agent’s response to be sent word by word (streaming) instead of waiting for the full response to be generated. Improves perceived user experience in chat applications.
Include State in Response: If activated, the agent’s output will include not only the textual response but also the full internal state of the agent (memory, intermediate steps, etc.). Useful for advanced debugging.

Memory

Use Memory: Activates conversational memory. When enabled, the agent will remember past interactions in the same session, allowing for coherent conversations.

Configuration (Tool Tab)

This tab configures how this agent behaves when it is used as a tool by another supervisor agent.

Parameter	Technical Description
`Tool Name`	The name the supervisor agent will see and use to invoke this sub-agent.
`Tool Description`	The description the supervisor agent will read to decide if it should delegate a task to this sub-agent. It must be very clear and descriptive!
`Tool Response Mode`	Defines how the response from this sub-agent will affect the supervisor agent’s state. `Standard` is the most common option.

Configuration (Batch Mode Tab)

Batch Mode: Activates batch processing. If you connect a list of inputs (instead of a single one), the agent will run once for each item in the list, processing all tasks in a parallel and efficient manner.