Trait rig::tool::Tool

pub trait Tool: Sized + Send + Sync {
    type Error: Error + Send + Sync + 'static;
    type Args: for<'a> Deserialize<'a> + Send + Sync;
    type Output: Serialize;

    const NAME: &'static str;

    // Required methods
    fn definition(
        &self,
        _prompt: String,
    ) -> impl Future<Output = ToolDefinition> + Send + Sync;
    fn call(
        &self,
        args: Self::Args,
    ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + Sync;

    // Provided method
    fn name(&self) -> String { ... }
}

Trait that represents a simple LLM tool

Example

use rig::tool::{ToolSet, Tool};

#[derive(Deserialize)]
struct AddArgs {
    x: i32,
    y: i32,
}

#[derive(Debug, thiserror::Error)]
#[error("Math error")]
struct MathError;

#[derive(Deserialize, Serialize)]
struct Adder;

impl Tool for Adder {
    const NAME: &'static str = "add";

    type Error = MathError;
    type Args = AddArgs;
    type Output = i32;

    async fn definition(&self, _prompt: String) -> ToolDefinition {
        ToolDefinition {
            name: "add".to_string(),
            description: "Add x and y together".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "x": {
                        "type": "number",
                        "description": "The first number to add"
                    },
                    "y": {
                        "type": "number",
                        "description": "The second number to add"
                    }
                }
            })
        }
    }

    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
        let result = args.x + args.y;
        Ok(result)
    }
}

Required Associated Types

type Error: Error + Send + Sync + 'static

The error type of the tool.

type Args: for<'a> Deserialize<'a> + Send + Sync

The arguments type of the tool.

type Output: Serialize

The output type of the tool.

Required Associated Constants

const NAME: &'static str

The name of the tool. This name should be unique.

Required Methods

fn definition( &self, _prompt: String, ) -> impl Future<Output = ToolDefinition> + Send + Sync

A method returning the tool definition. The user prompt can be used to tailor the definition to the specific use case.

fn call( &self, args: Self::Args, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send + Sync

The tool execution method. Both the arguments and return value are a String since these values are meant to be the output and input of LLM models (respectively)

Provided Methods

fn name(&self) -> String

A method returning the name of the tool.

Object Safety

This trait is not object safe.

Implementors