Why Rig? 5 Compelling Reasons to Use Rig for Your Next LLM Project

use rig::providers::{openai, cohere};
use rig::completion::Prompt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize OpenAI client using environment variables
    let openai_client = openai::Client::from_env();
    let gpt4 = openai_client.model("gpt-4").build();

    // Initialize Cohere client with API key from environment variable
    let cohere_client = cohere::Client::new(&std::env::var("COHERE_API_KEY")?);
    let command = cohere_client.model("command").build();

    // Use OpenAI's GPT-4 to explain quantum computing
    let gpt4_response = gpt4.prompt("Explain quantum computing in one sentence.").await?;
    println!("GPT-4: {}", gpt4_response);

    // Use Cohere's Command model to explain quantum computing
    let command_response = command.prompt("Explain quantum computing in one sentence.").await?;
    println!("Cohere Command: {}", command_response);

    Ok(())
}

GPT-4: Quantum computing utilizes quantum mechanics principles to perform complex computations exponentially faster than classical computers.
Cohere Command: Quantum computing harnesses quantum superposition and entanglement to process information in ways impossible for classical computers.

use rig::providers::openai;
use rig::embeddings::EmbeddingsBuilder;
use rig::vector_store::{in_memory_store::InMemoryVectorStore, VectorStore};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize OpenAI client and create an embedding model
    let openai_client = openai::Client::from_env();
    let embedding_model = openai_client.embedding_model("text-embedding-ada-002");

    // Create an in-memory vector store
    let mut vector_store = InMemoryVectorStore::default();

    // Generate embeddings for two documents
    let embeddings = EmbeddingsBuilder::new(embedding_model.clone())
        .simple_document("doc1", "Rust is a systems programming language.")
        .simple_document("doc2", "Python is known for its simplicity.")
        .build()
        .await?;

    // Add the embeddings to the vector store
    vector_store.add_documents(embeddings).await?;

    // Create an index from the vector store
    let index = vector_store.index(embedding_model);
    // Query the index for the most relevant document to "What is Rust?"
    let results = index.top_n_from_query("What is Rust?", 1).await?;

    // Print the most relevant document
    println!("Most relevant document: {:?}", results[0].1.document);

    Ok(())
}

Most relevant document: "Rust is a systems programming language."

use rig::providers::openai;
use rig::embeddings::EmbeddingsBuilder;
use rig::vector_store::{in_memory_store::InMemoryVectorStore, VectorStore};
use rig::completion::Prompt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize OpenAI client and create an embedding model
    let openai_client = openai::Client::from_env();
    let embedding_model = openai_client.embedding_model("text-embedding-ada-002");

    // Create an in-memory vector store
    let mut vector_store = InMemoryVectorStore::default();

    // Generate embeddings for two documents about Rust
    let embeddings = EmbeddingsBuilder::new(embedding_model.clone())
        .simple_document("doc1", "Rust was initially designed by Graydon Hoare at Mozilla Research.")
        .simple_document("doc2", "Rust's first stable release (1.0) was on May 15, 2015.")
        .build()
        .await?;

    // Add the embeddings to the vector store
    vector_store.add_documents(embeddings).await?;

    // Create an index from the vector store
    let index = vector_store.index(embedding_model);

    // Create a RAG agent using GPT-4 with the vector store as context
    let rag_agent = openai_client.context_rag_agent("gpt-4")
        .preamble("You are an assistant that answers questions about Rust programming language.")
        .dynamic_context(1, index)
        .build();

    // Use the RAG agent to answer a question about Rust
    let response = rag_agent.prompt("When was Rust's first stable release?").await?;
    println!("RAG Agent Response: {}", response);

    Ok(())
}

RAG Agent Response: Rust's first stable release (1.0) was on May 15, 2015.

use rig::providers::openai;
use rig::completion::Prompt;
use tokio::task;
use std::time::Instant;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let openai_client = openai::Client::from_env();
    let model = Arc::new(openai_client.model("gpt-3.5-turbo").build());

    let start = Instant::now();
    let mut handles = vec![];

    // Spawn 10 concurrent tasks
    for i in 0..10 {
        let model_clone = Arc::clone(&model);
        let handle = task::spawn(async move {
            let prompt = format!("Generate a random fact about the number {}", i);
            model_clone.prompt(&prompt).await
        });
        handles.push(handle);
    }

    // Collect results
    for handle in handles {
        let result = handle.await??;
        println!("Result: {}", result);
    }

    println!("Time elapsed: {:?}", start.elapsed());
    Ok(())
}

Result: The number 0 is the only number that is neither positive nor negative.
Result: The number 1 is the only number that is neither prime nor composite.
Result: The number 2 is the only even prime number.
Result: The number 3 is the only prime number that is one less than a perfect square.
...

Time elapsed: 1.502160549s

use rig::tool::Tool;
use rig::completion::ToolDefinition;
use serde::{Deserialize, Serialize};
use serde_json::json;

// Define the arguments for the addition operation
#[derive(Deserialize)]
struct AddArgs {
    x: i32,
    y: i32,
}

// Define a custom error type for math operations
#[derive(Debug, thiserror::Error)]
#[error("Math error")]
struct MathError;

// Define the Adder struct
#[derive(Deserialize, Serialize)]
struct Adder;

// Implement the Tool trait for Adder
impl Tool for Adder {
    const NAME: &'static str = "add";

    type Error = MathError;
    type Args = AddArgs;
    type Output = i32;

    // Define the tool's interface
    async fn definition(&self, _prompt: String) -> ToolDefinition {
        ToolDefinition {
            name: "add".to_string(),
            description: "Add two numbers".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "x": {
                        "type": "integer",
                        "description": "First number to add"
                    },
                    "y": {
                        "type": "integer",
                        "description": "Second number to add"
                    }
                },
                "required": ["x", "y"]
            }),
        }
    }

    // Implement the addition operation
    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
        Ok(args.x + args.y)
    }
}