Rig

https://docs.rig.rs/
Admin
Rig is a Rust library for building portable, modular, and lightweight Fullstack AI Agents, offering...
Tokens:57,768
Snippets:625
Trust Score:7.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Full Example Workflow

Source: https://docs.rig.rs/docs/integrations/vector_stores/qdrant

A complete example demonstrating the setup, connection, collection creation, and vector search using the rig-qdrant crate with OpenAI embeddings. Ensure environment variables like OPENAI_API_KEY are set.

```rust
const COLLECTION_NAME: &str = "MY_COLLECTION";
const COLLECTION_SIZE: usize = 1536; // vector embedding size for the collection goes here

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let openai_api_key = env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY not set");
    let openai_client = Client::new(&openai_api_key);
    let model = openai_client.embedding_model(TEXT_EMBEDDING_ADA_002);

    let qdrant_client = Qdrant::connect("http://localhost:6334").await?;

    // Create a collection with 1536 dimensions if it doesn't exist
    // Note: Make sure the dimensions match the size of the embeddings returned by the
    // model you are using
    if !qdrant_client.collection_exists(COLLECTION_NAME).await? {
        qdrant_client.create_collection(
            CreateCollectionBuilder::new(COLLECTION_NAME)
                .vectors_config(VectorParamsBuilder::new(
                    COLLECTION_SIZE as u64,
                    qdrant_client::qdrant::Distance::Cosine)
                ),
            ).await?;
    }

    let query_params = QueryPointsBuilder::new(COLLECTION_NAME).with_payload(true);
    let vector_store = QdrantVectorStore::new(qdrant_inner, model.clone(), query_params.build());


    let results = vector_store.top_n::<Utterance>(query, 1).await?;
    println!("{:#?}", results);

    Ok(())
}

```

--------------------------------

### OpenAI Client Initialization Example

Source: https://docs.rig.rs/docs/integrations/model_providers/openai

A minimal example showing how to create an OpenAI client with an API key and instantiate a GPT-4o completion model.

```rust
use rig::providers::openai;

let client = openai::Client::new("YOUR_API_KEY");

let gpt4o = client.completion_model(openai::GPT_4O);
```

--------------------------------

### Full Example Workflow

Source: https://docs.rig.rs/docs/integrations/vector_stores/neo4j

A complete example demonstrating connection to Neo4j, creating a vector index, performing a search, and printing the results. Ensure the Neo4j GenAI plugin is enabled and a vector index is pre-created or created by this code.

```rust
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let neo4j_client = Neo4jClient::connect("neo4j://localhost:7687", "username", "password").await?;
    let model = openai_client.embedding_model(TEXT_EMBEDDING_ADA_002);
 
    neo4j_client.create_vector_index(
        IndexConfig::new("moviePlots"),
        "Movie",
        &model
    ).await?;
 
    let index = neo4j_client.get_index(model, "moviePlots", SearchParams::default()).await?;
    let results = index.top_n::<Movie>("a historical movie on quebec", 5).await?;
    println!("{:#?}", results);
 
    Ok(())
}
```

--------------------------------

### In-Memory Vector Store Usage Example

Source: https://docs.rig.rs/docs/integrations/vector_stores/in_memory

A complete example demonstrating the initialization of an `InMemoryVectorStore`, adding documents with embeddings, creating an index, and performing a search query.

```rust
use rig::providers::openai;
use rig::embeddings::EmbeddingsBuilder;
use rig::vector_store::in_memory_store::InMemoryVectorStore;
use rig::vector_store::{VectorStoreIndex, VectorSearchRequest, InsertDocuments};

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let openai = openai::Client::from_env();
    let model = openai.embedding_model(openai::TEXT_EMBEDDING_ADA_002);

    // Initialize store
    let mut store = InMemoryVectorStore::default();

    // Create embeddings
    let embeddings = EmbeddingsBuilder::new(model.clone())
        .simple_document("doc1", "First document content")
        .simple_document("doc2", "Second document content")
        .build()
        .await?;

    // Add documents to store (uses InsertDocuments trait)
    store.add_documents(embeddings).await?;

    // Create vector store index
    let index = store.index(model);

    // Search similar documents using VectorSearchRequest
    let results = index.top_n(
        VectorSearchRequest::builder("search query", 5).build()
    ).await?;

    Ok(())
}
```

--------------------------------

### Full Example Workflow

Source: https://docs.rig.rs/docs/integrations/vector_stores/surrealdb

Demonstrates the complete workflow: connecting to SurrealDB, initializing an embedding model, creating a vector store, inserting documents, and performing a similarity search.

