🧾 Abstract

EDUBOT is an intelligent Retrieval-Augmented Generation (RAG) system that seamlessly integrates document retrieval with large language model reasoning to deliver accurate and context-aware answers.
Users can upload custom documents in multiple formats (PDF, DOCX, PPTX, XLSX, TXT), which are automatically processed, embedded, and stored in a FAISS vector database using a LangGraph-based ingestion pipeline.
The assistant leverages Hugging Face embeddings (all-MiniLM-L6-v2) for semantic search and Google Gemini as the core LLM to generate precise, evidence-grounded responses.
By combining a real-time RAG architecture with a modular ingestion workflow, EDUBOT provides a scalable, local, and explainable AI solution tailored for education, knowledge retrieval, and intelligent document analysis.

---

🧩 Introduction

Conventional AI assistants often depend solely on pretrained knowledge, which can lead to outdated or generic responses.
EDUBOT enhances this paradigm through a Retrieval-Augmented Generation (RAG) approach — integrating retrieval and generation into a single intelligent pipeline.
The system’s Document Ingestion Module, powered by LangGraph, continuously monitors and processes new documents, ensuring that the FAISS vector database remains up to date.
When a user submits a query via the Streamlit interface, the assistant retrieves semantically relevant content using Hugging Face embeddings and synthesizes context-rich answers through the Gemini LLM.

This architecture guarantees that every response is derived from the most relevant, up-to-date documents, ensuring factual accuracy and transparency.
With its modular design, agentic orchestration, and full offline compatibility, EDUBOT demonstrates the potential of open-source RAG systems for academic research, enterprise documentation, and educational AI applications.

---

🎯Purpose of This Project

This project implements EduRAG, an educational Retrieval-Augmented Generation (RAG) system, to enable intelligent question answering over custom documents. The goal is to provide a scalable, explainable assistant that retrieves relevant information from a knowledge base of PDFs, DOCX, PPTX, etc., and generates context-aware responses via a large language model. This system is designed for educational use cases such as summarizing study materials, answering academic questions, and assisting learners in navigating complex documents.

---

⚙️ Methodology

The EDUBOT system follows a modular, two-stage methodology integrating document ingestion and retrieval-augmented reasoning.
This approach ensures that every user query is answered using the most relevant and up-to-date information from uploaded documents.

---

🔹 Stage 1: Document Ingestion Pipeline (LangGraph Workflow)

1️⃣ File Detection and Monitoring

• The watcher agent continuously monitors a predefined data folder for any additions, modifications, or deletions of files.
• Supported file formats include .pdf, .docx, .pptx, .xlsx, and .txt.

2️⃣ Document Loading and Preprocessing

• Each detected file is read using LangChain’s document loaders such as PyPDFLoader, Docx2txtLoader, and UnstructuredPowerPointLoader.
• Non-textual elements and metadata are filtered out, retaining only meaningful textual data.

3️⃣ Text Chunking

• Documents are divided into smaller, overlapping chunks using the RecursiveCharacterTextSplitter to preserve semantic context.
• This step optimizes retrieval accuracy during the query stage.

4️⃣ Embedding Generation

• Text chunks are converted into dense vector embeddings using the Hugging Face model all-MiniLM-L6-v2.
• These embeddings represent the semantic meaning of the document content.

5️⃣ Vector Database Creation (FAISS)

• The embeddings are indexed and stored in a FAISS vector database, enabling high-speed similarity searches.
• Each file’s vector IDs and chunk information are tracked using file_mapping.pkl.

6️⃣ Validation and Synchronization

• The system verifies FAISS integrity after each ingestion cycle.
• Any deleted or modified files automatically trigger a vector database update, ensuring consistent synchronization between documents and embeddings.

---

✂️ Text Chunking Strategy

When ingesting documents, we split the text into smaller overlapping chunks to preserve context and improve retrieval quality. The parameters used are:

• Chunk size: 500 tokens
• Overlap: 50 tokens

Why these values were chosen:

1. Chunk size (500 tokens):

   • Large enough to capture meaningful context for the language model.
   • Small enough to avoid exceeding token limits during embedding and retrieval, keeping the process efficient.

2. Overlap (50 tokens):

   • Ensures that important content spanning across chunk boundaries is not lost.
   • Helps maintain context for queries that reference information at the edges of chunks.

