AI PDF question answering system using python

AI PDF question answering system using python

Dr. Balaji Kannan , Kavin kanmani. G , Harish Ragavendran. S

Vels institute of science technology and advanced studies, Chennai, Tamil Nadu

CHAPTER 1 INTRODUCTION

In todays digital era, organizations and individuals generate and store an enormous volume of information in document formats such as PDF files. These documents include research papers, business reports, legal contracts, manuals, e-books, and many other forms of structured and unstructured data. While storing information digitally offers convenience and scalability, extracting meaningful insights from these documents remains a significant challenge. Manually reading through lengthy PDFs to locate specific information is not only time-consuming but also inefficient, particularly when dealing with large datasets or time-sensitive tasks.

Traditional keyword-based search techniques have been widely used to retrieve information from documents. However, these methods often fall short when it comes to understanding the context or intent behind a users query. Keyword searches rely heavily on exact word matches, which means they may miss relevant information if different terminology is used or return irrelevant results when keywords appear in unrelated contexts. This limitation becomes even more pronounced when dealing with complex, unstructured documents where meaning is derived from context rather than isolated words.

To overcome these limitations, this project proposes the development of an AI-powered PDF Question Answering System. The primary goal of this system is to allow users to upload PDF documents and interact with them through an intuitive chatbot interface. Instead of manually searching for information, users can simply ask questions in natural language, and the system will provide accurate, context-aware answers derived directly from the content of the uploaded documents.

At the core of this system lies the concept of Retrieval-Augmented Generation (RAG). RAG is a powerful approach that combines information retrieval techniques with generative language models. When a user submits a query, the system first retrieves the most relevant sections of the document using semantic search methods. These retrieved segments are then passed to a Large Language Model (LLM), which generates a coherent and contextually accurate response. This hybrid approach ensures that the answers are both factually grounded in the document and linguistically natural.

A key component of the system is the use of vector embeddings. Instead of representing text as simple keywords, the system converts document content into high-dimensional numerical vectors that capture semantic meaning. These embeddings enable the system to perform similarity searches based on meaning rather than exact word matches. As a result, even if a users query is phrased differently from the original document text, the system can still identify relevant information accurately.

To efficiently store and retrieve these embeddings, the system employs a vector database. This allows for fast and scalable similarity searches, even when dealing with large collections of documents. When a query is received, it is also converted into an embedding and compared against the stored document embeddings to identify the most relevant content. This process significantly improves the accuracy and relevance of the retrieved information.

Another important aspect of this project is the use of a Local Large Language Model. Unlike cloud-based models, a local LLM runs directly on the users machine or within a secure environment. This approach offers several advantages, including enhanced data privacy, reduced dependency on internet connectivity, and lower operational costs. It is particularly beneficial for organizations that handle sensitive or confidential information, as it ensures that data remains within their control.

The system also incorporates text preprocessing techniques to improve performance. Uploaded PDF documents are first parsed and segmented into smaller chunks to ensure efficient processing. Noise such as headers, footers, and irrelevant formatting is removed, and the text is cleaned and structured for better understanding. These preprocessing steps help the model focus on meaningful content and improve the quality of responses.

The user interface is designed as a chatbot, making the system highly interactive and user-friendly. Users can engage in a conversational manner, asking follow-up questions and refining their queries as needed. This conversational approach not only enhances usability but also allows for a more natural and intuitive way of accessing information.

Furthermore, the system can be extended with additional features such as multi-document support, summarization capabilities, and context retention across multiple queries. For example, users could upload multiple PDFs and ask comparative questions, or request summaries of entire documents or specific sections. These enhancements would further increase the systems versatility and usefulness across different domains.

The proposed AI-powered PDF Question Answering System has a wide range of applications. In academia, it can assist students and researchers in quickly extracting information from research papers and textbooks. In business environments, it can help professionals analyze reports, contracts, and policy documents more efficiently. In the legal and healthcare sectors, where accuracy and speed are critical, such a system can significantly improve decision-making processes.

In conclusion, this project demonstrates how advanced natural language processing techniques and retrieval systems can be combined to build a practical and efficient solution for document understanding. By leveraging technologies such as Retrieval-Augmented Generation, vector embeddings, semantic search, and local language models, the system provides accurate, context-aware answers to user queries.

CHAPTER 2 MODULES AND MODULE DESCRIPTION

The AI-Powered PDF Question Answering System is designed as a modular architecture, where each component performs a well-defined function within the overall workflow. This modular design ensures scalability, maintainability, and efficient processing of document-based queries. Each module contributes to transforming raw PDF data into meaningful, context-aware answers for the user.

1. PDF Upload Module

   The PDF Upload Module serves as the entry point of the system, enabling users to provide input documents through a user-friendly web interface built using Streamlit. This module is responsible for handling file selection, upload, and validation processes. It ensures that only supported file formats (primarily PDF) are accepted, preventing errors in downstream processing. Additionally, the module may include file size checks and basic security validations to ensure that uploaded files are safe and manageable. Once validated, the uploaded PDF is temporarily stored and passed to the next stage of the pipeline for content extraction. The simplicity and responsiveness of this module play a crucial role in enhancing user experience, as it allows even non-technical users to interact with the system effortlessly.

2. PDF Text Extraction Module

   After a document is uploaded, the PDF Text Extraction Module processes the file to retrieve its textual content. This module uses the pypdf library to read the PDF file page by page. It extracts text from each page and combines it into a unified textual representation. The module handles diferent PDF structures, including multi-page documents, varying layouts, and embedded text formats. In cases where PDFs contain complex formatting, such as columns or tables, the module attempts to preserve readability as much as possible. The extracted text is then cleaned to remove unnecessary elements like extra whitespace, special characters, or encoding issues. This preprocessing ensures that the text is in a consistent and usable format, forming the foundation for subsequent analysis and processing.

3. Text Chunking Module

   Processing large documents as a single block of text is inefficient and can negatively impact both performance and accuracy. To address this, the Text Chunking Module divides the extracted text into smaller, manageable segments known as chunks. Each chunk typically contains a fixed number of words or characters, along with a slight overlap with adjacent chunks to preserve contextual continuity. This overlapping strategy ensures that important information spanning across chunk boundaries is not lost. By breaking the document into smaller units, the system can perform more precise and faster retrieval operations. Additionally, chunking improves the effectiveness of downstream embedding and search processes, as smaller segments are easier to compare and match with user queries. This module plays a critical role in balancing computational efficiency with contextual understanding.

