Struct Agent 

pub struct Agent<M: Completion> {

    pub model: Ref<M>,
    pub store_indices: Vec<(usize, Box<dyn Storage>)>,
    pub tools: Ref<Vec<Box<dyn Tool>>>,
    pub knowledges: Arc<Vec<Box<dyn Knowledge>>>,
    pub memory: Option<Ref<dyn Memory>>,
    pub id: Uuid,
    pub name: String,
    pub preamble: String,
    pub temperature: Option<f32>,
    pub max_tokens: Option<usize>,
    pub max_execution_time: Option<usize>,
    pub respect_context_window: bool,
    pub allow_code_execution: bool,
    /* private fields */
}

Fields

model: Ref<M>

The model to use.

store_indices: Vec<(usize, Box<dyn Storage>)>

Indexed storage for the agent.

tools: Ref<Vec<Box<dyn Tool>>>

The tools to use.

knowledges: Arc<Vec<Box<dyn Knowledge>>>

Knowledge sources for the agent.

memory: Option<Ref<dyn Memory>>

Agent memory.

id: Uuid

The unique ID of the agent.

name: String

The name of the agent.

preamble: String

System prompt for the agent.

temperature: Option<f32>

Temperature of the model.

max_tokens: Option<usize>

Maximum number of tokens for the completion.

max_execution_time: Option<usize>

Maximum execution time for the agent to complete a task.

respect_context_window: bool

Whether to respect the context window.

allow_code_execution: bool

Whether code execution is allowed.

Implementations

impl<M> Agent<M>

where M: Completion,

pub fn new(name: impl ToString, model: M) -> Agent<M>

Creates a new agent.

pub fn new_with_tools<I>(name: impl ToString, model: M, tools: I) -> Agent<M>

where I: IntoIterator<Item = Box<dyn Tool>>,

Creates a new agent with some tools

pub async fn tool(self, tool: impl Tool + 'static) -> Self

Add a tool into the agent

pub async fn tools<I>(self, tools: I) -> Self

where I: IntoIterator<Item = Box<dyn Tool>>,

Add some tools into the agent

pub fn memory(self, memory: impl Memory + 'static) -> Self

Adds a memory to the agent.

pub fn store_index(self, sample: usize, store: impl Storage + 'static) -> Self

Adds a storage index to the agent.

pub fn preamble(self, preamble: impl ToString) -> Self

System prompt for the agent.

pub async fn mcp_client(self, mcp_client: MCPClient) -> Self

Set the MCP client.

pub async fn mcp_config_path<P: AsRef<Path>>( self, path: P, ) -> Result<Self, MCPError>

Set the MCP server config path.

pub async fn mcp_sse_client<S: AsRef<str> + 'static>( self, sse_url: S, env: HashMap<String, String>, ) -> Result<Self>

Set the MCP sse client.

pub async fn mcp_stdio_client<S: AsRef<str> + 'static>( self, command: S, args: Vec<S>, env: HashMap<String, String>, ) -> Result<Self>

Set the MCP sse client.

pub async fn prompt(&self, prompt: &str) -> Result<String, TaskError>

Processes a prompt using the agent.

pub async fn chat( &self, prompt: &str, history: Vec<Message>, ) -> Result<String, TaskError>

Processes a prompt using the agent.