Heidelberg AICurriculum

Heidelberg AI Curriculum · 2026

Learn AI by doing for creators

Start here 1.1 · Why? Who? What? 112 chapters · no account needed
Latest updates Yesterday · 13 Aug Read more →
Show

Start here

why this course exists & how to use it open the track →
What this beginner track covers
  • This track explains why the course exists and how you should move through it.
  • It is for anyone who is new to the material and wants a clear picture of the tracks, difficulty tiers, and chapter structure before diving in.
  • After completing this short introduction you will be able to state the purpose of the overall course, identify who the intended learners are, and describe how each chapter is built and where specific topics are located.
  • You will also know how to choose a track that matches your current skill level and how to navigate between tracks without getting lost.
  • Start with the opening chapter “Why?
  • Who?
  • What?” before you begin Lesson 1.
  • Read it in full, then follow the recommended order of the subsequent tracks as they are presented on the site.
  • If you are pressed for time, you can skim the detailed explanations of difficulty tiers after you have a basic grasp of the course layout, but do not skip the “Why?
  • Who?
  • What?” chapter because it contains the essential context needed to use the rest of the material effectively.

Chat with AI

open a chatbot & use it open the track →
What this beginner track covers
  • This track teaches you how to start a conversation with an AI model and turn that dialogue into useful results.
  • It is for anyone who has never used a chatbot before or wants a clear, step‑by‑step way to become comfortable with the most common front‑line assistants.
  • After completing the chapters you will be able to open a chatbot, choose the one that fits your current need, and interact with it to ask questions, analyse documents you upload, and retrieve information that includes real citations.
  • You will know how to use Gemini inside Docs, Sheets, or Gmail, run source‑backed searches with Perplexity, leverage ChatGPT’s broad feature set for data analysis, and employ Claude for writing, coding, and general chat tasks.
  • Begin with Chapter 1 to understand the four main front‑line bots.
  • Then follow the order of Chapters 2 through 5, each focusing on a specific platform and its unique integration points.
  • If you are short on time, you can skip the detailed Gemini chapter after getting the overview in Chapter 1, but be sure to still review the sections on Perplexity, ChatGPT, and Claude so you experience the full range of capabilities.

Better prompting

get better, more reliable answers open the track →
What this beginner track covers
  • The craft of getting great, reliable answers from any model.
  • You will shape what you type (prompting) and what the model can see (context), then make it dependable the test-first way — writing a few input → expected examples and letting them drive every prompt edit, so you catch it when a change quietly breaks something.
  • This is the skill that quietly multiplies everything else you do with AI.

Build apps

describe it, get an app open the track →
What this intermediate track covers
  • This track shows you how to describe an app in plain English and receive a working version without writing code.
  • It is for beginners who want to see immediate results and later take control of the code they generate.
  • After completing the track you will be able to use AI app builders to turn descriptions into full‑stack applications, chat with Lovable to create React apps that you can export to GitHub, prompt v0 for polished UI that also handles testing and deployment, describe an idea to Base44 and get a complete backend with database, authentication and hosting, and finally export the generated code so you can modify and own the app yourself.
  • Start with Chapter 1 to experience vibe‑coding, then move through Chapters 2, 3, and 4 in order to compare different no‑code builders.
  • Finish with Chapter 5 when you are ready to take the code out of the platform.
  • If you are short on time, you can skip directly from Chapter 3 to Chapter 5 after you have a working UI, but be aware that you will miss the backend setup shown in Base44.

Create Media