```rust
use rig::{embeddings::EmbeddingsBuilder, vector_store::VectorStoreIndex, Embed};
use rig_surrealdb::{Mem, SurrealVectorStore};
use serde::{Deserialize, Serialize};
use surrealdb::Surreal;

#[derive(Embed, Serialize, Deserialize, Clone, Debug, Eq, PartialEq, Default)]
struct WordDefinition {
    word: String,
    #[serde(skip)]
    #[embed]
    definition: String,
}

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let openai_client = rig::providers::openai::Client::from_env();
    let model = openai_client.embedding_model(rig::providers::openai::TEXT_EMBEDDING_3_SMALL);

    let surreal = Surreal::new::<Mem>(()).await?;
    surreal.use_ns("example").use_db("example").await?;

    let words = vec![
        WordDefinition {
            word: "flurbo".to_string(),
            definition: "A fictional currency from Rick and Morty.".to_string()
        },
        WordDefinition {
            word: "glarb-glarb".to_string(),
            definition: "A creature from the marshlands of Glibbo.".to_string()
        },
    ];

    let documents = EmbeddingsBuilder::new(model.clone())
        .documents(words)
        .unwrap()
        .build()
        .await?;

    let vector_store = SurrealVectorStore::with_defaults(model, surreal);
    vector_store.insert_documents(documents).await?;

    let query = "weird alien creature";
    let results = vector_store.top_n::<WordDefinition>(query, 2).await?;

    for (distance, _id, doc) in results {
        println!("Distance: {:.3}, Word: {}", distance, doc.word);
    }

    Ok(())
}
```

--------------------------------

### Full Streaming Agent Example

Source: https://docs.rig.rs/docs/concepts/streaming

An end-to-end example of using a streaming agent with OpenAI. It builds an agent, initiates a streaming prompt, and prints the text content as it arrives.

```rust
use rig::providers::openai;
use rig::streaming::StreamingPrompt;
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    let openai = openai::Client::from_env();

    let agent = openai.agent("gpt-5.2")
        .preamble("You are a storyteller.")
        .temperature(0.9)
        .build();

    let mut stream = agent.stream_prompt("Tell me a short story about a robot.").await?;

    while let Some(chunk) = stream.next().await {
        match chunk? {
            StreamedAssistantContent::Text(text) => {
                print!("{text}");
            }
            _ => {} // Handle other content types as needed
        }
    }
    println!();

    Ok(())
}
```

--------------------------------

### Initialize and Run Discord Bot

Source: https://docs.rig.rs/guides/advanced/discord_bot

Sets up the bot with environment variables, logging, Discord token, intents, and an event handler. Starts the bot client and handles potential errors.

```rust
#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();
 
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .init();
 
    let token = env::var("DISCORD_TOKEN").expect("Expected DISCORD_TOKEN in environment");
 
    let rig_agent = Arc::new(RigAgent::new().await?);
 
    let intents = GatewayIntents::GUILD_MESSAGES
        | GatewayIntents::DIRECT_MESSAGES
        | GatewayIntents::MESSAGE_CONTENT;
 
    let mut client = Client::builder(&token, intents)
        .event_handler(Handler {
            rig_agent: Arc::clone(&rig_agent),
        })
        .await
        .expect("Err creating client");
 
    if let Err(why) = client.start().await {
        error!("Client error: {:?}", why);
    }
 
    Ok(())
}
```

--------------------------------

### Main Example Code

Source: https://docs.rig.rs/examples/advanced/concurrent_processing

This is the core Rust code for setting up the Rig client, a shared model, and spawning concurrent Tokio tasks for LLM queries.

```rust
use rig_core::client::Client;
use rig_core::model::Model;
use rig_core::message::Message;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize OpenAI client
    let client = Client::new();

    // Create a shared GPT-3.5-turbo model instance
    let model = Model::new("gpt-3.5-turbo");

    let mut tasks = vec![];

    // Spawn multiple concurrent tasks
    for i in 0..10 {
        let client = client.clone();
        let model = model.clone();
        let task = tokio::spawn(async move {
            // Define the prompt for each task
            let prompt = format!("Hello from task {}!", i);
            let messages = vec![Message::new_user(prompt)];

            // Execute the LLM query concurrently
            match client.query_model(&model, messages).await {
                Ok(response) => {
                    println!("Task {} response: {}", i, response);
                    Ok(())
                }
                Err(e) => {
                    eprintln!("Task {} error: {}", i, e);
                    Err(e)
                }
            }
        });
        tasks.push(task);
    }

    // Wait for all tasks to complete and collect results
    for task in tasks {
        task.await??;
    }

    Ok(())
}

```

--------------------------------

### Initialize and Start Discord Bot Client

Source: https://docs.rig.rs/guides/advanced/discord_bot

Sets up the Discord bot client with environment variables, logging, and event handling. Requires DISCORD_TOKEN to be set in the environment.

```rust
use discord::Client;
use discord::GatewayIntents;
use std::env;
use std::sync::Arc;
use dotenv::dotenv;
use tracing::error;
use rig_rs::RigAgent;
use rig_rs::Handler;
use anyhow::Result;

#[tokio::main]
async fn main() -> Result<()> {
    dotenv().ok();

    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .init();

    let token = env::var("DISCORD_TOKEN").expect("Expected DISCORD_TOKEN in environment");

    let rig_agent = Arc::new(RigAgent::new().await?);

    let intents = GatewayIntents::GUILD_MESSAGES
        | GatewayIntents::DIRECT_MESSAGES
        | GatewayIntents::MESSAGE_CONTENT;

    let mut client = Client::builder(&token, intents)
        .event_handler(Handler {
            rig_agent: Arc::clone(&rig_agent),
        })
        .await
        .expect("Err creating client");

    if let Err(why) = client.start().await {
        error!("Client error: {:?}", why);
    }

    Ok(())
}
```

