Analyzing Agreements with RAG

Welcome to the final lesson of our course on building a RAG-powered chatbot with Go! Throughout this course, you've built a complete Retrieval-Augmented Generation system from the ground up. You've created a document processor for handling document retrieval, developed a chat engine for managing conversations, and integrated these components into a unified RAG chatbot. Now it's time to put your creation to work on a practical application.

In this lesson, we'll explore how to use your RAG chatbot to analyze a collection of fictional interplanetary agreements. This scenario mimics real-world document analysis tasks that professionals often face — reviewing multiple complex documents, extracting specific information, and making comparisons across documents. While our documents are fictional and space-themed, the techniques you'll learn apply directly to real-world use cases such as legal document review, policy analysis, or research synthesis.

Our interplanetary agreements dataset consists of three fictional documents:

• An Interplanetary Trade Agreement
• A Space Exploration Partnership
• A Galactic Environmental Protection Pact

These documents contain various clauses, terms, and provisions that our RAG chatbot will help us analyze. By the end of this lesson, you'll understand how to apply your RAG chatbot to extract insights from document collections efficiently.

Before diving into document analysis, let's review how our complete RAG system works. The RAGChatbot struct we built in the previous lesson integrates both the document processor and chat engine components:

package ragchatbot

import (
    "context"
    "fmt"

    "github.com/tmc/langchaingo/embeddings"
    "github.com/tmc/langchaingo/llms/openai"

    "codesignal/chatengine"
    "codesignal/documentprocessor"
)

type RAGChatbot struct {
    DocumentProcessor *documentprocessor.DocumentProcessor
    ChatEngine        *chatengine.ChatEngine
}

func NewRAGChatbot(ctx context.Context) (*RAGChatbot, error) {
    // Initialize OpenAI LLM for embeddings
    embeddingLLM, err := openai.New(
        openai.WithEmbeddingModel("text-embedding-3-small"),
    )
    if err != nil {
        return nil, fmt.Errorf("failed to initialize embedding LLM: %w", err)
    }

    // Create an embedder
    embedder, err := embeddings.NewEmbedder(embeddingLLM)
    if err != nil {
        return nil, fmt.Errorf("failed to create embedder: %w", err)
    }

    // Initialize document processor
    docProcessor := &documentprocessor.DocumentProcessor{
        ChunkSize:    1000,
        ChunkOverlap: 100,
        Embedder:     embedder,
    }

    // Initialize chat engine
    chatEngine, err := chatengine.NewChatEngine(ctx)
    if err != nil {
        return nil, fmt.Errorf("failed to initialize chat engine: %w", err)
    }

    return &RAGChatbot{
        DocumentProcessor: docProcessor,
        ChatEngine:        chatEngine,
    }, nil
}

The key methods we'll be using are:

• UploadDocument: Processes a document and adds it to our knowledge base
• SendMessage: Retrieves relevant context and generates a response
• ResetAll: Clears both conversation history and document knowledge

With this understanding, let's implement a systematic approach to analyzing our document collection.

For complex document analysis tasks, it's often helpful to follow a structured approach. We'll implement a workflow that progressively builds our understanding:

1. Single Document Analysis: Start by analyzing individual documents to understand their content
2. Comparative Analysis: Add more documents and compare information between them
3. Comprehensive Analysis: Synthesize information across all documents
4. Strategic Reset: Reset and focus on specific documents when needed

This progressive approach helps build a comprehensive understanding while making efficient use of our RAG system's capabilities. Let's see how to implement this workflow in Go.

Let's begin by creating a program that uploads a single document and asks specific questions about it. This approach helps us understand the content of individual documents before attempting to make comparisons or draw broader conclusions.

package main

import (
    "context"
    "fmt"
    "log"

    "codesignal/ragchatbot"
)

func main() {
    ctx := context.Background()

    // Initialize the RAG chatbot
    chatbot, err := ragchatbot.NewRAGChatbot(ctx)
    if err != nil {
        log.Fatalf("failed to initialize RAG chatbot: %v", err)
    }

    fmt.Println("=== Single Document Analysis ===\n")

    // Step 1: Upload a single document and ask a specific question about it
    tradeAgreement := "../data/interplanetary_trade_agreement.pdf"
    result, err := chatbot.UploadDocument(ctx, tradeAgreement)
    if err != nil {
        log.Fatalf("error uploading document: %v", err)
    }
    fmt.Printf("Uploaded %s: %s\n", tradeAgreement, result)

    // Ask a specific question about the trade agreement
    question := "How are disputes resolved?"
    response, err := chatbot.SendMessage(ctx, question)
    if err != nil {
        log.Fatalf("error sending message: %v", err)
    }

    fmt.Printf("\nQuestion: %s\n", question)
    fmt.Printf("Answer: %s\n", response)
}

