Capstone — Your AI-Powered Application

Build an AI application end-to-end. It must include:

• A real problem you genuinely care about.
• An AI core — a trained model (classic/neural) OR an LLM-powered feature.
• A UI — Flask web app or a polished CLI.
• Honest evaluation + a model card (Lesson 46).

Path A — Classic ML:   predict/classify from a dataset (Lessons 9-20)
Path B — Deep Learning: image or text classifier (Lessons 21-38)
Path C — LLM app:       chatbot, RAG over notes, smart tool (Lessons 39-45)
Path D — Vision:        live webcam app (Lessons 30-33)

0-5    write the problem statement in ONE sentence
5-15   get + prep data (or pick the LLM/vision approach)
15-35  build the AI core; evaluate honestly
35-50  wrap in a UI (Flask route or CLI menu)
50-55  model card + README
55-60  test the golden path end-to-end

Example problem statements (good = specific)

"Sort my photos into 'food' / 'people' / 'screenshots'."  (Path B/D)
"Tell me if a movie review is positive or negative."       (Path A/C)
"Chat with my biology notes before an exam."               (Path C - RAG)
"Predict which of my plants needs water from a photo."     (Path B)

Reuse what you built

You don't start from scratch — pull from earlier lessons:

• Prep pipeline (L5-6, 18), evaluation (L5-11), model card (L5-46).
• Flask + sessions + templates (Level 4).
• LLM call / RAG / tools (L5-39 to 45).

The honesty requirement

Your model card must include real metrics (CV accuracy / RMSE / per-group fairness) and at least three honest limitations. "It works on my 8 test images" is a limitation worth stating.

A Path C capstone combining RAG (L5-45) + Flask (L5-44). File tree:

notesbot/
├─ app.py            # Flask: /upload, /chat
├─ rag.py            # chunk, index, retrieve (from L5-45)
├─ templates/
│   └─ index.html    # upload notes + chat box
├─ MODEL_CARD.md     # honest documentation
└─ README.md

# app.py (sketch) — RAG-backed notes chatbot
from flask import Flask, render_template, request, jsonify, session
import anthropic, rag

app = Flask(__name__)
app.secret_key = "dev"
client = anthropic.Anthropic()
INDEX = {}   # filename -> (chunks, vectoriser, matrix)

@app.route("/upload", methods=["POST"])
def upload():
    text = request.files["notes"].read().decode("utf-8")
    INDEX["notes"] = rag.build(text)        # chunk + index
    return jsonify({"ok": True, "chunks": len(INDEX["notes"][0])})

@app.route("/chat", methods=["POST"])
def chat():
    q = request.json["message"]
    chunks = rag.retrieve(q, *INDEX["notes"], k=3)
    context = "\n---\n".join(chunks)
    msg = client.messages.create(
        model="claude-haiku-4-5", max_tokens=400,
        system="Answer ONLY from the context; else say 'not in the notes'.",
        messages=[{"role": "user",
                   "content": f"Context:\n{context}\n\nQ: {q}"}])
    return jsonify({"reply": msg.content[0].text, "sources": chunks})

if __name__ == "__main__":
    app.run(debug=True)

Read the sketch

Every piece is something you already built: RAG retrieval, a Flask JSON endpoint, the key on the server, grounded prompting that refuses to guess, and it even returns its sources for transparency. The capstone is composition, not new material. Build your own version of whichever path fits your problem.

Now build. Hold yourself to the 60-minute order above. Tips:

• Get the smallest end-to-end version working first (data → model → one output).
• Then add the UI, then polish.
• Deploy or record a demo so others can see it run.
• Write the model card AS you go — note limitations the moment you hit them.

You shipped a complete AI application: a real problem, an AI core, a UI, honest evaluation, and a model card. It composes skills from across Levels 4 and 5 — that breadth is exactly what a portfolio project should show. Next lesson: prep for the PCEI exam and close out the level.