voice, avatars & video open the track →
What this intermediate track covers
  • This track teaches you how to create media that people can watch and hear.
  • It is for anyone who wants to turn text, images, or audio into voiceovers, avatars, pictures, or video without relying on proprietary services.
  • When you finish the chapters you will be able to give a script a face using AI avatars, generate pictures from prompts with both cutting‑edge and free local tools, create short video clips from sentences or photos, add spoken dialogue to an app and make it understand speech, and build real‑time voice agents that converse live.
  • Start with Chapter 1 on AI avatars, then move to Chapter 2 for image generation, followed by Chapter 3 on video creation.
  • After you have visual media covered, continue with Chapter 4 to add text‑to‑speech and speech‑to‑text capabilities, and finish with Chapter 5 for real‑time voice agents.
  • If you are short on time, you can skip the optional deep dive into frontier image apps in Chapter 2 and go straight to the free, local route before proceeding.
  • Follow this order to build a solid foundation before adding interactive voice features, ensuring each skill builds on the previous one.

Automation Tools

pipelines & agents that run open the track →
What this advanced track covers
  • This track teaches you how to build pipelines and agents that run without your constant attention.
  • It is for anyone who wants to connect applications, automate data flows, and create self‑operating AI assistants using no‑code tools.
  • After completing the modules you will be able to design n8n workflows, choose and configure the right automation platform, move an AI agent from a demo environment into production, construct visual canvases with branches, loops, and error handling, set up quick automations with Zapier, extend agents with custom skills and tools, and deploy open‑source LLM applications with Dify.
  • Start with Chapter 1 to get hands‑on experience in the n8n lab bench, then follow Chapters 2 and 3 to understand tool selection and production deployment.
  • Continue with Chapter 4 for visual canvas design, use Chapter 5 for fast Zapier integrations, explore Chapter 6 to add skills and extensions, and finish with Chapter 7 to build a grounded chatbot using Dify.
  • If you are short on time, you can skip Chapters 4 and 7 after mastering the core workflow and agent deployment concepts.

Agent frameworks

Build & orchestrate your own custom AI agents. open the track →
What this advanced track covers
  • This track teaches you how to build and orchestrate your own custom AI agents.
  • It is for developers who want to move beyond pre‑made bots and control the logic of each agent in code or visually.
  • After completing the chapters you will be able to create a team of agents with defined roles, assign them tasks, and connect tools using CrewAI; you will also be able to design chatbot, RAG bot, or multi‑agent flows by dragging boxes on a canvas with Flowise; finally you will know how to use Langflow’s visual canvas while keeping the underlying Python editable.
  • In short, you will have practical skills to build agents from scratch and choose the right framework for any project.
  • Start with the introductory chapter that explains what an agent framework is and compares the three options.
  • Then follow the Build agents chapter to see the overall process, move on to CrewAI for code‑first development, continue with Flowise for a drag‑and‑drop approach, and finish with Langflow to combine visual design with editable Python.
  • If you are short on time, you can skip the detailed comparison in the intro after reading the overview, but do not skip the Build agents chapter because it ties all later sections together.

Personal AI Assistants

a standing digital employee open the track →
What this intermediate track covers
  • This track shows you how to set up a personal AI assistant that works for you around the clock.
  • It is aimed at anyone who wants an always‑on digital helper without needing deep system‑admin experience.
  • When you finish, you will be able to install a ready‑made agent on your own machine, configure a self‑hosted assistant that remembers past interactions and can write its own skills, delegate complete tasks to Claude using a chat interface, and run an AI agent through WhatsApp or Telegram with OpenClaw.
  • Each chapter gives you concrete steps to achieve those outcomes.
  • Start with Chapter 1 to get the basic installation and chat experience.
  • Then move to Chapter 2 to set up Hermes for persistent, self‑hosted operation.
  • After that, choose either Chapter 3 if you prefer delegating whole tasks to Claude without using a terminal, or Chapter 4 if you want to connect an assistant to your messaging apps.
  • If time is limited, you can skip Chapter 4 and still have a functional always‑on assistant.
  • Follow the chapters in the order presented; they build on each other and assume the previous setup is in place.
  • Skipping ahead may require you to backtrack later to fill missing configuration steps.

Chat with your Data - RAG

