Lesson 1 of 5
How does a program reach the supplier table?
Module 3 gave an agent five tools and traced what happened when the model asked for them. It did not say where a tool comes from. This module does. It follows one operation, finding a supplier in an approved list, through three different ways of reaching it, so that the words you will meet in product descriptions, command line, API and MCP, name something you have already seen work. Nothing in the module needs installing; every exchange shown is an authored illustration.
Numbered links identify sources. Underlined terms offer a definition without leaving the lesson.
The table and the operation
The garden committee keeps a list of suppliers it has checked and approved. In this module it is a named approved-suppliers.csv in the folder Documents/Garden/Suppliers, and its contents are as follows. Everything about it is invented for the lessons.
id,name,category,contact,approved_on,notes
S-001,Northfence Ltd,fencing,quotes@northfence.example,2025-03-14,
S-002,Hedgerow Fencing,fencing,office@hedgerow.example,2025-03-14,
S-003,Parkside Fencing,fencing,quotes@parkside-fencing.example,2026-01-20,
S-004,Parkside Nurseries,plants,hello@parkside-nurseries.example,2024-06-02,supplies bare-root hedging
S-005,Millbrook Timber,timber,sales@millbrook.example,2023-11-30,
The first line names six columns; each later line is one supplier. Lesson 3 explains this layout properly. For now, read it as a table: five approved suppliers, each with a code, a name, what they supply, a contact address and the date the committee approved them.
The operation this module follows is small: given some text, return the rows whose name contains that text, ignoring letter case. Searching for “Hedgerow Fencing” finds one row; searching for “Parkside” finds two. The matching rule is stated now because later lessons depend on it. The organizer wants the operation because the fencing task in module 3 read quotes from suppliers without checking whether they were approved. Adding that check means some software has to open the file, find the rows whose name matches, and hand them back. Module 3 called such an operation a when a harness offers it to a model. The same operation can be reached in several ways, and each way adds a layer of software with its own job. Seeing the layers separately is what lets you later read a claim such as “our agent integrates with your suppliers database” and ask what, exactly, was connected to what.
Through a command line
The first route is a program a person can run by typing. Module 2 introduced the , which shows and accepts text, and the , which reads a typed line and starts the program it names with the inputs given. A program designed to be used this way has a : the set of names, options and inputs you can type to it, and the text it prints back. Here is an authored exchange. No real program has exactly these words.
> suppliers find "Hedgerow Fencing"
S-002 Hedgerow Fencing fencing office@hedgerow.example approved 2025-03-14
Three things happened, and each is a module 2 idea. The shell started a program named suppliers as a , passing it two inputs: the word find and the name. That process opened the file, read it, kept the matching row and printed it. Then the process ended, handing the shell a number called an exit code that reports success or failure; the transcript does not display it, but it was there, and a program that starts another program reads it. The file was read by that process, on this , under whatever limits applied to the process: the file permissions of whoever ran it, and any further restriction, such as a sandbox, that the software which started it had placed around it.
Two details matter later. The program printed its result in a form meant for a person to read. And it printed nothing about how it decided what matched, or what it would do with a name that matched two rows. Those are properties of the program, and lesson 3 shows why a caller needs to know them. Practitioners who write about designing command-line programs, in a guide by Aanand Prasad, Ben Firshman, Carl Tashian and Eva Parish, recommend that a program also be able to print its output in a form other programs can read, signal success or failure through the exit code, and keep error messages separate from results. 5 Those recommendations exist because a program is often run by another program rather than by a person, which is exactly the situation a harness creates.
Through a network API
The second route reaches the same rows on a different computer. Suppose the committee moves its list into a shared service, so that the file sits on that service's host and the organizer's laptop no longer has it. Module 2 explained what happens then: a program sends a request over the network, a program on the other host receives it, does the work and sends back a response with a status and content. The agreed set of requests and responses is the service's . Here is an authored request and reply, shortened:
request: GET /suppliers?name=Hedgerow%20Fencing
Authorization: (the garden account's credential)
response: 200 OK
[{"id": "S-002", "name": "Hedgerow Fencing", "category": "fencing",
"contact": "office@hedgerow.example", "approved_on": "2025-03-14"}]
The operation is the same: find the rows whose name matches. What changed is where it ran and what it took to be allowed. The file was read by the server program, on the service's host, under that program's own identity there. The garden account's did not give the caller's laptop any reading of that file; what the server authorized, as module 2's access lesson described, was this request for this data. The reply came back in a form built for programs: labelled values in brackets, which lesson 3 names. And its status came in a different form from the command line's: 200 OK is a number and phrase inside the response, where the command line's exit code was a number handed to the shell. Both are reports of how the request was handled, and module 2 taught you to read neither as proof that the request meant what you intended.
Notice what the API route does not settle. Whether the garden account may read the whole list or only fencing suppliers is decided by the service's authorization, not by the request. Whether the service keeps a record of every lookup is decided by the service. A network API is an agreement about how to ask; the answers about access and data handling live with the software that answers.
Through an MCP connection
The third route exists so that a harness can find and use operations like this one without a developer writing new connecting code for each harness and each service. The , usually shortened to MCP, is a published agreement about how an AI application discovers what a separate program offers and asks it to run one of those offerings. In that agreement the AI application is called the host, and it creates one client for each program it connects to. The program at the other end is an : a program that provides tools, resources and prompt templates to the client. The MCP documentation, read on 29 September 2026, describes exactly these three participants and says an MCP server can run on the same machine as the application or on a remote one. 1 Hugging Face's free course on the protocol presents the same three roles and the same flow: the host's client asks the server what it offers, then asks it to run a chosen capability, and the result comes back to the host. 4
One word needs care. MCP's host is the AI application, a role in the protocol. Module 2's host is the computer a process runs on. Both words appear in product descriptions, and this course uses the module 2 meaning unless it says MCP host. An MCP host may run on your laptop, connecting to an MCP server that runs on the same laptop, or one that runs on a supplier's service somewhere else.
Here is the supplier lookup as an authored MCP exchange, shortened and in words rather than the protocol's actual message format:
harness's client -> supplier server: what do you offer?
supplier server -> client: one tool, find_supplier; input: name (text);
returns matching rows with id, name, category,
contact, approved_on, and the source location
model (tool call): find_supplier name="Hedgerow Fencing"
harness's client -> supplier server: run find_supplier with name="Hedgerow Fencing"
supplier server -> client: [ {id: S-002, name: Hedgerow Fencing, ...,
source: approved-suppliers.csv row 3} ]
Read the two halves separately. The first two lines are discovery: the harness learns that a tool named find_supplier exists, what input it takes and what it returns. That is how a tool description reaches the model's context, which module 3 left unexplained. The remaining lines are the loop from module 3: the model generates a , the harness runs it, and the result returns as an observation. MCP standardizes the discovery and the call, and for servers reached over a network it includes provisions for authorizing the connection. It does not decide what the server does with a request once authorized: whether it reads a local file or forwards the request to the committee's service is the server's implementation, and a server can be written carelessly while following the protocol exactly. The protocol has also changed over time. Its July 2026 revision removed the earlier connection handshake in favor of each request carrying what the server needs, and marked some earlier features as deprecated, which lesson 5 returns to. 2 The point that does not depend on those details is this: the name of a connection tells you that a harness can reach a program's tools, and not what those tools may read or change.
What each layer adds, and what none of them settles
Line the three routes up against one operation and the pattern is the same one module 3 found for tools. In every case a process opened the file and matched the rows. The command line let a person, or a shell script, start that process on the local host. The network API let a program on one host ask a server on another host to do it, under the server's authorization. The MCP connection let a harness discover the operation and ask for it in a standard way, so that the model could request it as a tool. Each layer is software with a job, and each job has a name so that you can ask which one a product means.
The layers also combine. An MCP server can be a thin program that calls the committee's network API; a harness with a shell tool can run the command-line program directly, which is how a minimal harness might reach the same rows with no MCP server at all. Mario Zechner, who built a small coding agent and wrote about it in November 2025, describes preferring ordinary command-line programs with a short instruction file over dedicated integrations, because the agent then reads the instructions only when it needs them and can chain programs together. 17 That is one author's preference for one design at one time. The reason it is worth knowing is that it shows the same operation reached through a different layer, with different consequences: the harness sees the command's printed text rather than a described tool, and the limit on what the command may do is whatever the shell process runs under.
What none of the three routes settles by name is access. Setting up a route often does add access: a connection configured with the garden account's credential lets the harness reach whatever that credential is authorized for, which it could not reach before. What the route's name does not say is how much. The command-line program reads what the process's permissions and any sandbox allow. The API server answers what the credential is authorized for, and reads its own data under its own identity. The MCP server reads whatever its implementation reads, under whatever it runs as. In every case the question from module 2 stands: which software enforces the limit, and what does it cover? Lesson 5 makes that the last line of a tool's contract. Before then, the next lesson separates this kind of connection from something that is often sold alongside it.
Carry this forward
- One operation, finding a supplier's rows by a stated matching rule, can be reached through a command line, a network API or an MCP connection. In every case a process reads the file; the routes differ in where it runs, who starts it and what it took to be allowed.
- A command-line interface is what a program accepts when typed to and what it prints, with an exit code reporting success or failure. A network API is a server's agreed set of requests and responses, with a status inside each response. MCP is a published agreement for a harness to discover a program's tools and ask it to run one.
- MCP's host is the AI application, a protocol role; module 2's host is the computer a process runs on. MCP servers can run locally or remotely, and the protocol's details have changed between revisions.
- Setting up a route can add access, and the route's name does not say how much. What an operation may read or change is set by process permissions and sandboxes, the server's authorization, or the connected program's own implementation, and it has to be asked about separately.
Lesson check
Choose an answer for each question.
This is a practice check. Answers reset when you leave this page. Results are not saved and do not place you in another module or award a qualification.
A harness can now discover and call an operation. Products also sell something that sounds similar and does a different job: instructions for using operations. The next lesson keeps the two apart.
Sources · Reviewed 2026-09-29
- 5. Command Line Interface Guidelines (Prasad, Firshman, Tashian, Parish)
- 1. Model Context Protocol: Architecture overview (2026-07-28 revision)
- 4. Hugging Face MCP Course: Architectural components of MCP
- 2. Model Context Protocol: Key changes in the 2026-07-28 revision
- 17. Mario Zechner (30 November 2025): What I learned building an opinionated and minimal coding agent
Sources support nearby explanations. Product details can change. Scenarios and model results are authored illustrations unless a lesson explicitly identifies a recorded execution. Module 7 identifies its offline code checks.