Multi-Tier Document Reasoning with RAG

This repository contains a synthetic knowledge corpus designed specifically for benchmarking and demonstrating capabilities of Retrieval-Augmented Generation (RAG) pipelines. The dataset simulates a complex, high-governance corporate environment, making it ideal for portfolio projects focused on enterprise AI solutions.

Project Description

This project implements a RAG (Retrieval-Augmented Generation) AI assistant that can answer questions about corporate documents by finding relevant information and using it to generate responses. The system combines document search with AI chat capabilities, allowing users to query a knowledge base of corporate policies, procedures, and reports.

Key Features:

• 📄 Document Loading: Loads and processes corporate documents from various departments
• 🔍 Intelligent Search: Uses vector embeddings to find relevant information across documents
• 💬 Contextual Responses: Generates answers using retrieved context and large language models
• 🧠 Multi-hop Reasoning: Can trace relationships between documents and synthesize information from multiple sources
• 🏢 Enterprise Focus: Designed for complex corporate environments with governance tiers and policy hierarchies

The system is built using modern AI technologies including ChromaDB for vector storage, LangChain for orchestration, and supports multiple LLM providers (OpenAI, Groq, Google AI).

Architecture Diagram

Project Structure

rt-aaidc-project1/
├── src/
│   ├── app.py              # Main RAG application with query pipeline
│   └── vectordb.py          # Vector database wrapper and document processing
├── data/                   # Corporate documents corpus
│   ├── DOC-COMP-00*.txt    # Compliance documents
│   ├── DOC-ENG-00*.txt     # Engineering reports
│   ├── DOC-EXEC-00*.txt    # Executive memos
│   ├── DOC-FIN-00*.txt     # Financial policies
│   ├── DOC-HR-00*.txt      # Human resources policies
│   ├── DOC-IT-00*.txt      # IT security policies
│   ├── DOC-LEG-00*.txt     # Legal documents
│   ├── DOC-LOG-00*.txt     # Logistics schedules
│   ├── DOC-MARK-00*.txt    # Marketing materials
│   ├── DOC-PROC-00*.txt    # Process documentation
│   ├── DOC-PROD-00*.txt    # Product specifications
│   └── DOC-SEC-00*.txt     # Security audit findings
├── chroma_db/              # Vector database storage (auto-generated)
├── requirements.txt        # Python dependencies
├── LICENSE                 # Project license
├── PROJECT-README.md       # Implementation guide
└── README.md              # This file

Key Components:

• src/app.py: Main application implementing the RAG query pipeline
• src/vectordb.py: Vector database operations and document processing
• data/: 18 corporate documents representing different departments and governance levels
• chroma_db/: Persistent vector database storage for embeddings

Model Selection Rationale

The project uses Sentence-Transformers Embedding model (specifically models like all-MiniLM-L6-v2) for several strategic reasons:
Privacy-Preserving: Local deployment means corporate documents never leave your infrastructure—critical for sensitive enterprise data
Cost-Effective: Zero API costs compared to OpenAI embeddings ($0.0001/1K tokens)​
Performance: 384-dimensional embeddings provide excellent semantic similarity for enterprise documents while maintaining fast inference​
Offline Capability: No external API dependencies for embedding generation​

The system supports three LLM providers to accommodate different deployment scenarios:
OpenAI GPT-4/GPT-4o Best for: Complex multi-hop reasoning, highest accuracy on nuanced queries
Groq Best for: Real-time applications requiring ultra-fast responses
Google Gemini 2.5 Pro Best for: Applications with very long context requirements

The modular design allows users to select the appropriate provider based on their specific constraints (budget, latency requirements, accuracy needs), demonstrating architectural flexibility for enterprise deployment.

Author

Author: Sachin Ambe

Date: October 27, 2025

Description: This project is part of the ReadyTensor AAIDC (Agentic AI Developer Certification) curriculum, designed as a learning template for implementing RAG systems in enterprise environments.

