Built to order

Campus FAQ Chatbot using Retrieval-Augmented Generation

This project builds a campus FAQ chatbot with Retrieval-Augmented Generation — student questions are embedded, the top-3 passages are retrieved from the college's own documents via FAISS, and the generator answers strictly from those passages with citations. When nothing relevant is found, it abstains instead of hallucinating dates or fees. Updating a document updates the chatbot with zero retraining. Suitable for B.E./B.Tech final-year projects in Computer Science, Information Technology and AI/ML.

Campus FAQ Chatbot using Retrieval-Augmented Generation — project thumbnail preview
More project photos (2)

The problem

College helpdesks answer the same questions — hostel fees, exam dates, bonafide certificates, library timings — hundreds of times each admission season, and static FAQ pages go unread. A plain LLM chatbot is worse than none here: it hallucinates official figures with total confidence. Retrieval-Augmented Generation fixes this architecturally — the model may only answer from retrieved passages of an approved corpus, every answer cites its sources, and low retrieval scores trigger an explicit "I don't have verified info" instead of a guess. For a college, where fees and dates change yearly, RAG has a decisive operational edge: replacing a PDF updates the chatbot with zero retraining. The project ships the corpus builder, the FAISS pipeline, the grounded-answer backend and an evaluation harness measuring faithfulness, hit@3 and abstention.

How it works

  1. College PDFs and notices are parsed, cleaned and chunked (512 tokens, 64 overlap) by the corpus builder.
  2. Each chunk is embedded with all-MiniLM-L6-v2 and indexed in FAISS.
  3. A student question is embedded the same way; FAISS returns the top-3 passages by cosine similarity.
  4. Passages + question + a "answer only from passages" instruction go to the generator LLM.
  5. The answer is returned with cited sources; if no passage clears the similarity threshold, the bot abstains.
  6. Evaluation scores faithfulness (claims ⊆ passages), hit@3 and abstention on the shipped test protocol.

Tech stack:

  • Python 3.10, sentence-transformers
  • FAISS (vector retrieval)
  • all-MiniLM-L6-v2 embeddings
  • Instruction-tuned LLM (API or local)
  • Flask (chat backend)
  • HTML/CSS/JavaScript (chat UI)
  • Git

Dataset & Model Details

  • Dataset: The college's own FAQ corpus (buyer compiles; starter template ships) — design target ~1,240 chunks. RAG needs no labeled training set; the "dataset" is the document collection. Chunking: 512 tokens, 64 overlap.
  • Model input: student question text. Output: grounded answer + cited source passages.
  • Architecture: corpus → all-MiniLM-L6-v2 (384-dim) → FAISS cosine top-3 → grounded generator prompt → cited answer / abstention.
  • Metric: answer faithfulness (manual claim⊆passage check, 50 questions), retrieval hit@3, abstention rate on 20 out-of-corpus questions — all measured on the buyer's corpus. RAG quality follows corpus coverage, so no generic accuracy is pre-claimed.
Parameter Value
Retrieval FAISS, cosine, top-3 passages
Embeddings 384-dim (all-MiniLM-L6-v2)
Chunking 512 tokens, 64 overlap
Abstention Similarity-threshold gated
Hardware CPU sufficient, 4 GB RAM
Demo Chat UI + visible retrieved passages

Project features

  • [Grounded answers with citations] Every claim traces to a retrieved passage; sources are shown with similarity scores.
  • [Abstention, not hallucination] Out-of-corpus questions get an explicit "no verified info" response instead of an invented answer.
  • [FAISS retrieval] all-MiniLM-L6-v2 embeddings (384-dim), cosine top-3 over chunked campus documents.
  • [Corpus builder] PDF/notice ingestion with 512-token chunking and 64-token overlap; starter FAQ template included.
  • [Zero-retraining updates] Replace a document and reindex — answers update without touching any model.
  • [Evaluation harness] Faithfulness, retrieval hit@3 and abstention rate measured on a shipped 50+20 question protocol.
  • [Chat web demo] Working chat UI with suggested questions and visible retrieved passages.

What is included

  • Corpus-builder script (PDF parsing, chunking, starter FAQ template)
  • FAISS indexing + retrieval pipeline
  • Grounded-answer chatbot backend with abstention logic
  • Evaluation harness (faithfulness / hit@3 / abstention protocol)
  • Chat web demo
  • Project report PDF (RAG architecture, evaluation, maintenance workflow)
  • PPT presentation for final review
  • Viva Q&A preparation document

