Slides

WEEK 04

# Ask a dataset, build the plots

## Plotting tools, a NiceGUI interface, and a small PydanticAI team

---

# What is a tool?

## A function the model can request through the application

A tool can retrieve information, compute a result or perform an action. The application controls which capabilities are available.

Reference: <a href="https://ai.pydantic.dev/tools/">PydanticAI function tools</a>. Data: Vasco (vascos), Swiss Popular Voting, Kaggle, MIT; see <code>dataset/README.md</code>.

<aside class="notes">
Introduce a tool as an ordinary function made available through a defined
interface. The model receives its name, purpose and input schema. PydanticAI
derives that schema from the function's types and docstring. The code runs in
the application when a permitted request is accepted. The figure simplifies
the input schema; the lab also supports optional year filters.
Reading a file, searching documents, plotting and sending a message are possible
tool capabilities. Our plotting worker receives only its registered plotting
tool. Tool access is a trust boundary: the application must validate inputs
and enforce permissions, rather than relying on instructions to the model.
The coding assistant will help implement these functions. Students inspect
before-and-after copies of the changed files and run checks before registration.
Ask students which part would need to change to add a new plot type.
</aside>

---

# How a tool call works

## The model requests an operation, then receives its result

A tool call is structured data: a tool name and arguments. Python executes the function and returns the result for the next model response.

Reference: <a href="https://ai.pydantic.dev/tools/">PydanticAI function tools</a>. Example call uses the Week 04 plotting tool; optional year filters are omitted.

<aside class="notes">
Read the diagram downward. The code-shaped request is a readable illustration
of the tool name and structured arguments, not arbitrary Python generated for
execution. A direct Python call can run the same calculation without a model.
The model's contribution is selecting a permitted operation and interpreting
its returned evidence. The application manages the conversation and tool loop.
The application checks the request against the schema and worker assignment.
Invalid inputs or failures must be handled explicitly. A typed request alone
does not prove that the function ran or that its result is scientifically sound.
The return path passes through the application before reaching the model.
This example shows one call; later slides add the worker's limits and evidence ID.
Ask: if the model writes a plausible filename in its answer, what evidence
would show that the plotting function actually ran?
</aside>

---

# Tool results need scientific review

## Keep computed evidence and generated interpretation distinguishable

Use the coding assistant to implement and test the tool. Inspect the changed files and check the result before accepting the model's explanation.

Data: Vasco (vascos), <a href="https://www.kaggle.com/datasets/vascos/swiss-popular-voting">Swiss Popular Voting, Kaggle</a>, MIT; see <code>dataset/README.md</code>. Counts describe the supplied snapshot.

<aside class="notes">
The numbers come from deterministic counting of the fixed CSV. The middle
panel is an illustrative model explanation to review, not a recorded model run.
Students compare it with the actual table and plot, including the denominator
and missing outcomes. The 692 rows are proposal records, not individual voters
or unique voting dates. Deterministic calculation does not certify the source
data or the scientific interpretation.
Ask the coding assistant to test all-outcome and accepted-only counts, then
inspect the before-and-after files and verify the evidence yourself.
In this app, the plotting tool creates working PNGs. The separate reviewed
export saves only results the student selects and approves in the interface.
Retrieved text or tool output should be treated as evidence to inspect, not as
instructions granting new permissions. Actions such as sending or publishing
need their own explicit approval boundary.
</aside>

---

# Before we begin

## Prepare the course folder and model access

Run from the folder containing `pyproject.toml`:

```bash
uv run scripts/update.py
uv sync --group examples --group gui
```

Review the updater summary. Read `dataset/README.md` and keep the CSV unchanged.
Create `artifacts/week04/` for your brief, Python files, and saved results.
This weekly lab does not depend on your Week 3 app.

Reuse the course `.env`. Plotting tools and the instructor's `--demo` mode
work without a model key; live agents use the supplied application key.

---

