SabiLearn
LIVE COHORT · STARTS 1 NOVEMBER · LIMITED SEATS

Build a complete AI agent. Ship it with a UI.

Eight evenings. Python-first. You leave with a deployed LangGraph agent, a streaming FastAPI backend, a Next.js chat UI — and a public URL to prove it.

The full syllabus — all 8 days

Balance: agent core 4 days · backend 1 · frontend 1 · production 1 · ship 1. Everything below is what we actually build, session by session — expand any day for the full topic list.

Day 1Python, LLM APIs & the Agent Loop (LangChain)
  • Project setup: uv, pyproject, venv, .env + API keys
  • LLM API anatomy: chat completions, messages, roles, tokens, context windows, temperature
  • Tool calling from the model's side: JSON schema, tool definitions, tool-call responses
  • The agent loop hand-rolled — while loop, execute tool, feed result back (no framework)
  • Structured outputs: Pydantic schemas as the contract
  • LangChain init_chat_model + @tool decorator — docstrings are the model's UI
  • create_agent — the framework rebuild of our hand-rolled loop
  • System prompts & agent persona design; multi-turn history management
Day 2LangGraph: Graphs, State & Memory
  • StateGraph: state schema (TypedDict → Pydantic), nodes, edges
  • START / END, conditional edges, router functions
  • Reducers: add_messages, custom reducers, the parallel-writers gotcha
  • Checkpointers: InMemory → SQLite → Postgres; thread_id
  • Time travel: get_state, history walk, replay, fork
  • Context management: trim_messages, summarization
  • Long-term memory: the Store (cross-thread, semantic search)
  • Debugging graphs: mermaid diagrams, stream_mode="debug"
Day 3RAG & Tool Engineering
  • Embeddings & vector stores — the 10-minute intuition
  • Chunking strategies (fixed, recursive, semantic); the indexing pipeline
  • Retrieval as a tool: agentic RAG vs fixed RAG pipelines
  • Grounding & citations: source-passing, inline attribution
  • Grading & filtering retrieved docs; top-k, re-ranking, latency trade-offs
  • Tool design: small, composable, error-returning; typed Pydantic tools
  • Testing tools in isolation before the agent ever sees them
  • Adding a second knowledge source — routing between corpora
Day 4Deep Agents: Control, Delegation & Middleware
  • interrupt() and Command(resume=...) — pausing and resuming mid-flight
  • Approval gates: wrapping dangerous tools (email, payments, deletes)
  • Threshold approvals: auto-allow cheap, interrupt expensive
  • Subagents & the task tool; orchestrator/worker pattern
  • Planning: todo-list middleware; filesystem & state middleware
  • create_deep_agent — the one-line stack, and what it assembles
  • Custom middleware: wrap_model_call, wrap_tool_call
  • Guardrails basics: input/output checks, injection defense
Day 5FastAPI: The Agent Backend
  • API design for agents: /chat, /resume, /threads, /health
  • Async fundamentals: event loop, dependency injection, Pydantic contracts
  • Streaming architectures: SSE vs WebSocket — why SSE wins for chat
  • astream_events → SSE: text_delta, tool_start, tool_end, approval_gate, agent_end
  • Correct SSE headers & buffering (no-cache, X-Accel-Buffering)
  • Sessions: thread_id lifecycle, conversation resume
  • Interrupt handling over HTTP: pause → approve → /resume
  • Failure handling mid-stream; testing streaming endpoints
Day 6Next.js: The Agent Frontend
  • App Router essentials: routes, layouts, server vs client components
  • Consuming SSE in the browser: fetch reader streams vs EventSource
  • Token-by-token rendering in React
  • Chat UI anatomy: message list, composer, scroll behavior
  • Tool-call cards: making agent actions visible
  • Approval UI: buttons wired to /resume
  • Zustand store for threads/messages; markdown + code blocks
  • UX states: loading, streaming, error, reconnect-after-drop; Vercel deploy
Day 7Production: Evals, Observability & Deployment
  • Tracing: LangSmith setup, reading a trace, finding the bad hop
  • Evals: dataset from real transcripts; exact, heuristic, LLM-as-judge graders
  • Running evals in CI — quality gates before deploy
  • Cost: token accounting per thread, caching, cheaper-model routing
  • Latency: time-to-first-token, parallel tool calls
  • Security: prompt injection via retrieved docs, tool permissioning, sandboxing
  • Docker multi-stage build; Fly/Render + Vercel deploys, secrets
  • Monitoring in production: alerts on cost & error rate
Day 8Ship: Demo Day & Portfolio
  • Portfolio packaging: README with architecture diagram + eval numbers
  • Telling the failure story — what judges and interviewers actually want
  • Recording the 2-minute demo video
  • Student demos: live URL → architecture → failure story → evals
  • Hardening checklist: what you'd build next with 4 more weeks
  • Where next: multi-agent, guardrails depth, LLMOps — the growth map

What you leave with

A LangGraph agent

Tools, RAG, approval gates, checkpointed memory — the real architecture, not a demo toy.

A FastAPI stream

SSE endpoint with the full event taxonomy: tokens, tool calls, gates, end.

A Next.js UI

Token-by-token chat with tool-call cards and approve/reject buttons.

A public URL

Deployed and shareable on Day 8 — portfolio-ready with evals and a demo video.

Who it's for

You'll keep up if you have:

  • Basic Python — functions, classes, pip/uv, reading errors
  • Comfort with the terminal and editing config files
  • 8 evenings (120 min) between 1–8 November

Not required:

  • TypeScript or JavaScript — Day 6 is guided copy-and-adapt, Python stays your home
  • Prior ML or maths beyond high-school level
  • Absolute beginners: take the free pre-course first — message the WhatsApp group and we'll point you to it
LIVE 1 NOV · 20 SEATSWhatsApp