4. Embedding Generation Module

   The Embedding Generation Module is responsible for transforming text chunks into numerical representations known as vector embeddings. This module utilizes models from Sentence Transformers to encode each chunk into a high-dimensional vector space. Unlike traditional keyword-based representations, embeddings capture the semantic meaning of the text, allowing the system to understand relationships between words and phrases. For example, phrases with similar meanings will have similar vector representations, even if they use different wording. These embeddings are essential for enabling semantic similarity search, where the system identifies relevant document chunks based on meaning rather than exact keyword matches. The generated embeddings are then stored in a vector database for efficient retrieval during query processing. This module is a cornerstone of the systems intelligence, as it enables accurate, context-aware matching between user queries and document content.

5. Vector Database Module

   The Vector Database Module is responsible for storing and managing the embeddings generated from the text chunks. Once the embeddings are created, they are indexed and stored in a specialized database optimized for similarity search. Unlike traditional databases that rely on exact matches, a vector database enables fast retrieval of semantically similar data points using distance metrics such as cosine similarity or Euclidean distance. Popular implementations like FAISS or Chroma can be used for this purpose.

   This module plays a crucial role in ensuring scalability and efficiency, especially when handling large volumes of documents. When a user submits a query, the system searches the vector database to identify the most relevant text chunks based on their embeddings. The ability to perform high-speed similarity searches allows the system to deliver near real-time responses. Additionally, the database can be updated dynamically, enabling users to upload new documents and expand the knowledge base without reprocessing the entire dataset.

6. Query Processing Module

   The Query Processing Module handles user input and prepares it for retrieval and answer generation. When a user enters a question through the chatbot interface, this module first preprocesses the query by cleaning the text, removing unnecessary symbols, and normalizing the input. It then converts the query into a vector embedding using the same model employed in the embedding generation stage to ensure consistency.

   Once the query embedding is generated, it is compared against the embeddings stored in the vector database. The module retrieves the top k most relevant text chunks that closely match the semantic meaning of the query. This retrieval step ensures that only the most contextually relevant portions of the document are passed forward. By focusing on relevant content, the system reduces noise and improves the accuracy of the generated answers. This module essentially acts as the bridge between user input and document knowledge.

7. Retrieval-Augmented Generation (RAG) Module

   The Retrieval-Augmented Generation (RAG) Module is the core intelligence layer of the system. It combines the retrieved document chunks with a Large Language Model (LLM) to generate accurate and context-aware responses. Instead of relying solely on the models pre-trained knowledge, the RAG approach ensures that answers are grounded in the actual content of the uploaded documents.

   In this module, the retrieved text chunks are provided as context along with the users query to the LLM. The model then processes both inputs and generates a coherent, human-like response. This significantly reduces the chances of hallucination (incorrect or fabricated answers) and improves factual accuracy. A local LLM implementation such as LLaMA can be used to maintain data privacy and reduce dependency on external APIs.

   The RAG module ensures that the system not only retrieves relevant information but also presents it in a clear and conversational manner. This combination of retrieval and generation is what makes the system highly effective for document-based question answering.

8. Response Generation Module

   The Response Generation Module refines and formats the output generated by the RAG module before presenting it to the user. While the LLM produces a raw answer, this module ensures that the response is clear, concise, and contextually appropriate. It may

   include formatting improvements such as structuring the answer into paragraphs, highlighting key points, or simplifying complex explanations.

   Additionally, this module can incorporate features such as source attribution, where the system indicates which part of the document was used to generate the answer. This increases transparency and helps users verify the accuracy of the information. The module may also support multi-turn conversations by maintaining context from previous queries, enabling a more interactive and engaging user experience.

9. Chatbot Interface Module

   The Chatbot Interface Module provides the front-end through which users interact with the system. Built using Streamlit, this interface offers a simple and intuitive conversational environment. Users can upload documents, ask questions, and receive answers in real time, all within a single application window.

   The chatbot design supports natural language interaction, allowing users to ask questions in a flexible and conversational manner rather than using rigid commands. It can also display chat history, enabling users to revisit previous questions and answers . Furthermore, the interface can include additional features such as loading indicators, document status updates, and error messages to enhance usability.

   This module is essential for bridging the gap between complex backend processes and end users. By providing a clean and interactive interface, it ensures that the advanced capabilities of the system are accessible to users with varying levels of technical expertise.

10. Overall Workflow Integration

All the modules work together in a seamless pipeline to deliver the final functionality of the system. The workflow begins with PDF upload, followed by text extraction, chunking, embedding generation, and storage in the vector database. When a user submits a query, it is pocessed, matched with relevant document chunks, and passed through the RAG module to generate a response. Finally, the response is formatted and displayed through the chatbot interface.

This modular and integrated design ensures that the system is efficient, scalable, and easy to maintain. Each module can be independently improved or replaced without affecting the entire system, making it adaptable to future advancements in AI and natural language processing technologies.

CHAPTER 3- CSV FILE / DATA FILE EXPLANATION

The proposed AI-Powered PDF Question Answering System fundamentally differs from traditional machine learning applications in terms of how data is handled and utilized. Unlike conventional systems that depend on structured datasets such as CSV (Comma-Separated Values) files for training and inference, this system operates entirely on dynamic, user-provided PDF documents. These documents act as the primary and only data source, making the system highly flexible and adaptable to a wide range of use cases.

In traditional data-driven applications, a predefined dataset is collected, cleaned, and stored in a structured format like CSV or relational databases. Models are then trained on this static dataset, and their performance is limited to the scope and quality of the data they were trained on. However, such an approach is not suitable for scenarios where users need to extract information from diverse and ever-changing document collections. The proposed system addresses this limitation by eliminating the dependency on static datasets and instead focusing on real-time document processing.

In this system, users can upload PDF files containing various types of content, including academic notes, research papers, business reports, legal documents, technical manuals, and more. This flexibility allows the system to be used across multiple domains without requiring retraining or dataset modification. Each uploaded document is treated as a new knowledge source, enabling the system to provide answers tailored specifically to the content of that document. This dynamic approach significantly enhances the systems usability and relevance in real-world applications.

Once a PDF document is uploaded, it undergoes a series of processing steps to convert it into a format suitable for machine understanding. The first step involves extracting textual content from the PDF using libraries such as pypdf. This process reads the

