AI Engineer
From consumer to builder
Build AI-powered applications from scratch. Master embeddings, RAG pipelines, tool calling, and agentic architectures.
What You’ll Learn
Section titled “What You’ll Learn”- Understand tokenization and attention at implementation level
- Implement semantic search using embeddings
- Build RAG pipelines from scratch
- Create custom tools and MCP servers
- Design agentic systems with proper guardrails
- Build evaluation frameworks using LLM-as-Judge
Learning Path
Section titled “Learning Path”Level 4: AI Primitives
How the engine works under the hood: tokens, attention, embeddings, and type-safe schemas
Level 5: Retrieval Systems
Connect LLMs to your data with RAG pipelines and semantic search
Level 6: Agentic Systems
Build loops, tools, and autonomous systems with proper safety and evaluation
Tools & MCP
Extend LLM capabilities beyond text generation. Learn how tool calling works, build your own tools, and implement the Model Context Protocol.
45 minAgentic Architecture
Design autonomous AI systems with loops, guardrails, and evaluation. Build agents that plan, execute, and learn.
75 minConcepts Covered
Section titled “Concepts Covered”Fundamentals
LLMs process text as tokens — chunks of characters that form the atomic units of input and output, directly affecting pricing and context limits.
10 minThe context window is the maximum amount of text (in tokens) an LLM can 'see' at once, including prompts, history, injected documents, and responses.
12 minThe core mechanism that allows language models to understand how words relate to each other by dynamically focusing on relevant parts of the input.
15 minEmbeddings convert text into numerical vectors that capture semantic meaning, enabling similarity search, clustering, and the foundation for RAG systems.
15 minConstrain AI responses to follow a specific format using JSON Schema, enabling reliable data extraction and type-safe integrations.
15 minRAG combines document retrieval with LLM generation, allowing AI to answer questions grounded in your specific data without fine-tuning.
20 minType Systems
JSON Schema defines the exact structure and constraints for LLM outputs, ensuring type-safe, validated responses without post-processing guesswork.
15 minZod brings runtime validation to TypeScript AI applications, ensuring LLM outputs match your types at runtime while maintaining compile-time type safety.
20 minPydantic brings runtime validation and type safety to Python AI applications, automatically converting JSON Schema to validated Python objects with IDE autocomplete.
20 minPatterns
Building high-quality evaluation datasets that anchor AI system quality - because an eval is only as good as its test cases.
12 minIterative refinement pattern where AI generates output, evaluates it against criteria, and improves through multiple cycles until quality thresholds are met.
12 minSafety constraints and validation mechanisms that prevent AI systems from producing harmful, incorrect, or policy-violating outputs.
10 minObservability practices for AI systems that track model performance, costs, latency, and output quality in production.
12 minStrategies to reduce AI infrastructure costs by 50-90% through prompt caching, batch APIs, model tiering, and context pruning.
10 minProtocols
Tool use enables LLMs to interact with external systems by generating structured function calls that applications execute and return results for.
15 minMCP is an open protocol by Anthropic that standardizes how AI applications connect to data sources and tools through a unified server architecture.
12 minHands-On Exercises
Section titled “Hands-On Exercises”Design and implement a Zod schema for structured AI outputs. Learn to constrain LLM responses for reliable data extraction.
Learn to extract structured data from unstructured text using JSON Schema constraints, ensuring type-safe outputs from LLMs.
Build a Retrieval-Augmented Generation system from scratch. Index documents, embed queries, retrieve relevant chunks, and generate sourced answers.
Learn to mine git commit history for evaluation test cases, creating a robust dataset that captures real-world code patterns and edge cases.
Evaluate three different AI architectures for a real-world scenario to understand when to use each approach.
Learn to identify, diagnose, and fix AI hallucinations in a production-like scenario using grounding techniques.
Implement a tool from scratch without using a framework, to deeply understand how tool calling works under the hood.
Create a Model Context Protocol server that exposes safe, read-only tools to AI assistants. Learn MCP architecture and identify security vulnerabilities.
Implement an agent that can plan, execute, and iterate on multi-step tasks with tool use and state management.
Learn to evaluate AI outputs using model-graded evaluation (LLM-as-Judge), the pattern where a stronger model grades outputs from weaker models.
Learn to build a security layer that detects and blocks prompt injection attacks before they reach your main LLM application.
Decision Guides
Section titled “Decision Guides”When should I use a simple chatbot vs RAG vs an autonomous agent?
20 minShould I fine-tune a model or use RAG for domain-specific knowledge?
20 minShould I use LangChain (or similar frameworks) or build custom?
15 minRelated Resources
Section titled “Related Resources”- AI Assisted Developer Track - Master using AI tools first
- RAG vs Fine-tuning - When to use retrieval vs training
- LangChain vs Custom - Framework vs building from scratch