When you run this code, you'll see output similar to:

=== Single Document Analysis ===

Uploaded data/interplanetary_trade_agreement.pdf: Document successfully processed.

Question: How are disputes resolved?
Answer: Disputes are resolved through mediation facilitated by the Galactic Trade Council, followed by binding arbitration under the rules established by the Galactic Arbitration Tribunal, and ultimately falling under the exclusive jurisdiction of the Galactic Court of Justice.

This example demonstrates how to extract specific information from a single document. Behind the scenes, here's what happens:

1. The UploadDocument method loads the PDF, splits it into chunks, generates embeddings, and stores them in the vector database
2. The SendMessage method converts your question into an embedding
3. The document processor performs similarity search to find relevant chunks
4. The chat engine formats these chunks as context and sends them to the language model
5. The language model generates an answer based solely on the provided context

When formulating questions for single document analysis, it's best to be specific and focused. Questions like "How are disputes resolved?" or "What are the confidentiality obligations?" target specific aspects of the document and yield precise, useful information.

Once we understand individual documents, we can progress to comparative analysis. This involves uploading multiple documents and asking questions that require the chatbot to compare information across them.

Let's extend our program to add a second document and perform comparative analysis:

package main

import (
    "context"
    "fmt"
    "log"

    "codesignal/ragchatbot"
)

func main() {
    ctx := context.Background()

    // Initialize the RAG chatbot
    chatbot, err := ragchatbot.NewRAGChatbot(ctx)
    if err != nil {
        log.Fatalf("failed to initialize RAG chatbot: %v", err)
    }

    fmt.Println("=== Single Document Analysis ===\n")

    // Upload first document
    tradeAgreement := "../data/interplanetary_trade_agreement.pdf"
    result, err := chatbot.UploadDocument(ctx, tradeAgreement)
    if err != nil {
        log.Fatalf("error uploading document: %v", err)
    }
    fmt.Printf("Uploaded %s: %s\n", tradeAgreement, result)

    // Ask about the first document
    question := "How are disputes resolved?"
    response, err := chatbot.SendMessage(ctx, question)
    if err != nil {
        log.Fatalf("error sending message: %v", err)
    }
    fmt.Printf("\nQuestion: %s\n", question)
    fmt.Printf("Answer: %s\n", response)

    fmt.Println("\n=== Comparative Document Analysis ===\n")

    // Step 2: Upload a second document and ask a comparative question
    spacePartnership := "../data/space_exploration_partnership.pdf"
    result, err = chatbot.UploadDocument(ctx, spacePartnership)
    if err != nil {
        log.Fatalf("error uploading document: %v", err)
    }
    fmt.Printf("Uploaded %s: %s\n", spacePartnership, result)

    // Ask a comparison question between the two documents
    question = "What are the liability clauses?"
    response, err = chatbot.SendMessage(ctx, question)
    if err != nil {
        log.Fatalf("error sending message: %v", err)
    }
    fmt.Printf("\nQuestion: %s\n", question)
    fmt.Printf("Answer: %s\n", response)
}

The output will look like:

=== Single Document Analysis ===

Uploaded data/interplanetary_trade_agreement.pdf: Document successfully processed.

Question: How are disputes resolved?
Answer: Disputes are resolved through mediation facilitated by the Galactic Trade Council, followed by binding arbitration under the rules established by the Galactic Arbitration Tribunal, and ultimately falling under the exclusive jurisdiction of the Galactic Court of Justice.

=== Comparative Document Analysis ===

Uploaded data/space_exploration_partnership.pdf: Document successfully processed.

Question: What are the liability clauses?
Answer: The liability clauses in the provided context state that neither partner shall be held liable for failure to perform obligations due to events beyond reasonable control, such as natural disasters, interstellar disruptions, interstellar conflicts, or systemic technological disruptions.

Comparative questions require our RAG system to retrieve relevant information from multiple documents and synthesize a response. When you ask "What are the liability clauses?", the system performs similarity search across all uploaded documents (both the trade agreement and space partnership), retrieves the most relevant chunks from either or both documents, and generates a comprehensive answer.

