Every course, in one place.

Build AI agents from scratch — single-agent patterns, multi-agent pipelines, memory, observability with Langfuse, and a complete hands-on project. Covers LangGraph, CrewAI, AutoGen, and Agno with real code examples.

Learn Model Context Protocol from scratch — how it works, how to build servers in Python, and how to give AI assistants safe access to your files, databases, and APIs. Ends with a complete hands-on project.

Start from 'what is RAG and why' and go all the way to a retrieval system you can trust in production — ingestion, chunking, retrieval quality, grounding, evaluation, and the hard edge cases (stale data, access control, prompt injection, cost). With interactive playgrounds to make it click.

Move beyond keyword matching — dense vector search, embedding models, hybrid retrieval, and RAG pipelines that actually ground LLM responses in real knowledge.

The difference between a demo and a product that survives real users: monitoring, cost control, security, guardrails, and rollback. The operational layer that keeps AI systems safe, affordable, and trustworthy in production.

Start here, even if you've never built software. What an API actually is, how two programs talk through one, and the simple parts every API is made of — explained with everyday analogies and real examples.

There isn't one kind of API — there are several styles, each good at a different job. A plain-English tour of REST, GraphQL, gRPC, SOAP, and WebSockets: what each is, when to use it, and the standard behind it.

The single idea — letting a model decide what to pay attention to — that fixed the memory problem in older networks and became the architecture behind every modern AI. Explained from scratch, in plain words.

Your API has to live somewhere. A beginner's map of cloud computing — renting vs. owning, the IaaS/PaaS/SaaS layers, serverless, and how AWS, Azure, and GCP fit — so you can choose where to build without drowning in jargon.

How computers turn a grid of pixels into understanding — detecting features, recognising objects, and tracking motion. The ideas behind face unlock, medical imaging, and self-driving, explained simply with real use cases.

The craft that decides whether an AI system is reliable or flaky: giving the model exactly the right information, in the right shape, at the right moment. Far more than writing clever prompts.

What neural networks really are, why stacking layers lets them learn features on their own, and how CNNs and RNNs see images and read sequences — explained with everyday analogies and real use cases.

The single idea underneath every modern AI — turning words into numbers you can measure and do maths on. From an eight-year-old's picture to the billions of numbers inside ChatGPT and Claude, with a spinnable 3D model and the real facts on scale, compute, and cost.

Two ways to give an AI your knowledge — organise it as a folder (Google's Open Knowledge Format) or embed it as vectors (RAG). What a folder and a vector really are, how they compare, and how to combine them into one architecture. Built from scratch, for beginner to advanced.

The model is one small part; the system around it does the real work. Tools, memory, permissions, runtime safety, evaluations, and observability — the 'harness' that turns a clever model into a dependable product.

How to give machines structured, connected knowledge they can reason over — facts as a web of relationships rather than loose text. The idea behind Google's panels, recommendations, and grounding LLMs in real facts.

How machines store what they *know* — facts, rules, and meaning encoded so a computer can reason over them, not just pattern-match. The symbolic half of AI, from Aristotle's syllogisms to ontologies and today's neuro-symbolic systems.

What an LLM really is, how 'predict the next word' produces something that feels like reasoning, how these models are trained and made helpful, and where they quietly fail — in plain language.

An agent isn't one answer — it's a cycle: plan, act, observe, check, repeat. Designing that loop so it converges on a result instead of spinning forever is where AI agents become genuinely dependable.

How machines learn patterns from data instead of following hand-written rules — the three families of learning, why models overfit, and how to tell a good model from a lucky one. Plain language, real examples.

The mathematical foundation every AI practitioner needs — vectors, matrices, probability, and the calculus behind learning — explained with intuition and everyday examples, not just equations.

When a problem has more possible answers than atoms in the universe, you can't check them all. Nature-inspired search — evolution, ant trails, swarms — finds excellent answers fast. The elegant maths behind scheduling, routing, and tuning.

How the pieces connect into a real system you could build — the journey of a request, monolith vs. microservices, and the API gateway every serious API needs. The capstone that turns the whole track into one clear picture.

How computers came to understand human language — from counting words, to capturing meaning with embeddings, to the modern era of LLMs. The story and the still-useful fundamentals, in plain language.

How to connect a language model to real knowledge and real actions — so it answers from your documents instead of guessing, and can search, calculate, and call APIs. The leap from 'chatbot' to 'useful system'.

Reason + Act: the Thought → Action → Observation loop behind every modern AI agent. From the 2022 research to production practice — with an interactive trace you can step through, move by move.

The difference between an API people love and one they curse: naming, versioning, errors, security, and documentation. Practical principles — with the standards to follow — that keep an API clean and usable for years.