Build LLM apps with APIs: tools, structured output, evals

Go beyond chat: call model APIs from Python, get reliable JSON, give models tools, build small agents and measure quality with evals

7 ratings 2,390 students Sample

Created by Elena Petrova

  • Updated October 2026
  • English
  • Intermediate

What you will learn

  • Call LLM APIs from Python with system prompts, parameters and streaming
  • Produce schema valid structured output and handle failures
  • Implement tool calling and a bounded agent loop
  • Design safe tools with clear permissions and confirmations
  • Build evaluation sets and automated checks for LLM features
  • Control cost and latency and defend against prompt injection

Course content

5 sections, 24 lessons, 4h 4m total

LLM APIs from the ground up 5 lessons · 52 min
  • Video: From chat window to product feature Preview 9 min
  • Article: Messages, parameters and tokens Preview 13 min
  • Article: Writing system prompts for products 12 min
  • Article: Structured output you can parse 13 min
  • Quiz: Check your understanding 5 min
Tools and agents 5 lessons · 55 min
  • Video: How tool calling works 11 min
  • Video: Building Desk's lookup tools 13 min
  • Video: The agent loop, with limits 12 min
  • Video: Actions that change things 11 min
  • Article: When not to use an agent 8 min
Grounding answers in data 4 lessons · 40 min
  • Video: Adding policy search 11 min
  • Video: Chunking and retrieval quality 10 min
  • Video: Citations and verification 10 min
  • Article: Conversation memory and summaries 9 min
Evaluating LLM features 5 lessons · 50 min
  • Article: Why vibes are not enough 8 min
  • Video: Building an evaluation set 11 min
  • Video: Automated graders 12 min
  • Article: Testing tools and edge cases 9 min
  • Video: Running evals in CI 10 min
Production concerns 5 lessons · 47 min
  • Video: Cost and latency 11 min
  • Video: Prompt injection and data exposure 12 min
  • Video: Logging, privacy and monitoring 10 min
  • Video: Choosing and switching models 9 min
  • Quiz: Final check 5 min

Requirements

  • Comfortable with Python, HTTP APIs and JSON
  • An API key from at least one model provider, with a small budget for experiments

Description

Using an AI assistant in a browser is one thing. Building a product feature on top of a language model is another. You need predictable output your code can parse, ways for the model to look up data or take actions, protection against misuse, control over cost and latency, and some way of knowing whether a change made things better or worse.

This course teaches those skills by building Desk, an internal helpdesk assistant that answers employee questions, looks up order and account data through tools, drafts replies and escalates to a human when it should. We write Python against model provider APIs directly, so you understand what frameworks do before deciding whether to use one.

What you will learn

  • How chat completion style APIs work: messages, system prompts, tokens, parameters and streaming
  • Getting structured output that matches a JSON schema
  • Tool calling, and the loop that turns a model into a small agent
  • Designing tools that are safe, narrow and easy for a model to use
  • Evaluations: test sets, graders and regression checks
  • Cost, latency, caching and choosing between models
  • Security: prompt injection, data exposure and permission boundaries

Vendor neutral

Examples use a thin wrapper so the same code runs with different providers' SDKs. We point out where providers differ, but the concepts are the same across them.

You should be comfortable with Python, HTTP APIs and JSON. No machine learning background is required.

Who this course is for

  • Software engineers adding LLM features to products
  • Data and ML engineers moving into AI engineering
  • Technical product managers who want to understand LLM systems in depth

Instructor

Elena Petrova

AI engineer teaching prompting, LLM APIs and retrieval apps that work in practice

  • 4.5 instructor rating
  • 22 reviews
  • 9,111 students
  • 3 courses
  • Sample

I build applications on top of large language models: assistants, document search and internal tools that save teams real time. I have learned most of what I teach by shipping features, watching them fail in odd ways and fixing them.

My courses are hands on and vendor neutral. We use the APIs from several model providers, compare results, and write small evaluations so you can tell whether a change helped.

I care about the unglamorous parts: cost, latency, privacy and knowing when a plain search or a simple rule is better than a model.

View profile

Student reviews

4.4 7 ratings
5 star 57%
4 star 29%
3 star 14%
2 star 0%
1 star 0%
Thomas R. Oct 1, 2026
Sample

Finally, LLM engineering done properly

Evals, tool limits and structured output in one course. This is what I needed to ship our first AI feature.

Hiro T. Sep 25, 2026
Sample

Citations check is clever

Verifying citations in code against retrieved sections caught many unsupported answers in our app.

Ananya B. Sep 15, 2026
Sample

The eval section is worth the price

We had no evaluation suite before. Now every prompt change runs through one in CI.

Lars N. Aug 29, 2026
Sample

Vendor neutral and practical

The thin wrapper approach made it easy to compare providers. A bit more on streaming UIs would help.

Grace O. Aug 12, 2026
Sample

Honest about agents

The lesson on when not to use an agent saved us weeks. A fixed workflow covered most of our cases.

Mateo S. Jul 20, 2026
Sample

Strong security content

The prompt injection demos were sobering. Clear, realistic defences without overselling any of them.

Keisha W. Jun 23, 2026
Sample

Assumes solid Python

You need to be comfortable with Python and APIs. Otherwise the pace is tough.

$69.99 Enroll now
SampleSample catalog: the instructors, courses, reviews and stats on this site are demo content.