Struct AgentBuilder

pub struct AgentBuilder { /* private fields */ }

Builder for Agent.

Implementations

impl AgentBuilder

pub fn hooks<VALUE: Into<Vec<Hook>>>(&mut self, value: VALUE) -> &mut Self

Hooks are functions that are called at specific points in the agent’s lifecycle.

pub fn toolboxes(&mut self, value: Vec<Box<dyn ToolBox>>) -> &mut Self

Toolboxes are collections of tools that can be added to the agent.

Toolboxes make their tools available to the agent at runtime.

pub fn system_prompt<VALUE: Into<Prompt>>(&mut self, value: VALUE) -> &mut Self

System prompt for the agent when it starts

Some agents profit significantly from a tailored prompt. But it is not always needed.

See SystemPrompt for an opiniated, customizable system prompt.

Swiftide provides a default system prompt for all agents.

Example

Agent::builder()
    .system_prompt(
        SystemPrompt::builder().role("You are an expert engineer")
        .build().unwrap())
    .build().unwrap();

pub fn limit(&mut self, value: usize) -> &mut Self

Optional limit on the amount of loops the agent can run. The counter is reset when the agent is stopped.

pub fn tool_retry_limit(&mut self, value: usize) -> &mut Self

The maximum amount of times the failed output of a tool will be send to an LLM before the agent stops. Defaults to 3.

LLMs sometimes send missing arguments, or a tool might actually fail, but retrying could be worth while. If the limit is not reached, the agent will send the formatted error back to the LLM.

The limit is hashed based on the tool call name and arguments, so the limit is per tool call.

This limit is not reset when the agent is stopped.

pub fn streaming(&mut self, value: bool) -> &mut Self

Enables streaming the chat completion responses for the agent.

pub fn build(&self) -> Result<Agent, AgentBuilderError>

Builds a new Agent.

Errors

If a required field has not been initialized.

impl AgentBuilder

pub fn context( &mut self, context: impl AgentContext + 'static, ) -> &mut AgentBuilder

where Self: Clone,

The context in which the agent operates, by default this is the DefaultContext.

pub fn no_system_prompt(&mut self) -> &mut Self

Disable the system prompt.

pub fn add_hook(&mut self, hook: Hook) -> &mut Self

Add a hook to the agent.

pub fn before_all(&mut self, hook: impl BeforeAllFn + 'static) -> &mut Self

Add a hook that runs once, before all completions. Even if the agent is paused and resumed, before all will not trigger again.

pub fn on_start(&mut self, hook: impl OnStartFn + 'static) -> &mut Self

Add a hook that runs once, when the agent starts. This hook also runs if the agent stopped and then starts again. The hook runs after any before_all hooks and before the before_completion hooks.

pub fn on_stream(&mut self, hook: impl OnStreamFn + 'static) -> &mut Self

Add a hook that runs when the agent receives a streaming response

The response will always include both the current accumulated message and the delta

This will set self.streaming to true, there is no need to set it manually for the default behaviour.

pub fn before_completion( &mut self, hook: impl BeforeCompletionFn + 'static, ) -> &mut Self

Add a hook that runs before each completion.

pub fn after_tool(&mut self, hook: impl AfterToolFn + 'static) -> &mut Self

Add a hook that runs after each tool. The Result<ToolOutput, ToolError> is provided as mut, so the tool output can be fully modified.

The ToolOutput also references the original ToolCall, allowing you to match at runtime what tool to interact with.

pub fn before_tool(&mut self, hook: impl BeforeToolFn + 'static) -> &mut Self

Add a hook that runs before each tool. Yields an immutable reference to the ToolCall.

pub fn after_completion( &mut self, hook: impl AfterCompletionFn + 'static, ) -> &mut Self

Add a hook that runs after each completion, before tool invocation and/or new messages.

pub fn after_each(&mut self, hook: impl AfterEachFn + 'static) -> &mut Self

Add a hook that runs after each completion, after tool invocations, right before a new loop might start

pub fn on_new_message( &mut self, hook: impl MessageHookFn + 'static, ) -> &mut Self

Add a hook that runs when a new message is added to the context. Note that each tool adds a separate message.

pub fn on_stop(&mut self, hook: impl OnStopFn + 'static) -> &mut Self

pub fn llm<LLM: ChatCompletion + Clone + 'static>( &mut self, llm: &LLM, ) -> &mut Self

Set the LLM for the agent. An LLM must implement the ChatCompletion trait.

pub fn tools<TOOL, I: IntoIterator<Item = TOOL>>( &mut self, tools: I, ) -> &mut Self

where TOOL: Into<Box<dyn Tool>>,

Define the available tools for the agent. Tools must implement the Tool trait.

See the tool attribute macro and the tool derive macro for easy ways to create (many) tools.

pub fn add_toolbox(&mut self, toolbox: impl ToolBox + 'static) -> &mut Self

Add a toolbox to the agent. Toolboxes are collections of tools that can be added to the to the agent. Available tools are evaluated at runtime, when the agent starts for the first time.

Agents can have many toolboxes.

Trait Implementations

impl Clone for AgentBuilder

fn clone(&self) -> AgentBuilder

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for AgentBuilder

fn default() -> Self

Returns the “default value” for a type.