document page by page and consolidates the text into a continuous format. Since PDF files can vary widely in structure and formatting, the extraction process may also involve cleaning and normalization to remove noise such as extra spaces, special characters, headers, and footers.

After text extraction, the content is divided into smaller segments or chunks. This step is essential because large documents cannot be efficiently processed as a single block. Chunking ensures that each segment retains meaningful context while remaining computationally manageable. Additionally, overlapping between chunks is often introduced to preserve continuity of information across boundaries. This improves the systems ability to retrieve accurate and contextually relevant information during query processing.

The next stage involves transforming these text chunks into numerical representations known as vector embeddings. This is achieved using models from Sentence Transformers, which encode semantic meaning into high-dimensional vectors. Unlike traditional keyword-based representations, embeddings capture the underlying meaning of the text, allowing the system to identify similarities between different phrases even if they are worded differently. This capability is crucial for understanding natural language queries and retrieving relevant information effectively.

Once generated, these embeddings are stored in a vector database such as FAISS. This database is specifically designed for efficient similarity search, enabling the system to quickly locate the most relevant text chunks based on a users query. When a query is entered, it is also converted into an embedding and compared with the stored vectors to identify the closest matches. This process allows the system to perform semantic search rather than relying on exact keyword matches, resulting in more accurate and meaningful responses.

A key advantage of this approach is that the system does not require pre-training on a specific dataset. Instead, it processes documents in real time, making it highly adaptable to new information. Users can upload different PDFs at any time, and the system will immediately incorporate them into its knowledge base without requiring retraining. This makes the system particularly useful in environments where information is frequently updated or varies across users.

In conclusion, the AI-Powered PDF Question Answering System replaces the concept of a static CSV dataset with a dynamic, document-driven data pipeline. By leveraging user-uploaded PDF files as the primary data source and applying advanced techniques such as text extraction, chunking, embedding generation, and vector-based retrieval, the system enables flexible, efficient, and context-aware information access. This approach not only enhances scalability and usability but also aligns with the growing need for intelligent systems capable of handling unstructured data in real-world applications.

CHAPTER 4 EXISTING SYSTEM

Existing document retrieval systems have long been used to locate information within digital documents such as PDFs. These systems typically rely on manual reading, keyword-based search, or simple text-matching techniques. While such approaches may be effective for small documents or when the user knows exactly what to search for, they become increasingly inefficient and inadequate when dealing with large, complex, and unstructured datasets. As the volume of digital documents continues to grow across domains such as education, business, healthcare, and research, the limitations of these traditional methods become more evident.

Manual reading is the most basic form of document retrieval, where users scan through entire documents to find relevant information. Although this method ensures accuracy, it is extremely time-consuming and impractical for lengthy documents such as research papers, technical manuals, or legal contracts. In time-sensitive scenarios, manual searching can significantly reduce productivity and lead to missed information. Furthermore, human error and fatigue may affect the quality of information extraction, making this approach unreliable for large-scale applications.

Keyword-based search mechanisms were introduced to address some of these limitations by allowing users to quickly locate specific words or phrases within a document. However, these systems depend heavily on exact keyword matching, which restricts their effectiveness. If the users query does not contain the exact terms present in the document, relevant information may not be retrieved.

For example, a query using the word automobile may fail to retrieve content that uses the term car, despite both referring to the same concept. This lack of semantic understanding makes keyword-based systems rigid and often frustrating to use.

Additionally, keyword search methods do not consider the context in which words are used. A single keyword may appear multiple times within a document, but not all occurrences are relevant to the users query. As a result, users are often presented with multiple matches, many of which may be irrelevant. This forces users to manually filter through results, defeating the purpose of automated retrieval. Moreover, such systems cannot interpret complex or conversational queries, limiting their usability in modern, user-friendly applications.

Another limitation of traditional document retrieval systems is their inability to perform contextual reasoning. These systems treat text as isolated units rather than interconnected information. They annot understand relationships between different sections of a document or synthesize information from multiple parts to generate meaningful answers. This makes them unsuitable for tasks that require deeper comprehension, such as answering analytical or inferential questions.

In recent years, AI-powered document assistants have emerged as a more advanced alternative. These systems leverage machine learning and natural language processing techniques to improve information retrieval and user interaction. However, many of these solutions rely heavily on cloud-based APIs provided by external service providers such as OpenAI or Google. While these platforms offer powerful capabilities, they introduce several challenges that limit their practicality in certain environments.

One of the primary concerns associated with cloud-based systems is data privacy. When documents are uploaded to external servers for processing, sensitive information may be exposed to third parties. This is particularly problematic in industries such as healthcare, finance, and legal services, where confidentiality is critical. Organizations handling sensitive data may be reluctant or even legally restricted from using such systems, limiting their adoption.

Another issue is dependency on internet connectivity. Cloud-based solutions require a stable and high-speed internet connection to function effectively. In scenarios where connectivity is limited or unreliable, such systems may experience delays or become completely unusable. This dependency reduces accessibility, especially in remote or resource-constrained environments.

Latency and operational cost are additional drawbacks. Since cloud-based systems process data remotely, there is an inherent delay in sending data to the server and receiving responses. This latency can affect real-time interaction, making the user experience less seamless. Furthermore, many cloud-based AI services operate on a pay-per-use model, which can become expensive over time, particularly for applications involving large volumes of data or frequent queries.

Traditional keyword-search chatbots also face significant limitations when applied to document retrieval tasks. These chatbots typically rely on predefined rules or basic pattern matching, which restricts their ability to understand natural language queries. They often fail to handle large and complex documents effectively, as they are not designed to process and analyze extensive textual data. As a result, they may return irrelevant, incomplete, or overly generic responses that do not fully address the users query.

Moreover, such systems lack the ability to adapt to different contexts or user intents. They cannot engage in meaningful conversations or provide follow-up answers based on previous interactions. This reduces their usefulness in real-world applications, where users often require detailed explanations and interactive engagement. The inability to understand the underlying meaning behind queries significantly impacts the overall user experience.

Given these limitations, there is a clear need for an improved document retrieval system that goes beyond simple keyword matching and incorporates advanced language understanding capabilities. An ideal system should be able to interpret natural language queries, understand context, and retrieve relevant information based on semantic meaning rather than exact word matches. It should also be capable of synthesizing information from multiple sections of a document to generate coherent and accurate responses.

