LangChain Course
LangChain is the toolkit most LLM applications are built on: model abstractions, prompt templates, output parsers, document loaders, retrievers and tools. This course covers the components properly, when the library helps and when it is one abstraction too many, and how to keep a large chain readable and testable.
LangChain is the toolkit most LLM applications are built on: model abstractions, prompt templates, output parsers, document loaders, retrievers and tools. This course covers the components properly, when the library helps and when it is one abstraction too many, and how to keep a large chain readable and testable.
- Components over one long chain
- Runnable interface and composition
- Retriever and tool abstractions
- Swapping providers in one line
- Modules
- 8
- Format
- Online
- Mentorship
- Weekly 1:1
- Project
- Production
Why this track
What you get that a general AI course does not cover.
The abstractions you would write anyway
Prompt templates, parsers and provider clients are code you would otherwise write and test by hand. We use the library's versions and then show you what they do underneath, so the abstraction is never a black box.
Composition over a linear chain
Runnable is the primitive the whole library is built on. Once you can compose runnables, you can build branching, parallel and fallback logic that a naive chain cannot express.
Provider portability without a rewrite
Swapping OpenAI for a local open-weight model should be a config change. We build the abstraction boundary deliberately so it stays that way as the app grows.
Know when not to use it
For a single prompt with a single model call, LangChain is overhead. We cover the line where a plain function is better, because reaching for the library too early is its own kind of debt.
Curriculum
Eight modules, each ending in something you can show.
- M01
The Runnable interface
Everything in the library implements the same interface. Once you understand it, the rest of the API stops feeling arbitrary.
- Runnable
- Composition operators
- Batch and stream
- invoke vs stream
Tools
- LangChain
- M02
Models, messages and chat history
The message model, chat vs completion APIs, multi-turn history, and normalised tool-calling across providers.
- Message types
- Chat history
- Tool calling
- Provider normalisation
Tools
- LangChain
- OpenAI
- Anthropic
- M03
Prompt templates and output parsing
Templating, partials and variables, then parsing into typed objects so downstream code gets data rather than strings.
- PromptTemplate
- ChatPromptTemplate
- Partial variables
- Structured parsers
Tools
- LangChain
- Pydantic
- M04
Retrieval and the RAG chain
Loaders, splitters, embeddings, vector stores and retrievers, assembled into a chain you can evaluate end to end.
- Document loaders
- Text splitters
- Vector stores
- Retrievers
Tools
- LangChain
- Chroma
- pgvector
- M05
Tools and agents
Defining tools, handling schemas and errors, and the built-in agent patterns, plus when to graduate to a state graph.
- Tool definition
- Toolkit
- Agent types
- When to use LangGraph
Tools
- LangChain
- M06
Memory and conversation state
Buffer, summary and window memory, the trim and summarise helpers, and the pitfalls of naive conversation history.
- Buffer memory
- Summary memory
- Trimming
- Persisting history
Tools
- LangChain
- M07
Evaluation and tracing
Building a test set for a chain, scoring outputs against references, and tracing every step to find where quality is lost.
- Evaluators
- Test sets
- Tracing
- Regression testing
Tools
- LangSmith
- promptfoo
- M08
Structuring a real application
Moving a working chain into a service: configuration, caching, rate limits, cost tracking and a structure that survives more than one feature.
- Project structure
- Caching
- Rate limiting
- Cost tracking
Tools
- LangChain
- FastAPI
Roles this maps to
Where this track lines up with real job descriptions.
LLM Application Engineer
Assemble retrieval, tools and parsing into a maintainable LLM feature rather than a chain nobody can debug.
AI Developer
Ship integrations and automations on top of foundation models with typed interfaces and real error handling.
Prompt Engineer
Turn vague prompt requests into templated, versioned, testable components with measurable behaviour.
AI Platform Engineer
Give teams a shared component library and consistent evaluation, instead of every team inventing its own chain.
What you can do afterwards
Concrete capabilities, not a certificate.
- Compose branching, parallel and fallback pipelines from the Runnable primitive
- Build retrieval pipelines with loaders, splitters, vector stores and rerankers
- Define tools with schemas and handle malformed arguments without crashing
- Write evaluation sets and score a chain across changes before shipping
- Structure a LangChain app that stays readable as features accumulate
Questions
Should I learn LangChain or LangGraph first?
LangChain first. It is the lower level and the vocabulary carries over. If you already know it, go straight to LangGraph.
LangChain has changed a lot. Will this be out of date?
The Runnable interface and the message model have been the stable core across recent versions. We teach those and explain the reasoning, so the specifics are easy to re-check against current docs.
Do I need a paid API key?
A free tier is enough for the exercises. We also work with open-weight models through a local runtime so you can practise without a paid key at all.
Is LangChain overkill for my use case?
Sometimes, and that is covered explicitly. If you have one prompt and one model call, a plain function is better. The course shows you how to tell.
Related tracks
Ready when you are
Applications for the next cohort are open. You pick your track during the first month, so you can change if the material does not suit you.