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<T>(tool: &T) -> Result<ToolSchema, EmbedError>

where T: PortableToolEmbedding + 'static,

Convert an embedding-backed tool to a ToolSchema.

Example

use rig_core::{
    embeddings::ToolSchema,
    tool::{PortableTool, PortableToolEmbedding},
};

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

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

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

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

    fn description(&self) -> String {
        "nothing".to_string()
    }

    fn parameters(&self) -> serde_json::Value {
        serde_json::json!({})
    }

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

impl PortableToolEmbedding 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>

Append all text fragments that should be embedded for this value.

impl Eq for ToolSchema

impl PartialEq for ToolSchema

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ToolSchema

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ToolSchema