# The app we will build

## Ask a question and choose up to N worker agents

- Enter: “Compare recorded outcomes and participation; show the pattern by decade.”
- Choose **maximum workers N**, initially 1, then 3.
- See figures with two or three explanatory sentences and one caveat each.
- Open computed evidence and the tool trace when checking a claim.
- Select useful cards and **save their figures and explanations together**.

The coordinator may use fewer than N workers. More workers do not automatically
mean a better answer; a narrow question may need only one figure.

---

# The application around the agents

## The interface, model and tools have different jobs

The agents are components of the application. Python runs the tools; the model receives the context and evidence the application sends.

Pattern: <a href="https://ai.pydantic.dev/multi-agent-applications/">PydanticAI multi-agent applications</a>. Data: Vasco (vascos), Swiss Popular Voting, Kaggle, MIT; see <code>dataset/README.md</code>.

<aside class="notes">
Start at the browser and trace one question through the local application.
The coordinator produces a typed plan; Python validates it and dispatches the
workers. Each worker has registered plotting tools and its own model calls.
The same model endpoint can serve several agents; an agent is not another
model installed inside the browser. The interface, orchestration, plotting and
saving are ordinary application code. Only the configured model calls go to
the remote endpoint. Tool results sent as context can include computed data;
local CSV storage does not mean that every value stays off the model API.
Ask: which component reads the CSV, and who chooses what to save?
</aside>

---

# From a question to a testable brief

<video class="course-video" controls muted playsinline preload="metadata" width="1920" height="1080" poster="assets/videos/week-04-goal-and-brief.jpg" aria-label="Silent demonstration: preview a completed plot studio, inspect a question and result, then write a short brief for tools, interface, and agents.">
 <source src="assets/videos/week-04-goal-and-brief.mp4" type="video/mp4">
 <a href="assets/videos/week-04-goal-and-brief.mp4">Open the goal and brief demonstration video</a>.
</video>

<a href="assets/videos/week-04-goal-and-brief.mp4">Open video separately</a> · 97 seconds · silent

<aside class="notes">
Trace the question and maximum-worker control to the figure, explanation,
caveat, and computed evidence. Then inspect the coding-assistant prompt and its
generated brief: plotting tools, NiceGUI interface, and PydanticAI agents.
N is a ceiling for workers; the coordinator is additional.

Editorial sequence: prepared completed-app preview, captured later; original
brief-writing sequence follows. The live preview uses
deepseek/deepseek-v4.1-flash through PPQ. Saving is demonstrated in video 5.

Long setup/generation waits are cut; retained screen actions play at 1×, with
short stage dissolves and crops for readability.
Data: Vasco (vascos), Swiss Popular Voting, Kaggle v1, MIT; see dataset/README.md.
</aside>

---

# Build the app, then use the app

## The coding assistant and runtime agents have different roles

“Add a date filter” → coding assistant. “Compare participation by decade” → running application.

In this lab: coding-assistant account for building; application key in <code>.env</code> for running. Keep keys out of prompts and saved results. <a href="setup.html">Model setup</a>.

<aside class="notes">
The coding assistant can inspect files, propose changes and run checks through
the tools its environment permits. Students inspect the changed files and try
the result. The saved Python files then run the plot studio independently of
the coding-assistant conversation. Runtime workers receive the analysis task,
their instructions and their registered tool definitions; this lab does not
give them a general-purpose code editor or terminal.
Both roles can use the same underlying language model. Multiple coding-assistant
sidebar agents are not the N workers inside the application.
The app reads LLM_BASE_URL, LLM_MODEL and LLM_API_KEY from .env. Keep the supplied
defaults and restart after changing them. Ask: where would you type “add a date
filter”, and where would you type “compare participation by decade”?
</aside>

---

# A familiar dataset, carefully interpreted

## Each row is a national proposal record

