AI Tutoring System Capstone with LangChain (Python 2026)

An AI tutoring system is one of the most defensible 2026 capstone topics because it combines genuine educational value with proven AI architecture (RAG, LangChain, embeddings). Students upload their textbooks or course PDFs, ask questions in plain language, and get answers grounded in the actual material plus follow-up explanations.

This guide walks through building one end-to-end: architecture, code, deployment, and the panel-defense angle. Full Python source linked at the bottom.

📌 Stack at a glance: Python 3.11 + LangChain 0.3 + OpenAI API (gpt-4o-mini) + Chroma (vector DB) + Streamlit (UI) + PyPDF (PDF parsing). Total monthly cost: ~$3-8 for a class of 50 active students. Build time: 2-3 weeks of part-time work.

Architecture Overview

The system has 4 layers, each independently testable:

1. Ingestion, PDFs are uploaded by teacher/admin, split into chunks (~500 tokens each), embedded via OpenAI text-embedding-3-small, and stored in Chroma vector DB
2. Retrieval, student question is embedded, top-5 similar chunks are pulled from Chroma
3. Generation, retrieved chunks + question are sent to GPT-4o-mini with a tutoring-style system prompt; answer streams back to UI
4. Frontend, Streamlit chat interface (or Next.js if you want fancier UX)

This is classic RAG (Retrieval-Augmented Generation), the gold standard pattern for “AI that knows your specific documents.” It’s defensible at the panel because every architectural choice has a clear reason.

First Step: Setup and Dependencies

# Create virtual environment
python -m venv tutor_env
source tutor_env/bin/activate  # Linux/Mac
# tutor_env\Scripts\activate  # Windows

# Install dependencies
pip install langchain==0.3.0 langchain-openai==0.2.0 langchain-chroma==0.1.4
pip install streamlit==1.40.0 pypdf==4.3.0 chromadb==0.5.5
pip install python-dotenv==1.0.1

# Create .env file
OPENAI_API_KEY=sk-proj-...

Second Step: PDF Ingestion (ingest.py)

from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
import os

def ingest_pdf(pdf_path: str, persist_dir: str = "./chroma_db"):
    """Load PDF, split into chunks, embed, store in Chroma."""
    loader = PyPDFLoader(pdf_path)
    docs = loader.load()

    splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50,
        separators=["\n\n", "\n", ". ", " "]
    )
    chunks = splitter.split_documents(docs)
    print(f"Split {len(docs)} pages into {len(chunks)} chunks")

    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        persist_directory=persist_dir
    )
    print(f"Saved to {persist_dir}")

if __name__ == "__main__":
    ingest_pdf("course_material.pdf")

Third Step: RAG Chain (chain.py)

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnablePassthrough
from langchain.schema.output_parser import StrOutputParser

TUTOR_PROMPT = """You are a friendly tutor helping a BSIT student understand course material.
Use only the provided context to answer. If the context does not contain the answer,
say so honestly and suggest what to study next.

Context:
{context}

Student question: {question}

Answer in clear, conversational English. Use examples when helpful."""

def build_chain(persist_dir: str = "./chroma_db"):
    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
    vectorstore = Chroma(persist_directory=persist_dir, embedding_function=embeddings)
    retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
    prompt = ChatPromptTemplate.from_template(TUTOR_PROMPT)

    def format_docs(docs):
        return "\n\n".join(doc.page_content for doc in docs)

    chain = (
        {"context": retriever | format_docs, "question": RunnablePassthrough()}
        | prompt
        | llm
        | StrOutputParser()
    )
    return chain

Fourth Step: Streamlit UI (app.py)

import streamlit as st
from dotenv import load_dotenv
from chain import build_chain

load_dotenv()
st.set_page_config(page_title="AI Tutor", page_icon="🎓")
st.title("🎓 AI Tutor for BSIT")

if "messages" not in st.session_state:
    st.session_state.messages = []
if "chain" not in st.session_state:
    st.session_state.chain = build_chain()

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

if question := st.chat_input("Ask about your course material..."):
    st.session_state.messages.append({"role": "user", "content": question})
    with st.chat_message("user"):
        st.markdown(question)

    with st.chat_message("assistant"):
        response = st.write_stream(st.session_state.chain.stream(question))
        st.session_state.messages.append({"role": "assistant", "content": response})

# Run with: streamlit run app.py

Fifth Step: Panel-Defensible Extensions

Strip-down version above is a strong demo but light on capstone scope. Add these for defense:

• User accounts (Streamlit Authenticator or migrate to Django frontend)
• Multi-course support, separate Chroma collection per course
• Question history per student stored in SQLite/Postgres
• Teacher dashboard, see what students ask most (identifies weak topics)
• Citation display, show which page of which PDF each answer came from
• Quiz generation, “create 5 multiple-choice questions from Chapter 3” via second LangChain prompt
• Evaluation, BLEU/ROUGE scores on a gold-standard Q&A set (panel loves quantitative metrics)

Cost Estimate (For Your Chapter 4 Budget Section)

Related Guides

• 40 ChatGPT Capstone Project Ideas
• Machine Learning Projects
• Deep Learning Projects
• 150 Best Capstone Project Ideas