--------------------------------

### Custom Document Loading Example

Source: https://docs.rig.rs/guides/advanced/discord_bot

Example of how to load custom Markdown documents and integrate them into the Rig agent's knowledge base. Update file paths and document names as needed.

```rust
// Example
let my_doc_path = documents_dir.join("my_custom_doc.md");
let my_doc_content = Self::load_md_content(&my_doc_path)?;
```

```rust
let embeddings = EmbeddingsBuilder::new(embedding_model.clone())
    .simple_document("My Custom Doc", &my_doc_content)
    .build()
    .await?;
```

--------------------------------

### Example Usage of TryOp

Source: https://docs.rig.rs/docs/concepts/chains

Provides an example of calling a `TryOp` operation. This demonstrates how to handle potential errors returned by operations that implement `TryOp`.

```rust
let result = op.try_batch_call(2, vec![2, 4]).await;
assert_eq!(result, Ok(vec![3, 5]));
```

--------------------------------

### Streaming Prompt Example

Source: https://docs.rig.rs/docs/concepts/streaming

Demonstrates how to use the `StreamingPrompt` trait to get a stream of text chunks from the LLM. Handles text, tool call deltas, and final usage statistics.

```rust
use rig::streaming::StreamingPrompt;
use futures::StreamExt;

let agent = openai.agent("gpt-4o")
    .preamble("You are a helpful assistant.")
    .build();

let mut stream = agent.stream_prompt("Tell me a story").await?;

while let Some(chunk) = stream.next().await {
    match chunk? {
        StreamedAssistantContent::Text(text) => print!("{text}"),
        StreamedAssistantContent::ToolCallDelta(delta) => { /* handle tool call deltas */ },
        StreamedAssistantContent::FinalUsage(usage) => { /* handle final usage stats */ }
    }
}
```

--------------------------------

### Create a New Rust Project

Source: https://docs.rig.rs/guides/advanced/flight_assistant

Initializes a new Rust project using Cargo. Navigate into the created directory to continue setup.

```bash
cargo new flight_search_assistant
cd flight_search_assistant
```

--------------------------------

### Example Interaction with RAG System

Source: https://docs.rig.rs/examples/rag/rag_pdf

Demonstrates an example of user interaction, including a question about Sam Altman's premise and the system's response.

```text
RAG System ready. Type 'exit' to quit.
Enter your question: tell me the premise of what sam altman is talking about
Response: Sam Altman discusses the coming technological revolution driven by powerful artificial intelligence (AI) systems that can think, learn, and perform tasks currently done by people. He highlights how this AI revolution will lead to the creation of phenomenal wealth but also emphasizes the need for policy changes to distribute this wealth and ensure inclusivity in society. Altman proposes the idea of embracing AI advancements, transitioning taxation from labor to capital (such as companies and land), and distributing wealth equitably through the American Equity Fund. This plan aims to improve the standard of living for everyone by leveraging technology and fair economic policies in a rapidly changing future.
Enter your question:
```

--------------------------------

### Gemini Agent Example

Source: https://docs.rig.rs/examples/model_providers/gemini

Demonstrates how to initialize a Gemini client, build an agent with specific configurations like preamble and generation settings, and prompt the agent for a response. Ensure Gemini API credentials are set in the environment.

```rust
use rig::completion::Prompt;
use rig::providers::gemini::{self, completion::gemini_api_types::GenerationConfig};
#[tracing::instrument(ret)]
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .with_target(false)
        .init();

    // Initialize the Google Gemini client
    let client = gemini::Client::from_env();

    // Create agent with a single context prompt
    let agent = client
        .agent(gemini::completion::GEMINI_1_5_PRO)
        .preamble("Be creative and concise. Answer directly and clearly.")
        .temperature(0.5)
        // The `GenerationConfig` utility struct helps construct a typesafe `additional_params`
        .additional_params(serde_json::to_value(GenerationConfig {
            top_k: Some(1),
            top_p: Some(0.95),
            candidate_count: Some(1),
            ..Default::default()
        })?) // Unwrap the Result to get the Value
        .build();

    tracing::info!("Prompting the agent...");

    // Prompt the agent and print the response
    let response = agent
        .prompt("How much wood would a woodchuck chuck if a woodchuck could chuck wood? Infer an answer.")
        .await;

    tracing::info!("Response: {:?}", response);

    match response {
        Ok(response) => println!("{}", response),
        Err(e) => {
            tracing::error!("Error: {:?}", e);
            return Err(e.into());
        }
    }

    Ok(())
}
```

--------------------------------

### Install rmcp Crate for MCP Client

Source: https://docs.rig.rs/docs/integrations/model_context_protocol

Install the `rmcp` crate with client, macros, and HTTP transport features. Ensure `rig-core` also has the `rmcp` feature enabled.

```bash
cargo add rmcp -F client,macros,transport-streamable-http-client-reqwest,\    transport-streamable-http-server
```

```bash
cargo add rig-core -F rmcp
```

--------------------------------

### Install rmcp Crate for MCP Server