This combination balances retrieval accuracy and computational efficiency, ensuring the RAG system provides relevant answers without unnecessary overhead.

---

🔹 Stage 2: Retrieval-Augmented Generation (RAG Application)

1️⃣ User Query Input (Streamlit UI)

• Users interact with the system through a simple, intuitive Streamlit interface.
• Queries are entered in natural language.

2️⃣ Query Vectorization and Retrieval

• The query is converted into an embedding vector using the same MiniLM model to ensure semantic alignment.
• FAISS retrieves the most relevant text chunks based on similarity scoring.

3️⃣ Context Construction

• The retrieved chunks are merged and formatted into a structured context prompt.
• This context is passed to the LLM for reasoning.

4️⃣ Response Generation (Google Gemini LLM)

• The Gemini model generates responses grounded in the retrieved content.
• It ensures accuracy, contextual depth, and source relevance.

5️⃣ Semantic Evaluation and Display

• The generated response is compared with the retrieved context to assess semantic similarity.
• The final answer, along with source references, is displayed to the user in real time.

---

🔹 Stage 3: Logging, Monitoring, and Continuous Improvement

• Each ingestion and query session is logged with timestamps and performance metrics such as semantic similarity and response time.
• The watcher agent ensures continuous monitoring and automatic updates to the FAISS store.
• The modular architecture allows seamless scalability and integration of additional LLMs or domain-specific agents in future releases.

---

✅ Summary

The EDUBOT methodology combines automated document ingestion, vector-based retrieval, and contextual LLM reasoning within a unified agentic framework.
By leveraging LangGraph for orchestration, FAISS for storage, and Gemini for generation, it delivers a reliable, transparent, and explainable AI assistant capable of dynamic knowledge retrieval and reasoning.

---

✨ Features

---

🏗️ EDUBOT Document Ingestion Architecture (LangGraph Workflow)

📌 Overview

The Document Ingestion system in EDUBOT automates the entire data pipeline -
from file detection to embedding generation and vector database management.

It uses a LangGraph Agentic Workflow to create a robust, modular,
and the self-healing ingestion process.

This ensures that new, modified, or deleted documents are automatically
processed and reflected in the FAISS Vector Database without manual intervention.

🔁 Workflow Overview

START → DETECT → INGEST → VALIDATE → UPDATE VECTOR DB → END

Each stage in this workflow corresponds to a LangGraph node, connected
sequentially to ensure smooth execution and error handling.

🧩 Step-by-Step Architecture Explanation

1️⃣ START Node

• Entry point of the workflow.
• Initializes the LangGraph state and prepares the pipeline.
• Triggers the first node: "Detect".

2️⃣ DETECT Node

• Scans the Data Folder for supported file types (.pdf, .pptx, .docx, .xlsx, .txt).
• Identifies:
  1. New files to be ingested.
  2. Removed files to be deleted from FAISS.
• Logs all file detection activity to update_log.txt.
• Returns a dictionary of detected files as workflow state.

3️⃣ INGEST Node

• The heart of the ingestion process.
• Loads and processes detected documents using LangChain loaders:
  1. PyPDFLoader
  2. PyMuPDFLoader
  3. Docx2txtLoader
  4. UnstructuredPowerPointLoader
  5. UnstructuredExcelLoader
• Splits documents into chunks using RecursiveCharacterTextSplitter.
• Generates embeddings using HuggingFace all-MiniLM-L6-v2.
• Adds the embeddings to FAISS Vector DB.
• Updates file_mapping.pkl with vector IDs and chunk counts.
• Removes deleted file embeddings from FAISS to maintain consistency.

4️⃣ VALIDATE Node

• Ensures FAISS database integrity after ingestion.
• Checks:
  1. Whether FAISS DB exists and is accessible.
  2. Whether the total number of chunks matches expected values.
• If validation passes → logs success.
• If validation fails → logs error and stops the workflow.

5️⃣ UPDATE VECTOR DB

• Saves all updated FAISS indexes to disk.
• Commits the latest file mapping (file_mapping.pkl) for future consistency.
• Produces a summary of:
  1. Old chunks
  2. Added chunks
  3. Deleted chunks
  4. Final chunk total
• Logs the final update summary to update_log.txt.

6️⃣ END Node

