Struct Message

pub struct Message { /* private fields */ }

An individual message in a chat.

Implementations

impl Message

pub fn system(content: &str) -> Self

Create a new system message.

System messages are used to provide instructions to the model. It’s not recommended to use more than one of these in a given chat.

Examples found in repository

examples/text_generation_pipeline_with_messages.rs (line 16)

fn main() -> Result<()> {
    println!("Building pipeline...");

    // 1. Create the pipeline, using the builder to configure the model
    let pipeline = TextGenerationPipelineBuilder::new(ModelOptions::Phi4(Phi4Size::Size14B))
        .temperature(0.7)
        .build()?;
    println!("Pipeline built successfully.");

    // 2. Define messages and max length
    let mut messages = vec![
        Message::system("You are a helpful pirate assistant."),
        Message::user("Explain the concept of Large Language Models in simple terms."),
    ];
    let max_length = 500; // Maximum number of tokens to generate

    // Get the last user message in the messages vector
    let prompt = messages
        .iter()
        .rev()
        .find(|message| message.role() == "user")
        .unwrap()
        .content();

    println!("Generating text for prompt: '{}'", prompt);

    // 3. Generate text
    let generated_text = pipeline.message_completion(messages.clone(), max_length)?;

    println!("\n--- Generated Text ---");
    println!("{}", generated_text);
    println!("--- End of Text ---\n");

    // Add the models response to the messages
    messages.push(Message::assistant(generated_text.as_str()));

    messages.push(Message::user(
        "Explain the fibonacci sequence in simple terms. /no_think",
    ));

    let generated_text = pipeline.message_completion(messages, max_length)?;

    println!("\n--- Generated Text 2 ---");
    println!("{}", generated_text);
    println!("--- End of Text 2 ---");

    Ok(())
}

pub fn user(content: &str) -> Self

Create a new user message.

User messages are used to send messages from the user to the model.

Examples found in repository

examples/text_generation_pipeline_with_messages.rs (line 17)

fn main() -> Result<()> {
    println!("Building pipeline...");

    // 1. Create the pipeline, using the builder to configure the model
    let pipeline = TextGenerationPipelineBuilder::new(ModelOptions::Phi4(Phi4Size::Size14B))
        .temperature(0.7)
        .build()?;
    println!("Pipeline built successfully.");

    // 2. Define messages and max length
    let mut messages = vec![
        Message::system("You are a helpful pirate assistant."),
        Message::user("Explain the concept of Large Language Models in simple terms."),
    ];
    let max_length = 500; // Maximum number of tokens to generate

    // Get the last user message in the messages vector
    let prompt = messages
        .iter()
        .rev()
        .find(|message| message.role() == "user")
        .unwrap()
        .content();

    println!("Generating text for prompt: '{}'", prompt);

    // 3. Generate text
    let generated_text = pipeline.message_completion(messages.clone(), max_length)?;

    println!("\n--- Generated Text ---");
    println!("{}", generated_text);
    println!("--- End of Text ---\n");

    // Add the models response to the messages
    messages.push(Message::assistant(generated_text.as_str()));

    messages.push(Message::user(
        "Explain the fibonacci sequence in simple terms. /no_think",
    ));

    let generated_text = pipeline.message_completion(messages, max_length)?;

    println!("\n--- Generated Text 2 ---");
    println!("{}", generated_text);
    println!("--- End of Text 2 ---");

    Ok(())
}

pub fn assistant(content: &str) -> Self

Create a new assistant message.

Assistant messages are used to store responses from the model.

Examples found in repository

examples/text_generation_pipeline_with_messages.rs (line 39)

