Skip to content
NeuralForge

00Build what’s next

Engineer AI systems that work in the real world.

Learn to build LLM applications, retrieval-augmented generation (RAG), AI agents, model evaluation and production deployment — through hands-on projects you design, test and document yourself.

Explore AI ProgramsSee the Learning Path

Practical projects. Clear foundations. Production-minded engineering.

Engineer with long red hair typing at a desk with two monitors showing codeCh. 02 — Retrieval
handbook_assistant.ipynbpython 3.12
index = Index.load("handbook-v3")rag = Pipeline(index, top_k=4)
res = rag.answer("Duplicate charge refund time?")
“Duplicate charges are refunded automatically within 5 business days.” [1][1] policies/refunds.md §4.1 · score 0.81

fig. 00 — a grounded answer with its source

Demo data

The curriculum covers

01What you’ll learn

From model calls to dependable AI products.

Five capabilities, taught in the order you need them. Each one ends with something you can run, test and explain.

  1. LLM Foundations

    • tokens
    • context windows
    • model APIs
    • prompting
    • structured outputs

    OutcomeCall models deliberately: predict token cost, budget the context window and get typed, validated output back.

    LLM Foundations for Developers

  2. RAG Engineering

    • ingestion
    • chunking
    • embeddings
    • retrieval
    • reranking
    • citations

    OutcomeBuild assistants that answer from your documents, cite their sources and say “not found” when they should.

    RAG & Knowledge Systems

  3. AI Agents

    • tool calling
    • orchestration
    • guardrails
    • state and memory

    OutcomeDesign multi-step workflows with allow-listed tools, bounded loops and explicit failure paths.

    AI Agents & Workflow Engineering

  4. Evaluation & Quality

    • test sets
    • groundedness checks
    • failure analysis
    • regression tests

    OutcomeMeasure quality with a golden set and catch regressions in CI before a prompt change reaches users.

    A practical evaluation checklist

  5. Production Systems

    • latency
    • cost controls
    • logging
    • security
    • monitoring
    • deployment

    OutcomeShip services you can observe and afford: traced requests, budgets, redaction and sensible timeouts.

    Deploying LLM Applications

02Flagship program

AI Engineering: From Foundations to Production

Build, evaluate, and ship a working LLM application end to end.

Level
Intermediate
Format
Online, self-paced demo course
Duration
12 weeks (sample schedule)
Modules
  1. 01LLM Foundations
  2. 02Retrieval-Augmented Generation
  3. 03Tools, Agents, and Workflows
  4. 04Evaluation and Reliability
  5. 05Deployment and Operations
  6. 06Capstone: Build and Document an AI Application
Project
Build and document a working AI application

Program length, schedule and pricing are configurable sample content. No job placement or career outcome is promised.

View Program Details
fig. — production LLM application

Request path

web client

streams tokens to the UI

api · FastAPI

auth, input limits, rate limits

orchestrator

prompt templates, routing, guardrails

model

hosted or open-weight

retriever

pgvector

tools

allow-listed

Cross-cutting

  • tracing— OpenTelemetry spans per call
  • cache— exact-match response cache
  • evals— regression suite in CI
  • budgets— token + cost limits per user
  • redaction— PII scrubbed before logging
Reference architecture used in the capstone. Cross-cutting concerns sit beside the request path, not after it.
capstone/api.pymodule 06
@app.post("/answer", response_model=Answer)async def answer(req: Question, user: User = Depends(auth)):    budget.check(user, est_tokens(req.text))    with tracer.start_as_current_span("rag.answer"):        return await pipeline.answer(req.text, timeout=20)
Capstone excerpt

03Learning paths

Choose your learning path.

Four routes through the same rigorous foundations. Pick the kind of system you want to build; each path orders the programs and projects for you.

Compare all paths

Route · 5 stages

  1. 01

    LLM Fundamentals

    Tokens and context windows · Calling a hosted model API or an open-weight model

  2. 02

    Prompting and Structured Outputs

    Prompt structure and templates · JSON Schema and Pydantic models

  3. 03

    Retrieval and Tool Use

    Chunking and embeddings · Vector search with pgvector

  4. 04

    Application Layer

    FastAPI endpoints with Pydantic models · Streaming responses to a TypeScript front end

  5. 05

    Evaluate and Ship

    Test sets and regression checks with pytest · Docker packaging and configuration

Who it’s for

Backend and full-stack developers who want to design, build, and ship LLM features inside real applications.

Suggested pace

Approx. 5–6 months part-time (suggested)

  • LLM Fundamentals
  • Prompting and Structured Outputs
  • Retrieval and Tool Use
  • Application Layer
  • Evaluate and Ship
Explore this path

04Learn by building

Your portfolio should prove what you can build.

Every program ends in a documented project. Screenshots and metrics shown here are illustrative demo material.

All projects
fig. — retrieval-augmented generation

Ingestion · offline

  1. documents/

    PDF, Markdown, HTML

  2. parse + clean

    keep headings & ids

  3. chunk

    structure-aware, overlap

  4. embed

    vector per chunk

  5. index

    vectors + metadata

shared index

Query · online

  1. question

    user input

  2. retrieve top-k

    hybrid: vector + keyword

  3. rerank

    keep the best 4

  4. generate

    answer only from sources

  5. answer + [1][2]

    citations to chunks

Ingestion runs offline when documents change; the query path runs on every question.
P.01RAGDemo project

Knowledge Assistant with RAG

Build an assistant that answers questions over a private document set, retrieves the passages it relies on and cites them in every answer. You own the full pipeline, from ingestion to source-aware responses.

  • Chunking
  • Embeddings
  • Vector search
  • Citations
  • Context budgets
  • Grounding