- **692 records**, including 6 with missing outcomes; proposal numbers repeat.
- Participation is observed in **659 records**; a missing value is not zero.
- Participation and yes shares are fractions; multiply by 100 for percentage labels.
- Means weight proposal records equally and need their own observed counts.

The snapshot cannot answer questions about individual voters or differences
between named cantons. Keep conclusions descriptive.

Data: Vasco (vascos), <a href="https://www.kaggle.com/datasets/vascos/swiss-popular-voting">Swiss Popular Voting, Kaggle</a>, version 1 (24 November 2024), MIT license. Read <code>dataset/README.md</code> for units, missingness, provenance, and limitations.

---

# First build the plotting tools

## A small menu makes each result checkable

| Tool capability | Figure | Evidence to return |
| --- | --- | --- |
| Count recorded outcomes | Bar chart, including missing outcome | Counts and retained record total |
| Compare participation by outcome | Mean participation bars | Mean, observed count, missing count per group |
| Inspect participation by decade | Mean participation over time | Same evidence for each decade |

Start with the first two. Add the time view when they work. Give arguments
explicit allowed values, such as an outcome filter; reject unsupported values.

**Tool output = figure file + computed table + filters + source and dataset hash.**

---

# Build the tools · 20 minutes

## Create and verify tools before introducing an agent

> Read dataset/README.md. Create artifacts/week04/plot_tools.py with typed
> matplotlib tools for outcome counts and mean participation by outcome.
> Preserve the CSV and missing outcomes. Exclude missing participation from
> means; report observed and missing counts. Return labelled PNGs, tables,
> filters, units, source, license, and dataset hash. Run offline checks for
> all outcomes and accepted-only results. Explain the changed files.

Inspect the actual figure and table. The tools must already work before
a model chooses when to call them.

---

# Check the tool's result

## Plot appearance cannot verify arithmetic

| Check | Expected evidence |
| --- | --- |
| All outcome counts | 325 accepted, 361 not accepted, 6 missing |
| Accepted-only filter | 325 retained records; no other outcome group |
| All participation values | 659 observed and 33 missing |
| Missing-outcome participation | Unavailable; no invented zero-valued mean |

Check axis units, group labels, and denominators beside the chart. If you add
a date filter, test an empty interval and report no observations explicitly.
Save a before-copy before asking the coding assistant to fix a problem.

---

# Build tools and check their evidence

<video class="course-video" controls muted playsinline preload="metadata" width="1920" height="1080" poster="assets/videos/week-04-plot-tools.jpg" aria-label="Silent demonstration: ask the coding assistant to build plotting tools, run deterministic calculations, and compare figure values with filters and observed counts.">
 <source src="assets/videos/week-04-plot-tools.mp4" type="video/mp4">
 <a href="assets/videos/week-04-plot-tools.mp4">Open the plotting tools demonstration video</a>.
</video>

<a href="assets/videos/week-04-plot-tools.mp4">Open video separately</a> · 184 seconds · silent

<aside class="notes">
Pause on a computed table and find the corresponding figure value. Compare
all records with accepted-only records and inspect observed and missing counts.
The coding assistant implements the functions and reports a metadata correction;
Python computes the plotted evidence. These tool checks make no runtime model
call. Keep missing values distinct from zero.

---

# Vibe code the interface · 15 minutes

## Describe the interaction in a few bullets

> Create artifacts/week04/app.py with NiceGUI. Add a dataset-question box,
> a maximum-worker selector N from 1 to 4, and an Ask button. Below, show
> figure cards with a short explanation, a caveat, and expandable evidence.
> Let me select cards and save their PNGs with their explanations. Use a clear,
> spacious layout. First connect the real plotting tools with explicitly
> labelled local demo captions; keep a separate async function for live analysis.

Try the interface before wiring the agents. A loading indicator, a visible
error, and a disabled Ask button during a run help make its behavior clear.

