Adigam AI

Your lectures, slides and textbooks become a tutor that cites the exact page or second, adaptive quizzes with verified answers, and a study plan that adapts to you.

Comment

Inspiration

Students study from lecture videos, slides and textbooks scattered across places, and general chatbots answer without tying anything to the course — or to what the student already understands. I wanted a study companion that teaches only from your material, backs every claim with a citation you can open, and adapts to how you are actually doing.

What it does

Adigam AI turns your own course material into a source-cited tutor and an adaptive study plan.

  • Multimodal knowledge base — upload PDFs, slide decks (PPTX) or lecture recordings, or paste a YouTube link. Text, slide images, figures and transcripts become excerpts that remember their page, slide or timestamp. Scanned PDFs are read with OCR; videos without captions are transcribed.
  • Course map — topics, key concepts and prerequisites are extracted automatically and shown as an interactive graph coloured by your mastery.
  • Grounded tutor — every answer cites numbered excerpts; one tap opens the exact PDF page, slide or second of video. Questions the material doesn't cover are declined or clearly labelled as general knowledge. It explains in English, Hindi or Hinglish, and works by voice.
  • Adaptive assessment — diagnostic, practice and mock exams with MCQ, multi-select, numerical and short-answer questions. Generated questions are verified by an independent second solve before anyone sees them; every answer gets cited feedback, and wrong answers are traced to likely misconceptions.
  • Learner model — per-topic mastery from evidence (recent vs historical accuracy, difficulty, consistency, decay), SM-2 spaced repetition, self-rated confidence as a prior for new learners, a prerequisite-aware day-by-day plan that rebuilds itself when you fall behind, cited flashcards with an audio brief, and an exam-readiness score that shows its working.

How I built it

  • Backend: Go (standard-library net/http), PostgreSQL on Supabase with row-level security on every table (API reads run as the learner, so a forgotten WHERE can't leak data), and Redis for the auth cache, per-learner rate limits and a Redis Streams queue that makes ingestion durable across crashes and deploys.
  • AI: Claude (Opus for data that gets stored — questions, answer checks, course maps; Sonnet for explanations) or Gemini, switchable with one setting. Gemini also provides embeddings, speech-to-text and OCR.
  • Retrieval: hybrid search — Postgres full text plus pgvector embeddings, fused with reciprocal-rank fusion and a similarity floor chosen from evaluation data.
  • Frontend: React 19 with a custom soft-3D design system — day (neumorphic) and night (neon glass) — that works the same on a phone and a laptop.
  • Design rule: arithmetic where arithmetic works, a model only where language is needed. Mastery, spaced repetition, planning and readiness are deterministic Go, so every number is testable; the app keeps working without an AI key.
  • Scale: stateless instances behind a load balancer, overload shedding with Retry-After, and a transaction-pooler mode for the database.
  • The adaptive engine (learner model, planner, spaced repetition, mock tests) builds on my earlier Adigam project; the Go platform, multimodal knowledge base, grounded tutor, design system and evaluation were built for this hackathon.

Evaluation

  • RAGAS on a 36-question test set with known source locations over MIT 6.006 lectures 1–3 (PDF notes + lecture videos), Claude as judge: faithfulness 0.79 · answer relevancy 0.88 · context precision 0.88 · context recall 0.95.
  • Grounding: retrieval hit rate 96.4 %, citation accuracy 96.4 %, off-material questions correctly declined 100 % (8/8), in-material questions wrongly declined 0 %.
  • Simulated students (4 learner profiles × 10 sessions × 5 seeds, adaptive vs random): weak-topic gain up to 46.1 vs 24.9, within-session question repetition 0 %.
  • Load test: one million learners in the database, ~2,800 requests/s on a single laptop with zero server errors; load-balancer failover tested with an instance killed mid-run.
  • 195 Go tests (unit + live-database integration, including RLS proofs), 17 frontend tests, CI on every push.

Challenges I ran into

  • The PDF lecture notes had silently failed ingestion on a NUL byte in extracted text — the first evaluation looked plausible but was measuring the videos alone. Finding and fixing that (plus hybrid retrieval) lifted context recall from 0.48 to 0.95. Lesson: evaluate early, and distrust numbers that look fine.
  • Keeping timestamps correct when transcribing long recordings in ten-minute ranges.
  • Making refusals reliable without refusing things the material does cover — the similarity floor was chosen from the gap between in-material and off-material matches, not guessed.

Accomplishments that I'm proud of

Citations that open the exact second of a lecture; refusals that are right 100 % of the time on the test set; a system that stayed error-free with a million learners in the database; and an honest evaluation section that reports what got worse as well as what got better.

What I learned

Measurement changes what you build. The evaluation harness found bugs the unit tests didn't, and the real numbers decided every next step. Also: deterministic engines plus a model only where language is needed makes an AI product testable.

What's next for Adigam AI

A similarity floor on the full-text side, server-side audio revision briefs, deeper misconception analysis across learners, and classroom / mentor dashboards.

Built With

Share this project:

Updates

Submission history