View project brief
fig. — bounded agent loop
  1. 1

    plan

  2. 2

    select tool

  3. 3

    validate args

  4. 4

    execute

  5. 5

    observe

  6. loop while goal not met
P.02AgentsDemo project

Tool-Using AI Agent

Build an agent that completes multi-step tasks by calling a small set of well-defined tools, with explicit workflow state, step limits and predictable failure handling.

  • Tool calling
  • Workflow state
  • Step budgets
  • Retries & fallbacks
  • Human handoff
  • Guardrails
View project brief
fig. — eval pass rate by prompt versionIllustrative
Eval pass rate by prompt version (illustrative)Groundedness rises from 62% at v1 to 89% at v6, dipping at v4. Format validity rises from 81% to 99%. The release threshold is 85%.50%60%70%80%90%100%release threshold 85%v1v2v3v4v5v6prompt versionregression
  • groundedness
  • format validity
Illustrative demo data on a fixed 120-case test set. v4 shows a groundedness regression caught before release.
P.03EvaluationDemo project

LLM Evaluation Bench

Build a repeatable evaluation harness that runs test cases against prompts and models, scores the results and tracks regressions between versions.

  • Test cases
  • Rubric grading
  • Regression tracking
  • Baselines
  • CI gates
View project brief

05The learning method

Learn it the way you’ll build it.

Every module follows the same four-stage loop, and every stage leaves behind an artifact you keep.

  1. 01

    Understand the system

    Build foundations before adding complexity. Each module starts with how the parts work and where they fail.

    Artifact: Architecture sketch

  2. 02

    Build a working version

    Implement a small, complete version with guided exercises, then extend it one decision at a time.

    Artifact: Working prototype

  3. 03

    Test the failure cases

    Measure quality, safety and reliability with test sets, adversarial inputs and regression checks.

    Artifact: Evaluation report

  4. 04

    Prepare for production

    Document trade-offs, add tracing and budgets, and deploy thoughtfully with a rollback plan.

    Artifact: Deployment checklist

06Meet the mentors

Reviewed by engineers who read the README first.

The profiles below are fictional sample content for this template. Replace them with your own instructors, bios and photos.

Portrait of Alex Morgan, sample mentor, standing by tall windows in an open-plan officeSample profile

LLM Application Engineering

Alex Morgan

Alex focuses on the unglamorous parts of LLM products: input validation, structured outputs and graceful failure. Their sessions are about turning a promising prototype into code a team can maintain.

How they review work

Alex reviews projects by reading the README first, then running the code. Feedback focuses on failure paths, schema design and whether another engineer could pick the project up tomorrow.
  • Prompt design and versioning for developers
  • Structured outputs with JSON Schema and Pydantic
  • Tokens, context windows and request budgeting
Portrait of Priya Raman, sample mentor, smiling in soft indoor light

RAG & Knowledge Systems

Priya Raman

Priya teaches retrieval-augmented generation from the data up: parsing, chunking, retrieval and the evaluation that tells you whether any of it is working.

Sample profile
Portrait of Jordan Lee, sample mentor, in front of an office glass wall

Evaluation & AI Reliability

Jordan Lee

Jordan teaches how to know whether an LLM feature is good enough to ship — and how to notice when it stops being good enough.

Sample profile
Meet the Mentors

07Technical field notes

Notes from the engineering bench.

Self-contained articles on the decisions that shape AI systems — written to be read with an editor open.

Explore All Resources
fig. — choosing an approach
Fit of prompting, RAG and fine-tuning for common requirements
RequirementPromptRAGFine-tune
Knowledge changes oftenweak fitstrong fitweak fit
Answers must cite sourcesweak fitstrong fitweak fit
Consistent style or formatpartial fitpartial fitstrong fit
Narrow, repetitive taskpartial fitweak fitstrong fit
Low setup effortstrong fitpartial fitweak fit

● strong fit · ◐ partial · ○ weak

RAGGuide9 min read

RAG vs. Fine-Tuning: Choosing the Right Approach

Retrieval and fine-tuning solve different problems. This guide breaks down what each one actually changes, where each tends to fail, and how to decide with evidence instead of instinct.

By Priya Raman · sample author

fig. — eval pass rate by prompt versionIllustrative
Eval pass rate by prompt version (illustrative)Groundedness rises from 62% at v1 to 89% at v6, dipping at v4. Format validity rises from 81% to 99%. The release threshold is 85%.50%60%70%80%90%100%release threshold 85%v1v2v3v4v5v6prompt versionregression
  • groundedness
  • format validity

EvaluationChecklist8 min read

A Practical Checklist for Evaluating LLM Outputs

A repeatable way to decide whether your LLM feature is getting better or worse: define quality, build a representative eval set, layer cheap and expensive checks, and read results honestly.

By Jordan Lee · sample author

fig. — bounded agent loop
  1. 1

    plan

  2. 2

    select tool

  3. 3

    validate args

  4. 4

    execute

  5. 5

    observe

  6. loop while goal not met

AgentsGuide10 min read

Designing AI Agents with Guardrails and Clear Failure Paths

An agent is a loop that lets a model choose actions. This guide covers how to bound that loop, constrain tools, validate arguments, and design an explicit path for when things go wrong.

By Maya Chen · sample author

08Questions

Straight answers before you start.

Policies shown are editable demo content. Something else on your mind?

Contact the academy

No. The programs are designed for software engineers who are comfortable writing and debugging code, not for machine-learning researchers. You will learn the concepts you need — tokens, embeddings, retrieval and evaluation — as you build. Comfort with Python, HTTP APIs and Git is the recommended starting point.

Move from experimenting with AI to engineering it.

Build the foundations, projects, and habits needed to design more dependable AI applications.

Explore ProgramsBrowse Learning Paths