This is where the power of RAG really shines — the system can pull context from different documents based on semantic relevance, not just keyword matching. The vector embeddings allow the system to understand that "liability clauses" might be discussed using different terminology in different documents.

After understanding individual documents and making targeted comparisons, we can perform comprehensive analysis across all documents. This involves uploading all relevant documents and asking questions that might require synthesizing information from the entire collection.

Let's add our third document and ask a question that requires searching across all documents:

package main

import (
    "context"
    "fmt"
    "log"

    "codesignal/ragchatbot"
)

func main() {
    ctx := context.Background()

    // Initialize the RAG chatbot
    chatbot, err := ragchatbot.NewRAGChatbot(ctx)
    if err != nil {
        log.Fatalf("failed to initialize RAG chatbot: %v", err)
    }

    // Upload all three documents
    documents := []string{
        "../data/interplanetary_trade_agreement.pdf",
        "../data/space_exploration_partnership.pdf",
        "../data/galactic_environmental_protection_pact.pdf",
    }

    fmt.Println("=== Uploading Document Collection ===\n")

    for _, docPath := range documents {
        result, err := chatbot.UploadDocument(ctx, docPath)
        if err != nil {
            log.Fatalf("error uploading document: %v", err)
        }
        fmt.Printf("Uploaded %s: %s\n", docPath, result)
    }

    fmt.Println("\n=== Comprehensive Multi-Document Analysis ===\n")

    // Step 3: Ask for a comprehensive analysis across all documents
    question := "What document mentioned fines?"
    response, err := chatbot.SendMessage(ctx, question)
    if err != nil {
        log.Fatalf("error sending message: %v", err)
    }
    fmt.Printf("Question: %s\n", question)
    fmt.Printf("Answer: %s\n", response)
}

The output will look like:

=== Uploading Document Collection ===

Uploaded data/interplanetary_trade_agreement.pdf: Document successfully processed.
Uploaded data/space_exploration_partnership.pdf: Document successfully processed.
Uploaded data/galactic_environmental_protection_pact.pdf: Document successfully processed.

=== Comprehensive Multi-Document Analysis ===

Question: What document mentioned fines?
Answer: The document that mentioned fines is the Galactic Federation Galactic Environmental Protection Pact.

This example shows how our RAG system can search across all uploaded documents to find specific information. The question "What document mentioned fines?" requires the system to:

1. Generate an embedding for the query
2. Search through all chunks from all three documents in the vector store
3. Identify which chunks (and therefore which documents) mention "fines"
4. Generate a response that identifies the specific document

The RAG chatbot efficiently handles this by maintaining all document chunks in a single vector store, allowing for fast similarity search across the entire collection. The system doesn't need to search each document sequentially; instead, it finds the most semantically similar chunks regardless of which document they came from.

For complex document analysis tasks, it's sometimes helpful to reset your knowledge base and focus on specific documents. This allows for more targeted analysis without interference from other documents in the collection.

The ResetAll method clears both the conversation history and the document knowledge base, giving you a clean slate:

package main

import (
    "context"
    "fmt"
    "log"

    "codesignal/ragchatbot"
)

func main() {
    ctx := context.Background()

    // Initialize the RAG chatbot
    chatbot, err := ragchatbot.NewRAGChatbot(ctx)
    if err != nil {
        log.Fatalf("failed to initialize RAG chatbot: %v", err)
    }

    // Upload all three documents initially
    documents := []string{
        "../data/interplanetary_trade_agreement.pdf",
        "../data/space_exploration_partnership.pdf",
        "../data/galactic_environmental_protection_pact.pdf",
    }

    fmt.Println("=== Initial Document Upload ===\n")

    for _, docPath := range documents {
        result, err := chatbot.UploadDocument(ctx, docPath)
        if err != nil {
            log.Fatalf("error uploading document: %v", err)
        }
        fmt.Printf("Uploaded %s: %s\n", docPath, result)
    }

    // Ask a broad question
    question := "What are the main topics covered?"
    response, err := chatbot.SendMessage(ctx, question)
    if err != nil {
        log.Fatalf("error sending message: %v", err)
    }
    fmt.Printf("\nQuestion: %s\n", question)
    fmt.Printf("Answer: %s\n", response)

    fmt.Println("\n=== Strategic Knowledge Base Management ===\n")

    // Step 4: Reset everything and focus only on the environmental pact
    resetResult := chatbot.ResetAll()
    fmt.Println(resetResult)

    // Re-upload only the environmental pact
    environmentalPact := "../data/galactic_environmental_protection_pact.pdf"
    result, err := chatbot.UploadDocument(ctx, environmentalPact)
    if err != nil {
        log.Fatalf("error uploading document: %v", err)
    }
    fmt.Printf("\nRe-uploaded %s: %s\n", environmentalPact, result)

    // Ask a specific question about the environmental pact
    question = "What penalties exist for emissions violations?"
    response, err = chatbot.SendMessage(ctx, question)
    if err != nil {
        log.Fatalf("error sending message: %v", err)
    }
    fmt.Printf("\nQuestion: %s\n", question)
    fmt.Printf("Answer: %s\n", response)
}