answer from your own files open the track →
What this intermediate track covers
  • This track teaches you how to make an AI answer questions using your own files instead of only its training data.
  • It is for developers, data engineers, or anyone who wants a private chat assistant that can cite documents, papers, and databases.
  • After completing the track you will be able to: create a system that answers from your own documents with citations (Chapter 1); set up an open-source, privacy‑focused notebook environment as an alternative to commercial notebook AI (Chapter 2); deploy Onyx to provide cited answers, agent actions, and deep research over your team’s docs, apps, and people (Chapter 3); and run AnythingLLM as a private, all‑in‑one chat interface that supports agents, connectors, and local or self‑hosted keys for your document collections (Chapter 4).
  • Start with Chapter 1 to learn the basic retrieval‑augmented generation workflow, then move to Chapter 2 to explore the notebook environment.
  • Continue with Chapter 3 to see how Onyx extends the core ideas into a multi‑agent research tool, and finish with Chapter 4 for a full private chat deployment.
  • If you need only a quick proof of concept, you can skip Chapter 2 and go straight from Chapter 1 to Chapter 4, but following the full order gives the most coherent learning path.

All-in-one AI platforms

one login, every model open the track →
What this intermediate track covers
  • This track teaches you how to use an all‑in‑one AI platform that lets you access many language models with a single login.
  • It is for anyone who wants to simplify their workflow and avoid managing separate accounts for each model.
  • After completing the track you will be able to set up a shared EU‑hosted workspace for your team (Langdock), choose and switch between models through a single subscription (All-in-one AI platforms), integrate a model aggregator with its own machine‑learning tools (Abacus.AI), run multiple chatbots from one window (Poe), perform agentic searches that return full pages instead of link lists (Genspark), and rely on an advanced answer engine as your primary research tool (Perplexity Max).
  • Start with the overview of all‑in‑one platforms, then move to Langdock for team collaboration.
  • Follow with Poe and Genspark to see practical chat and search uses, and finish with Abacus.AI and Perplexity Max for deeper model integration and high‑quality answers.
  • If you are short on time, you can skip the detailed Abacus.AI chapter after you understand the aggregator concept, but keep the others to retain a complete workflow.

AI + Data Processing

clean and analyse data without code open the track →
What this advanced track covers
  • This track teaches you how to build a no‑code data pipeline for cleaning and analysing data.
  • It is for anyone who finds spreadsheets limiting but does not want to write Python code, including analysts, marketers, and small‑team developers.
  • After completing the track you will be able to create visual workflows in KNIME to clean messy exports, join inconsistent sources, classify rows, and generate repeatable reports.
  • You will also set up a headless content management system with Directus to store and serve your data, and you will design simple AI‑enabled automations in n8n that can run without manual intervention.
  • With the advanced n8n module you will extend those automations into more complex scientific tools, turning your workflow platform into a virtual lab bench.
  • Start with Chapter 1 (KNIME) to learn the visual data‑science environment, then move to Chapter 2 (Directus) to manage your content.
  • Continue with Chapter 3 (basic n8n) for first AI agents, and finish with Chapter 4 (advanced n8n) for sophisticated tools.
  • If you are short on time, you can skip Chapter 2 after understanding that Directus is optional for simple pipelines, but the rest of the sequence should be followed to keep the learning flow coherent.

Local AI & Private Cloud

run it in-house, govern it open the track →
What this advanced track covers
  • This track teaches you how to keep AI workloads inside your own infrastructure and obey data‑residency rules.
  • It is aimed at research groups, small‑to‑medium enterprises, or institutes that need to decide where their data lives and still run modern models.
  • After completing the chapters you will be able to install Docker on macOS, Linux, and Windows; evaluate and apply a governance checklist for private AI; use EU‑hosted inference endpoints that comply with GDPR; run open‑weight models locally so no data leaves your machine; set up a self‑hosted private cloud with Dokploy either on Hetzner or on‑premises; and finally deploy applications using Docker containers, images, and volumes.
  • Start with the Docker installation chapters for the operating system you use (macOS, Linux, Windows) to get comfortable with containers.
  • Then move to "Private AI for your org" and "EU‑sovereign inference" to understand governance and compliant model access.
  • Follow with "Local & Private Models" before tackling the self‑hosting sections (Docker on Linux, Self‑host on a private cloud, Self‑hosting with Dokploy).
  • End with "Deploy & Run Applications with Docker" to tie everything together.
  • If you are short on time, skip the OS‑specific Docker chapters you do not need and go straight from the governance checklist to self‑hosting with Dokploy.

