About AI Agents
An AI agent is a system built around a large language model that can reason about a
goal, decide which tools to use, and act on the world instead of
just answering a single prompt. This course starts with two foundation modules:
Foundations: Backend & APIs covers the backend development,
Git and terminal usage, and REST API knowledge
you need to build and connect real systems, while LLM Foundations
covers how transformer models actually work and the major
model families and licenses you'll be choosing between.
AI Agents 101 then covers what an agent actually is, what a tool
is, and the agent loop that ties reasoning and action together —
illustrated with real example use cases. Prompt Engineering covers
the techniques, like chain of thought and clear tool definitions, that make an
agent's reasoning reliable instead of a coin flip.
The Model Context Protocol standardizes how an agent connects to
tools and data sources, and you'll build your own MCP servers rather than just using
someone else's. Agent Memory covers how agents remember things
across a conversation and over time, including the difference between
episodic and semantic memory.
Agent Architectures covers the structural patterns behind different
kinds of agents before Building Agents puts it all into practice —
first by hand, then with native function calling, then with frameworks like
LangChain — so you understand what a framework is actually doing for you before you
rely on one. Finally, Security & Ethics covers the failure
modes unique to agents: prompt injection, unsafe tool access, data privacy, bias,
and the red-teaming practices that catch problems before your agent meets real
users.
Content
9 modules
01
Foundations: Backend & APIs
Basic backend development concepts, Git and terminal usage, and REST API knowledge — the practical skills you need before building anything that talks to an LLM.
Backend Dev
Git
REST APIs
02
LLM Foundations
How transformer models actually work under the hood, and a practical tour of the major model families and their licenses.
Transformers
LLMs
Model Licenses
03
AI Agents 101
What an AI agent and a tool actually are, the core agent loop, and how agents differ from plain LLM calls and fixed workflows — with real example use cases.
Agent Loop
Tools
Use Cases
04
Prompt Engineering
Chain of thought reasoning, few-shot and zero-shot prompting, system prompt design, tool definitions, and structured outputs that agents can act on reliably.
Chain of Thought
Tool Definitions
JSON Mode
05
Model Context Protocol
What MCP is and its core components, then building, connecting, and debugging your own MCP servers instead of just consuming someone else's.
MCP
MCP Servers
stdio / SSE
06
Agent Memory
Why agents need memory, episodic vs semantic memory, vector stores and embeddings for retrieval, and managing context window limits.
Episodic Memory
Vector Stores
Embeddings
07
Agent Architectures
The structural patterns behind different kinds of agents — single-agent vs multi-agent systems, reactive vs planning-driven designs, and how to choose between them.
Multi-Agent
Planning
Design Patterns
08
Building Agents
Building an agent manually from scratch, native function calling, and building with frameworks like LangChain or LlamaIndex.
Function Calling
LangChain
ReAct
09
Security & Ethics
Prompt injection and jailbreaks, tool sandboxing and permissioning, PII redaction, bias and toxicity guardrails, and red team testing before shipping.
Prompt Injection
Sandboxing
Red Teaming
What You Can Do After This Course
By the end of the curriculum you'll have shipped several real agent projects and
covered the full path from LLM fundamentals to a secured, production-ready agent.
Concretely, you'll be able to:
Work confidently with LLMs and APIs — call LLM APIs from your own backend, and reason about transformer models, model families, and licensing.
Design a reliable agent loop — define tools clearly, structure prompts with chain of thought, and get consistent, structured outputs back from a model.
Build and consume MCP servers — expose your own tools and data sources through the Model Context Protocol instead of hand-rolling every integration.
Give agents useful memory — implement episodic and semantic memory with vector stores, and manage what fits in a limited context window.
Build agents multiple ways — from scratch, with native function calling, or with a framework like LangChain — and know what each approach trades off.
Secure agents before they meet real users — defend against prompt injection, sandbox tool access, redact PII, and red-team your own agent.