Furthermore, the system should address the challenges associated with cloud-based solutions by offering a privacy-preserving alternative. Implementing a local processing approach ensures that sensitive data remains within the users environment, reducing security risks and enhancing trust. At the same time, the system should maintain efficiency and scalability, enabling it to handle large and complex documents without compromising performance.

In conclusion, while existing document retrieval systems have laid the foundation for information access, they fall short in meeting the demands of modern applications. Their reliance on manual processes, keyword-based search, and limited contextual understanding restricts their effectiveness. Additionally, the challenges associated with cloud-based AI solutions further highlight the need for a more robust and flexible approach. By integrating intelligent retrieval mechanisms with advanced natural language processing techniques, a new generation of systems can provide accurate, context-aware, and user-friendly document question answering, addressing the shortcomings of existing methods and significantly improving the way users interact with digital documents.

CHAPTER 5 PROPOSED SYSTEM

The proposed system is an advanced AI-Powered PDF Question Answering System designed to provide intelligent, accurate, and context-aware responses to user queries based on the content of uploaded PDF documents. Unlike traditional document retrieval systems that rely on simple keyword matching, this system leverages modern artificial intelligence techniques to understand both the meaning of the query and the contextual information within the document. By integrating Retrieval-Augmented Generation (RAG) with a Local Large Language Model (LLM), the system significantly enhances the quality, relevance, and reliability of the generated answers.

At a high level, the system is designed to function as an end-to-end pipeline that transforms unstructured PDF documents into an interactive knowledge source. The process begins when a user uploads a PDF file through a user-friendly interface. These documents may include a wide variety of content such as academic materials, business reports, research papers, technical manuals, or any other text-based resources. Unlike systems that require pre-trained datasets, this approach dynamically processes each uploaded document, making it highly flexible and adaptable to different use cases.

Once the PDF is uploaded, the system initiates the document processing phase. In this stage, textual content is extracted from the document using tools such as pypdf. The extraction process involves reading each page of the document and consolidating the content into a structured textual format. Since PDF files often contain complex layouts, the system performs basic preprocessing steps such as removing unnecessary whitespace, special characters, and formatting inconsistencies. This ensures that the extracted text is clean, consistent, and suitable for further analysis.

After text extraction, the system performs text segmentation through a process known as chunking. Large documents are divided into smaller, manageable segments or chunks, each containing a portion of the original text. To preserve contextual continuity, overlapping regions are maintained between consecutive chunks. This ensures that important information spanning across boundaries is not lost. Chunking not only improves computational efficiency but also enhances the accuracy of information retrieval by allowing the system to focus on smaller, contextually meaningful units of text.

The next step involves converting these text chunks into numerical representations known as vector embeddings. This is achieved using models from Sentence Transformers, which are specifically designed to capture the semantic meaning of text. Unlike traditional keyword-based approaches, embeddings represent text in a high-dimensional vector space where similar meanings are positioned closer together. This enables the system to understand the intent behind a query, even if the exact words used in the query differ from those in the document.

These embeddings are then stored in a vector database such as FAISS, which is optimized for fast and efficient similarity search. The database indexes all embeddings, allowing the system to quickly retrieve the most relevant text chunks when a query is submitted. This design ensures scalability, asthe system can handle large volumes of documents and data without significant performance degradation.

When a user interacts with the system by asking a question, the query processing phase begins. The users input is first preprocessed and converted into an embedding using the same model used during the document processing stage. This ensures consistency in representation. The query embedding is then compared with the stored embeddings in the vector database to identify the most relevant chunks based on semantic similarity. Instead of returning raw search results, the system selects the top matching segments that are most likely to contain the answer.

The core intelligence of the system lies in the Retrieval-Augmented Generation (RAG) mechanism. In this approach, the retrieved text chunks are combined with the users query and passed as input to a Local Large Language Model, such as LLaMA. The LLM uses this contextual information to generate a coherent and meaningful response. By grounding the response in actual document content, the system minimizes the risk of generating incorrect or fabricated information, a common issue in standalone language models.

An important feature of the proposed system is the use of a local LLM instead of relying on cloud-based APIs. This design choice offers several advantages, particularly in terms of data privacy and security. Since all processing occurs locally, sensitive documents do not need to be transmitted over the internet, reducing the risk of data breaches. Additionally, local execution eliminates dependency on external services, ensuring consistent performance even in offline or low-connectivity environments. It also helps reduce operational costs associated with API usage.

The system is further enhanced by an interactive chatbot-based user interface, typically implemented using Streamlit. This interface allows users to communicate with the system in a natural and conversational manner. Users can ask questions, request clarifications, and engage in multi-turn interactions, making the system intuitive and easy to use. The chatbot format improves accessibility, enabling users with minimal technical expertise to effectively retrieve information from complex documents.

The proposed system offers several key advantages over existing solutions. First, it provides improved answer relevance by leveraging semantic search and contextual understanding. Second, it ensures data privacy through local processing, making it suitable for sensitive applications. Third, it reduces reliance on external APIs, lowering operational costs and improving reliability. Finally, its interactive interface enhances user experience, making document exploration faster and more efficient.

In conclusion, the AI-Powered PDF Question Answering System represents a significant advancement in document retrieval technology. By combining techniques such as text extraction, chunking, embedding generation, vector-based search, and Retrieval-Augmented Generation, the system transforms static documents into dynamic, interactive knowledge sources. This approach not only addresses the limitations of traditional systems but also provides a scalable, efficient, and user-friendly solution for modern information retrieval needs.

CHAPTER 6 DOMAIN EXPLANATION

The proposed project falls within the broader domain of Artificial Intelligence (AI), with a specific focus on key subfields such as Natural Language Processing (NLP), Information Retrieval, and Large Language Model (LLM) applications. These domains collectively aim to enable machines to process, understand, and generate human language in a way that is both meaningful and contextually relevant. As the volume of digital text data continues to grow exponentially, these fields have become increasingly important in developing intelligent systems capable of handling unstructured information efficiently.

Natural Language Processing is a core component of this project, as it provides the foundational techniques required for interpreting and understanding human language. NLP enables the system to process user queries written in natural, conversational language rather than requiring rigid or predefined commands. Through semantic analysis, the system can identify the intent behind a question, recognize relationships between words, and interpret contextual meaning. This capability allows users to interact with the system in a more intuitive and user-friendly manner, significantly improving accessibility and usability. NLP also plays a role in text preprocessing tasks such as tokenization, normalization, and cleaning, which are essential for preparing document content for further analysis.