• Marks successful workflow completion.
• Returns summarized ingestion statistics as the final output.

👁️ Watcher Agent (Continuous Monitoring)

• A background thread (watcher_agent) continuously monitors the Data Folder.
• Polls every 5 seconds (configurable).
• Detects:
  1. Newly added files → triggers LangGraph ingestion.
  2. Deleted files → removes their embeddings from FAISS.
• Automatically re-runs the LangGraph pipeline upon any file change.
• Maintains continuous synchronization between local documents and vector database.

---

💾 Storage Components

Data Folder (D:\AAIDC\Project 1\Data)

• Holds all raw input documents (TXT, PDF, DOCX, PPTX, XLSX).

FAISS Vectorstore (D:\AAIDC\Project 1\vectorstore)

• Stores all dense embeddings for document retrieval.

File Mapping (file_mapping.pkl)

• Dictionary mapping each file path to its vector IDs and chunk counts.

Log File (update_log.txt)

• Tracks every ingestion cycle with timestamps, errors, and chunk details.

---

🧭 EDUBOT HIGH LEVEL ARCHITECTURE

🔷 EDUBOT RAG PIPELINE EXPLANATION

---

The diagram above represents the Retrieval-Augmented Generation (RAG) architecture used in EDUBOT.
It combines document retrieval and large language model reasoning to provide accurate, context-aware responses.

🧩 Step-by-Step Workflow

1️⃣ Document Input

• The pipeline begins with multiple input documents (PDFs, DOCX, etc.).
• These are preprocessed and sent for text extraction.

2️⃣ Text Extraction

• Extracts readable text from all supported file types using document loaders.
• Removes formatting and metadata to keep only clean, processable content.

3️⃣ Chunking

• Long texts are split into smaller, overlapping chunks.
• This improves embedding quality and ensures better semantic retrieval.

4️⃣ Vectorization (Embedding Generation)

• Each text chunk is converted into a numerical vector using a Hugging Face embedding model (all-MiniLM-L6-v2).
• These embeddings capture semantic meaning for efficient similarity search.

5️⃣ Vector Database (FAISS)

• All embeddings are stored in a FAISS vector store.
• Enables fast and scalable similarity search when user queries are made.

6️⃣ User Query

• A user submits a natural-language question or prompt through the Streamlit UI.

7️⃣ Query Embedding & Similarity Search

• The query is also converted into an embedding vector.
• FAISS compares it with stored document vectors to find the most relevant chunks.

8️⃣ Context Retrieval

• The top-matching chunks are retrieved and passed to the language model as context.
• This ensures the model’s answer is grounded in real document data.

9️⃣ LLM Reasoning (Gemini / GPT)

• The language model generates an accurate, context-aware response.
• Uses the retrieved content to ensure factual and relevant outputs.

🔟 Response Generation & Display

• The final response is formatted and shown to the user.
• Optionally includes source highlighting or citation of document names.

---

⚙️ Key Features

• Hybrid RAG pipeline combining retrieval + generation.
• FAISS vector DB ensures low-latency document search.
• LangChain orchestration connects embedding, retrieval, and LLM reasoning.
• Fully local and offline-compatible with open-source models.

---

✅ Summary

This architecture allows EDUBOT to provide reliable answers derived directly from the uploaded documents, ensuring accuracy, explainability, and transparency in every generated response.

---

🔧 Project Structure Snapshot

🛠️ Tool Integration

🔹 Local Tools & Services

Gemini LLM Integration (Google Gemini)

• Large language model inference for academic reasoning and summarization
• Configurable temperature and output tokens for adaptive responses
• Provides accurate, context-aware, and educational answers

Document Ingestion Agent (LangGraph + LangChain)

• Automated multi-format file processing (TXT, PDF, DOCX, PPTX, XLSX)
• StateGraph-driven workflow: detect → ingest → validate
• Real-time file watching with auto vector DB updates

Embedding & Retrieval Engine

• Embeddings generated via HuggingFace MiniLM (all-MiniLM-L6-v2)
• Vector indexing and retrieval powered by FAISS
• Persistent FAISS storage for long-term memory

Evaluation & Analysis Tools

• Integrated BLEU, ROUGE, and cosine similarity scoring
• Automatic semantic similarity tracking for generated responses
• Logging of ingestion events and evaluation metrics

Image Understanding Agent

