AI Training Academies • AI Application Engineer

Build Production LLM-Powered Applications

A 20-day intensive program for teams building LLM-powered products. Covers frontier models, production RAG, agentic orchestration with MCP, and a deployed capstone with observability, cost engineering, and an eval harness.

20
Training Days
4
Weeks
4–8
Weeks Flexible

Schedule options: Full-time (4 weeks, Mon–Fri) · Half-days (~8 weeks) · Custom cadence for global teams

Request Training Quote View Curriculum
ClaudeClaude API
TypeScriptTypeScript
PythonPython
PostgreSQL / pgvectorpgvector
Cloud Deployment
AWSAWS
AzureAzure
Google CloudGCP

Ship LLM Features Your Team Can Own, Operate, and Improve

Most LLM tutorials stop at "it works in a notebook." This academy trains engineers to build LLM-powered features that perform reliably in production: well-evaluated, observable, cost-controlled, and maintainable by a real team. TypeScript and Python tracks available.

  • Production Focus
    Every module targets production quality, not demos
  • TypeScript or Python Track
    Choose the language that matches your team
  • Hands-On Labs
    Real code throughout; deployed capstone in week 4
  • Flexible Scheduling
    Full days, half-days, or custom cadence
  • Online or On-Site
    Delivered wherever your team works
  • Session Recordings
    Review material at your own pace (online delivery)
Week 1: LLM Foundations

Frontier models, prompting and context engineering, structured outputs, tool use

Week 2: Production RAG

Chunking, hybrid search, reranking, evaluation harnesses

Week 3: Agentic Architecture

Multi-agent orchestration, MCP servers, internal tool integration

Week 4: Capstone + Operations

End-to-end capstone deployed to cloud with observability, cost engineering, and eval harness

Academy Curriculum

Four weeks from LLM API basics to a deployed, evaluated, observable LLM application.

Week1

LLM Application Foundations

5 full-days or 10 half-days · 35 training hours

Build the engineering foundations for LLM-powered features: model APIs, prompting, context management, structured outputs, and tool/function calling in production-quality TypeScript or Python.

Topics

  • Frontier model APIs: Anthropic, OpenAI, Gemini
  • Prompting and context engineering for apps
  • Streaming responses and error handling
  • Structured outputs with Zod / Pydantic
  • Tool/function calling in applications
  • Conversation state and context window management
  • Cost tracking and retry patterns
  • Spec-driven development with GitHub Spec Kit for LLM feature work

Lab Project

Build a streaming LLM API service with tool calling, structured output validation, and per-request cost tracking.

Week2

Production RAG Systems

5 full-days or 10 half-days · 35 training hours

Go beyond naive chunk-embed-retrieve to build RAG systems that perform reliably on real enterprise data: advanced chunking, hybrid search, reranking, multi-turn retrieval, and evaluation harnesses.

Topics

  • Advanced chunking: semantic, hierarchical, late
  • Vector stores and indexing (pgvector, Qdrant)
  • Hybrid search: BM25 + dense retrieval
  • Cross-encoder reranking
  • Query transformation (HyDE, step-back)
  • Multi-turn RAG with conversation history
  • RAGAS-style evaluation metrics

Lab Project

Build a fully-evaluated RAG pipeline on a realistic document corpus with a golden dataset and RAGAS metrics CI check.

Week3

Agentic Architecture and MCP

5 full-days or 10 half-days · 35 training hours

Design and build agentic application architectures: planner/worker patterns, multi-agent orchestration, MCP server development, and internal tool integration.

Topics

  • Multi-agent architectural patterns
  • Agent hand-off and shared state design
  • Building MCP servers (TypeScript and Python)
  • Connecting internal APIs as MCP tools
  • Failure detection and recovery
  • Safety boundaries and approval gates
  • Agentic pipeline observability

Lab Project

Build a planner/worker agentic pipeline with a custom MCP server grounding it in an internal data source.

Week4

Capstone: Deployed LLM Application

5 full-days or 10 half-days · 35 training hours

Ship a complete LLM-powered application to cloud—with distributed tracing, token cost attribution, prompt versioning, eval harness in CI, and a cost dashboard. All the production infrastructure a real LLM app needs.

Topics

  • LLM observability: tracing, Langfuse/Braintrust
  • Token cost attribution and budgets
  • Prompt versioning and A/B testing
  • Eval harness integration in CI
  • Cost and quality dashboards
  • Deployment to AWS / Azure / GCP
  • Securing LLM application services

Capstone Project

Deploy a complete LLM application (customer-specified domain) with RAG, agentic features, observability, eval CI, and a cost dashboard. Presented to stakeholders on the final day.

Request a Training Quote

We'll respond within 1 business day