Struct Tool 

pub struct Tool {
    pub name: String,
    pub description: String,
    pub parameters: Value,
}

Definition of a tool/function that the LLM can call.

Tools allow LLMs to perform actions by generating structured calls that your application executes. The LLM sees the tool’s name, description, and parameter schema to understand when and how to use it.

Example

use multi_llm::Tool;

let search_tool = Tool {
    name: "web_search".to_string(),
    description: "Search the web for information".to_string(),
    parameters: serde_json::json!({
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "The search query"
            },
            "max_results": {
                "type": "integer",
                "description": "Maximum results to return",
                "default": 10
            }
        },
        "required": ["query"]
    }),
};

Parameter Schema

The parameters field should be a valid JSON Schema object describing the tool’s input. Use type, properties, required, and description fields to help the LLM understand how to call your tool correctly.

Fields

name: String

Tool name - must be unique within a request.

Use descriptive names like “get_weather” or “search_documents”. This is how the LLM identifies which tool to call.

description: String

Human-readable description of what the tool does.

Be specific about capabilities and limitations. This helps the LLM decide when to use this tool vs. others.

parameters: Value

JSON Schema defining the tool’s input parameters.

Should be a JSON Schema object with type: "object" and properties describing each parameter. Include description for each property.

Trait Implementations

impl Clone for Tool

fn clone(&self) -> Tool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tool

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tool

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Tool

fn eq(&self, other: &Tool) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Tool

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Tool