Another important domain relevant to this project is Information Retrieval (IR). Information Retrieval focuses on the efficient organization, searching, and retrieval of relevant information from large datasets. In traditional systems, IR relies heavily on keyword-based indexing and matching. However, the proposed system enhances this approach by incorporating semantic search techniques. Instead of relying solely on exact keyword matches, the system uses vector-based representations to measure the similarity between user queries and document content. This allows for more accurate retrieval of relevant information, even when the query uses different wording or phrasing than the original text. As a result, the system can provide more precise and contextually appropriate responses.

The project also aligns with the emerging field of Retrieval-Augmented Generation (RAG), which represents a significant advancement in AI-driven question answering systems. RAG combines the strengths of retrieval-based systems and generative language models to produce high-quality answers. In this approach, relevant information is first retrieved from a document or knowledge base and then used as context for generating a response. This ensures that the generated answers are grounded in actual data rather than relying solely on pre-trained knowledge. By integrating retrieval and generation, RAG improves both the factual accuracy and contextual relevance of responses, making it highly suitable for document-based question answering applications.

In addition, the use of Local Large Language Models places this project within the domain of offline or self-hosted AI systems. Unlike cloud-based AI solutions that require external servers and internet connectivity, local models run directly on the users system or within a controlled environment. This approach emphasizes data privacy, security, and independence from third-party services. It is particularly valuable in scenarios where sensitive or confidential information is involved, such as legal documents, medical records, or corporate data. By keeping all processing local, the system reduces the risk of data exposure and ensures compliance with privacy requirements.

The relevance of this domain extends across a wide range of modern applications. AI-powered document understanding systems are increasingly used in enterprise environments for knowledge management and decision support. In the education sector, such systems can assist students and researchers in quickly extracting information from textbooks and research papers. In the legal and healthcare industries, they can be used to analyze complex documents and provide accurate insights. Additionally, intelligent virtual assistants and chatbots are becoming more sophisticated advancements in NLP and LLM technologies, enabling more natural and effective human-computer interaction.

In conclusion, the proposed AI-Powered PDF Question Answering System represents an integration of multiple advanced AI domains, including Natural Language Processing, Information Retrieval, and Retrieval-Augmented Generation. By leveraging these technologies along with local LLMs, the system addresses real-world challenges associated with unstructured data and document analysis. This makes the project highly relevant in both academic research and prctical industry applications, highlighting its significance in the evolving landscape of intelligent information systems.

CHAPTER 7 SOFTWARE AND HARDWARE REQUIREMENTS

SOFTWARE REQUIREMENTS

• Operating System: Windows 10 / Windows 11

  The operating system provides the base environment in which the entire application runs. Windows 10 or 11 ensures compatibility with development tools, Python libraries, and AI runtimes. It also supports drivers and system resources required for running local AI models smoothly.

• Programming Language: Python

  Python is the core language used to develop the system. It is widely used in AI and machine learning due to its simplicity and extensive ecosystem of libraries. Python enables integration of NLP, vector search, and LLM-based components into a unified pipeline.

• Development Environment: Visual Studio Code / Jupyter Notebook / Anaconda Prompt

  Visual Studio Code is used for writing, debugging, and managing project files efficiently.

  Jupyter Notebook is useful for testing code, experimenting with models, and visualizing outputs step by step. Anaconda helps manage environments, dependencies, and packages required for AI development.

  These tools improve developer productivity and simplify project management.

• User Interface Framework: Streamlit

  Streamlit is used to build the web-based chatbot interface. It allows quick creation of interactive applications where users can upload PDFs and ask questions. Its simplicity makes it ideal for developing user-friendly AI applications without complex frontend coding.

• AI Runtime: Ollama

  Ollama is responsible for running large language models locally on the system. It manages model execution, inference, and resource utilization. This enables offline processing and ensures that sensitive data does not leave the users machine.

• Large Language Model: Phi / LLaMA 3

  Phi is a lightweight model suitable for efficient local inference.

  LLaMA 3 provides more advanced language understanding and generation capabilities.

  These models generate context-aware answers based on retrieved document content.

• AI Framework: LangChain

  LangChain acts as the backbone of the system by connecting different components such as document loaders, embeddings, vector databases, and LLMs. It simplifies the implementation of the Retrieval-Augmented Generation (RAG) pipeline.

• PDF Processing Library: pypdf

  pypdf is used to extract text from uploaded PDF documents. It reads each page and converts the content into machine-readable text for further processing.

• Embedding Model Library: Sentence Transformers

  Sentence Transformers converts text chunks into vector embeddings. These embeddings capture semantic meaning, enabling the system to perform similarity-based search instead of keyword matching.

• Vector Database: FAISS

  FAISS stores and indexes embeddings for efficient retrieval. It allows the system to quickly find the most relevant text chunks based on user queries using similarity search algorithms.

  HARDWARE REQUIREMENTS

• Processor: Intel Core i5 / i7 or equivalent

  The CPU handles general computation tasks such as text processing, embedding generation, and running the application. A multi-core processor improves performance, especially when handling large documents or multiple queries.

• RAM: Minimum 8 GB (Recommended 16 GB)

  Memory is crucial for loading language models, storing embeddings, and processing text chunks. While 8 GB is sufficient for basic functionality, 16 GB ensures smoother performance and faster processing, especially when working with larger PDFs or advanced models.

• Storage: Minimum 10 GB free disk space

  Storage is required to install dependencies, save models, and store vector databases. Large language models and embedding files can occupy several gigabytes, so sufficient disk space is necessary for proper operation.

• GPU: Optional (Recommended for faster inference)

  A Graphics Processing Unit accelerates computation, particularly for embedding generation and LLM inference. While the system can run on CPU, a GPU significantly reduces response time and improves overall performance, especially for large models.

• Internet Connection: Required for initial setup

An internet connection is needed only during the initial phase to download required libraries, models, and dependencies (such as via Ollama or Python packages). After setup, the system can function offline, ensuring privacy and independence from external services.

CHAPTER 8 ARCHITECTURE DIAGRAM

The architecture of the proposed AI-Powered PDF Question Answering System is designed as a pipeline of interconnected components, where each module performs a specific function to transform raw PDF data into meaningful answers. This modular architecture ensures scalability, efficiency, and ease of maintenance.

The workflow begins with the User Interface Layer, developed using Streamlit. This layer acts as the interaction point between the user and the system. Users can upload PDF documents and submit queries in natural language through a chatbot-style interface. The simplicity of this interface allows even non-technical users to interact with complex AI functionalities seamlessly.