Write code

code with AI in your repo open the track →
What this advanced track covers
  • This track teaches you how to bring AI into your own codebase and work with it as a teammate.
  • After completing the track you will be able to write product requirements and specs before coding, run voice-controlled agents, use terminal agents like Codex, Claude Code, Aider, opencode and jcode to read, edit and execute code, collaborate with AI assistants inside editors such as Cursor, GitHub Copilot, Antigravity and Devin Desktop, and tell which of them is the right shape for the job in front of you.
  • Start with "Product requirements & spec engineering" to set up clear specs, then move into "AI coding assistants" and work through the tools underneath it: the terminal agents first (Codex, Claude Code, Aider, opencode, jcode, and the voice-driven opencode + voice), then the editor integrations (Cursor, GitHub Copilot, Antigravity, Devin Desktop).
  • If you need to move quickly, cover at least one terminal agent and one editor assistant and skip the rest of the deep dives.
  • What this track deliberately does not cover is making any of them dependable on a large, real repository, or the repository platforms the work lives in.
  • That is its own track: "Building complex codebases".
  • Pick your tool here, make it reliable there.

Building complex codebases

make an AI agent reliable on a big, real repo open the track →
What this advanced track covers
  • This track is what comes after you have picked a coding assistant.
  • Choosing the tool is the "Write code" track; making any of them dependable on a large, real repository is this one.
  • The move is to stop treating the agent as a chat window and start treating your project as something that has to explain itself.
  • You build a second, version-controlled layer next to the code — a lean rules file, reusable commands, and later skills, subagents and MCP — so that every session starts already knowing your architecture instead of guessing it.
  • Then you run each task through the same Plan → Implement → Validate loop, and turn every mistake the agent makes into a permanent fix to the layer rather than a correction you retype.
  • Start with "Building complex codebases" for the discipline itself.
  • The GitHub and Gitea chapters underneath it are the place that layer lives: the repository is what makes it reviewable, shareable and undoable, which is the whole reason it is checked in rather than pasted.

AI memory systems

give an assistant a memory that outlives the session open the track →
What this advanced track covers
  • Every assistant you have used so far forgets.
  • The context window is not memory — it is a desk that gets cleared when you close the window, and everything you explained goes with it.
  • This track is about the layer you build so that it does not.
  • It is taught from one real, running system rather than from a diagram: Marvin, the memory the Heidelberg team runs behind its own AI sessions.
  • You will see what writes, what reads, what deletes, how text becomes vectors, why the retriever fuses keyword search with meaning instead of choosing one, and how the whole thing is held to a number that fails loudly when recall drops.
  • The track ends where most write-ups stop early: the promotion loop.
  • Capture and recall are the easy half; a memory only compounds when an expiring conversation can become a reviewed, durable lesson in seconds.
  • Build that step first, and the rest of the machinery is worth having.

AI + Hardware

put a model on real hardware open the track →
What this advanced track covers
  • This track teaches you how to move an AI model from a cloud service onto physical hardware, and it is for anyone who wants to run AI directly on robots, edge devices, or other constrained systems.
  • After completing the chapters you will be able to take an existing model and embed it in firmware, deploy it on a robot, and operate it on low‑power hardware while handling latency, power consumption, and failure modes.
  • You will learn the steps needed to integrate AI assistants into embedded code, adapt models for limited resources, and test them on real devices.
  • Start with the first chapter, "AI for robotics & edge devices," which introduces the concepts and tools you need.
  • Follow the material in the order presented, as each section builds on the previous one.
  • If you are pressed for time, you can skim the background discussion of network limitations and go straight to the practical deployment steps, but skipping those explanations may leave gaps in understanding how latency and power constraints affect your design.

