Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund
WisdomCharms — home
Cart 0 items in cart
Prompt Engineering Intermediate

Tool Use and Function Calling: Give Your Model Hands

Design tool schemas a model calls correctly, and handle the failures when it does not.

Rated 3.5 out of 5 from 2 reviews 15 students

PR Created by Priya Raman

  • Last updated August 2026
  • English
  • 4h 45m of material
  • 36 lessons

What you will learn

8 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Implement a tool-use loop by hand before reaching for a framework
  • Write tool descriptions aimed at a reader who cannot ask a follow-up question
  • Use enums and required arguments so invalid calls become impossible
  • Understand why a model picks the wrong tool and how to change that
  • Handle malformed arguments, timeouts and repeated identical calls
  • Make write operations idempotent so a retry cannot double-charge anyone
  • Separate tools that report from tools that act, and treat them differently
  • Ship an assistant that queries a database and calls an external API safely

Course curriculum

6 modules · 36 lessons · 4h 45m of material

6 lessons running 44m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 lessons running 50m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 lessons running 48m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 lessons running 52m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 lessons running 46m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 lessons running 45m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 modules · 36 lessons

4h 45m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Comfortable writing Python or TypeScript
  • You have called a model API and handled its response
  • Basic understanding of HTTP APIs and JSON schemas

About this course

A model that can only produce text is a very expensive autocomplete. Tool use is what turns it into something that can look things up, calculate properly, and change the state of your system, which is also exactly why it deserves careful engineering.

The course opens with the request and response cycle in detail: how a tool definition reaches the model, what a tool call looks like coming back, how results are returned, and how a multi-step exchange is assembled turn by turn. You implement the loop by hand before any framework appears, because debugging a framework you do not understand is miserable.

Most of the course is about schema design, since that is where correctness is won. Descriptions written for a reader who cannot ask a clarifying question. Enums that make an invalid call impossible. Required arguments that prevent silent defaults. Tools split by intent rather than by convenience. You will study why a model chooses the wrong tool and how naming, ordering and description length shift that choice.

The last third is failure engineering: malformed arguments, repeated identical calls, tools that time out, partial success, idempotency for anything that writes, and the difference between a tool that reports and a tool that acts. You finish with a working assistant that queries a database, calls an external API and refuses cleanly when it should.

Topics covered

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

Tool use is the mechanism an agent depends on. This course covers the mechanism thoroughly. Planning, memory and long-running loops are the subject of the agentic systems course.

Claude and ChatGPT tool calling are both implemented, with the differences in schema handling and parallel calls shown side by side.

A SQLite file and seed script are provided, so nothing needs installing beyond your language runtime and an API key.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

Reviews are written by people who bought this course. We publish the critical ones too.

3.5

Rated 3.5 out of 5

Course rating · 2 reviews

Rating distribution

  • 5 stars 0%
  • 4 stars 50%
  • 3 stars 50%
  • 2 stars 0%
  • 1 star 0%
  • AM

    Ana Beatriz Moreira

    Software engineer

    Jan 2026
    Rated 4.0 out of 5

    Implementing the cycle by hand first

    Writing the loop manually before touching any SDK is the right way round, because you end up understanding what the abstraction is hiding from you. The highlight is the chapter where two similar tool descriptions get rewritten until the model stops confusing them.
  • FM

    Fionn Murphy

    Backend engineer

    Jul 2025
    Rated 3.0 out of 5

    The state chapter did not land

    Schema design and failure engineering are both worth the money. The multi-step section, though, keeps everything in one in-process dictionary and never addresses what happens when a tool call spans two requests or the worker restarts halfway through, which is the exact situation I am in. I bought this for that chapter and finished it with the same question I started with.

Your instructor

PR

Priya Raman

Applied AI and machine-learning engineer

  • 236 students taught
  • 13 courses published
  • 4.3 instructor rating
  • Machine learning
  • RAG
  • Fine-tuning
  • LLM agents

Priya builds language-model features for a document-heavy SaaS product, which means she has taken retrieval and fine-tuning from a promising notebook to something on call at three in the morning. She teaches the mathematics only where it changes a decision you are about to make, and spends the rest of the time on data quality, evaluation and the cost of an agent that loops. Her courses run on a laptop and a modest API budget, so nobody has to rent a cluster to follow along. She publishes reproducible notebooks alongside every module.

See every course by Priya Raman
$29 USD

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.