• OCR extraction using EasyOCR
• Visual captioning with BLIP (Salesforce/blip-image-captioning-base)
• Summarization of detected text for study notes

File Management & Logging

• Organized FAISS vectorstore with metadata preservation
• Automated file mapping, update logs, and error handling
• Continuous monitoring by Watcher Agent for changes in Data folder

---

⚙️ Setup Instructions

1️⃣ Install Dependencies

Make sure you have Python 3.11+ installed, then run:

pip install streamlit langchain langgraph faiss-cpu sentence-transformers transformers easyocr google-generativeai evaluate rouge-score python-docx PyPDF2 python-pptx openpyxl pillow python-dotenv

2️⃣ Add Documents

Place your TXT, PDF, PPTX, DOCX, or XLSX files inside the Data/ folder.
Ensure PDFs are text-based (not scanned images).

3️⃣ Run Document Ingestion Agent

python "Document ingestion.py"

4️⃣ Launch the RAG Assistant

streamlit run app.py

---

🖥️ Example Usage

Ask a question:
What are the applications of Artificial Intelligence?

Answer:
Artificial Intelligence (AI) is applied in robotics, healthcare, education, autonomous vehicles, and recommendation systems.
It enables machines to perform human-like decision-making, perception, and learning.
Sources: ai_notes.pdf

---

🧪 Experiments

🧩 Ingestion and Monitoring Process

Process Flow:

The Watcher Agent continuously monitors the Data directory for new, modified, or deleted files.

When a change is detected, it automatically triggers the LangGraph ingestion workflow.

Each document is loaded, split into semantic chunks, embedded using Hugging Face MiniLM, and stored in the FAISS vector database.

The ingestion log tracks:

Old Chunks: Previously existing embeddings.

Added Chunks: New embeddings from newly uploaded documents.

Deleted Chunks: Removed embeddings from deleted files.

After ingestion, the FAISS store is updated instantly, ensuring that the latest study materials are always available for retrieval during user queries.

---

📄 Output (Educational Query Example)

User: “What is Retrieval-Augmented Generation (RAG)?”
Output:
Process Flow:

The system first searches the FAISS vector database for relevant text chunks that match the user’s question using semantic similarity.

If relevant context is found within the uploaded documents, EDURAG retrieves those chunks and constructs a detailed answer grounded in the user’s own study material.

If no relevant data exists in the FAISS store, the system automatically switches to LLM-based reasoning (Google Gemini 2.0 Flash) to generate an accurate explanation using general academic knowledge.

---

💻 System Requirements

• Operating System: Windows 10/11, Linux (Ubuntu 20.04+), macOS 11+
• Python Version: 3.10 or higher (tested on 3.11)
• RAM: Minimum 8 GB (16 GB recommended for faster embedding and LLM inference)
• Storage: 5–10 GB free (for vector DB, logs, and local documents)
• GPU (Optional): NVIDIA GPU with CUDA support for BLIP and EasyOCR acceleration
• Dependencies: Refer to requirements.txt or setup instructions above

---

⚙️ Tech Stack

• LLM: Google Gemini 2.0 Flash
• Frameworks: LangChain, LangGraph, Streamlit
• Embeddings: HuggingFace MiniLM (all-MiniLM-L6-v2)
• Vector Database: FAISS (local persistent store)
• OCR & Image Captioning: EasyOCR, BLIP (Salesforce)
• Document Loaders: LangChain Unstructured, PyPDFLoader, Docx2txt, PowerPoint, Excel loaders
• Evaluation Metrics: BLEU, ROUGE, Cosine Similarity
• Memory: ConversationBufferMemory (LangChain)
• Logging: Auto timestamped logs for ingestion & updates
• UI: Streamlit with custom HTML/CSS chat interface

---

📊 Highlights

✅ Agentic document ingestion using LangGraph workflow (detect → ingest → validate)
✅ Real-time RAG assistant powered by Google Gemini 2.0 Flash
✅ Multi-file support with auto text extraction (PDF, DOCX, PPTX, XLSX, TXT)
✅ Memory-based conversation management for contextual responses
✅ Semantic evaluation using BLEU, ROUGE, and cosine similarity metrics
✅ Integrated image-to-text and captioning (EasyOCR + BLIP)
✅ Auto logging of ingestion activity and FAISS vector updates
✅ Modern Streamlit UI with chat history, new chat, and logout features