Once a PDF is uploaded, it moves to the Document Processing Layer. In this stage, the PDF parser extracts textual content from the document. The extracted text is then cleaned and preprocessed to remove unnecessary formatting issues such as extra spaces or symbols. After preprocessing, the text is divided into smaller chunks. Chunking is essential because large documents cannot be processed efficiently as a whole. By breaking the text into manageable segments with slight overlap, the system preserves context while improving processing speed and retrieval accuracy.

The next stage is the Embedding Layer, where each text chunk is converted into a vector embedding using an embedding model. These embeddings capture the semantic meaning of the text, allowing the system to understand context rather than relying on exact keyword matches. This step is crucial for enabling semantic search capabilities.

Following embedding generation, the vectors are stored in the Vector Database Layer (FAISS). This database is optimized for similarity search and allows fast retrieval of relevant text chunks. Each embedding is indexed so that it can be efficiently compared with query embeddings during the search process.

When a user submits a query, it enters the Query Processing Layer. The query is first converted into an embedding using the same embedding model to maintain consistency. The system then performs a semantic similarity search in the vector database to identify the most relevant document chunks related to the query.

These retrieved chunks are passed to the Retrieval-Augmented Generation (RAG) Layer, which is the core intelligence of the system. In this stage, the retrieved context and the users query are combined and sent to a Local Large Language Model (LLM) running via Ollama. The LLM analyzes both the query and the context to generate a meaningful, accurate, and human-like response.

Finally, the generated answer is sent back to the User Interface Layer, where it is displayed to the user in a conversational format. This completes the cycle, enabling interactive and intelligent document-based question answering.

CHAPTER 9 SOURCE CODE

The implementation of the proposed AI-Powered PDF Question Answering System is caried out using the Python programming language along with modern AI frameworks and libraries. The system is developed as a web-based chatbot application using Streamlit, which provides an interactive and user-friendly interface for uploading documents and querying information. The implementation follows a modular approach, where each component is designed to handle a specific task such as document processing, semantic retrieval, and response generation.

The first stage of implementation involves the PDF Processing Module, which is responsible for extracting textual content from uploaded documents. This is achieved using the pypdf library, which reads the PDF file page by page and converts its contents into machine-readable text. Since PDF files may contain inconsistent formatting, the extracted text undergoes preprocessing steps such as removing unnecessary whitespace, special characters, and formatting irregularities. This ensures that the text is clean and suitable for further processing.

Once the text is extracted, it is passed to the Text Chunking Module. In this stage, the document is divided into smaller segments or chunks using text splitting techniques. Chunking is essential because large documents cannot be efficiently processed as a single unit. Each chunk is created with a fixed size and may include a small overlap with adjacent chunks to preserve contextual continuity. This overlapping strategy ensures that important information spanning multiple sections is not lost, thereby improving the accuracy of retrieval and response generation.

The next stage involves the Embedding Generation Module, where each text chunk is transformed into a vector embedding. This is done using models from Sentence Transformers, which convert textual data into high-dimensional numerical vectors that capture semantic meaning. Unlike traditional keyword-based representations, embeddings enable the system to understand relationships between words and phrases, allowing it to identify relevant information even when different wording is used.

These embeddings are then stored in the Vector Database Module, implemented using FAISS. FAISS is optimized for efficient similarity search and indexing of large volumes of vector data. Each embedding is indexed so that it can be quickly compared with query embeddings during retrieval. This enables the system to perform fast and accurate semantic searches, even for large document collections.

When a user submits a query through the chatbot interface, the Query Processing Module is activated. The users query is first preprocessed and converted into an embedding using the same embedding model used for document chunks. This ensures consistency in the representation of both queries and document data. The query embedding is then compared against the stored embeddings in the FAISS database to retrieve the top k most relevant text chunks based on semantic similarity.

The retrieved chunks are passed to the Response Generation Module, which implements the Retrieval-Augmented Generation (RAG) approach. In this stage, the retrieved context and the users query are provided as input to a local Large Language Model running through Ollama. Models such as LLaMA 3 or Phi are used to generate context-aware and human-like responses. By grounding the response in retrieved document content, the system ensures higher accuracy and reduces the likelihood of generating incorrect or irrelevant answers.

The generated response is then displayed to the user through the Streamlit-based chatbot interface. The interface supports conversational interaction, allowing users to ask follow-up questions and refine their queries. This enhances the overall usability and makes the system more intuitive and engaging.

To improve performance and efficiency, the implementation incorporates caching techniques. For example, processed documents, generated embeddings, and vector indexes can be cached so that they do not need to be recomputed each time the system is used. Streamlits built-in caching mechanisms help reduce redundant computations, resulting in faster response times and improved system responsiveness.

CHAPTER 10 OUTPUT & SCREENSHOTS

The developed AI-Powered PDF Question Answering System was successfully implemented and evaluated using multiple PDF documents containing academic, technical, and informational content. The system was tested under various scenarios to assess its ability to extract meaningful information and generate accurate responses based on user queries. The results demonstrate that the system performs effectively in transforming static PDF documents into interactive knowledge sources.

The system allows users to upload PDF files through an intuitive chatbot interface built using Streamlit. Once a document is uploaded, it undergoes a series of processing steps, including text extraction, chunking, embedding generation, and storage in a vector database. The text extraction process, implemented using pypdf, was found to be reliable for most standard PDF formats, successfully retrieving textual content from multiple pages.

After extraction, the text is segmented into smaller chunks to improve processing efficiency and contextual understanding. These chunks are then converted into vector embeddings using Sentence Transformers. The embeddings effectively capture the semantic meaning of the text, allowing the system to perform similarity-based retrieval rather than relying on exact keyword matches. This significantly enhances the systems ability to understand user queries and locate relevant information.

The embeddings are stored and indexed using FAISS, which enables fast and efficient semantic search. During query processing, the system retrieves the most relevant text chunks based on similarity scores. These retrieved chunks serve as contextual input for the response generation stage.

The integration of a local Large Language Model through Ollama allows the system to generate intelligent, context-aware responses. Models such as Phi were used to ensure efficient local inference. The LLM processes both the users query and the retrieved context to produce coherent and meaningful answers. The results show that the system is capable of handling a wide range of queries, including factual, descriptive, and moderately inferential questions.

