Struct Agent 

pub struct Agent {
    pub cache: MessageStack,
    pub completion_model: CompletionModel,
}

Fields

cache: MessageStack

completion_model: CompletionModel

Implementations

impl Agent

pub fn new(init_prompt: Option<&str>, completion_model: CompletionModel) -> Self

For creating an Agent given optional system prompt content and model

Examples found in repository

examples/rag.rs (lines 164-167)

async fn main() {
    dotenv::dotenv().ok();
    let api_key = std::env::var("OPENAI_KEY").unwrap();
    let embedder = EmbeddingModel::default_openai(&api_key);
    let mut agent = Agent::new(
        Some("You are jerry!!"),
        CompletionModel::default_openai(&api_key),
    );

    let mut rag = RagManager {
        embedder,
        data: None,
    };

    rag.init_products().await;
    // agent.insert_listener(listener);

    let m = Message::new_user("I need a new fitness toy, what is the best product for me?");
    let message_embedding = rag
        .embed(&m.content)
        .await
        .expect("Failed to embed message content");
    let relavent = rag
        .data
        .as_ref()
        .unwrap()
        .get_close_embeddings_from_query_embedding(message_embedding, 5)
        .await;
    println!("Got relavent structs: {relavent:#?}");
    agent.cache.push(m);
    agent.cache.push(relavent.to_message(MessageRole::User));
    let response = agent.io_completion().await.unwrap();
    println!("{:?}", response);
}

examples/summarize_at_limit.rs (lines 43-46)

async fn main() {
    dotenv::dotenv().ok();
    let api_key = std::env::var("ANTHROPIC_KEY").unwrap();
    let mut agent = Agent::new(
        Some("You are jerry!!"),
        CompletionModel::default_anthropic(&api_key),
    );

    let summarizer = Agent::new(
        Some("Your job is to summarize chunks of a conversation"),
        CompletionModel::default_anthropic(&api_key),
    );
    let mut sal = SummarizeAtLimit::new(5usize, summarizer);

    // agent.insert_listener(sal);
    let message = Message::new_user("im saying things to fill space");

    for _ in 0..=5 {
        // And now we use our predefined action method
        push_to_cache_with_limit(&mut agent, &mut sal, message.clone())
            .await
            .unwrap();
    }

    // env.finalize_dispatch().await.unwrap();
    println!("STACK: {:?}", agent.cache);
    assert_eq!(agent.cache.len(), 4);
    assert_eq!(agent.cache.as_ref()[0].role, MessageRole::System);
    assert_eq!(agent.cache.as_ref()[1].role, MessageRole::Assistant);
    assert_eq!(agent.cache.as_ref()[2].role, MessageRole::User);
    println!("All asserts passed, summarize at limit working as expected");
}

pub async fn io_completion(&mut self) -> AgentResult<String>

Get a simple string response from a model

Examples found in repository

examples/summarize_at_limit.rs (line 30)

async fn push_to_cache_with_limit(
    agent: &mut Agent,
    sum: &mut SummarizeAtLimit,
    m: Message,
) -> AgentResult<()> {
    if agent.cache.len() >= sum.limit {
        let message = Message::new_user(&format!(
            "Summarize this chat history: {}",
            agent.cache.to_string()
        ));
        sum.summarizer.cache.push(message);

        let summary = sum.summarizer.io_completion().await?;

        agent.cache.mut_filter_by(&MessageRole::System, true);
        agent.cache.push(Message::new_assistant(&summary));
    }
    agent.cache.push(m);
    Ok(())
}

examples/rag.rs (line 191)

async fn main() {
    dotenv::dotenv().ok();
    let api_key = std::env::var("OPENAI_KEY").unwrap();
    let embedder = EmbeddingModel::default_openai(&api_key);
    let mut agent = Agent::new(
        Some("You are jerry!!"),
        CompletionModel::default_openai(&api_key),
    );

    let mut rag = RagManager {
        embedder,
        data: None,
    };

    rag.init_products().await;
    // agent.insert_listener(listener);

    let m = Message::new_user("I need a new fitness toy, what is the best product for me?");
    let message_embedding = rag
        .embed(&m.content)
        .await
        .expect("Failed to embed message content");
    let relavent = rag
        .data
        .as_ref()
        .unwrap()
        .get_close_embeddings_from_query_embedding(message_embedding, 5)
        .await;
    println!("Got relavent structs: {relavent:#?}");
    agent.cache.push(m);
    agent.cache.push(relavent.to_message(MessageRole::User));
    let response = agent.io_completion().await.unwrap();
    println!("{:?}", response);
}

pub async fn stream_completion(&mut self) -> AgentResult<ProviderStreamHandler>

Get a streamed response from a model

pub async fn function_completion( &mut self, function: Function, ) -> AgentResult<Value>

Get a function completion from a model, returns a JSON object

Trait Implementations

impl Clone for Agent

fn clone(&self) -> Agent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Agent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Agent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Agent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.