Kursus · MitmekeelneKesktaseÕppeteekonna AI & Agent Engineering 1. etapp

Agent Engineering in Java: From LLM Foundations to Production Systems

Build agents. Understand the architecture. Engineer for production. Learn to design, build and own a production AI agent in Java, from one model call to a durable, observable, secured system you operate through real incidents.

PakkujaTarkev
  • 16 moodulit
  • 136 õppetundi
  • 24 nädalat
  • Mitmekeelne
  • Fumu igas õppetunnisKüsi Fumult mis tahes õppetunnis. Ta selgitab materjali selle õppetunni põhjal, kus sa parasjagu oled.
  • Kinnitatud tunnistus sinu profiililVarstiLisatakse sinu avalikule profiilile lõpetamise päeval ja seotakse sinu kinnitatud identiteediga.
Kursuse ülevaade

Kursusest

Most agent courses teach you to make an agent work. This one teaches you to own one in production.

You will build one system through the whole course: the Order Support Assistant, which answers order questions, cancels and refunds within policy, retrieves return rules, and asks a person before it does anything it cannot undo. It is never thrown away. Every module adds a capability and a new way for it to break, and the capstone is the same system, hardened and run under traffic.

Every lesson asks you to make a decision, not just write code: whether a task needs an LLM, a tool, an agent, retrieval or several agents at all, and what the cheaper deterministic alternative would cost. You will list what can fail and how you would know, trace every model call and tool call from the first module, and keep the documents real teams keep: an architecture doc, an ADR log, a failure and threat register, a runbook, an evaluation set, a cost ledger and postmortems.

You build the mechanism before you use the tool that hides it. You call the provider's API directly before LangChain4j, write the agent loop, budgets and retries yourself before Spring Boot packages them, and build checkpoint and resume by hand before Temporal makes execution durable. That way you can judge when a framework helps and when it is overkill.

You are assessed the way engineering teams assess senior engineers: through decision memos, design reviews, incident drills with postmortems, and evaluation-driven changes. Code that runs is the entry ticket, not the grade.

The course has a core path and optional depth lessons, and four credentials along the way: Foundations after Module 2, Reliable Agent after Module 5, Production Agent after Module 12 and Agent Engineer after the capstone.

Õppekava

16 moodulit · 136 õppetundi
1Orientation2 õppetundiThe whole system in miniature before the foundations begin. In one sitting you run the starter repository, make one model call, give the model one tool, and read the trace of the run end to end. Nothing is explained in depth yet; the point is to see the destination, the Order Support Assistant you will build and own for the rest of the course, and the artifacts you will keep alongside it.
  1. 1.1 The Whole System in One HourVideo ja lugemine · 48 min
  2. 1.2 Module 1 Model Answers: Lesson 1.01Lugemine
2LLM Foundations12 õppetundiWhat changes when part of a system is probabilistic. You learn how a model reads tokens and messages, how providers and APIs expose it, how prompts and structured outputs shape its behaviour, and where it fails. The module ends with the prototype of the Order Support Assistant: one traced model call that classifies a support request into a validated result, the first entry in the cost ledger, version 0 of the architecture doc, and a decision memo on whether an LLM or plain rules should do the classification.
  1. 2.1 From Traditional Software to LLM-Powered SystemsVideo ja lugemine · 23 min
  2. 2.2 Tokens, Tokenization, and Context WindowsVideo ja lugemine · 30 min
  3. 2.3 Messages and the LLM Conversation ModelVideo ja lugemine · 25 min
  4. 2.4 How LLM Generation WorksVideo ja lugemine · 20 min
  5. 2.5 Models, Providers, and LLM APIsVideo ja lugemine · 28 min
  6. 2.6 Prompts, Instructions, and Model BehaviorVideo ja lugemine · 32 min
  7. 2.7 Structured OutputsVideo ja lugemine · 35 min
  8. 2.8 Embeddings and Semantic RepresentationVideo ja lugemine · 20 min
  9. Selles moodulis on veel 4 õppetundi
3Tool Calling and Structured Interaction13 õppetundiThe model gets its first capabilities, and you decide which ones it must never have. You specify tool contracts before coding them, run the tool-calling lifecycle by hand, enforce validation, authorization and least privilege in application code, and handle errors, timeouts and retries with idempotent side effects. The failure-mode and threat register and the first evaluation cases start here. The module ends with Design Review 1 and the Foundations credential.
  1. 3.1 From Structured Output to Tool CallingVideo ja lugemine · 25 min
  2. 3.2 Tool Definitions, Descriptions, and SchemasVideo ja lugemine · 30 min
  3. 3.3 The Tool Calling LifecycleVideo ja lugemine · 28 min
  4. 3.4 Returning Tool Results to the ModelVideo ja lugemine · 28 min
  5. 3.5 Designing Good Tools for LLMsVideo ja lugemine · 17 min
  6. 3.6 Validation and AuthorizationVideo ja lugemine · 37 min
  7. 3.7 Least Privilege and the Tool PolicyVideo ja lugemine · 33 min
  8. 3.8 Tool Errors, Timeouts, Retries, and IdempotencyVideo ja lugemine · 34 min
  9. Selles moodulis on veel 5 õppetundi
4Agent Fundamentals9 õppetundiWhen a single call is not enough, and when an agent is too much. You learn what makes a system agentic, choose between an LLM call, a workflow and an agent, and build the observe–decide–act loop with stopping conditions and an execution budget written before the loop is coded. Every step is traced, so loop count and budget use are visible. The module ends with the Order Support Assistant's agent loop and an ADR on workflow versus agent for the return flow.
  1. 4.1 What Makes a System AgenticVideo ja lugemine · 25 min
  2. 4.2 LLM Application, Workflow, or Agent: Choosing the ShapeVideo ja lugemine · 25 min
  3. 4.3 The Observe–Decide–Act LoopVideo ja lugemine · 16 min
  4. 4.4 Agent State, Goals, and ObservationsVideo ja lugemine · 18 min
  5. 4.5 Stopping Conditions and Execution BudgetsVideo ja lugemine · 27 min
  6. 4.6 Bounded Autonomy and When Not to Use an AgentVideo ja lugemine · 24 min
  7. 4.7 Building the Order Support Agent LoopVideo ja lugemine · 37 min
  8. 4.8 Module 4 Model Answers: Lessons 4.01–4.04Lugemine
  9. Selles moodulis on veel 1 õppetundi
Veel 12 moodulit · 100 õppetundi
Pärast seda kursust

Järgmisena õppeteekonnal AI & Agent Engineering

See kursus on 2 etapist 1. etapil: Foundation.

Agent Engineering in Java: From LLM Foundations to Production SystemsVaata kogu õppeteekonda