<aside class="notes">
Students choose colors and arrangement. The teacher reference uses red, white,
and charcoal. Keep visual refinement short enough to finish agent integration.
A local demo is deterministic computation, not a model run.
</aside>

---

# Build and try the NiceGUI interface

<video class="course-video" controls muted playsinline preload="metadata" width="1920" height="1080" poster="assets/videos/week-04-nicegui-interface.jpg" aria-label="Silent demonstration: build the question and worker-limit controls in NiceGUI, then preview the interface after connecting live PydanticAI agents.">
 <source src="assets/videos/week-04-nicegui-interface.mp4" type="video/mp4">
 <a href="assets/videos/week-04-nicegui-interface.mp4">Open the NiceGUI interface demonstration video</a>.
</video>

<a href="assets/videos/week-04-nicegui-interface.mp4">Open video separately</a> · 174 seconds · silent

<aside class="notes">
Follow the question, N selector, running state, trace, figure, explanation,
caveat, and computed table. The original offline-first prompt is the initial
UI draft. The explicit transition ‘Preview after connecting live agents’ leads
to a later real N=1 submission using deepseek/deepseek-v4.1-flash through PPQ.
That live result is not presented as the direct output of the offline request.
The coding assistant is separate from the app's runtime model.

---

# Inside one application agent

## A worker alternates model calls and Python tool execution

The model requests a tool. Python checks its arguments, executes the registered function, and returns evidence for the next model call.

Reference: <a href="https://ai.pydantic.dev/tools/">PydanticAI function tools</a>. Our application also enforces request, tool-call and time limits.

<aside class="notes">
Zoom into one worker from the application diagram. An Agent combines
instructions, model configuration, registered tools and an output contract;
the runtime manages the conversation and tool loop. A model tool request is
structured data naming a tool and its arguments. Python performs the actual
calculation. Returning tool results gives the model evidence for its next
response. More than one call may be needed, within the configured limits.
The final figure ID must belong to evidence created by this worker; Python
checks this ownership as well as the typed output. Those checks do not prove
the explanation scientifically correct: the student still reviews it.
Ask students to point to the deterministic calculation and the generated text.
</aside>

---

# Give a worker access to a tool

## A PydanticAI agent needs explicit registration

```python
worker = Agent(model, instructions="Use plot evidence for every claim.")
worker.tool_plain(plot_participation_by_outcome)
result = await worker.run(assignment, usage_limits=worker_limits)
```

This is the wiring pattern; use your own function signature and typed output.
Types and docstrings describe arguments to the model. Python performs the
calculation and file creation when the tool is called.

Return a figure identifier, a short explanation, and a caveat. Verify that
the identifier belongs to a figure this worker actually created.

API reference: <a href="https://ai.pydantic.dev/tools/">PydanticAI function tools</a>. A file path written in model text is not proof of a successful tool call.

---

# Add the coordinator

## Turn one question into a few useful assignments

For “Compare recorded outcomes and participation over time,” a plan might be:

| Worker | Assignment |
| --- | --- |
| 1 | Count records by recorded outcome |
| 2 | Compare mean participation by recorded outcome |
| 3 | Show mean participation by decade |

Use a Pydantic output model for the plan: permitted plot type, filter, and
purpose. Each worker is another PydanticAI `Agent`, with its own assignment.
Python dispatches the plan asynchronously and collects the successful cards.

---

# What does “up to N” mean?

## N limits workers for the whole question

- Allow **1 ≤ N ≤ 4**, enforced in Python before making model calls.
- The coordinator is additional: at most **1 coordinator + N workers**.
- Validate the entire plan before dispatch; do not silently drop assignments.
- Set request, tool-call, and time limits; prevent recursive delegation.
- Keep successful cards when another worker fails; show the failed assignment.

Run the same question with N=1 and N=3. Compare coverage, duplication, waiting
time, and whether each explanation is supported. N is a ceiling, not a target.

---

# Connect the team · 25 minutes

