Struct AgentBuilder 

pub struct AgentBuilder { /* private fields */ }

Agent Builder — fluent API to create a FunctionCallingAgent

Uses the Builder pattern so users can create and run an Agent in just 3 lines.

Basic usage

let agent = AgentBuilder::new()
    .llm(OpenAIChat::new(OpenAIConfig::new("sk-...")))
    .system("You are a helpful assistant.")
    .tool(Calculator::new())
    .build()?;

Using Arc<dyn BaseChatModel>

let llm = wrap_chat_model(OpenAIChat::new(config));
let agent = AgentBuilder::new()
    .llm_from_arc(llm)
    .system("You are a helpful assistant.")
    .build()?;

Implementations

impl AgentBuilder

pub fn new() -> Self

Creates a new AgentBuilder

pub fn llm<L>(self, llm: L) -> Self

where L: BaseChatModel + Send + Sync + 'static, L::Error: Into<ProviderError>,

Sets the LLM (any type implementing BaseChatModel)

Automatically wraps it as Arc<dyn BaseChatModel<Error = ProviderError>>.

pub fn llm_from_arc( self, llm: Arc<dyn BaseChatModel<Error = ProviderError> + Send + Sync>, ) -> Self

Sets the LLM (from an already-wrapped Arc<dyn BaseChatModel>)

For LLM instances already created via wrap_chat_model() or LLMClient.

pub fn system(self, prompt: impl Into<String>) -> Self

Sets the system prompt

pub fn tool<T: BaseTool + 'static>(self, tool: T) -> Self

Adds a single tool

pub fn tools(self, tools: Vec<Arc<dyn BaseTool>>) -> Self

Adds multiple tools

pub fn max_iterations(self, n: usize) -> Self

Sets max iterations (clamped to [1, 100] to prevent 0 or runaway limits)

pub fn build(self) -> Result<FunctionCallingAgent, AgentError>

Builds a FunctionCallingAgent

Errors

Returns AgentError::Other if no LLM was set.

pub fn build_as_agent(self) -> Result<Arc<dyn BaseAgent>, AgentError>

Builds and wraps as Arc<dyn BaseAgent> for direct use with AgentExecutor

Errors

Returns AgentError::Other if no LLM was set.

pub fn get_max_iterations(&self) -> usize

Returns the max iterations

Trait Implementations

impl Default for AgentBuilder

fn default() -> Self

Returns the “default value” for a type.