Source: https://docs.rig.rs/docs/integrations/model_context_protocol

Install the `rmcp` crate with server and HTTP server transport features, along with `tokio` for asynchronous runtime.

```bash
cargo add rmcp -F server,macros,transport-streamable-http-server
```

```bash
cargo add tokio -F full
```

--------------------------------

### Basic Rig Usage for OpenAI GPT-4

Source: https://docs.rig.rs/docs/quickstart/getting_started

This example demonstrates how to use Rig to prompt OpenAI's GPT-4 model. Ensure your OPENAI_API_KEY environment variable is set.

```rust
use rig::client::{CompletionClient, ProviderClient};
use rig::completion::Prompt;
use rig::providers::openai;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    // Create OpenAI client
    let client = openai::Client::from_env();

    // Create agent with a single context prompt
    let comedian_agent = client
        .agent("gpt-5.2")
        .preamble("You are a comedian here to entertain the user using humour and jokes.")
        .build();

    // Prompt the agent and print the response
    let response = comedian_agent.prompt("Entertain me!").await?;

    println!("{response}");

    Ok(())
}
```

--------------------------------

### Handle Bot Readiness and Setup Slash Commands

Source: https://docs.rig.rs/guides/advanced/discord_bot

Logs bot connection, stores the bot's user ID in TypeMap, and sets up global application commands like 'hello' and 'ask'.

```rust
async fn ready(&self, ctx: Context, ready: Ready) {
    info!("{} is connected!", ready.user.name);
 
    {
        let mut data = ctx.data.write().await;
        data.insert::<BotUserId>(ready.user.id);
    }
 
    let commands = Command::set_global_application_commands(&ctx.http, |commands| {
        commands
            .create_application_command(|command| {
                command
                    .name("hello")
                    .description("Say hello to the bot")
            })
            .create_application_command(|command| {
                command
                    .name("ask")
                    .description("Ask the bot a question")
                    .create_option(|option| {
                        option
                            .name("query")
                            .description("Your question for the bot")
                            .kind(CommandOptionType::String)
                            .required(true)
                    })
            })
    })
    .await;
 
    println!("Created the following global commands: {:#?}", commands);
}
```

--------------------------------

### Prompt OpenAI GPT-4 Model

Source: https://docs.rig.rs/

This example demonstrates how to create an OpenAI client and agent using the `rig-core` library. It requires the `OPENAI_API_KEY` environment variable to be set. Ensure you have the necessary tokio features enabled for `#[tokio::main]`.

```rust
use rig::{completion::Prompt, providers::openai};

#[tokio::main]
async fn main() {
    // Create OpenAI client and agent.
    // This requires the `OPENAI_API_KEY` environment variable to be set.
    let openai_client = openai::Client::from_env();
 
    let gpt4 = openai_client.agent("gpt-4").build();
 
    // Prompt the model and print its response
    let response = gpt4
        .prompt("Who are you?")
        .await
        .expect("Failed to prompt GPT-4");
 
    println!("GPT-4: {response}");
}
```

--------------------------------

### Streaming Chat Example

Source: https://docs.rig.rs/docs/concepts/streaming

Shows how to perform a streaming chat interaction, maintaining conversation history.

```rust
use rig::streaming::StreamingChat;

let mut stream = agent.stream_chat("Continue the story", chat_history).await?;
```

--------------------------------

### Streaming Completion Example

Source: https://docs.rig.rs/docs/concepts/streaming

Illustrates the low-level `StreamingCompletion` interface for customized streaming requests. Allows setting parameters like temperature before sending.

```rust
use rig::streaming::StreamingCompletion;

let builder = agent.stream_completion("prompt", chat_history).await?;
let response = builder
    .temperature(0.9)
    .send()
    .await?;
```

--------------------------------

### Provider Integration: Implementing CompletionModel

Source: https://docs.rig.rs/docs/concepts/completion

Example of implementing the CompletionModel trait for a custom provider.

```rust
impl CompletionModel for CustomProvider {
    type Response = CustomResponse;
 
    async fn completion(
        &self,
        request: CompletionRequest
    ) -> Result<CompletionResponse<Self::Response>, CompletionError> {
        // Provider-specific implementation
    }
}
```

--------------------------------

### Build the Rust Project

Source: https://docs.rig.rs/guides/advanced/flight_assistant

Compiles the Rust project. Ensure all dependencies are correctly installed and resolve any compilation errors.

```bash
cargo build
```

--------------------------------

### Example Output from Unified API Calls

Source: https://docs.rig.rs/docs/why_rig

Illustrates the expected output when using Rig's unified API to query different LLM providers for the same prompt. Shows distinct responses from GPT-4 and Cohere's Command model.

```text
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.
```

--------------------------------

### Run MCP Server

Source: https://docs.rig.rs/docs/integrations/model_context_protocol

Start an MCP server using `tokio` and `rmcp`. The server listens on a specified address and port, ready to handle tool discovery and invocations.

```rust
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = CalculatorServer;
 
    let transport = rmcp::transport::StreamableHttpServerTransport::new(
        "127.0.0.1:8080".parse()?
    );
 
    server.serve(transport).await?;
 
    Ok(())
}
```

