rig — Rust में LLM इंटीग्रेशन के लिए लाइब्रेरी

Rust डेवलपमेंट की दुनिया में, बड़ी भाषा मॉडल (LLM) के साथ काम करना लंबे समय से एक चुनौतीपूर्ण कार्य रहा है। अधिकांश SDK Python या JavaScript में लिखे गए थे, और Rust इकोसिस्टम में केवल कुछ बिखरे हुए HTTP क्लाइंट उपलब्ध थे। rig (Rust Integration with GGUF/LLM) लाइब्रेरी इस समस्या को हल करती है, जो OpenAI, Anthropic, Cohere, Google Gemini, Llama.cpp, Ollama और अन्य दर्जनों LLM प्रदाताओं के साथ इंटरैक्ट करने के लिए एक एकीकृत, एर्गोनॉमिक और सुरक्षित इंटरफ़ेस प्रदान करती है।

rig की आवश्यकता क्यों है? सबसे पहले, यह एक टाइप-सेफ API प्रदान करती है: सभी अनुरोध और प्रतिक्रियाएं सख्ती से टाइप की गई हैं, जो रनटाइम एरर के एक पूरे वर्ग को समाप्त करती हैं। दूसरा, rig पाइपलाइन (pipelines) लागू करती है — स्ट्रीमिंग, कॉन्टेक्स्ट विंडो और टूल कॉलिंग के समर्थन के साथ LLM कॉल की कंपोज़ेबल चेन। तीसरा, लाइब्रेरी को प्रदर्शन को ध्यान में रखकर डिज़ाइन किया गया है: बिल्ट-इन एसिंक्रोनस, न्यूनतम एलोकेशन और बैचिंग का समर्थन।

यह लेख rig पर सबसे विस्तृत गाइड है। हम इंस्टॉलेशन, मुख्य तरीकों को समझेंगे, एक वास्तविक उदाहरण लिखेंगे और ऑप्टिमाइज़ेशन के टिप्स देंगे। अंत तक, आप Rust में LLM का उपयोग करके प्रोडक्शन-रेडी एप्लिकेशन बना सकेंगे।

इंस्टॉलेशन

अपने Cargo प्रोजेक्ट में rig जोड़ें:

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

यदि आपको केवल एक प्रदाता चाहिए, जैसे OpenAI:

cargo add rig-core --features openai

llama.cpp के माध्यम से लोकल मॉडल के साथ काम करने के लिए, आपको स्वयं llama.cpp इंस्टॉल करना होगा (GitHub से डाउनलोड करें) और CUDA/Metal सपोर्ट के साथ कंपाइल करना होगा। फिर llama-cpp फीचर जोड़ें।

न्यूनतम Rust वर्शन: 1.75.0। जांचें:

rustc --version

त्वरित शुरुआत

src/main.rs फ़ाइल बनाएं और OpenAI के लिए एक सरल अनुरोध लिखें:

use rig::providers::openai;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // OPENAI_API_KEY एनवायरनमेंट वेरिएबल के माध्यम से क्लाइंट इनिशियलाइज़ेशन
    let client = openai::Client::from_env();
    
    // मॉडल बनाना
    let model = client.model("gpt-4o-mini").build();
    
    // अनुरोध भेजना
    let response = model.prompt("प्रोग्रामर्स पर एक चुटकुला सुनाओ").await?;
    
    println!("{}", response);
    Ok(())
}

रन करें:

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

आपको एक जनरेटेड चुटकुला दिखाई देगा। बधाई हो — आपने अभी-अभी Rust में LLM को इंटीग्रेट किया है!

मुख्य तरीके और फंक्शन

rig के प्रमुख तरीकों पर नज़र डालते हैं। प्रत्येक के लिए, हम सिग्नेचर, विवरण और एक काम करने वाला उदाहरण देंगे।

1. Client::from_env()

सिग्नेचर: pub fn from_env() -> Self

यह क्या करता है: किसी विशिष्ट प्रदाता के लिए क्लाइंट बनाता है, एनवायरनमेंट वेरिएबल (जैसे, OPENAI_API_KEY) से API-की पढ़ता है।

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

2. Client::model(name)

सिग्नेचर: pub fn model(&self, model_name: &str) -> ModelBuilder

यह क्या करता है: मॉडल कॉन्फ़िगरेशन के लिए बिल्डर लौटाता है। तापमान, max_tokens, स्टॉप-वर्ड और अन्य पैरामीटर सेट करने की अनुमति देता है।

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

3. Model::prompt(text)

सिग्नेचर: pub async fn prompt(&self, prompt: impl Into<String>) -> Result<String, ModelError>

यह क्या करता है: मॉडल को एक टेक्स्ट प्रॉम्प्ट भेजता है और जनरेटेड प्रतिक्रिया लौटाता है।

let response = model.prompt("Rust में स्मार्ट कॉन्ट्रैक्ट कैसे लिखें?").await?;
println!("{}", response);

4. Model::chat(messages)

सिग्नेचर: pub async fn chat(&self, messages: Vec<ChatMessage>) -> Result<ChatResponse, ModelError>

यह क्या करता है: मल्टी-टर्न चैट के लिए संदेशों की एक सूची भेजता है। ChatMessage में role (user, assistant, system) और content शामिल है।

use rig::providers::openai::{ChatMessage, Role};

let messages = vec![
    ChatMessage::new(Role::System, "आप एक सहायक AI हैं।"),
    ChatMessage::new(Role::User, "Rust में वेक्टर क्या है?"),
];

let response = model.chat(messages).await?;
println!("{}", response.content);

5. Model::stream_prompt(text)

सिग्नेचर: pub async fn stream_prompt(&self, prompt: impl Into<String>) -> Result<impl Stream<Item = Result<String, ModelError>>, ModelError>

यह क्या करता है: स्ट्रीमिंग मोड में प्रॉम्प्ट भेजता है, जहां प्रतिक्रिया टुकड़ों में आती है। रीयल-टाइम आउटपुट के लिए उपयोगी।

use futures::StreamExt;

let mut stream = model.stream_prompt("एक कहानी सुनाओ").await?;
while let Some(chunk) = stream.next().await {
    print!("{}", chunk?);
}

वास्तविक उदाहरण: AI-संचालित कोड समीक्षक

आइए एक व्यावहारिक उदाहरण बनाएं: एक Rust फंक्शन जो कोड स्निपेट की समीक्षा करता है और सुझाव देता है।

use rig::providers::openai;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = openai::Client::from_env();
    let model = client.model("gpt-4o-mini")
        .temperature(0.3)
        .max_tokens(500)
        .build();

    let code = r#"
fn add(a: i32, b: i32) -> i32 {
    a + b
}
"#;

    let prompt = format!(
        "कृपया इस Rust कोड की समीक्षा करें और सुधार के सुझाव दें:\n\n{}",
        code
    );

    let response = model.prompt(prompt).await?;
    println!("कोड समीक्षा:\n{}", response);
    Ok(())
}

यह उदाहरण दिखाता है कि कैसे rig का उपयोग करके एक सरल AI-संचालित टूल बनाया जा सकता है।

निष्कर्ष

rig Rust डेवलपर्स के लिए LLM इंटीग्रेशन को सरल, सुरक्षित और तेज़ बनाती है। इस गाइड में, हमने इंस्टॉलेशन, मुख्य तरीकों और एक वास्तविक उदाहरण को कवर किया। अब आप अपने Rust प्रोजेक्ट्स में LLM की शक्ति का उपयोग कर सकते हैं। अधिक जानकारी के लिए, आधिकारिक दस्तावेज़ देखें।