Struct openai_gpt_rs::args::ChatArgs

pub struct ChatArgs {
    pub model: String,
    pub messages: Vec<Message>,
    pub n: i32,
    pub temperature: f64,
    pub top_p: f64,
    pub max_tokens: u32,
    pub presence_penalty: f64,
    pub frequency_penalty: f64,
}

Fields

model: String

messages: Vec<Message>

n: i32

temperature: f64

top_p: f64

max_tokens: u32

presence_penalty: f64

frequency_penalty: f64

Implementations

impl ChatArgs

pub fn model(&mut self, model: ChatModels) -> &mut Self

Set the model to use

pub fn messages(&mut self, messages: Vec<Message>) -> &mut Self

Set the messages to use

Examples found in repository

examples/chat.rs (line 44)

async fn main() {
    let client = Client::new(env::var("OPENAI_API_KEY").unwrap().as_str());

    let mut role: String;
    let mut message = String::new();

    let mut index = String::new();

    print!("    1: system\n    2: assistant\n    3: user\nSelect a role: ");
    let _ = stdout().flush();

    stdin().read_line(&mut index).unwrap();

    if index.trim() == "1" {
        role = "system".to_string();
    } else if index.trim() == "2" {
        role = "assistant".to_string();
    } else if index.trim() == "3" {
        role = "user".to_string();
    } else {
        panic!("Invalid role!");
    }

    role = role.trim().to_string();

    print!("Enter a message: ");
    let _ = stdout().flush();

    stdin().read_line(&mut message).unwrap();

    let content = message.trim().to_string();

    let message = Message { role, content };

    let message = vec![message];

    let resp = client
        .create_chat_completion(|args| args.messages(message))
        .await
        .unwrap();

    let content = resp.get_content(0).unwrap();

    println!("Response: {}", content);
}

pub fn n(&mut self, n: i32) -> &mut Self

Set the number of messages to return

pub fn temperature(&mut self, temperature: f64) -> &mut Self

Set the temperature to use

pub fn top_p(&mut self, top_p: f64) -> &mut Self

Set the top_p to use

pub fn max_tokens(&mut self, max_tokens: u32) -> &mut Self

Set the max_tokens to use

pub fn presence_penalty(&mut self, presence_penalty: f64) -> &mut Self

Set the presence_penalty to use

pub fn frequency_penalty(&mut self, frequency_penalty: f64) -> &mut Self

Set the frequency_penalty to use

Trait Implementations

impl Debug for ChatArgs

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

Formats the value using the given formatter.

impl Default for ChatArgs

fn default() -> Self

Default chat arguments