--------------------------------

### Agent Context Loading with FileLoader

Source: https://docs.rig.rs/docs/concepts/loaders

Loads Rust example files using FileLoader and then uses the content to build an agent with multiple context documents. Errors during loading are ignored.

```rust
// Load in all the rust examples
let examples = FileLoader::with_glob("rig-core/examples/*.rs")?
    .read_with_path()
    .ignore_errors()
    .into_iter();

// Create an agent with multiple context documents
let agent = examples
    .fold(AgentBuilder::new(model), |builder, (path, content)| {
        builder.context(format!("Rust Example {{:?}}:\n{{}}", path, content).as_str())
    })
    .build();
```

--------------------------------

### Gemini Embeddings Example

Source: https://docs.rig.rs/examples/model_providers/gemini

Shows how to generate embeddings for text documents using the Gemini API. This requires initializing the client and specifying the embedding model. The `Embed` derive macro simplifies document structuring.

```rust
use rig::providers::gemini;
use rig::Embed;

#[derive(Embed, Debug)]
struct Greetings {
    #[embed]
    message: String,
}

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    // Initialize the Google Gemini client
    // Create OpenAI client
    let client = gemini::Client::from_env();

    let embeddings = client
        .embeddings(gemini::embedding::EMBEDDING_001)
        .document(Greetings {
            message: "Hello, world!".to_string(),
        })?
        .document(Greetings {
            message: "Goodbye, world!".to_string(),
        })?
        .build()
        .await
        .expect("Failed to embed documents");

    println!("{:?}", embeddings);

    Ok(())
}
```

--------------------------------

### Define a Custom Adder Tool for Rig

Source: https://docs.rig.rs/docs/quickstart/tools

Create a custom tool named 'add' that takes two i32 arguments and returns their sum. This example shows how to implement the `Tool` trait, including defining the tool's schema and its execution logic.

```rust
use rig_core::tool::Tool;
use rig_core::tool::ToolDefinition;
use serde::{Deserialize, Serialize};
use serde_json::json;

#[derive(Deserialize)]
struct AddArgs {
    x: i32,
    y: i32,
}
 
#[derive(Deserialize, Serialize)]
struct Adder;

// Placeholder for MathError, replace with actual error type if available
#[derive(Debug)]
struct MathError;

impl Tool for Adder {
    const NAME: &'static str = "add";
    type Error = MathError;
    type Args = AddArgs;
    type Output = i32;

    async fn definition(&self, _prompt: String) -> ToolDefinition {
        ToolDefinition {
            name: "add".to_string(),
            description: "Add x and y together".to_string(),
            parameters: json!({
                "type": "object",
                "properties": {
                    "x": { "type": "number", "description": "First number" },
                    "y": { "type": "number", "description": "Second number" }
                }
            })
        }
    }

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

--------------------------------

### Document Schema Example

Source: https://docs.rig.rs/docs/integrations/vector_stores/mongodb

An example of a `Document` struct that can be stored in MongoDB for vector search. It includes a unique ID, content, and an embedding vector.

```rust
#[derive(Embed, Clone, Deserialize, Debug)]
struct Document {
    #[serde(rename = "_id")]
    id: String,
    #[embed]
    content: String,
    embedding: Vec<f64>,
}
```

--------------------------------

### Initialize OpenAI Client

Source: https://docs.rig.rs/docs/integrations/model_providers/openai

Demonstrates creating an OpenAI client using either environment variables or an explicit API key. Also shows how to instantiate completion and embedding models.

```rust
use rig::providers::openai;
 
// Create client from environment variable
let client = openai::Client::from_env();
 
// Or explicitly with API key
let client = openai::Client::new("your-api-key");
 
// Create a completion model
let gpt4 = client.completion_model(openai::GPT_4);
 
// Create an embedding model
let embedder = client.embedding_model(openai::TEXT_EMBEDDING_3_LARGE);
```

--------------------------------

### Initialize OpenAI Client and Agent

Source: https://docs.rig.rs/docs/integrations/model_providers

Demonstrates initializing an OpenAI client and creating an agent using either the `completion_model` or direct `agent` method. The same pattern applies to other providers like Cohere.

```rust
use rig::{providers::openai, agent::AgentBuilder};

// Initialize the OpenAI client
let openai = openai::Client::new("your-openai-api-key");

// Create a model and initialize an agent
let gpt_4o = openai.completion_model("gpt-4o");

let agent = AgentBuilder::new(gpt_4o)
    .preamble("\
        You are Gandalf the white and you will be conversing with other \
        powerful beings to discuss the fate of Middle Earth.\
    ")
    .build();

// Alternatively, you can initialize an agent directly
let agent = openai.agent("gpt-4o")
    .preamble("\
        You are Gandalf the white and you will be conversing with other \
        powerful beings to discuss the fate of Middle Earth.\
    ")
    .build();
```

--------------------------------

### Initialize OpenAI Client and Model

Source: https://docs.rig.rs/docs/integrations

Demonstrates how to initialize the OpenAI client and create a completion model. Requires an API key.

```rust
use rig::providers::openai;

// Initialize the client
let client = openai::Client::new("your-api-key");