GOOD TO KNOW

GOOD TO KNOW open the track →
What this advanced track covers
  • This track gives you the essential background you need to work responsibly with AI applications, and it is aimed at developers, product managers, or anyone who builds or oversees AI‑powered tools.
  • After completing the four chapters you will be able to defend your app against prompt injection and abuse, calculate token usage and control spending, keep private data out of AI prompts, and set up evaluations that objectively measure whether your model meets its goals.
  • Each skill is drawn directly from a chapter: security, cost management, privacy protection, and testing.
  • Start with the security chapter to learn basic defenses, then move on to understanding token economics and pricing.
  • Follow with privacy practices before finishing with evaluation methods so you can verify everything you built works as intended.
  • If you are short on time, you can skip the privacy chapter after reviewing its key points in the cost section, but be sure to at least skim it, because data leaks often stem from cost‑cutting shortcuts.

Reference

look it up any time open the track →
What this advanced track covers
  • This track is a reference resource you can look up any time.
  • It is for anyone who needs quick, reliable access to the complete set of tools, terms, creators, and source material used throughout the curriculum.
  • After completing this track you will be able to locate any AI tool listed in the index, identify which large language model runs on your hardware or is available as a service, find plain‑language definitions for every command and concept across all courses, see who authored each part of the curriculum and what primary documents support it, and retrieve any video from the curated library by tool or creator.
  • Start with Chapter 1 to get an overview of every AI tool side by side.
  • Then move to Chapter 2 to understand model options, followed by Chapter 3 for the glossary of terms.
  • Continue with Chapter 4 to learn about the authors and sources, and finish with Chapter 5 to explore the full video collection.
  • If you are pressed for time, you can skip directly from Chapter 1 to Chapter 5 after reviewing the index, but returning to the other chapters later will give you complete reference coverage.

Heidelberg AI Bench

run the whole course on your own machine — one download, no server, no account open the track →
What this beginner track covers
  • Every other track in this course teaches a tool.
  • This one gives you the machine to run them on — yours.
  • The Heidelberg AI Bench is one download and one double-click.
  • It puts automation, document chat, an agent, a model gateway and the model itself on the laptop you already own, already wired to each other, with one switch that decides where the AI comes from: the model on your own disk, one on a lab machine, or an EU-hosted service if you want a bigger brain for an afternoon.
  • Nothing leaves your network unless you choose that.
  • The track starts with what the bench is and how to install it, then walks the dashboard, the provider switch and the app store.
  • After that it teaches each app the easy way — open it from the bench, it already knows your model, do one real thing with it.
  • Every one of those chapters ends with a link to the harder version of itself: the same app on a server you administer.
  • Start here, move there when you need to.

Swarm & multi-agent systems

make several agents work as one system — and know when not to open the track →
What this advanced track covers
  • The Agent frameworks track answers "which framework, and how do I author an agent in it".
  • This one answers the question that comes after: what happens when there is more than one.
  • Multi-agent is sold as a way to get more done and is usually a way to get the same thing done less predictably.
  • So the track starts with the primitive that actually matters — handoff, the moment one agent transfers control and state to another — and with the honest test for whether you need a second agent at all.
  • From there: the interoperability layer, where you will learn to sort a new "agent protocol" into adopted, announced, or dead before you build on it; and fleets, where several coding agents work one repository at once and the bottleneck quietly moves from writing code to reviewing it.
  • It ends where the field currently ends.
  • Multi-agent evaluation tooling barely exists in 2026, so the last thing you learn is how to score a trajectory rather than an answer, and how to report variance across runs instead of the one run that worked.