RAG in Action: A Simple Workflow

Welcome to our second lesson in the “Introduction to RAG” course! In the previous lesson, you learned how RAG evolved from traditional Information Retrieval (IR). Today, we'll connect those ideas to concrete code and illustrate a simple end-to-end RAG workflow. By the end of this lesson, you'll see how indexing, retrieval, prompt augmentation, and final text generation fit together to produce a targeted answer.

In this lesson, we showcase a scenario involving “Project Chimera.” Think of this as an internal project of a company — here, it's just an example to demonstrate how a naive, context-free system can invent inaccurate details, whereas a RAG-based system will provide reliable answers using information from an authoritative knowledge base. Please note that we are deliberately using extremely simplified methods (like simple keyword matching) to illustrate how each part of a RAG pipeline can work. Later in this course, we will explore more realistic and robust approaches—such as using embeddings and vector databases—for each component of our RAG pipeline.

Before diving into the code, let's take a quick look at the four primary steps of our simple RAG workflow:

• Indexing: Documents are structured in a way that makes them easy to search.
• Retrieval: The most relevant piece of text is fetched based on a user query.
• Prompt (Query) Augmentation: The retrieved text is combined with the user's question to form a context-rich prompt.
• Generation: A language model processes the prompt and produces a final answer anchored to the provided text.

This process ensures that answers are backed by your data, reducing the risk of fabricated or off-topic responses. Let's examine each step through code!

We start by defining our knowledge base. Below, “Project Chimera” serves as the example domain:

use std::collections::HashMap;

/// Represents a document in our knowledge base
#[derive(Debug, Clone)]
struct Document {
    title: String,
    content: String,
}

type KnowledgeBase = HashMap<String, Document>;

/// Creates and returns our sample knowledge base
fn create_knowledge_base() -> KnowledgeBase {
    let mut kb = HashMap::new();
    
    kb.insert(
        "doc1".to_string(),
        Document {
            title: "Project Chimera Overview".to_string(),
            content: "Project Chimera is a research initiative focused on developing \
                     novel bio-integrated interfaces. It aims to merge biological \
                     systems with advanced computing technologies.".to_string(),
        },
    );

    kb.insert(
        "doc2".to_string(),
        Document {
            title: "Chimera's Neural Interface".to_string(),
            content: "The core component of Project Chimera is a neural interface \
                     that allows for bidirectional communication between the brain \
                     and external devices. This interface uses biocompatible \
                     nanomaterials.".to_string(),
        },
    );

    kb.insert(
        "doc3".to_string(),
        Document {
            title: "Applications of Chimera".to_string(),
            content: "Potential applications of Project Chimera include advanced \
                     prosthetics, treatment of neurological disorders, and enhanced \
                     human-computer interaction. Ethical considerations are paramount.".to_string(),
        },
    );

    kb
}

Here's a quick breakdown:

• We define a Document struct to represent our documents with proper types.
• We use Rust's HashMap to store our knowledge base.
• Each document has a String ID and contains both title and content fields.
• The knowledge base is created using a function that returns a populated HashMap.

Next, we create a function to return the best document from our knowledge base, based on simple keyword overlap:

use std::collections::HashSet;

/// Retrieves the most relevant document based on query word overlap
fn rag_retrieval<'a>(query: &str, documents: &'a KnowledgeBase) -> Option<&'a Document> {
    let query_lower = query.to_lowercase();
    let query_words: HashSet<_> = query_lower.split_whitespace().collect();

    documents.iter()
        .map(|(_, doc)| {
            let doc_lower = doc.content.to_lowercase();
            let doc_words: HashSet<_> = doc_lower.split_whitespace().collect();
            let overlap = query_words.intersection(&doc_words).count();
            (doc, overlap)
        })
        .max_by_key(|&(_, overlap)| overlap)
        .map(|(doc, _)| doc)
}

Let's walk through the code:

• The query is split into lowercase words and stored in a HashSet.
• Each document's text is similarly tokenized.
• The function picks the document with the greatest word overlap.
• If no match is found, it returns None.

Once we retrieve the relevant document, we augment the user's original question with that document's content. This additional context significantly reduces hallucinations because the language model sees both the question and real data.

/// Generate a response using the retrieved document as context.
async fn rag_generation(query: &str, document: Option<&Document>, llm: &llm::LlmClient) -> Result<String, Box<dyn std::error::Error>> {
    let prompt = match document {
        Some(doc) => {
            format!(
                "Using the following information: '{}: {}', answer: {}",
                doc.title, doc.content, query
            )
        }
        None => {
            format!("No relevant information found. Answer directly: {}", query)
        }
    };
    llm.get_llm_response(&prompt).await
}

Here's the process in detail:

• If a document was found, we include its title and main content as a snippet in the prompt.
• We pass the combined query and document text to the language model.
• If no document matches, we still form a direct prompt.

Given our KnowledgeBase and the query "What is the main goal of Project Chimera?", the resulting RAG-augmented prompt may be similar to the following:

Using the following information: 'Chimera's Neural Interface: The core component of Project Chimera is a neural interface that allows for bidirectional communication between the brain and external devices. This interface uses biocompatible nanomaterials.', answer: What is the main goal of Project Chimera?

Finally, let's see the difference between a naive approach—one that might invent details if it doesn't have any context—and a RAG approach, which leverages the knowledge base.

/// Naively generate a response for the query.
async fn naive_generation(query: &str, llm: &llm::LlmClient) -> Result<String, Box<dyn std::error::Error>> {
    let prompt = format!("Answer directly the following query: {}", query);
    llm.get_llm_response(&prompt).await
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let kb = create_knowledge_base();
    let query = "What is the main goal of Project Chimera?";
    
    // Instantiate the LlmClient once.
    let llm_client = llm::LlmClient::new();

    println!("Naive approach: {}", naive_generation(query, &llm_client).await?);
    
    let retrieved_doc = rag_retrieval(query, &kb);
    println!("RAG approach: {}", rag_generation(query, retrieved_doc, &llm_client).await?);
    
    Ok(())
}

Let's break down this section:

• naive_generation(query) can easily lead to random or inaccurate answers regarding “Project Chimera”, such as: "The main goal of Project Chimera is to develop advanced artificial intelligence systems that can enhance human capabilities and improve decision-making processes across various fields.".
• rag_generation(query, doc) provides contextual information from the knowledge base, ensuring the answer is grounded: "The main goal of Project Chimera is to enable bidirectional communication between the brain and external devices through the use of a neural interface.".
• Seeing both approaches (and their actual output) helps you compare how naive answers can deviate from your authoritative data, while RAG-based responses stay closer to truth.

You've now implemented:

• A simple knowledge base indexing scheme.
• Basic retrieval to find the most relevant document.
• Prompt augmentation to combine user queries and reference data.
• Generation that relies on actual context, lowering the chance of hallucinations.

Up next, you'll get hands-on practice with these steps in coding exercises. As you progress, you'll see how RAG can be extended to tackle more complex tasks and domains—whether you're talking about a literal “Project Chimera” or a real-world internal project.