Experimental evaluation indicates that the proposed system outperforms traditional keyword-based search methods in terms of relevance and accuracy. While keyword-based systems often return multiple irrelevant results, the proposed system provides concise and contextually appropriate answers. This improvement is primarily due to the use of semantic embeddings and Retrieval-Augmented Generation (RAG), which enable deeper understanding of both the query and the document content.

The chatbot interface enhances user experience by enabling natural language interaction. Users can ask questions in a conversational manner without needing to know specific keywords or document structure. The system also supports follow-up queries, making it easier to explore document content interactively. This feature significantly improves usability compared to conventional document search tools.

Another important outcome of the implementation is the systems ability to operate locally. By using a local LLM instead of cloud-based APIs, the system ensures data privacy and security. Sensitive documents remain within the users environment, making the system suitable for applications in domains such as education, research, and business. Additionally, local execution reduces dependency on internet connectivity and eliminates recurring API costs.

In terms of performance, the system demonstrates acceptable response times, particularly when caching mechanisms are applied. The use of caching reduces redundant computations, such as repeated embedding generation or database creation, thereby improving efficiency. However, performance may vary depending on the size of the document and the computatonal resources available, especially when running larger language models on CPU.

Despite its strengths, the system has some limitations. For instance, the accuracy of responses depends on the quality of text extraction and the relevance of retrieved chunks. Complex PDF layouts or scanned documents may affect extraction quality. Additionally, while lightweight models provide faster responses, they may not always match the reasoning capabilities of larger models.

Overall, the results confirm that the proposed AI-Powered PDF Question Answering System successfully achieves its objectives. It provides accurate, context-aware answers, improves information retrieval efficiency, and enhances user interaction through a conversational interface. By combining semantic search, vector databases, and local language models, the system represents a practical and effective solution for intelligent document understanding in real-world applications.

Execution of Streamlit Application in Command Prompt

AI PDF Chatbot User Interface (Initial Screen)

PDF Upload and Processing in AI Chatbot

Query Input and Response Generation in AI PDF Chatbot

Multiple Query Interaction with AI PDF Chatbot

CHAPTER 11 SYSTEM TESTING EXPLANATION

System testing was conducted to evaluate the overall performance, reliability, and effectiveness of the AI-Powered PDF Question Answering System. The testing phase focused on verifying whether all system components function correctly when integrated and whether the system meets its intended objectives. Various types of testing, including functional testing, accuracy testing, performance testing, and usability testing, were carried out using multiple PDF documents containing academic and technical content.

During the testing process, different types of PDF files were uploaded into the system, including structured documents such as textbooks and semi-structured documents such as reports and notes. A wide range of natural language queries was used to assess how well the system could understand user intent and retrieve relevant information. These tests were designed to simulate real-world usage scenarios and ensure that the system performs effectively under varying conditions.

Functional Testing

Functional testing was performed to verify that each module of the system operates as expected. The PDF upload functionality was tested to ensure that users could successfully upload valid PDF files through the chatbot interface built using Streamlit. The system correctly validated file formats and initiated processing upon successful upload.

The text extraction process, implemented using pypdf, was tested across multiple documents. The results showed that the system could accurately extract textual content from most standard PDFs. Following extraction, the text chunking mechanism was verified to ensure that large documents were properly divided into smaller segments with contextual overlap.

The embedding generation and storage process was also tested. The system successfully converted text chunks into vector embeddings using Sentence Transformers and stored them in the FAISS database. Retrieval functionality was validated by submitting queries and confirming that relevant text chunks were fetched based on semantic similarity.

Finally, the response generation module was tested using a local language model executed via Ollama. The chatbot interface was verified to ensure that both user queries and generated responses were displayed correctly, maintaining a smooth conversational flow.

Accuracy Testing

Accuracy testing focused on evaluating the correctness and relevance of the responses generated by the system. This was done by comparing the chatbots answers with the actual content present in the uploaded PDF documents. Queries of different typesincluding factual, descriptive, and conceptual questionswere used to test the systems understanding.

The results indicated that the system provides highly relevant and context-aware answers when the required information exists within the document. The use of semantic embeddings and Retrieval-Augmented Generation enabled the system to identify relevant content even when queries were phrased differently from the original text. This represents a significant improvement over traditional keyword-based search systems.

However, it was observed that the accuracy of responses depends on the quality of the extracted text and the relevance of retrieved chunks. In cases where the document contained complex formatting or ambiguous content, the response quality varied slightly. Despite these minor limitations, the system consistently demonstrated strong contextual understanding.

Performance Testing

Performance testing was carried out to measure the systems response time and efficiency under different conditions. The performance was evaluated based on factors such as PDF file size, number of text chunks, hardware specifications, and the type of language model used.

The results showed that smaller documents were processed quickly, with near real-time response generation. For larger documents, initial processing (including text extraction and embedding generation) required more time, but subsequent queries were significantly faster due to caching mechanisms. The use of caching helped reduce redundant computations and improved overall system responsiveness.

The choice of language model also affected performance. Lightweight models provided faster responses, while larger models offered better reasoning capabilities at the cost of increased processing time. The system demonstrated acceptable performance on standard hardware configurations, especially when optimized using efficient retrieval and caching techniques.

Usability Testing

Usability testing was conducted to evaluate the ease of interaction and overall user experience. The chatbot interface developed using Streamlit was found to be intuitive and user-friendly. Users were able to upload documents, ask questions, and receive answers without requiring technical knowledge.

The conversational interface allowed users to interact naturally with the system, making it more accessible compared to traditional search tools. Features such as real-time response display, clear status messages (e.g., processing indicators), and chat history contributed to a smooth user experience.

Reliability Testing

The system was also tested for reliability by running multiple queries across different sessions and documents. It consistently produced stable and repeatable results without crashes or unexpected errors. The modular architecture ensured that individual components functioned independently while maintaining overall system integrity.

Summary of Testing Results

The testing phase confirmed that the AI-Powered PDF Question Answering System operates reliably and efficiently across various scenarios. It successfully fulfills its intended functionality by enabling intelligent, context-aware interaction with PDF documents. The integration of semantic search, vector databases, and local language models ensures accurate information retrieval and response generation.

In conclusion, the system demonstrates strong performance in terms of functionality, accuracy, usability, and reliability. While minor limitations exist, the overall results validate the effectiveness of the proposed approach and highlight its potential for real-world applications in document analysis and information retrieval.

CHAPTER 12 USER MANUAL

