rig — Bibliothek zur LLM-Integration in Rust

In der Rust-Entwicklung war die Arbeit mit großen Sprachmodellen (LLMs) lange Zeit eine komplexe Herausforderung. Die meisten SDKs waren in Python oder JavaScript geschrieben, während das Rust-Ökosystem nur vereinzelte HTTP-Clients bot. Die Bibliothek rig (Rust Integration with GGUF/LLM) löst dieses Problem, indem sie eine einheitliche, ergonomische und sichere Schnittstelle für die Interaktion mit Dutzenden von LLM-Anbietern bereitstellt: OpenAI, Anthropic, Cohere, Google Gemini, Llama.cpp, Ollama und viele mehr.

Warum rig? Erstens bietet sie eine typsichere API: Alle Anfragen und Antworten sind streng typisiert, was eine ganze Klasse von Laufzeitfehlern ausschließt. Zweitens implementiert rig Pipelines – komponierbare Aufrufketten für LLMs mit Unterstützung für Streaming, Kontextfenster und Tool Calling. Drittens ist die Bibliothek auf Leistung ausgelegt: Asynchronität von Haus aus, minimale Allokationen und Batching-Unterstützung.

Dieser Artikel ist eine ausführliche Anleitung zu rig. Wir behandeln die Installation, die wichtigsten Methoden, schreiben ein praktisches Beispiel und geben Optimierungstipps. Am Ende können Sie produktionsreife Rust-Anwendungen mit LLM-Integration erstellen.

Installation

Fügen Sie rig zu Ihrem Cargo-Projekt hinzu:

cargo add rig-core --features openai,anthropic,cohere,gemini,ollama,llama-cpp

Wenn Sie nur einen Anbieter benötigen, z. B. OpenAI:

cargo add rig-core --features openai

Für die Arbeit mit lokalen Modellen über llama.cpp müssen Sie llama.cpp selbst installieren (laden Sie es von GitHub herunter) und mit CUDA/Metal-Unterstützung kompilieren. Fügen Sie dann das Feature llama-cpp hinzu.

Mindestversion von Rust: 1.75.0. Überprüfen Sie:

rustc --version

Schnellstart

Erstellen Sie eine Datei src/main.rs und schreiben Sie eine einfache Anfrage an OpenAI:

use rig::providers::openai;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Client-Initialisierung über die Umgebungsvariable OPENAI_API_KEY
    let client = openai::Client::from_env();
    
    // Modell erstellen
    let model = client.model("gpt-4o-mini").build();
    
    // Anfrage senden
    let response = model.prompt("Erzähl einen Witz über Programmierer").await?;
    
    println!("{}", response);
    Ok(())
}

Starten Sie:

export OPENAI_API_KEY="sk-..."
cargo run

Sie sehen einen generierten Witz. Herzlichen Glückwunsch – Sie haben gerade ein LLM in Rust integriert!

Wichtige Methoden und Funktionen

Betrachten wir die wichtigsten Methoden von rig. Für jede geben wir die Signatur, eine Beschreibung und ein funktionierendes Beispiel an.

1. `Client::from_env()`

Signatur: pub fn from_env() -> Self

Funktion: Erstellt einen Client für einen bestimmten Anbieter, indem der API-Schlüssel aus einer Umgebungsvariable gelesen wird (z. B. OPENAI_API_KEY).

use rig::providers::openai;
let client = openai::Client::from_env();

2. `Client::model(name)`

Signatur: pub fn model(&self, model_name: &str) -> ModelBuilder

Funktion: Gibt einen Builder zur Konfiguration des Modells zurück. Ermöglicht das Festlegen von Temperatur, max_tokens, Stoppwörtern und anderen Parametern.

let model = client.model("gpt-4o")
    .temperature(0.7)
    .max_tokens(200)
    .build();

3. `Model::prompt(text)`

Signatur: pub async fn prompt(&self, prompt: impl Into<String>) -> Result<String, ModelError>

Funktion: Sendet eine Prompt-Anfrage an das Modell und gibt die Antwort als String zurück. Ideal für einfache Frage-Antwort-Szenarien.

let antwort = model.prompt("Was ist der Sinn des Lebens?").await?;
println!("{}", antwort);

4. `Model::stream_prompt(text)`

Signatur: pub async fn stream_prompt(&self, prompt: impl Into<String>) -> Result<impl Stream<Item = Result<String, ModelError>>, ModelError>

Funktion: Wie prompt, aber die Antwort wird als Stream von Textfragmenten empfangen. Nützlich für Echtzeitanwendungen wie Chatbots.

use futures::StreamExt;

let mut stream = model.stream_prompt("Erzähl eine Geschichte").await?;
while let Some(chunk) = stream.next().await {
    print!("{}", chunk?);
}

