rllm

Rllm

Nota: Comenzando con la versión 1.x, RLLM se ha convertido en una envoltura simple alrededor de LLM. Ambas cajas se mantendrán activamente y se mantendrán sincronizadas. Si es nuevo en este ecosistema, puede usar LLM directamente o RLLM, proporcionan las mismas características.

RLLM es una biblioteca de óxido que le permite usar múltiples backends de LLM en un solo proyecto: OpenAi, Anthrope (Claude), Ollama, Deepseek, Xai, Phind, Groq y Google. Con una API unificada y un estilo de constructor , similar a la experiencia de Stripe, puede crear fácilmente solicitudes de finalización de chat o texto sin multiplicar estructuras y cajas.

Características clave

• Multi-backend : gestione Openai, Anthrope, Ollama, Deepseek, Xai, Phind, Groq y Google a través de un solo punto de entrada.
• Cadenas de múltiples pasos : cree cadenas de múltiples pasos con diferentes backends en cada paso.
• Plantillas : use plantillas para crear indicaciones complejas con variables.
• Patrón del constructor : Configure su LLM (modelo, temperatura, max_tokens, tiempos de espera ...) con algunas llamadas simples.
• Chat & Finalations : Dos rasgos unificados ( ChatProvider y CompletionProvider ) para cubrir la mayoría de los casos de uso.
• Extensible : agregue fácilmente nuevos backends.
• Amable : diseñado con rasgos claros, manejo de errores unificados y compilación condicional a través de características .
• Validación : agregue la validación a sus solicitudes para asegurarse de que la salida sea lo que espera.
• Evaluación : agregue la evaluación a sus solicitudes para obtener la salida de la salida de LLMS.
• Llamadas de funciones : Agregue la función Llamando a sus solicitudes para usar herramientas en sus LLM.

Instalación

Simplemente agregue rllm a su Cargo.toml :

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

Ejemplos

Nombre	Descripción
anthropic_example	Demuestra integración con el modelo Claude de Anthrope para completar el chat
chain_example	Muestra cómo crear cadenas rápidas de varios pasos para explorar las características del lenguaje de programación
deepseek_example	Ejemplo básico de finalización del chat de DeepSeek con modelos Deepseek-chat
embedding_example	Ejemplo de incrustación básica con la API de OpenAi
multi_backend_example	Ilustra encadenar múltiples backends de LLM (OpenAi, antrópico, Deepseek) juntos en un solo flujo de trabajo
ollama_example	Ejemplo del uso de LLM locales a través de la integración de Ollama
openai_example	Ejemplo básico de finalización de chat de Openai con modelos GPT
phind_example	Ejemplo de finalización de chat de Phind Basic con modelo PHIND-70B
validator_example	Ejemplo de validador básico con el modelo Claude de Anthrope
xai_example	Ejemplo básico de finalización de chat XAI con modelos Grok
evaluation_example	Ejemplo de evaluación básica con antrópico, Phind y DeepSeek
google_example	Ejemplo básico de finalización de chat de Google Gemini con modelos Gemini
google_embedding_example	Ejemplo básico de incrustación de Google Gemini con modelos Gemini

Otro ejemplo en LLM Crate

Uso

Aquí hay un ejemplo básico que usa OpenAI para completar el chat. Consulte el directorio de ejemplos para otros backends (antrópico, Ollama, Deepseek, Xai, Google, Phind), capacidades de incrustación y casos de uso más avanzados.

 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 ) ,
    }