# **Abstract** ## 1. Project Overview This project presents a university enquiry chatbot solution tailored for incoming students at **Kwame Nkrumah University of Science and Technology (KNUST). Developed as a capstone project, the chatbot leveraged LlamaIndex and OpenAI GPT-3 to provide conversational responses to common inquiries from freshmen. ## 2. Technological Context at the Time At the time of development, frameworks such as LangChain and LlamaIndex were just gaining traction, and the modality of Generative AI (GenAI) applications was still evolving. Tools for building agents with seamless web scraping and data retrieval capabilities were not readily available. ## 3. Challenges in Development The project relied on manual web scraping, implemented through custom Python functions, and utilized the scheduler library to periodically update the dataset. These limitations required innovative problem-solving and early adoption of GenAI techniques. ## 4. Significance and Future Potential Future additions and features to this project will include a **location-based search functionality**, allowing users to request specific locations on campus using the **Google Maps API**, and an **integrated speech-to-text feature** to enhance accessibility and user convenience. Other potential multimodal features include **text-to-speech integration** for voice-assisted responses, **image recognition for campus landmarks** to identify and provide information about campus locations, making it a versatile tool for students. # Problem Statement ## 1. Student Challenges at KNUST Freshmen at KNUST often face significant challenges in accessing timely and accurate information about registration processes, campus facilities, academic programs, and extracurricular activities. These difficulties are exacerbated by the overwhelming demand placed on administrative staff during peak enrollment periods, leading to delays and frustration for students. ## 2. Limitations of Existing Solutions The absence of a centralized, intelligent system for handling student queries left a critical gap in addressing the needs of incoming students. This gap created an opportunity to explore the application of conversational AI to provide accurate, personalized assistance. ## 3. Call for Innovation The absence of automated, end-to-end solutions for building such systems created a pressing need for innovative approaches to developing a chatbot capable of providing accurate, context-aware, and conversational assistance to new students. This work demonstrates how early GenAI techniques bridged this gap and foreshadows the possibilities offered by the rapid evolution of GenAI tools and frameworks. # Methodology The methodology for this project involved a structured approach across four key stages: **data preprocessing**, **data encoding**, **model evaluation**, and **response generation**. Data was collected and cleaned from various sources, including KNUST guides, websites, and third-party files, and organized into a structured knowledge base. Using **LlamaIndex**, the data was indexed with vector embeddings for efficient retrieval. The GPT-3 **text-davinci-003 model** was selected and fine-tuned for its contextual awareness and conversational response capabilities. Real-time query processing was implemented through **FastAPI**, while **Firebase** and **React Native** facilitated user authentication and a seamless frontend experience. This framework ensured accurate, context-aware, and user-friendly interactions. ## 1. **Data Preprocessing Stage** ### (a) Data Collection: - Extracted text from student guides and PDF documents using **PyPDF2**. - Implemented web crawling using **Beautiful Soup 4** and **Requests libraries** to scrape KNUST website content. - Gathered additional information from **third-party files** shared by students. ```python pip install APScheduler ``` ```python pip install beautifulsoup4 ``` ```python import bs4 as bs import urllib.request import time from apscheduler.schedulers.blocking import BlockingScheduler ``` ```python # Function to perform text preprocessing on the document def preprocess_document(document): # Remove special characters, URLs, and numbers document = re.sub(r'http\S+|www.\S+', '', document) # Remove URLs document = re.sub(r'\d+', '', document) # Remove numbers document = re.sub(r'[^\w\s]', ' ', document) # Remove special characters except whitespace # Convert all text to lowercase document = document.lower() # Remove extra whitespaces document = re.sub(r'\s+', ' ', document).strip() # Add any other preprocessing steps you may need, such as removing stopwords, stemming, etc. return document ``` ```python import requests import time from apscheduler.schedulers.background import BackgroundScheduler ``` ```python # Function to scrape the website and save the data to a file with a specific title def scrape_website(): url = 'https://www.knust.edu.gh/' response = urllib.request.urlopen(url) html_content = response.read() # Taking the data out of the site using beautiful soup data = bs.BeautifulSoup(html_content, 'lxml') data_paragraphs = data.find_all('p') data_text = '' for para in data_paragraphs: data_text += para.text # Perform text preprocessing preprocessed_data_text = preprocess_document(data_text) # Add the title to the document desired_title = "KNUST News" # Replace "KNUST News" with your desired title document_with_title = f"# {desired_title}\n\n{preprocessed_data_text}" filename = r'/content/drive/MyDrive/Web crawler/KNUST News.txt' with open(filename, 'w', encoding='utf-8') as file: file.write(document_with_title) ``` ```python def job(): print("Scraping the website...") scrape_website() scheduler = BackgroundScheduler() scheduler.add_job(job, "interval", seconds = 5) scheduler.start() for i in range(5): #print(i) time.sleep(1) ``` ### (b) Data Cleaning: - Removed unnecessary characters, symbols, and non-alphanumeric content. - Standardized text formats and converted all documents to **.txt format** for compatibility with the indexing process. ```python !pip install PyPDF2 ``` ```python from google.colab import drive drive.mount('/content/drive') ``` ```python import pandas as pd import PyPDF2 import re def extract_text_from_pdf(pdf_path): with open(pdf_path, "rb") as f: reader = PyPDF2.PdfReader(f) num_pages = len(reader.pages) text = "" for page_num in range(num_pages): page = reader.pages[page_num] text += page.extract_text() return text def remove_non_alphanumeric(text): cleaned_text = re.sub(r'[^a-zA-Z0-9\s]', '', text) return cleaned_text if __name__ == "__main__": # Specify the path to your PDF file pdf_path = "/content/drive/MyDrive/Case Study1/Student Guide.pdf" # Extract text from the PDF text = extract_text_from_pdf(pdf_path) # Remove non-alphanumeric characters cleaned_text = remove_non_alphanumeric(text) # Print the cleaned text print(cleaned_text) ``` ```python import os import pandas as pd import PyPDF2 import re def extract_text_from_pdf(pdf_path): with open(pdf_path, "rb") as f: reader = PyPDF2.PdfReader(f) num_pages = len(reader.pages) text = "" for page_num in range(num_pages): page = reader.pages[page_num] text += page.extract_text() return text def remove_non_alphanumeric(text): cleaned_text = re.sub(r'[^a-zA-Z0-9\s]', '', text) return cleaned_text if __name__ == "__main__": # Specify the directory containing your PDF files pdf_directory = "/content/drive/MyDrive/KnowledgeBase" # Specify the directory to save the output text files output_directory = "/content/drive/MyDrive/KnowledgeBase" # Iterate through each PDF file in the directory for filename in os.listdir(pdf_directory): if filename.endswith(".pdf"): pdf_path = os.path.join(pdf_directory, filename) # Extract text from the PDF text = extract_text_from_pdf(pdf_path) # Remove non-alphanumeric characters cleaned_text = remove_non_alphanumeric(text) # Save the cleaned text to a text file output_text_path = os.path.join(output_directory, filename.replace(".pdf", ".txt")) with open(output_text_path, 'w', encoding='utf-8') as text_file: text_file.write(cleaned_text) print("Converted:", pdf_path, "to", output_text_path) ``` ### (c) Data Organization: - Structured the processed text files into a **knowledge base folder** organized by topics and categories. ![Screenshot 2024-12-29 150552.png](Screenshot%202024-12-29%20150552.png) ## 2. **Data Encoding/Word Embedding Stage** **Document Organization and Indexing:** - Utilized **LlamaIndex** to create a **GPTVectorStoreIndex** from the processed documents. - Employed a storage context comprising four JSON files: - `docstore.json`: Stored indexed text content. - `vector_store.json`: Contained vector embeddings for retrieval. - `index_store.json`: Maintained index IDs. - `graph_store.json`: Represented relationships between data points. **Efficient Data Retrieval:** - Leveraged vector embeddings for structured data organization. - Integrated an indexing mechanism to enable quick and accurate access to stored information. ```python !pip install langchain ``` ```python !pip install openai ``` ```python !pip install gpt_index ``` ```python pip install llama-index==0.7.11.post1 ``` ```python from llama_index import SimpleDirectoryReader, GPTVectorStoreIndex, LLMPredictor, PromptHelper from llama_index import StorageContext, load_index_from_storage import openai openai.api_key = input("Paste your OpenAI key here and press enter") #openai.api_key = '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' import os # os.environ['OPENAI_API_KEY'] = openai.api_key from langchain import OpenAI import sys import os from IPython.display import Markdown, display def construct_index(directory_path): max_input_size = 4096 num_outputs = 300 max_chunk_overlap = 0.5 chunk_size_limit = 600 llm_predictor = LLMPredictor(llm=OpenAI(temperature = 0.5, model_name = "text-davinci-003", max_tokens=num_outputs)) prompt_helper = PromptHelper(max_input_size, num_outputs, max_chunk_overlap, chunk_size_limit=chunk_size_limit) documents = SimpleDirectoryReader("/content/drive/MyDrive/FYP code files/KnowledgeBase").load_data() index = GPTVectorStoreIndex.from_documents(documents) storage_context = StorageContext.from_defaults() index.storage_context.persist(persist_dir="/content/drive/MyDrive/FYP code files/index.json") return index def ask_ai(): #index = SimpleDirectoryReader("index.json").load_data() storage_context = StorageContext.from_defaults(persist_dir='/content/drive/MyDrive/FYP code files/index.json') index = load_index_from_storage(storage_context) query_engin = index.as_query_engine() #index = GPTVectorStoreIndex.load_from_disk('index.json') while True: query = input("Hey, there KNUST Fresher, how can I serve you today? ") response = query_engin.query(query) #response = index.query(query, response_mode="compact") display(Markdown(f"Response: {response.response}")) ``` ```python #os.environ["OPENAI_API_KEY"] = input("Paste your OpenAI key here and press enter") ``` ```python construct_index("/content/drive/MyDrive/FYP code files/KnowledgeBase") ``` ```python ask_ai() ``` ## 3. **Model Evaluation Stage** (a) ### Model Selection and Configuration: - Chose the **GPT-3 text-davinci-003 model** for its: - Natural language text generation capabilities. - Contextual awareness and response accuracy. - Ability to manage open-ended queries effectively. (b) ### Parameter Tuning: - Set maximum output length to **300 tokens**. - Built a simple document retriever (RAG) for **conversational response quality** and **context retention**. ```python def construct_index(directory_path): max_input_size = 4096 num_outputs = 300 max_chunk_overlap = 0.5 chunk_size_limit = 600 ``` ## 4. Prediction/Generation Stage ### Query Processing Workflow: - Enabled real-time query processing using FastAPI endpoints: - User submits a query through the chat interface. Query is processed against the indexed knowledge base. Model generates a contextually relevant response. Response is delivered back to the user. Testing Scenarios: Conducted manual testing with diverse scenarios, including: Basic information queries. Follow-up questions. Context-dependent responses. Real-time information retrieval. ## 5. System Integration User Authentication and Storage: Used Firebase for managing user authentication and storing chat history. #### Frontend Development: Built the user interface using React Native, enabling seamless interaction with the chatbot system. ![Screenshot 2024-12-29 153828.png](Screenshot%202024-12-29%20153828.png)