// Create a model
let gpt4 = client.completion_model("gpt-4");

// Or create an agent directly
let agent = client.agent("gpt-4")
    .preamble("You are a helpful assistant")
    .build();
```

--------------------------------

### Set up a RAG system with Rig

Source: https://docs.rig.rs/docs/why_rig

Shows how to set up a complete Retrieval-Augmented Generation (RAG) system using Rig's abstractions. This includes initializing an embedding model, creating an in-memory vector store, adding documents, and performing a vector search.

```rust
use rig::{
    client::EmbeddingsClient,
    embeddings::EmbeddingsBuilder,
    providers::openai,
    vector_store::{VectorSearchRequest, VectorStoreIndex, in_memory_store::InMemoryVectorStore},
};

#[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())
        .documents(vec![
            "1. Rust is a systems programming language.",
            "2. Python is known for its simplicity.",
        ])? 
        .build()
        .await?;

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

    // Create an index from the vector store
    let index = vector_store.index(embedding_model);
    let req = VectorSearchRequest::builder()
        .samples(1)
        .query("What is Rust?")
        .build()?;
    let results = VectorStoreIndex::top_n::<String>(&index, req).await?;

    // Print the most relevant document
    println!("RAG Agent Response: {}", results[0]);

    Ok(())
}
```

--------------------------------

### Clone Repository and Navigate

Source: https://docs.rig.rs/examples/rag/rag_pdf

Clone the project repository and change into the project directory.

```bash
git clone this repo
cd pdf-rag-system
```

--------------------------------

### Integration with File Loaders

Source: https://docs.rig.rs/docs/concepts/extractors

Example of loading documents from files using `FileLoader` and then processing them with an extractor.

```rust
let docs = FileLoader::with_glob("*.txt")?
    .read()
    .ignore_errors();

let extractor = client.extractor::<DocumentData>(model).build();

for doc in docs {
    let structured_data = extractor.extract(&doc).await?;
    // Process structured data
}
```

--------------------------------

### Initialize Media Generation Models

Source: https://docs.rig.rs/docs/concepts/media_generation

Instantiate various media generation models from a provider client. Ensure the necessary features (e.g., `image`, `audio`) are enabled for specific models.

```rust
use rig::client::CompletionClient;
// Image generation, audio generation, and transcription are accessed
// through provider-specific methods on the client.

let openai = openai::Client::from_env();

// Completion model
let gpt4 = openai.completion_model("gpt-4o");

// Embedding model
let embed = openai.embedding_model("text-embedding-3-small");

// Image generation model (requires `image` feature)
let dalle = openai.image_generation_model("dall-e-3");

// Audio generation model (requires `audio` feature)
let tts = openai.audio_generation_model("tts-1");

// Transcription model
let whisper = openai.transcription_model("whisper-1");
```

--------------------------------

### Sentiment Classification with Prompt Engineering

Source: https://docs.rig.rs/guides/text_extraction_classification

Use prompt engineering with examples in the preamble to improve the accuracy of sentiment classification.

```rust
let sentiment_classifier = openai_client
    .extractor::<SentimentClassification>("gpt-3.5-turbo")
    .preamble("
        You are a sentiment analysis AI. Classify the sentiment of the given text.
        Examples:
        Text: 'This movie was terrible. I hated every minute of it.'
        Sentiment: Negative, Confidence: 0.9
        Text: 'The weather today is okay, nothing special.'
        Sentiment: Neutral, Confidence: 0.7
        Text: 'I\'m so excited about my upcoming vacation!'
        Sentiment: Positive, Confidence: 0.95
    ")
    .build();
```

--------------------------------

### Create OpenAI Client

Source: https://docs.rig.rs/docs/concepts/provider_clients

Demonstrates creating an OpenAI client using environment variables or an explicit API key. Ensure the 'openai' feature is enabled.

```rust
use rig::providers::openai;

// Create a client from environment variables
let client = openai::Client::from_env();

// Or with an explicit API key
let client = openai::Client::new("your-api-key");
```

--------------------------------

### Insert Embeddings into Vector Store

Source: https://docs.rig.rs/docs/concepts/embeddings

After generating embeddings, you can insert them into a vector store. This example uses a pseudo-code function for inserting documents into a Qdrant vector store.

```rust
use rig::vector_store::InsertDocuments;
// note: this function is pseudo-code
// look into specific crate integrations for more indepth
// usage explanations
let qdrant = create_qdrant_vector_store();
 
qdrant.insert_documents(embeddings).await?;
```

--------------------------------

### Manual Embed Trait Implementation

Source: https://docs.rig.rs/docs/concepts/embeddings

Implement the `Embed` trait manually for custom embedding logic. This example shows embedding only the `name` field after splitting definitions.

```rust
struct Foo {
    id: i32,
    name: String
}
 
impl Embed for WordDefinition {
    fn embed(&self, embedder: &mut TextEmbedder) -> Result<(), EmbedError> {
       // Embeddings only need to be generated for `definition` field.
       // Split the definitions by comma and collect them into a vector of strings.
       // That way, different embeddings can be generated for each definition in the `definitions` string.
       embedder.embed(self.name.to_owned());
 
       Ok(())
    }
}
```

--------------------------------

### Build and Run the Application

Source: https://docs.rig.rs/examples/rag/rag_pdf

Compile and execute the Rust application. The system will indicate when it's ready for questions.

```bash
cargo run
```

--------------------------------

### Add Dependencies for Langfuse Integration

Source: https://docs.rig.rs/docs/concepts/observability

Include these dependencies in your `Cargo.toml` file to enable OpenTelemetry and Langfuse integration. This setup is ideal for local development and most production workloads.

```toml
[dependencies]
opentelemetry = "0.31"
opentelemetry_langfuse = "0.6"
tracing-opentelemetry = "0.31"
tracing-subscriber = "0.3"
```

--------------------------------

### Initialize and Use In-Memory Vector Store with Embeddings

Source: https://docs.rig.rs/docs/why_rig

Demonstrates initializing an OpenAI client, creating an embedding model, and using Rig's in-memory vector store to generate embeddings for documents, add them to the store, and perform a semantic search.

```rust
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(())
}
```

--------------------------------

### Initialize and Configure Flight Search Agent

Source: https://docs.rig.rs/guides/advanced/flight_assistant

Sets up the OpenAI client, defines an agent with a preamble and a custom FlightSearchTool, and prompts it for flight information. Requires `dotenv` for environment variables.

```rust
mod flight_search_tool;

