rllm

Rllm

Remarque: Commençant par la version 1.x, Rllm est devenu un simple wrapper autour de LLM. Les deux caisses seront activement maintenues et maintenues en synchronisation. Si vous êtes nouveau dans cet écosystème, vous pouvez utiliser directement LLM ou RLLM - ils fournissent les mêmes fonctionnalités.

RLLM est une bibliothèque de rouille qui vous permet d'utiliser plusieurs backends LLM dans un seul projet: Openai, Anthropic (Claude), Olllama, Deepseek, Xai, Phind, Groq et Google. Avec une API unifiée et un style de constructeur - similaire à l'expérience Stripe - vous pouvez facilement créer des demandes de chat ou de complétion de texte sans multiplier les structures et les caisses.

Caractéristiques clés

• Multi-backend : Gérer Openai, Anthropic, Olllama, Deepseek, Xai, Phind, Groq et Google via un seul point d'entrée.
• Chaînes en plusieurs étapes : créez des chaînes en plusieurs étapes avec différents backends à chaque étape.
• Modèles : utilisez des modèles pour créer des invites complexes avec des variables.
• Modèle de générateur : configurez votre LLM (modèle, température, max_tokens, délais d'attente ...) avec quelques appels simples.
• CHAT & EXCHELIONS : Deux traits unifiés ( ChatProvider et CompletionProvider ) pour couvrir la plupart des cas d'utilisation.
• Extensible : ajoutez facilement de nouveaux backends.
• Rust-Friendly : Conçu avec des traits clairs, une gestion des erreurs unifiés et une compilation conditionnelle via des fonctionnalités .
• Validation : Ajoutez une validation à vos demandes pour vous assurer que la sortie est ce que vous attendez.
• Évaluation : ajoutez une évaluation à vos demandes pour marquer la sortie de LLMS.
• Appel de fonction : ajoutez des appels de fonction à vos demandes pour utiliser des outils dans votre LLMS.

Installation

Ajoutez simplement Rllm à votre Cargo.toml :

[ dependencies ]
rllm = { version = " 1.1.5 " , features = [ " openai " , " anthropic " , " ollama " ] }

Exemples

Nom	Description
anthropic_example	Démontre l'intégration avec le modèle Claude d'Anthropic pour l'achèvement du chat
chain_example	Montre comment créer des chaînes invites en plusieurs étapes pour explorer les fonctionnalités du langage de programmation
deepseek_example	Exemple d'achèvement de Basic Deepseek Chat avec des modèles de chat Deepseek
embedding_example	Exemple d'intégration de base avec l'API d'Openai
multi_backend_example	Illustre le chaînage de multiples backends LLM (Openai, Anthropic, Deepseek) ensemble dans un seul flux de travail
ollama_example	Exemple d'utilisation de LLMS locaux via l'intégration Olllama
openai_example	Exemple de complétion de base du chat Openai avec les modèles GPT
phind_example	Exemple de réalisation de Basic Phind Chat avec le modèle Phind-70B
validator_example	Exemple de validateur de base avec le modèle Claude d'Anthropic
xai_example	Exemple de complétion de base du chat xai avec les modèles Grok
evaluation_example	Exemple d'évaluation de base avec Anthropic, Phind et Deepseek
google_example	Exemple de complétion de base de Google Gemini avec les modèles Gemini
google_embedding_example	Exemple d'intégration de base Google Gemini avec les modèles Gemini

Un autre exemple sur LLM Crate

Usage

Voici un exemple de base en utilisant Openai pour l'achèvement du chat. Voir le répertoire des exemples pour les autres backends (Anthropic, Olllama, Deepseek, Xai, Google, Phind), les capacités d'intégration et les cas d'utilisation plus avancés.

 use rllm :: {
    builder :: { LLMBackend , LLMBuilder } ,
    chat :: { ChatMessage , ChatRole } ,
} ;

fn main ( ) {
    let llm = LLMBuilder :: new ( )
        . backend ( LLMBackend :: OpenAI ) // or LLMBackend::Anthropic, LLMBackend::Ollama, LLMBackend::DeepSeek, LLMBackend::XAI, LLMBackend::Phind ...
        . api_key ( std :: env :: var ( "OPENAI_API_KEY" ) . unwrap_or ( "sk-TESTKEY" . into ( ) ) )
        . model ( "gpt-4o" ) // or model("claude-3-5-sonnet-20240620") or model("grok-2-latest") or model("deepseek-chat") or model("llama3.1") or model("Phind-70B") ...
        . max_tokens ( 1000 )
        . temperature ( 0.7 )
        . system ( "You are a helpful assistant." )
        . stream ( false )
        . build ( )
        . expect ( "Failed to build LLM" ) ;
}

    let messages = vec ! [
        ChatMessage {
            role : ChatRole :: User ,
            content : "Tell me that you love cats" . into ( ) ,
        } ,
        ChatMessage {
            role : ChatRole :: Assistant ,
            content :
                "I am an assistant, I cannot love cats but I can love dogs"
                    . into ( ) ,
        } ,
        ChatMessage {
            role : ChatRole :: User ,
            content : "Tell me that you love dogs in 2000 chars" . into ( ) ,
        } ,
    ] ;

    let chat_resp = llm . chat ( & messages ) ;
    match chat_resp {
        Ok ( text ) => println ! ( "Chat response: n {}" , text ) ,
        Err ( e ) => eprintln ! ( "Chat error: {}" , e ) ,
    }