## Let the assistant implement one complete path

> Create artifacts/week04/agents.py and connect it to app.py using the course
> model configuration. A PydanticAI coordinator plans at most N PydanticAI workers.
> Each worker calls our plot tools and returns a short explanation and caveat.
> Enforce N and request/tool/time limits in Python. Keep the UI responsive and
> show partial failures. Record assignments, arguments, and evidence IDs;
> reject IDs not produced by that worker's tools. Run local checks and
> explain the changed files before we try a live question.

Begin with N=1. After one card works, ask for a broader comparison with N=3.

---

# Inspect one worker

## Trace an explanation back to a calculation

1. **Question → plan:** does the assignment match the requested scope?
2. **Plan → tool call:** are the plot type and filter correct?
3. **Tool result → figure:** do labels, values, and units match the table?
4. **Evidence → explanation:** are its comparisons and caveat supported?

Do not accept a claim merely because several agents agree. They may share
the same model, instructions, and data limitations.

**Try:** “Compare participation for accepted proposals only.”
Inspect the filter in the evidence, not just the card's title.

---

# Trace a bounded PydanticAI team

<video class="course-video" controls muted playsinline preload="metadata" width="1920" height="1080" poster="assets/videos/week-04-agent-team.jpg" aria-label="Silent demonstration: inspect the PydanticAI coordinator and workers, compare worker ceilings of one and three, and trace a tool call to its figure and evidence.">
 <source src="assets/videos/week-04-agent-team.mp4" type="video/mp4">
 <a href="assets/videos/week-04-agent-team.mp4">Open the agent team demonstration video</a>.
</video>

<a href="assets/videos/week-04-agent-team.mp4">Open video separately</a> · 219 seconds · silent

<aside class="notes">
After video 3's later preview, return to the authentic earlier integration
build. The visible code includes typed plan/finding models, asyncio.gather and
a whole-run timeout. Distinguish the assistant's implementation report from
runtime evidence; the excerpts do not show every Agent constructor or the exact
N-rejection lines.

Trace assignments through tool arguments, computed tables, figures and model
explanations. The N=1 and N=3 runs ask different questions; they demonstrate
bounded worker use, not a controlled comparison of speed, cost or answer quality.
N is the worker ceiling, with one additional coordinator. Coding-assistant
sidebar agents are separate from runtime workers. The app uses
deepseek/deepseek-v4.1-flash through PPQ; distinguish actual request use from its
configured ceiling.

---

# Make a limitation visible

## The app should explain when it cannot answer

Try “Which canton had the highest turnout?” The CSV has no canton-level
turnout records, so the app should explain the limitation without inventing a chart.

Also inspect one unavailable-data case and one worker failure. Successful
cards should remain visible, with the missing result clearly identified.

Ask the coding assistant to exercise failure handling with a local test double.
Label simulated failures and demo captions; they are not live model behavior.

---

# Save figures with their explanations

## Make the result usable outside the browser

Select cards and click **Save selected**. Create a new result folder under
`artifacts/week04/saved/` containing:

- Selected PNG figures and their stable identifiers.
- `explanations.md`: question, titles, generated explanations, and caveats.
- `evidence.json`: computed tables, filters, units, observed and missing counts.
- `manifest.json`: figure-to-text mapping, model ID, source, license, dataset hash.

Open the saved files and check one complete figure/text pair. Preserve the
model-text label; a saved explanation still needs scientific review.

---

# Review and save selected results

<video class="course-video" controls muted playsinline preload="metadata" width="1920" height="1080" poster="assets/videos/week-04-review-and-save.jpg" aria-label="Silent demonstration: review a model explanation against plotted evidence, save selected cards, and inspect the saved explanations, manifest, and original outcome figure.">
 <source src="assets/videos/week-04-review-and-save.mp4" type="video/mp4">
 <a href="assets/videos/week-04-review-and-save.mp4">Open the review and save demonstration video</a>.
