AI-powered course generation platform that turns any topic into a structured learning experience — powered by Amazon Nova, grounded in real textbooks via MCP.

Most AI learning tools generate shallow, generic content with no grounding in real material. TheTutor is different — it discovers real textbooks through a custom MCP pipeline, then uses Amazon Nova to synthesize structured courses grounded in actual published material. Every lesson includes quizzes, exercises, source citations, and curated video resources.

Our tagline: Just Ask.

• Full course from a single topic — modules, lessons, quizzes, exercises, and video resources generated end-to-end
• Grounded in real textbooks — a custom MCP server discovers and parses books from OpenLibrary, Gutendex, and Standard Ebooks so content is sourced, not hallucinated
• Real-time generation — watch your course build live via Server-Sent Events with per-lesson progress updates
• Crash-resilient pipeline — two-pass parallel lesson generation with automatic recovery from interrupted jobs
• Voice read-aloud — synchronized text highlighting as lessons are narrated via AWS Polly
• AI lesson assistant — ask follow-up questions in context while studying any lesson
• AI-graded quizzes — open-ended answers evaluated by Nova, not just multiple choice
• Course certificates — earn and download certificates on completion
• Community learning — explore, enroll in, and learn from courses published by others

• How It Works
• Tech Stack
• Architecture
• Course Generation Pipeline
• Further-MCP
• Project Structure
• API Surface
• Local Setup
• Environment Variables
• Documentation
• Developers
• License

flowchart LR
    U[User] --> FE[Next.js Frontend]
    FE --> PX[proxy.ts Middleware]
    FE -->|REST + SSE| BE[Express Backend]
    BE --> DB[(MongoDB)]
    BE --> REDIS[(Upstash Redis)]
    BE -->|AI SDK| NOVA[Amazon Bedrock: Nova]
    BE -->|HTTP| MCP[Further-MCP Server]
    MCP --> SRC[OpenLibrary + Gutendex + Standard Ebooks]
    BE --> YT[YouTube Data API]
    BE --> POLLY[AWS Polly TTS]

sequenceDiagram
    participant User
    participant FE as Frontend
    participant BE as Backend
    participant Google

    User->>FE: Click "Continue with Google"
    FE->>BE: GET /auth/google
    BE->>Google: OAuth redirect
    Google-->>BE: Callback with auth code
    BE->>BE: Create/find user, sign JWT
    BE->>FE: Redirect to /api/auth/callback?token=JWT
    FE->>FE: Set frontend-domain cookie, redirect
    FE->>FE: proxy.ts reads JWT for route protection

The generation pipeline uses a job-based architecture with 4 phases, crash recovery, and real-time SSE broadcasting:

sequenceDiagram
    participant User
    participant FE as Frontend
    participant API as Backend
    participant MCP as Further-MCP
    participant Nova as Amazon Nova
    participant DB as MongoDB

    User->>FE: Confirm subject → Click Generate
    FE->>API: POST /course/generate
    API-->>FE: { jobId }
    FE->>API: GET /course/jobs/:jobId/events (SSE)

    Note over API: Phase 1: MCP Discovery
    API->>MCP: discover_books + fetch_and_parse
    MCP-->>API: Book contexts + source refs

    Note over API: Phase 2: Outline
    API->>Nova: Generate structured outline (retry 2×)
    Nova-->>API: CourseOutline JSON
    API-->>FE: SSE: outline_done

    Note over API: Phase 3: Parallel Lesson Gen
    loop p-limit(4) parallel + sequential fallback
        API->>Nova: Generate lesson content
        Nova-->>API: Lesson markdown + quiz + citations
        API->>DB: Atomic $set on curriculum[i].lessons[j]
        API-->>FE: SSE: lesson_done
    end

    Note over API: Phase 4: Video Enrichment
    loop p-limit(6) parallel
        API->>API: YouTube search per lesson
        API->>DB: Update videoReferences
    end
    API-->>FE: SSE: complete

    API->>DB: Finalize course, create enrollment

TheTutor uses a custom MCP server built specifically for this project so Amazon Nova can discover, fetch, and parse real books before generating course content — ensuring lessons are grounded in actual published material, not hallucinated.

• Repository: https://github.com/TECHIES-V1/futher-mcp
• Live on Railway: https://futher-mcp-production.up.railway.app
• Health Check: https://futher-mcp-production.up.railway.app/health

Further-MCP combines OpenLibrary discovery with EPUB/PDF parsing and exposes both FastAPI routes and FastMCP tools. In TheTutor, this powers book discovery and content extraction during course generation.

• discover_books(query, sources?, limit?)
• fetch_and_parse_book(url, limit_pages?, limit_chapters?)
• search_books(query, keywords?, limit?)

TheTutor/
├── frontend/                         # Next.js 16 app
│   ├── src/app/                      # App Router pages
│   │   ├── (main)/                   # Authenticated app (dashboard, learn, explore, settings)
│   │   ├── auth/                     # Sign-in page
│   │   └── api/auth/                 # OAuth callback + logout handlers
│   ├── src/components/
│   │   ├── ui/                       # shadcn/ui components
│   │   ├── landing/                  # Marketing page sections
│   │   ├── dashboard/                # Sidebar, empty states
│   │   ├── onboarding/              # Course creation chat UI
│   │   ├── course/                   # Lesson viewer, AI assistant, quiz
│   │   ├── explore/                  # Course discovery components
│   │   └── providers/                # AuthProvider, ThemeProvider
│   ├── src/lib/                      # api.ts, seo.ts, backendUrl.ts
│   └── proxy.ts                      # JWT-based route protection middleware
├── backend/                          # Express API
│   ├── src/routes/                   # auth, user, chat, course, courses, dashboard, tts
│   ├── src/services/
│   │   ├── ai/                       # Nova prompts, generation, grading
│   │   ├── mcp/                      # MCP client + discovery pipeline
│   │   ├── course/                   # jobRunner, lessonGen, outline, contextBuilder
│   │   ├── sse/                      # SSE broadcaster + client management
│   │   ├── youtube/                  # YouTube video enrichment
│   │   └── cache/                    # Upstash Redis chat caching
│   ├── src/middleware/               # auth, sse, rateLimiter, validate, requestLogger
│   ├── src/models/                   # Mongoose schemas (User, Course, Enrollment, etc.)
│   ├── src/config/                   # database, passport, ai, logger, publicUrls
│   └── src/utils/                    # errors, auth helpers
├── docs/                             # Architecture, API reference, deployment guide
└── README.md

• Node.js 18+
• npm
• MongoDB (local or Atlas)
• Google OAuth app credentials
• AWS credentials with Bedrock access to Amazon Nova

cd backend && npm install
cd ../frontend && npm install

Create backend/.env and frontend/.env.local — see Environment Variables below.

# Terminal 1
cd backend && npm run dev     # http://localhost:5000

# Terminal 2
cd frontend && npm run dev    # http://localhost:3000

Detailed documentation is available in the docs/ directory:

• Architecture — System design, auth flow, theme system, deployment topology
• Course Generation — Pipeline phases, MCP integration, crash recovery
• API Reference — Complete route documentation with request/response schemas
• Deployment Guide — Environment setup, Vercel/Railway config, production checklist
• Wiki Pages — Official wiki link

This project is licensed under the MIT License. See LICENSE.