CONCEPT Roots: the client tells the server where it may operate
Tools, resources, and prompts flow server → client. Roots and
elicitation flow the other way — they are client-side capabilities the server
reaches into. A root defines a boundary: the spec says roots "define the boundaries of where
servers can operate within the filesystem." The client exposes a set of roots (each a file:// URI
with an optional name); the server calls roots/list to learn them and stays inside
those boundaries.
| Aspect | Roots |
|---|---|
| Who provides | The client (workspace/project config) |
| Capability | Declared by the client: "roots": { "listChanged": true } |
| Discovery | Server sends roots/list |
| Change signal | notifications/roots/list_changed |
| Root fields | uri (MUST be a file:// URI) + optional name |
| Purpose | Scope the server to allowed directories — a security boundary |
notifications/roots/list_changed.CONCEPT Elicitation: the server asks the user for structured input
Elicitation (newly introduced in the 2025-06-18 spec) lets a server request additional
information from the user, through the client, mid-operation. The server sends
elicitation/create with a human-readable message and a requestedSchema
(a restricted, flat JSON Schema of primitive properties). The client renders a form; the user responds. This
enables interactive workflows — an input request nested inside another server feature.
Responses use a three-action model: accept (user submitted — data is in
content), decline (explicit "no"), or cancel (dismissed without
choosing). Servers handle each differently.
DIAGRAM Client boundaries (roots) vs. server asking (elicitation)
CODE A root list and an elicitation request
The client returns its filesystem roots; the server later asks the user for a value it needs, constrained by
a flat schema, and reads the chosen action.
// roots/list → client tells the server its allowed boundaries { "result": { "roots": [ { "uri": "file:///home/user/projects/myproject", "name": "My Project" } ] } } // elicitation/create → server asks the user for structured input mid-op { "method": "elicitation/create", "params": { "message": "Please provide your GitHub username", "requestedSchema": { "type": "object", "properties": { "name": { "type": "string" } }, "required": ["name"] } } } // response → three-action model: accept | decline | cancel { "result": { "action": "accept", "content": { "name": "octocat" } } }
TRADE-OFFS Where roots and elicitation sit
| Capability | Direction | What it provides | Method(s) |
|---|---|---|---|
| Roots | Client → Server (server reads) | Allowed filesystem boundaries | roots/list, notifications/roots/list_changed |
| Elicitation | Server → Client → User | Structured user input mid-operation | elicitation/create |
| Sampling (6.4) | Server → Client → LLM | A completion from the client's model | sampling/createMessage |
EXAM TRAPS
roots/list to learn its boundaries and must respect them.uri
MUST be a file:// URI.accept (with content), decline (explicit no), cancel
(dismissed) — and requestedSchema is limited to flat, primitive properties.PRACTICE
Q1 · Who provides roots, and what are they for?
The client provides them (from workspace/project config). They define the filesystem
boundaries — file:// URIs — where a server may operate. The server learns them via
roots/list and re-checks on notifications/roots/list_changed.
Q2 · What are the three elicitation response actions?
accept (user submitted; data in content), decline
(explicit refusal), and cancel (dismissed without choosing). Servers should handle each
differently.
Q3 · How do roots, elicitation, and sampling relate as a group?
All three are client-declared capabilities the server uses — the mirror of server-side tools/resources/prompts. Roots bound where the server works, elicitation gathers structured user input mid-operation, and sampling borrows the client's LLM.