Struct ToolSchema 

pub struct ToolSchema {
    pub name: String,
    pub context: Value,
    pub embedding_docs: Vec<String>,
}

Embeddable document that is used as an intermediate representation of a tool when RAGging tools.

Fields

name: String

context: Value

embedding_docs: Vec<String>

Implementations

impl ToolSchema

pub fn try_from(tool: &dyn ToolEmbeddingDyn) -> Result<Self, EmbedError>

Convert item that implements ToolEmbeddingDyn to an ToolSchema.

Example

use rig::{
    completion::ToolDefinition,
    embeddings::ToolSchema,
    tool::{Tool, ToolEmbedding, ToolEmbeddingDyn},
};
use serde_json::json;

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

#[derive(Debug, thiserror::Error)]
#[error("Init error")]
struct InitError;

struct Nothing;
impl Tool for Nothing {
    const NAME: &'static str = "nothing";

    type Error = NothingError;
    type Args = ();
    type Output = ();

    async fn definition(&self, _prompt: String) -> ToolDefinition {
        serde_json::from_value(json!({
            "name": "nothing",
            "description": "nothing",
            "parameters": {}
        }))
        .expect("Tool Definition")
    }

    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
        Ok(())
    }
}

impl ToolEmbedding for Nothing {
    type InitError = InitError;
    type Context = ();
    type State = ();

    fn init(_state: Self::State, _context: Self::Context) -> Result<Self, Self::InitError> {
        Ok(Nothing)
    }

    fn embedding_docs(&self) -> Vec<String> {
        vec!["Do nothing.".into()]
    }

    fn context(&self) -> Self::Context {}
}

let tool = ToolSchema::try_from(&Nothing).unwrap();

assert_eq!(tool.name, "nothing".to_string());
assert_eq!(tool.embedding_docs, vec!["Do nothing.".to_string()]);

Trait Implementations

impl Clone for ToolSchema

fn clone(&self) -> ToolSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for ToolSchema

fn default() -> ToolSchema

Returns the “default value” for a type.

impl Embed for ToolSchema

fn embed(&self, embedder: &mut TextEmbedder) -> Result<(), EmbedError>

impl PartialEq for ToolSchema

fn eq(&self, other: &ToolSchema) -> 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 ToolSchema

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ToolSchema

impl StructuralPartialEq for ToolSchema