5. `Model::chat(messages)`

Signatur: pub async fn chat(&self, messages: Vec<ChatMessage>) -> Result<ChatResponse, ModelError>

Funktion: Führt einen Chat mit mehreren Nachrichten durch. Unterstützt System-, Benutzer- und Assistentenrollen für komplexe Konversationen.

use rig::providers::openai::ChatMessage;

let messages = vec![
    ChatMessage::system("Du bist ein hilfreicher Assistent."),
    ChatMessage::user("Wie installiere ich rig?"),
];
let response = model.chat(messages).await?;
println!("{}", response.content);

6. `Pipeline::new()`

Signatur: pub fn new(model: Model) -> Self

Funktion: Erstellt eine Pipeline – eine verknüpfte Kette von LLM-Aufrufen. Pipelines ermöglichen die Kombination mehrerer Schritte, z. B. Textextraktion, Übersetzung und Zusammenfassung in einem Durchlauf.

use rig::pipeline::Pipeline;

let pipeline = Pipeline::new(model)
    .chain("Extrahiere die Hauptpunkte aus dem folgenden Text:")
    .chain("Fasse sie in drei Sätzen zusammen:");

let ergebnis = pipeline.run("Langer Text hier...").await?;
println!("{}", ergebnis);

Praktisches Beispiel: KI-gestützter Chatbot

Lassen Sie uns einen einfachen Chatbot erstellen, der den Gesprächsverlauf speichert und auf Benutzereingaben reagiert:

use rig::providers::openai::{self, ChatMessage};
use std::io::{self, Write};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = openai::Client::from_env();
    let model = client.model("gpt-4o-mini").build();
    
    let mut verlauf = vec![
        ChatMessage::system("Du bist ein freundlicher Chatbot."),
    ];
    
    loop {
        print!("Du: ");
        io::stdout().flush()?;
        let mut eingabe = String::new();
        io::stdin().read_line(&mut eingabe)?;
        let eingabe = eingabe.trim().to_string();
        
        if eingabe.eq_ignore_ascii_case("exit") {
            break;
        }
        
        verlauf.push(ChatMessage::user(&eingabe));
        let antwort = model.chat(verlauf.clone()).await?;
        println!("Bot: {}", antwort.content);
        verlauf.push(ChatMessage::assistant(antwort.content));
    }
    
    Ok(())
}

Dieses Beispiel zeigt, wie einfach es ist, mit rig einen funktionsfähigen Chatbot zu erstellen. Der gesamte Gesprächsverlauf wird verwaltet und an das Modell gesendet.

Optimierungstipps

Streaming verwenden: Für bessere Benutzererfahrung nutzen Sie stream_prompt anstelle von prompt, um Antworten in Echtzeit anzuzeigen.
Batching aktivieren: Bei vielen gleichzeitigen Anfragen kann rig Anfragen bündeln, um die API-Auslastung zu optimieren.
Modellauswahl: Für einfache Aufgaben reicht gpt-4o-mini; für komplexe Analysen verwenden Sie gpt-4o oder claude-3-opus.
Tool Calling: rig unterstützt Tool Calling – definieren Sie Funktionen, die das LLM bei Bedarf aufrufen kann, z. B. für Datenbankabfragen oder API-Aufrufe.

Fehlerbehandlung

rig verwendet den Rust-Typ ModelError für Fehler. Behandeln Sie häufige Fehler wie API-Timeouts oder ungültige Schlüssel:

match model.prompt("Hallo").await {
    Ok(antwort) => println!("{}", antwort),
    Err(e) => eprintln!("Fehler: {}", e),
}

Für detailliertere Fehlerinformationen können Sie den Fehlertyp abgleichen:

use rig::error::ModelError;

match model.prompt("Test").await {
    Ok(antwort) => antwort,
    Err(ModelError::ApiError { status, message }) => {
        eprintln!("API-Fehler {}: {}", status, message);
        String::new()
    }
    Err(e) => {
        eprintln!("Anderer Fehler: {}", e);
        String::new()
    }
}

Fazit

rig ist eine leistungsstarke und benutzerfreundliche Bibliothek für die LLM-Integration in Rust. Mit ihrer typsicheren API, Pipeline-Unterstützung und umfassenden Anbieterkompatibilität eignet sie sich sowohl für schnelle Prototypen als auch für produktionsreife Anwendungen. Die Kombination aus Rusts Sicherheit und rigs Flexibilität macht sie zur ersten Wahl für Entwickler, die KI-Funktionalität in ihre Projekte einbauen möchten.

Beginnen Sie noch heute mit rig und entdecken Sie die Möglichkeiten der LLM-Integration in Rust!