llm 1.3.8

A Rust library unifying multiple LLM backends.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

use llm::{
    builder::{LLMBackend, LLMBuilder},
    chat::ChatMessage,
    memory::TrimStrategy,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let llm = LLMBuilder::new()
        .backend(LLMBackend::OpenAI)
        .api_key(std::env::var("OPENAI_API_KEY").unwrap_or("sk-TESTKEY".into()))
        .model("gpt-3.5-turbo")
        .sliding_window_with_strategy(3, TrimStrategy::Summarize)
        .build()?;

    println!("Testing TrimStrategy::Summarize with window size 3");

    let messages = [
        ChatMessage::user()
            .content("Hello, my name is Alice")
            .build(),
        ChatMessage::user()
            .content("I love programming in Rust")
            .build(),
        ChatMessage::user()
            .content("What's the weather like?")
            .build(),
        ChatMessage::user().content("Tell me about AI").build(),
    ];

    for (i, message) in messages.iter().enumerate() {
        println!("\n--- Message {} ---", i + 1);
        println!("Sending: {}", message.content);

        match llm.chat(std::slice::from_ref(message)).await {
            Ok(response) => println!("Response: {response}"),
            Err(e) => eprintln!("Error: {e}"),
        }

        if let Some(memory_contents) = llm.memory_contents().await {
            println!("\nMemory contents ({} messages):", memory_contents.len());
            for (j, msg) in memory_contents.iter().enumerate() {
                let role = match msg.role {
                    llm::chat::ChatRole::User => "User",
                    llm::chat::ChatRole::Assistant => "Assistant",
                };
                println!("  {}: {} - '{}'", j + 1, role, msg.content);
            }
        }
    }

    Ok(())
}