---

🧾 Performance & Metrics

⚡ Avg. Response Time: 2–4 seconds (text)
📊 Semantic Similarity: ≥ 0.85 (average on reference-based tests)
🧮 Evaluation Metrics: BLEU, ROUGE-L, and Cosine Similarity
🧠 Memory Retention: Full conversation buffer (preserves context during chat)

---

🪪 License

This project is licensed under the GNU General Public License v3.0 (GPL-3.0).
You are free to use, modify, and distribute this software under the same license terms.

---

🙌 Acknowledgements

🔹 LangChain / LangGraph — For building the ingestion and retrieval orchestration backbone.
🔹 Hugging Face — For providing open-source embedding and summarization models.
🔹 Google Gemini — For powering the LLM responses with contextual reasoning.
🔹 Streamlit — For creating an elegant and interactive user interface.
🔹 AAIDC Module 2 Program — For project structure, certification guidance, and evaluation standards.

---

Results

📊 System Evaluation

---

🧠 Conclusion

The EDURAG system establishes a robust and scalable framework for intelligent educational assistance. By combining LangGraph-based ingestion, FAISS vector storage, and Gemini-powered reasoning, it delivers contextually accurate and explainable responses grounded in real academic data. The system demonstrates strong semantic alignment, high retrieval precision, and consistent contextual retention, supported by automated monitoring and real-time updates. Overall, EDURAG represents a reliable, ethical, and adaptable AI model designed to enhance personalized learning and redefine the future of academic interaction.

---

🛠️ Maintenance & Support

• Document Updates:
  Whenever new study materials are added (e.g., in Data/), run the ingestion workflow to generate embeddings for the new chunks.

• Recomputing Embeddings:
  If documents change significantly, rerun the embedding generation using the same embedding model (all‑MiniLM‑L6-v2) to keep vector representations consistent.

• Model Versioning:
  To upgrade your LLM (for example, switch from Gemini v1 to a newer version), update the model configuration in your code (e.g., config.yaml), and validate responses.

• Logging & Monitoring:
  The ingestion agent logs chunk addition/deletion and timing. Monitor update_log.txt (or your log directory) to track ingestion health.

• Error Handling:
  If ingestion fails for a file, the validation step detects mismatches in chunk counts — re-trigger ingestion for that file.

• Scalability:
  The LangGraph-based workflow is modular: you can plug in more agents (e.g., for summarization, translation) or extend the RAG pipeline to handle new document types.

---

📜 Licensing & Usage Rights

This project, EDURAG, is released under the GNU General Public License v3.0 (GPL-3.0).

✔️ Commercial and private use
✔️ Distribution and modification
✔️ Patent use permitted

Permissions under this strong copyleft license require that the complete source code of all licensed works and derivative projects (including larger systems using EDURAG) be made available under the same license terms.
All copyright and license notices must be preserved.
Contributors provide an express grant of patent rights to ensure open and transparent software use.

A full license text is included in the accompanying LICENSE file.
When redistributing, please retain all copyright and attribution notices.

Model and API Licenses

External components such as Google Gemini, are governed by their respective creators’ licenses.
Ensure compliance with each provider’s terms when integrating, modifying, or extending these third-party components within the EDURAG framework.

---

🌐 Access to Technical Assets

---

🧭 Significance & Implications

By orchestrating specialized educational AI agents with structured retrieval and reasoning mechanisms, EDURAG demonstrates that accurate, explainable, and context-aware learning systems can be developed without depending solely on proprietary or opaque cloud infrastructures.

Key implications include:

• Data Integrity: Ensures reliable and verifiable responses through retrieval-augmented verification using FAISS embeddings and context-based reasoning.

• Transparency: Fully open-source and auditable under GPL-3.0, supporting academic review, educational research, and reproducibility.

• Scalability: Each agent is modular and independent, allowing seamless integration of additional language models, subject domains, or multimodal extensions.

• Ethical AI in Education: Promotes safe, research-backed knowledge delivery with strict academic content filtering and responsible AI alignment.

This framework serves as a foundation for developers, educators, and research institutions aiming to build open, agentic AI architectures for academic assistance and intelligent tutoring ensuring transparency, reliability, and scalability in the future of educational technology.