use crate::flight_search_tool::FlightSearchTool;
use dotenv::dotenv;
use rig::completion::Prompt;
use rig::providers::openai;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    dotenv().ok();

    let openai_client = openai::Client::from_env();

    let agent = openai_client
        .agent("gpt-4")
        .preamble("You are a helpful assistant that can find flights for users.")
        .tool(FlightSearchTool)
        .build();

    let response = agent
        .prompt("Find me flights from San Antonio (SAT) to Atlanta (ATL) on November 15th 2024.")
        .await?;

    println!("Agent response:\n{}", response);

    Ok(())
}
```

--------------------------------

### Create a New Rust Project

Source: https://docs.rig.rs/guides/text_extraction_classification

Initializes a new Rust project for text classification and extraction.

```bash
cargo new text_classifier_extractor
cd text_classifier_extractor
```

--------------------------------

### Connect to Qdrant

Source: https://docs.rig.rs/docs/integrations/vector_stores/qdrant

Establish a connection to the Qdrant instance using the Qdrant::connect function. Ensure the Qdrant server is running at the specified address.

```rust
let qdrant_client = Qdrant::connect("http://localhost:6334").await?;

```

--------------------------------

### Build a RAG Pipeline

Source: https://docs.rig.rs/docs/concepts/chains

Constructs a Retrieval-Augmented Generation (RAG) pipeline. This example chains parallel operations for querying and document lookup, followed by context formatting and LLM prompting.

```rust
use rig::pipeline::{self, Op};

let pipeline = pipeline::new()
    // Parallel: Query embedding & document lookup
    .chain(parallel!(
        passthrough(),
        lookup::<_, _, Document>(vector_store, 3)
    ))
    // Format context
    .map(|(query, docs)| format!(
        "Query: {}\nContext:જી",
        query,
        docs.join("\n")
    ))
    // Generate response
    .prompt(llm_model);
```

--------------------------------

### Initialize QdrantVectorStore

Source: https://docs.rig.rs/docs/integrations/vector_stores/qdrant

Initializes the QdrantVectorStore with the Qdrant client, an embedding model, and query parameters. The query parameters are built using QueryPointsBuilder.

```rust
let query_params = QueryPointsBuilder::new(COLLECTION_NAME).with_payload(true);
let vector_store = QdrantVectorStore::new(qdrant_inner, model.clone(), query_params.build());