fn main() -> Result<()> {
    println!("Building pipeline...");

    // 1. Create the pipeline, using the builder to configure the model
    let pipeline = TextGenerationPipelineBuilder::new(ModelOptions::Phi4(Phi4Size::Size14B))
        .temperature(0.7)
        .build()?;
    println!("Pipeline built successfully.");

    // 2. Define messages and max length
    let mut messages = vec![
        Message::system("You are a helpful pirate assistant."),
        Message::user("Explain the concept of Large Language Models in simple terms."),
    ];
    let max_length = 500; // Maximum number of tokens to generate

    // Get the last user message in the messages vector
    let prompt = messages
        .iter()
        .rev()
        .find(|message| message.role() == "user")
        .unwrap()
        .content();

    println!("Generating text for prompt: '{}'", prompt);

    // 3. Generate text
    let generated_text = pipeline.message_completion(messages.clone(), max_length)?;

    println!("\n--- Generated Text ---");
    println!("{}", generated_text);
    println!("--- End of Text ---\n");

    // Add the models response to the messages
    messages.push(Message::assistant(generated_text.as_str()));

    messages.push(Message::user(
        "Explain the fibonacci sequence in simple terms. /no_think",
    ));

    let generated_text = pipeline.message_completion(messages, max_length)?;

    println!("\n--- Generated Text 2 ---");
    println!("{}", generated_text);
    println!("--- End of Text 2 ---");

    Ok(())
}

pub fn role(&self) -> &str

Get the role of the message.

Examples found in repository

examples/text_generation_pipeline_with_messages.rs (line 25)

fn main() -> Result<()> {
    println!("Building pipeline...");

    // 1. Create the pipeline, using the builder to configure the model
    let pipeline = TextGenerationPipelineBuilder::new(ModelOptions::Phi4(Phi4Size::Size14B))
        .temperature(0.7)
        .build()?;
    println!("Pipeline built successfully.");

    // 2. Define messages and max length
    let mut messages = vec![
        Message::system("You are a helpful pirate assistant."),
        Message::user("Explain the concept of Large Language Models in simple terms."),
    ];
    let max_length = 500; // Maximum number of tokens to generate

    // Get the last user message in the messages vector
    let prompt = messages
        .iter()
        .rev()
        .find(|message| message.role() == "user")
        .unwrap()
        .content();

    println!("Generating text for prompt: '{}'", prompt);

    // 3. Generate text
    let generated_text = pipeline.message_completion(messages.clone(), max_length)?;

    println!("\n--- Generated Text ---");
    println!("{}", generated_text);
    println!("--- End of Text ---\n");

    // Add the models response to the messages
    messages.push(Message::assistant(generated_text.as_str()));

    messages.push(Message::user(
        "Explain the fibonacci sequence in simple terms. /no_think",
    ));

    let generated_text = pipeline.message_completion(messages, max_length)?;

    println!("\n--- Generated Text 2 ---");
    println!("{}", generated_text);
    println!("--- End of Text 2 ---");

    Ok(())
}

pub fn content(&self) -> &str

Get the content of the message.

Examples found in repository

examples/text_generation_pipeline_with_messages.rs (line 27)

fn main() -> Result<()> {
    println!("Building pipeline...");

    // 1. Create the pipeline, using the builder to configure the model
    let pipeline = TextGenerationPipelineBuilder::new(ModelOptions::Phi4(Phi4Size::Size14B))
        .temperature(0.7)
        .build()?;
    println!("Pipeline built successfully.");

    // 2. Define messages and max length
    let mut messages = vec![
        Message::system("You are a helpful pirate assistant."),
        Message::user("Explain the concept of Large Language Models in simple terms."),
    ];
    let max_length = 500; // Maximum number of tokens to generate

    // Get the last user message in the messages vector
    let prompt = messages
        .iter()
        .rev()
        .find(|message| message.role() == "user")
        .unwrap()
        .content();

    println!("Generating text for prompt: '{}'", prompt);

    // 3. Generate text
    let generated_text = pipeline.message_completion(messages.clone(), max_length)?;

    println!("\n--- Generated Text ---");
    println!("{}", generated_text);
    println!("--- End of Text ---\n");

    // Add the models response to the messages
    messages.push(Message::assistant(generated_text.as_str()));

    messages.push(Message::user(
        "Explain the fibonacci sequence in simple terms. /no_think",
    ));

    let generated_text = pipeline.message_completion(messages, max_length)?;

    println!("\n--- Generated Text 2 ---");
    println!("{}", generated_text);
    println!("--- End of Text 2 ---");

    Ok(())
}

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Message

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Message

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

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 Message

impl StructuralPartialEq for Message