llmkit 0.1.3

Production-grade LLM client - 100+ providers, 11,000+ models. Pure Rust.
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Embeddings Example
//!
//! Demonstrates text embedding generation and similarity computation.
//!
//! Requirements:
//! - Set OPENAI_API_KEY environment variable (for text-embedding-3-small)
//!
//! Run:
//!     cargo run --example 11_embeddings

use llmkit::{EmbeddingRequest, LLMKitClient};

#[tokio::main]
async fn main() -> llmkit::Result<()> {
    let client = LLMKitClient::builder()
        .with_openai_from_env()
        .build()
        .await?;

    // Example 1: Basic embedding
    println!("=== Example 1: Basic Embedding ===");
    let request = EmbeddingRequest::new("openai/text-embedding-3-small", "Hello, world!");
    let response = client.embed(request).await?;

    println!("Model: {}", response.model);
    println!("Dimensions: {}", response.dimensions());
    if let Some(values) = response.values() {
        println!("First 5 values: {:?}", &values[..5.min(values.len())]);
    }
    println!("Tokens used: {}", response.usage.total_tokens);

    // Example 2: Batch embeddings
    println!("\n=== Example 2: Batch Embeddings ===");
    let texts = vec![
        "The quick brown fox",
        "A lazy dog sleeps",
        "Python is a programming language",
        "Machine learning is fascinating",
    ];

    let request = EmbeddingRequest::batch("openai/text-embedding-3-small", texts.clone());
    let response = client.embed(request).await?;

    println!("Got {} embeddings", response.embeddings.len());
    println!("Dimensions: {}", response.dimensions());
    for emb in &response.embeddings {
        println!("  Text {}: {} dimensions", emb.index, emb.values.len());
    }

    // Example 3: Compute similarity
    println!("\n=== Example 3: Similarity Computation ===");
    let similarity_texts = vec![
        "I love programming in Python",
        "Python coding is my favorite",
        "The weather is nice today",
        "I enjoy writing code",
    ];

    let request =
        EmbeddingRequest::batch("openai/text-embedding-3-small", similarity_texts.clone());
    let response = client.embed(request).await?;

    let reference = &response.embeddings[0];
    println!("Reference: '{}'", similarity_texts[0]);
    println!("\nSimilarities:");

    for (i, emb) in response.embeddings.iter().skip(1).enumerate() {
        let similarity = reference.cosine_similarity(emb);
        println!("  vs '{}': {:.4}", similarity_texts[i + 1], similarity);
    }

    // Example 4: Semantic search
    println!("\n=== Example 4: Semantic Search ===");
    let documents = vec![
        "Python is a high-level programming language",
        "Machine learning uses algorithms to learn from data",
        "The Eiffel Tower is located in Paris, France",
        "Deep learning is a subset of machine learning",
        "JavaScript is commonly used for web development",
        "Natural language processing deals with text and speech",
    ];

    let query = "What is artificial intelligence?";
    println!("Query: '{}'", query);

    // Embed query
    let query_response = client
        .embed(EmbeddingRequest::new(
            "openai/text-embedding-3-small",
            query,
        ))
        .await?;
    let query_embedding = &query_response.embeddings[0];

    // Embed documents
    let doc_response = client
        .embed(EmbeddingRequest::batch(
            "openai/text-embedding-3-small",
            documents.clone(),
        ))
        .await?;

    // Compute similarities and rank
    let mut results: Vec<(f32, &str)> = doc_response
        .embeddings
        .iter()
        .enumerate()
        .map(|(i, emb)| (query_embedding.cosine_similarity(emb), documents[i]))
        .collect();

    results.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());

    println!("\nResults (by relevance):");
    for (similarity, doc) in results {
        println!("  [{:.4}] {}", similarity, doc);
    }

    // Example 5: Distance metrics
    println!("\n=== Example 5: Distance Metrics ===");
    let metric_texts = vec!["Hello world", "Hello there"];

    let response = client
        .embed(EmbeddingRequest::batch(
            "openai/text-embedding-3-small",
            metric_texts.clone(),
        ))
        .await?;

    let emb1 = &response.embeddings[0];
    let emb2 = &response.embeddings[1];

    println!("Text 1: '{}'", metric_texts[0]);
    println!("Text 2: '{}'", metric_texts[1]);
    println!();
    println!("Distance metrics:");
    println!("  Cosine similarity: {:.6}", emb1.cosine_similarity(emb2));
    println!("  Dot product: {:.6}", emb1.dot_product(emb2));
    println!("  Euclidean distance: {:.6}", emb1.euclidean_distance(emb2));

    Ok(())
}