</video>

<a href="assets/videos/week-04-review-and-save.mp4">Open video separately</a> · 159 seconds · silent

<aside class="notes">
Review the two selected participation figures and compare each explanation
with its computed evidence. Inspect the saved explanations.md and manifest.json,
follow their evidence links, and reopen the original outcome PNG. The bundle
also includes evidence.json and both selected PNG/JSON pairs. Follow a caption
to its filters, observed and missing counts, source hash and model ID. The
unselected count figure is absent.
The bundle records the actual deepseek/deepseek-v4.1-flash run through PPQ.
This reviewed bundle becomes the presentation input in video 7.

---

# Weekly lab · final 20 minutes

## Challenge the app, then keep a reproducible result

1. Exchange a broad question and an accepted-only question with another pair.
2. Compare N=1 with N=3; inspect the actual worker count and tool evidence.
3. Try an unsupported question; check that it does not invent findings.
4. Select useful cards, save them, and reopen the figure/text package.

**Keep:** your brief and Python files, one before-copy, a saved result, and
the checked trace. Add one sentence explaining a limitation you observed.

If model access is unavailable, finish the tools, UI, and saving path with
labelled demo captions; mark live coordination as unverified.

---

# Challenge the app and verify recovery

<video class="course-video" controls muted playsinline preload="metadata" width="1920" height="1080" poster="assets/videos/week-04-challenge-and-recovery.jpg" aria-label="Silent demonstration: challenge unsupported scope, inspect a clearly labeled simulated worker failure, retain successful results, and check recovery.">
 <source src="assets/videos/week-04-challenge-and-recovery.mp4" type="video/mp4">
 <a href="assets/videos/week-04-challenge-and-recovery.mp4">Open the challenge and recovery demonstration video</a>.
</video>

<a href="assets/videos/week-04-challenge-and-recovery.mp4">Open video separately</a> · 291 seconds · silent

<aside class="notes">
First inspect the live refusal of unsupported canton scope. Then separate
that dataset limitation from an application failure. ‘Simulated worker failure’
identifies the offline PydanticAI FunctionModel test double: its local
model calls make zero provider requests. One worker deliberately fails while
another calls the real plotting tool and produces a usable card. Its caption
and saved model identity remain explicitly offline. This is not a PPQ outage.

After the simulation, the separate live regression uses
deepseek/deepseek-v4.1-flash through PPQ. The mean-participation-by-recorded-outcome
question runs with N=1 and three provider requests; its missing-outcome group
remains ‘Unavailable’. This is not a filmed separate missing-only question.
Do not attribute the offline simulation to the live checks.

---

# Instructor reference and fallback

## Compare behavior with a working implementation

```bash
uv run --group examples --group gui python src/aiforlifescience/solutions/04_plot_studio.py --demo
```