The AI-Powered PDF Question Answering System provides a simple, interactive, and user-friendly interface that enables users to upload PDF documents and extract information through a conversational chatbot. The system is designed to minimize technical complexity while delivering powerful AI-driven document understanding capabilities. The complete working process of the system is described step-by-step below:

Step 1: Launch the Application

The application is started by executing the Streamlit command in the terminal:

python -m streamlit run app_advanced.py

This command initializes the backend services, loads the required libraries, and starts the local server required to run the application. The system prepares all necessary components, including the user interface and AI modules, for execution.

Step 2: Open the Interface

After launching, the application automatically opens in the default web browser using a local URL (typically http://localhost:8501). The interface is built using Streamlit and provides a clean layout with options for file upload and chatbot interaction. This interface acts as the primary point of communication between the user and the system.

Step 3: Upload PDF Document

The user uploads a PDF file by clicking the Upload PDF button or dragging and dropping the file into the upload area. The system validates the file format to ensure that only PDF documents are accepted. Once uploaded, the file is securely passed to the processing module.

Step 4: Document Processing

After uploading, the system begins processing the PDF document. This involves extracting textual content using pypdf, followed by dividing the text into smaller chunks. These chunks are then converted into vector embeddings using embedding models. The embeddings are stored in a vector database using FAISS. During this stage, a processing message is displayed to inform the user that the system is preparing the document.

Step 5: Ask Questions

Once processing is complete, the system is ready to accept user queries. The user can type a question in natural language into the chatbot input box. The system does not require specific keywords, allowing users to ask questions freely and intuitively.

Step 6: Response Generation

When a query is submitted, the system converts the query into an embedding and performs semantic similarity search to retrieve the most relevant text chunks from the database. The retrieved context, along with the query, is sent to a local language model running via Ollama. The model analyzes the context and generates a meaningful, accurate, and human-like response, which is then displayed in the chatbot interface.

Step 7: View and Interpret Results

The generated answer is displayed immediately in the chat window. The response is based on the content of the uploaded PDF, ensuring contextual relevance. The system presents the answer in a clear and readable format, improving user understanding.

Step 8: Continuous Interaction

The system supports continuous interaction, allowing users to ask multiple questions related to the same document without re-uploading it. This enables users to explore different aspects of the document in a conversational manner, making the system efficient and user-friendly.

The working procedure demonstrates how the system transforms static PDF documents into an interactive knowledge source. By combining document processing, semantic retrieval, and AI-based response generation, the system provides a seamless and efficient way to extract information. The step-by-step workflow ensures ease of use, making the application accessible to both technical and non-technical users.

CHAPTER 13 CONCLUSION

The AI-Powered PDF Question Answering System based on Retrieval-Augmented Generation (RAG) and Local Large Language Models has been successfully designed, developed, and implemented. The system provides an intelligent solution for interacting with PDF documents by enabling users to ask natural language questions and receive context-aware answers through a chatbot interface. This approach transforms static documents into dynamic and interactive sources of information.

The proposed system integrates multiple advanced technologies, including PDF text extraction, text chunking, semantic embedding generation, vector database retrieval, and AI-based response generation. The use of pypdf ensures efficient extraction of textual content from PDF files, while embedding models from Sentence Transformers enable semantic understanding of both document content and user queries. The integration of FAISS allows fast and efficient similarity-based retrieval of relevant document segments.

A key strength of the system lies in its use of a local Large Language Model executed through Ollama. This enables the system to generate meaningful and contextually accurate responses without relying on external cloud-based APIs. As a result, the system ensures better data privacy, reduced latency, and independence from internet connectivity after initial setup. This makes the solution particularly suitable for sensitive or offline environments.

The implementation successfully addresses the limitations of traditional keyword-based document retrieval systems. Unlike conventional approaches that depend on exact keyword matching, the proposed system uses semantic similarity and contextual reasoning to understand user queries. This significantly improves the relevance and accuracy of the responses, even when the query is phrased differently from the original document text.

Experimental results demonstrate that the system performs effectively across a variety of test cases, including academic and technical documents. It is capable of providing accurate answers for most queries when relevant information is present in the document. The chatbot-based interface, developed using Streamlit, enhances user experience by enabling intuitive and interactive communication with the system.

Although the system performs well overall, certain limitations exist, such as dependency on the quality of PDF text extraction and the capabilities of the selected language model. However, these limitations can be addressed in future improvements by incorporating more advanced models and enhanced document processing techniques.

In conclusion, the project successfully achieves its primary objective of developing an intelligent, efficient, and user-friendly PDF-based question answering system. By combining modern AI technologies with a practical implementation approach, the system demonstrates the potential of Retrieval-Augmented Generation in real-world applications. It serves as a valuable tool for improving document accessibility, reducing information retrieval time, and enhancing the overall user experience in handling large and complex textual data.

CHAPTER 14 REFERENCES

1. Lewis, P., Perez, E., Piktus, A., et al., Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks,

   Advances in Neural Information Processing Systems (NeurIPS), 2020.

2. Vaswani, A., Shazeer, N., Parmar, N., et al., Attention Is All You Need, Advances in Neural Information Processing Systems (NeurIPS), 2017.

3. LangChain Documentation, Available: https://python.langchain.com/

4. Ollama Documentation, Available: https://ollama.com/

5. Streamlit Documentation, Available: https://docs.streamlit.io/

6. FAISS Documentation, Facebook AI Similarity Search, Available: https://faiss.ai/

7. Sentence Transformers Documentation, Available: https://www.sbert.net/

8. pypdf Documentation, Available: https://pypdf.readthedocs.io/

CHAPTER 15 PUBLICATION

The project titled AI-Powered PDF Question Answering System using Retrieval-Augmented Generation has been successfully submitted for publication in the International Journal of Engineering Research & Technology. This journal is a recognized platform for publishing research work in the fields of engineering and technology, providing an opportunity to present innovative ideas and practical implementations to a wider academic audience.

At the time of submission of this project report, the manuscript is currently nder review by the editorial and peer-review committee of the journal. The review process involves evaluation of the research methodology, originality, technical implementation, and overall contribution of the work to the field of Artificial Intelligence and Information Retrieval.

The authors are awaiting further communication regarding acceptance, revision, or publication status. The submission of this work reflects the academic quality and practical relevance of the project.

As supporting evidence, the submission/acknowledgment email received from the journal has been attached in the Appendix section of this report. This serves as proof of successful submission and ongoing review status.