Struct Context 

pub struct Context {
    pub messages: Vec<Message>,
    pub context_tokens: usize,
    pub context_limit: usize,
}

Fields

messages: Vec<Message>

context_tokens: usize

context_limit: usize

Implementations

impl Context

pub fn new<S>(context: S, context_limit: usize) -> Self

where S: Into<String>,

Examples found in repository

examples/chat_completion.rs (lines 7-10)

async fn main() {
    let mut chat = Chat::new(
        Model::Kimiko13b,
        Context::new(
            "You're Jarvis – my assistant.", 
            4090
        ),
    );

    let request = Request {
        messages: vec!["Hello, Jarvis.".into()],
        context: true,
        stream: false,
        ..Default::default()
    };

    match chat.send(request).await {
        Ok(Some(res)) => println!("{}", res.text()),
        Err(e) => eprintln!("Error: {e}"),
        _ => {}
    }
}

examples/chat_completion_streaming.rs (line 7)

async fn main() {
    let mut chat = Chat::new(
        Model::Kimiko13b,   // Replace model if you are using a different one
        Context::new("You're Jarvis – my assistant.", 4090),
    );

    loop {
        eprint!("\n>> ");
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();

        let request = Request {
            messages: vec![buf.into()],
            context: true,
            stream: true,
            ..Default::default()
        };

        let _ = chat.send(request).await.unwrap();

        while let Some(result) = chat.next().await {
            match result {
                Ok(text) if !text.is_empty() => eprint!("{text}"),
                Err(e) => {
                    eprintln!("Error: {e}");
                    break;
                }
                _ => {}
            }
        }
    }
}

pub fn edit<S>(&mut self, modification: S)

where S: Into<String>,

pub fn add<M>(&mut self, message: M)

where M: Into<Message>,

pub fn get(&self) -> Vec<Message>

pub fn clear(&mut self)

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Context

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

Formats the value using the given formatter.

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.