```

--------------------------------

### Initialize LanceDB and Embed Documents

Source: https://docs.rig.rs/docs/integrations/vector_stores/lancedb

Demonstrates initializing a local LanceDB instance and preparing documents for embedding using an OpenAI model. Note the requirement for at least 256 rows to create an index.

```rust
#[path = "./fixtures/lib.rs"]
mod fixture;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    // Initialize OpenAI client. Use this to generate embeddings (and generate test data for RAG demo).
    let openai_client = Client::from_env();

    // Select an embedding model.
    let model = openai_client.embedding_model(TEXT_EMBEDDING_ADA_002);

    // Initialize LanceDB locally.
    let db = lancedb::connect("data/lancedb-store").execute().await?;

    // Generate embeddings for the test data.
    let embeddings = EmbeddingsBuilder::new(model.clone())
        .documents(words())?
        // Note: need at least 256 rows in order to create an index so copy the definition 256 times for testing purposes.
        .documents(
            (0..256)

```

--------------------------------

### Using Vector Store Index as an Agent Tool

Source: https://docs.rig.rs/docs/integrations/vector_stores/in_memory

Demonstrates how to integrate a vector store index directly as a tool for an agent, allowing the agent to search a knowledge base.

```rust
let agent = openai.agent("gpt-4o")
    .preamble("You can search a knowledge base.")
    .tool(vector_store_index)
    .build();
```

--------------------------------

### Custom Eval Implementation: LengthCheck

Source: https://docs.rig.rs/docs/concepts/evals

Example of implementing the `Eval` trait for custom evaluation logic. This `LengthCheck` evaluator verifies if the output string falls within a specified length range.

```rust
use rig::evals::{Eval, EvalOutcome, EvalError};

struct LengthCheck {
    min_length: usize,
    max_length: usize,
}

impl Eval for LengthCheck {
    type Input = String;
    type Output = String;

    async fn eval(
        &self,
        _input: Self::Input,
        output: Self::Output,
    ) -> Result<EvalOutcome, EvalError> {
        let len = output.len();
        if len >= self.min_length && len <= self.max_length {
            Ok(EvalOutcome::Pass)
        } else {
            Ok(EvalOutcome::Fail)
        }
    }
}
```

--------------------------------

### Initialize Tracing with Langfuse

Source: https://docs.rig.rs/docs/concepts/observability

Initialize the tracing subscriber with a Langfuse tracer. This requires setting `LANGFUSE_PUBLIC_KEY` and `LANGFUSE_SECRET_KEY` environment variables. This setup integrates seamlessly with the Langfuse UI for visualizing traces.

```rust
use opentelemetry_langfuse::LangfuseTracer;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

fn init_tracing() {
    let langfuse_public_key = std::env::var("LANGFUSE_PUBLIC_KEY").expect("LANGFUSE_PUBLIC_KEY not set");
    let langfuse_secret_key = std::env::var("LANGFUSE_SECRET_KEY").expect("LANGFUSE_SECRET_KEY not set");
    let tracer = LangfuseTracer::builder()
        .with_public_key(langfuse_public_key)
        .with_secret_key(langfuse_secret_key)
        .with_host("https://cloud.langfuse.com")
        .build()
        .expect("failed to create Langfuse tracer");

    tracing_subscriber::registry()
        .with(tracing_opentelemetry::layer().with_tracer(tracer))
        .with(tracing_subscriber::fmt::layer())
        .init();
}
```

--------------------------------

### Add Project Dependencies

Source: https://docs.rig.rs/guides/rag/rag_system

Add Rig, Tokio, anyhow, and pdf-extract to your Cargo.toml file.

```toml
[package]
name = "rag_system"
version = "0.1.0"
edition = "2024"

[dependencies]
rig-core = "0.24.0"
tokio = { version = "1.34.0", features = ["full"] }
anyhow = "1.0.75"
pdf-extract = "0.7.3"
```

--------------------------------

### Create Anthropic Client and Models

Source: https://docs.rig.rs/docs/integrations/model_providers/anthropic

Demonstrates how to create an Anthropic client with specific API versions and beta features, and then instantiate completion models or agents.

```rust
use rig::providers::anthropic::{ClientBuilder, CLAUDE_3_SONNET};
 
// Create client with specific version and beta features
let client = ClientBuilder::new("your-api-key")
    .anthropic_version("2023-06-01")
    .anthropic_beta("prompt-caching-2024-07-31")
    .build();
 
// Create a completion model
let claude = client.completion_model(CLAUDE_3_SONNET);
 
// Or create an agent directly
let agent = client
    .agent(CLAUDE_3_SONNET)
    .preamble("You are a helpful assistant")
    .build();
```

--------------------------------

### CloudWatch Logs Query for Lambda Metrics

Source: https://docs.rig.rs/guides/deploy/Blog_2_aws_lambda_lancedb

Use this query to gather average runtime, memory usage, and cold start times for Lambda functions over a day, broken down by memory configuration.

```logql
filter @type = "REPORT"
| stats
      avg(@maxMemoryUsed) / 1000000 as MemoryUsageMB,
      avg(@duration) / 1000 as AvgDurationSec,
      max(@duration) / 1000 as MaxDurationSec,
      min(@duration) / 1000 as MinDurationSec,
      avg(@initDuration) / 1000 as AvgColdStartTimeSec,
      count(*) as NumberOfInvocations,
      sum(@initDuration > 0) as ColdStartInvocations
by bin(1d) as TimeRange, @memorySize / 1000000 as MemoryConfigurationMB
```

--------------------------------

### Create a Basic Rig Agent

Source: https://docs.rig.rs/docs/concepts/agent

Instantiate a simple agent with a specified model and preamble. Ensure your OpenAI client is configured with environment variables.

```rust
use rig::{providers::openai, Agent};
 
let openai = openai::Client::from_env();
 
// Create simple agent
let agent = openai.agent("gpt-4")
    .preamble("You are a helpful assistant.")
    .temperature(0.7)
    .build();
 
// Use the agent
let response = agent.prompt("Hello!").await?;
```

--------------------------------

### Initialize Tracing Subscriber with Custom Layer

Source: https://docs.rig.rs/docs/concepts/observability

Configure the `tracing_subscriber` to use an `EnvFilter` for log levels and include the custom `MessageOnlyLayer` to ensure only log messages are outputted. This setup is essential for disabling span output.

```rust
tracing_subscriber::registry()
    .with(tracing_subscriber::EnvFilter::new("info"))
    .with(MessageOnlyLayer)
    .init();
```
Tokens:
Raw