The output will look like:

=== Initial Document Upload ===

Uploaded data/interplanetary_trade_agreement.pdf: Document successfully processed.
Uploaded data/space_exploration_partnership.pdf: Document successfully processed.
Uploaded data/galactic_environmental_protection_pact.pdf: Document successfully processed.

Question: What are the main topics covered?
Answer: The main topics covered include trade relations, space exploration partnerships, and environmental protection across interplanetary territories.

=== Strategic Knowledge Base Management ===

Both conversation history and document knowledge have been reset.

Re-uploaded data/galactic_environmental_protection_pact.pdf: Document successfully processed.

Question: What penalties exist for emissions violations?
Answer: Violation of any environmental standards may result in penalties including fines, suspension of operations, or revocation of eco-certification.

This example demonstrates the power of strategic knowledge base management. By resetting and focusing on a single document, you ensure that:

1. The similarity search only retrieves chunks from the environmental pact
2. The language model receives focused context without potentially conflicting information from other documents
3. Your answers are more precise and directly related to the specific document you're analyzing

Strategic knowledge base management involves deciding when to keep multiple documents in your knowledge base for comparative analysis and when to reset and focus on specific documents for deeper analysis. This flexibility allows you to tailor your analysis approach to your specific needs.

Let's take a moment to understand what happens behind the scenes when you use the RAG chatbot for document analysis. Here's the complete workflow:

1. Document Upload: When you call UploadDocument, the document processor:

   • Loads the PDF file using LangChain Go's document loaders
   • Splits the document into chunks using the recursive character text splitter
   • Generates embeddings for each chunk using OpenAI's embedding model
   • Stores these embeddings in the in-memory vector store

2. Message Sending: When you call SendMessage with a question, the system:

   • Generates an embedding for your question using the same embedding model
   • Performs similarity search in the vector store to find the most relevant chunks
   • Combines these chunks into context
   • Formats a prompt with the system instructions, context, and your question
   • Sends this prompt to the chat model (GPT-5.6 Luna)
   • Returns the model's response based on the provided context

3. Knowledge Base Reset: When you call ResetAll, the system:

   • Clears the conversation history in the chat engine
   • Resets the vector store in the document processor
   • Prepares the system for a fresh start with new documents

This architecture ensures that your RAG chatbot can efficiently handle document collections of various sizes while maintaining accuracy and context-awareness.

Congratulations! You've completed the final lesson in our course on building a RAG-powered chatbot with Go. Throughout this course, you've built a complete RAG system from the ground up and learned how to apply it to practical document analysis tasks.

In this lesson, you've learned several key techniques for document analysis with RAG:

1. Single Document Analysis: Extracting specific information from individual documents using targeted questions
2. Comparative Analysis: Identifying similarities and differences between multiple documents
3. Comprehensive Analysis: Synthesizing information across entire document collections
4. Strategic Knowledge Base Management: Resetting and focusing on specific documents for deeper analysis

The RAG architecture you've built is flexible and extensible. The modular design — with separate document processor and chat engine components integrated into a unified chatbot — allows you to:

• Easily swap out different embedding models or language models
• Adjust chunk sizes and overlap for different document types
• Extend the system with additional features like conversation memory or multi-turn dialogue
• Scale to handle larger document collections with alternative vector stores

Whether you're analyzing interplanetary agreements, legal contracts, research papers, or any other document collection, the techniques you've learned in this course will help you extract insights efficiently and effectively. The combination of vector similarity search for retrieval and language models for generation creates a powerful system that can understand and answer questions about your documents with remarkable accuracy.

Keep exploring, keep building, and keep pushing the boundaries of what's possible with RAG and Go!