License

This project is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0).

What this means:

• Attribution: You must give appropriate credit, provide a link to the license, and indicate if changes were made
• NonCommercial: You may not use the material for commercial purposes
• ShareAlike: If you remix, transform, or build upon the material, you must distribute your contributions under the same license

Key Points:

• ✅ Free to use for educational and personal projects
• ✅ Free to modify and adapt the code
• ✅ Free to distribute with proper attribution
• ❌ Cannot be used for commercial purposes without permission
• ❌ Cannot change the license terms

For the full license text, see the LICENSE file in this repository.

Requirements

System Requirements

• Python 3.8 or higher
• 4GB+ RAM (for embedding models)
• Internet connection (for LLM API calls)

Python Dependencies

The project requires the following key packages (see requirements.txt for complete list):

Core RAG Components:

• chromadb==1.0.12 - Vector database for embeddings storage
• langchain==0.3.27 - Framework for LLM applications
• sentence-transformers==5.1.0 - Embedding model for text similarity

LLM Providers (choose one):

• openai==1.107.1 - OpenAI GPT models
• groq==0.31.1 - Groq API for fast inference
• langchain-google-genai==2.1.10 - Google AI models

Additional Dependencies:

• fastapi==0.115.9 - Web framework for API endpoints
• python-dotenv==1.1.1 - Environment variable management
• numpy==2.3.3 - Numerical computing
• pydantic==2.11.7 - Data validation

API Keys Required

You need an API key from one of these providers:

• OpenAI (most popular)
• Groq (free tier available)
• Google AI (competitive pricing)

Usage

Quick Start

1. Install dependencies:

   pip install -r requirements.txt

2. Set up environment variables:

   # Create .env file
   echo "OPENAI_API_KEY=your_key_here" > .env
   # OR
   echo "GROQ_API_KEY=your_key_here" > .env
   # OR  
   echo "GOOGLE_API_KEY=your_key_here" > .env

3. Run the application:

   python src/app.py

Implementation Steps

The project requires implementing 7 main components:

1. Document Loading (src/app.py)

   • Load documents from the data/ directory
   • Handle different file formats (text, PDF, etc.)
   • Extract content and metadata

2. Text Chunking (src/vectordb.py)

   • Split documents into searchable chunks
   • Implement chunking strategies (word-based, sentence-based)
   • Handle overlapping chunks for better retrieval

3. Document Ingestion (src/vectordb.py)

   • Generate embeddings for document chunks
   • Store embeddings in ChromaDB
   • Create unique identifiers for each chunk

4. Similarity Search (src/vectordb.py)

   • Implement vector similarity search
   • Return ranked results based on relevance
   • Handle query embedding generation

5. RAG Prompt Template (src/app.py)

   • Design effective prompts for LLM
   • Include context and question placeholders
   • Handle cases with insufficient context

6. RAG Query Pipeline (src/app.py)

   • Combine search results into context
   • Generate responses using LLM
   • Return structured results with metadata

7. Testing and Validation

   • Test individual components
   • Validate end-to-end functionality
   • Use provided test cases for verification

Example Queries

Once implemented, you can ask questions like:

• "What training is recommended for Product Engineering?"
• "Why was the device security policy changed?"
• "What is the daily meal expense limit for Marketing employees?"
• "Can we deploy to staging on November 5th?"

For additional RAG test cases, see section RAG Test Cases below

Dataset Overview

The Aether Dynamics Corp. corpus is a collection of 18 small, interrelated text documents across three essential organizational categories: Operational, Governance, and Strategic.

The core value of this dataset for a portfolio project is its ability to test the RAG implementation's ability to not just find keywords, but to reason over linked pieces of information, a key requirement for enterprise AI deployment.[1]

RAG Test Cases and Expected Results

The following table provides essential test cases designed to stress-test key features of your RAG pipeline, including multi-hop retrieval, conflict resolution, and compliance checking.