Open [http://127.0.0.1:8084](http://127.0.0.1:8084). Demo mode makes local plots
and deterministic captions. Stop with Ctrl+C, remove `--demo`, and restart
to use the live PydanticAI coordinator and workers.

The reference uses `voting_plots.py` and `plot_agents.py` in the course package.
You may reuse them when needed; identify which code you reused and explain
where its tools, worker limit, and save operation are implemented.

---

# Bonus · turn saved results into a presentation

## Use a harness that can create an editable PPTX

Give it the **saved figures, explanations, and evidence**. Ask for five or six
slides: question, data and method, two or three findings, limitations and sources.

Use a **Swiss typographic theme**: white background, red accents, dark text,
a clear grid, sans-serif type, generous space, and large figure labels.
Keep chart evidence unchanged and retain caveats beside the findings.

This is a harness bonus after saving, not another tool the analysis agents
must implement. The core lab is complete without PPTX.

---

# Bonus · suitable presentation environments

## Check that the capability is enabled in your account

| Environment | PPTX capability |
| --- | --- |
| Claude with file creation enabled | Built-in downloadable PowerPoint creation |
| Codex / ChatGPT desktop with Presentations | PowerPoint creation through the available skill or plugin |
| Copilot in PowerPoint | Create and edit a presentation in PowerPoint; an Office alternative |

A plain coding assistant using `python-pptx` or PptxGenJS is a separate,
library-based route. The bonus does not require a new subscription.

Checked 2 October 2026: <a href="https://support.claude.com/en/articles/12111783-create-and-edit-files-with-claude">Claude file creation</a> · <a href="https://learn.chatgpt.com/use-cases/generate-slide-decks">Presentations in Codex / ChatGPT desktop</a> · <a href="https://support.microsoft.com/en-us/powerpoint/copilot/create-a-new-presentation-with-copilot-in-powerpoint">Copilot in PowerPoint</a>. Access and input workflows depend on the account; insert saved plots if folder input is unsupported.

---

# Bonus · the presentation prompt

## Build, open, and inspect the actual presentation

> Use this saved result folder to create a five- or six-slide editable PPTX.
> Apply a Swiss theme: red, white, charcoal, a grid, and sans-serif type.
> Embed the PNGs; keep titles and captions editable. Preserve claims and
> caveats; cite Vasco (vascos), Kaggle, MIT, and the snapshot. Do not invent
> findings or regenerate chart data. Render every slide and check clipping,
> readability, caption matches, and support for each claim.

Reopen the PPTX. Editable titles and captions with embedded figure images
are sufficient. Check the result against the saved evidence, slide by slide.

---

# Turn saved evidence into an editable deck

<video class="course-video" controls muted playsinline preload="metadata" width="1920" height="1080" poster="assets/videos/week-04-swiss-pptx.jpg" aria-label="Silent demonstration: create a Swiss-style PPTX from reviewed evidence, inspect its slides in LibreOffice Impress, select title and caption text to demonstrate editability, and compare a caption with source evidence.">
 <source src="assets/videos/week-04-swiss-pptx.mp4" type="video/mp4">
 <a href="assets/videos/week-04-swiss-pptx.mp4">Open the Swiss-style presentation demonstration video</a>.
</video>

<a href="assets/videos/week-04-swiss-pptx.mp4">Open video separately</a> · 193 seconds · silent

<aside class="notes">
Private folder details in the file dialog are redacted in this revision.
The reviewed selected-result bundle supplies the figures, explanations and
evidence. The ChatGPT/Codex harness uses its Presentations capability, separate
from the dataset app's DeepSeek runtime. The six-slide deck preserves chart
values, units, filters, counts, attribution and caveats in a Swiss typographic
theme.

The actual PPTX is inspected in LibreOffice Impress. Double-clicking the title
and caption and selecting their text demonstrates editability; no content is
changed or saved. The format is PowerPoint; the inspection application is
Impress. Embedded figures with editable titles and captions meet this bonus.
Compare the displayed caption with the saved evidence.

---

# Week 4 · guided work

## Separate 30-minute activity · improve one part

- **5 min:** choose an issue from the peer challenge: plot, explanation, or interaction.
- **10 min:** request one targeted change and inspect the before/after files.
- **10 min:** rerun the affected question and a previously successful question.
- **5 min:** save the revised result and describe the improvement.

Early finishers can add a bounded date filter, compare agent counts more
systematically, or try the optional PPTX workflow.

---

# Next week · expose a tool through MCP

## Separate the tool server from the agent application

Today workers call Python plotting functions inside the application.
Next week, play Connect Four against models, a decision API and your coding assistant through MCP.
No finished Week 4 app is required.

The transport changes; evidence still needs checked arguments, explicit units,
missing-value handling, and a source. Week 9 extends MCP to plots and artifacts.

---

# Week 4: course navigation

[Course overview](presentation.html)

[14-week course map](course_map.html)

[Previous: Week 3](week_03.html)

[Next: Week 5](week_05.html)