Limitations & prerequisites

  • Answer quality follows corpus coverage — missing documents mean abstentions, not answers.
  • The generator LLM needs an API key or a local model; API usage has ongoing cost.
  • Retrieval can miss heavily paraphrased questions; the evaluation protocol measures this.
  • Multi-hop questions ("fee AND last date in one answer") work only if one passage covers both.
  • Not a replacement for official notices — the bot cites them; students should still verify critical dates.

Frequently Asked Questions

Why RAG instead of fine-tuning a chatbot?

Campus facts change yearly. With RAG, updating a PDF updates the answers — fine-tuning would need retraining on every fee revision, and still couldn't cite sources.

What stops it from hallucinating?

The generator is instructed to answer only from retrieved passages, answers carry citations, and low retrieval scores trigger abstention. The evaluation harness measures faithfulness directly.

What documents do I need?

Your college's real material — fee circulars, hostel handbook, exam notices. A starter FAQ template ships so the demo works immediately, and the corpus builder ingests your PDFs.

Does it need a GPU or paid API?

Retrieval and embeddings run on CPU. The generator can be an API model (key needed) or a local instruction-tuned model — both paths are documented.

How is it evaluated?

50 in-corpus questions scored for faithfulness (every claim inside the retrieved passages), hit@3 for retrieval, and 20 out-of-corpus questions scored for correct abstention.

Is this project suitable for a final-year project?

Yes — for Computer Science, IT and AI/ML programs. It covers embeddings, vector search, prompt engineering, LLM evaluation and a real deployment story colleges actually need. Suitable for B.E./B.Tech final-year projects in Computer Science, Information Technology and AI/ML.

Components & software requirements
  • Python 3.10, sentence-transformers
  • FAISS (vector retrieval)
  • all-MiniLM-L6-v2 embeddings
  • Instruction-tuned LLM (API or local)
  • Flask (chat backend)
  • HTML/CSS/JavaScript (chat UI)
  • Git

Dataset & Model Details

  • Dataset: The college's own FAQ corpus (buyer compiles; starter template ships) — design target ~1,240 chunks. RAG needs no labeled training set; the "dataset" is the document collection. Chunking: 512 tokens, 64 overlap.
  • Model input: student question text. Output: grounded answer + cited source passages.
  • Architecture: corpus → all-MiniLM-L6-v2 (384-dim) → FAISS cosine top-3 → grounded generator prompt → cited answer / abstention.
  • Metric: answer faithfulness (manual claim⊆passage check, 50 questions), retrieval hit@3, abstention rate on 20 out-of-corpus questions — all measured on the buyer's corpus. RAG quality follows corpus coverage, so no generic accuracy is pre-claimed.
Delivery information

Built-to-order project. Delivery timeline is shared after order confirmation based on current queue.

Support terms

Complete documentation, setup guide, and viva preparation included. Support for setup and explanation provided.

Download abstract (PDF)

Related guides

All guides
Blueprint-style technical illustration of multiple decision trees voting together into one final predictionStudents with basic Python and pandas skills who want a reliable first classifier for ML coursework and tabular data projects.

Random Forests Explained: Why Decision Trees Vote Better Together

Decision trees are readable but overfit; random forests fix this by training hundreds of varied trees on bootstrapped data with random feature subsets, then letting them vote. This guide explains Gini impurity, bagging, out-of-bag validation and the four hyperparameters that matter, with a complete scikit-learn workflow, honest feature-importance practices, and the mistakes students keep making.

Read guide
Illustration of object tracking showing video frames with bounding boxes and persistent ID labels following people and vehicles, comparing motion prediction and appearance matching.B.E./B.Tech Computer Science and Electronics students building video analytics projects — people counting, vehicle tracking, sports analysis — who have detection working and need

Object Tracking: DeepSORT and ByteTrack Explained

Detection finds objects per frame; tracking keeps their identities across frames. This guide explains tracking-by-detection, Kalman motion models, DeepSORT's appearance embeddings vs ByteTrack's low-confidence box recovery, tracking metrics (HOTA, IDF1, ID switches), and the tuning parameters that determine real-world quality.

Read guide
Illustration of image segmentation showing U-Net's U-shaped encoder-decoder with skip connections producing pixel masks, alongside Mask R-CNN detecting instances with masks.B.E./B.Tech Computer Science and AI/ML students moving from image classification or detection to pixel-level understanding — medical imaging, defect detection, autonomous driving

Image Segmentation: U-Net and Mask R-CNN

When projects need pixel-level answers, segmentation delivers. This guide explains semantic vs instance vs panoptic segmentation, U-Net's encoder-decoder with skip connections, Mask R-CNN's parallel mask head, Dice and IoU evaluation, paired augmentation, and how to choose the right architecture for your data and question.

Read guide
Get a quotation