MCP Prompts, Resources, Sampling and Elicitation — the primitives you're not using

How Plugsky MCP works in practice

Everything in this guide runs on Plugsky’s live MCP endpoint (https://plugsky.com/mcp) or the npm bridge (npx -y @plugsky/mcp). A client request flows: JSON-RPC over Streamable-HTTP → auth (API key or OAuth 2.1 + Dynamic Client Registration with fine-grained scopes) → tool router → the service you asked for. Model calls run behind a 7-tier provider failover chain; browsing renders with headless Chromium; transcripts come from real captions and Groq Whisper; images generate on FLUX; code runs in a sandbox with no network; memory persists in your account (Postgres-backed); and every tool call is metered per user on your dashboard.

Relevant live tools for this article: 12 prompts + 10 resources are live today; sampling and elicitation are roadmap.

MCP Prompts, Resources, Sampling and Elicitation — the primitives you're not using

Direct answer

The MCP spec has three primitives — Tools, Resources, Prompts — and three advanced features — Sampling, Elicitation, Roots. Most MCP servers only implement Tools. That leaves free discoverability and better UX on the table. Prompts show up as slash-commands (/plugsky:pick-cheapest) in Claude and Cursor. Resources become clickable attachments (plugsky://collections/onboarding). Sampling lets your server borrow the client's LLM for cheap sub-tasks. Elicitation asks the user mid-tool. Roots limit filesystem scope.

Key facts

Tools	Model calls a function	Claude, ChatGPT, Cursor, VS Code, Windsurf, Zed, all frameworks
Resources	Attachable URIs	Claude ✅, Cursor ✅, VS Code ⚠️, Windsurf ✅
Prompts	Slash-command templates	Claude ✅ full, Cursor ⚠️, others ⚠️
Sampling	Server borrows client LLM	Claude ✅, Vercel AI SDK ✅, others ⚠️
Elicitation	Mid-tool user Q&A	Claude ✅, others ⚠️ (rendered as chat)
Roots	Client tells server allowed paths	Claude ✅, Cursor ✅, Zed ⚠️

TL;DR

• Adding Prompts to your MCP = free discoverability in Claude/Cursor.
• Adding Resources = first-class attachments instead of "query this via tool".
• Sampling = your server uses the client's LLM for free — saves your infra.
• Elicitation = fewer bad tool calls because the server can clarify.
• Roots = filesystem safety — you can only touch what the user allowed.

How it works

Prompts — free discoverability

Example Plugsky prompts:

• /plugsky:pick-cheapest — argues cheapest model for a described task
• /plugsky:compare-models — runs plugsky_fusion across N models
• /plugsky:draft-arabic — forces plugsky-arabic for native Arabic output
• /plugsky:migrate-from-openai — rewrites OpenAI SDK calls to Plugsky
• /plugsky:cost-estimate — estimates monthly bill from a traffic pattern
• /plugsky:llms-txt — generates a llms.txt for a URL
• /plugsky:rag-from-url — URL → collection → answer in one shot
• /plugsky:rag-from-youtube — video → transcript → collection → answer
• /plugsky:review-pr — fusion review of a GitHub PR
• /plugsky:eval-my-prompt — run a prompt across 5 models with a rubric
• /plugsky:agent-scaffold — generate starter agent code (LangChain/OpenAI SDK/Vercel AI SDK)
• /plugsky:sovereign-check — flag PDPL/GDPR concerns, recommend residency

Resources — first-class attachments

Instead of forcing the agent to call plugsky_rag_query to touch a collection, expose the collection as a Resource:

• plugsky://collections/{id} — attach a whole collection to a chat
• plugsky://collections/{id}/documents/{doc} — attach a single document
• plugsky://models — the model catalog as browsable resource
• plugsky://models/{id} — a single model card
• plugsky://usage/current — live workspace spend
• plugsky://prompts — self-describing prompt catalog
• plugsky://sessions/{id} — browser session (browser group)
• plugsky://sandboxes/{id} — live code sandbox (code group)

In Claude, these appear in the 📎 attach menu and become part of the model's context.

Sampling — let the client's LLM work for you

Sampling is the biggest untapped feature. Your server can ask the client's model to complete a small prompt during a tool call. Use cases:

• Summarize before returning: plugsky_traces fetches 5,000 log lines, uses sampling to have Claude summarize before returning.
• Categorize an entity: plugsky_route sends the user's task description to sampling to extract keywords, then picks a model.
• Reduce infra cost: sampling shifts intelligence to the client — no charge on your side.

Only ~5% of MCP servers implement sampling today. Adding it = instant differentiation.

Elicitation — clarifying instead of guessing

Mid-tool, your server can pop a modal: "Which collection? [dropdown]", "Confirm cost $0.12? [yes/no]", "Crawl depth 1 or 3?"

Without elicitation, agents make bad calls because they guessed wrong parameters. With it, users stay in control without abandoning the flow.

Roots — filesystem safety

Clients tell servers which paths are "in scope". A filesystem MCP that respects roots can only read/write inside them. Prevents a malicious or buggy server from reading ~/.ssh.

Comparison — what each primitive gives you

Tools	Buried in tool tray	Model	Full	Trivial — everyone does it
Resources	📎 attach menu	User	Low	Easy
Prompts	/ slash-commands	User	None	Easy — huge win
Sampling	Invisible (server → client LLM)	Server	Free	Medium
Elicitation	Modal	Server	None	Medium — UX-dependent
Roots	Config-time	Client	None	Easy

FAQ

Q: Why do most MCP servers only implement Tools?

A: Historical inertia and unclear docs. The three-primitives model was clarified in the 2026 spec, but tutorials still lag.

Q: Do all clients support Prompts?

A: Claude Desktop supports them fully. Cursor partial. VS Code / Windsurf / Zed vary release-to-release.

Q: What's the difference between a Resource and a Tool that returns data?

A: A Tool is invoked by the model. A Resource is attached by the user — it's context, not an action. Both can return the same data; the UX is completely different.

Q: When should I use Sampling?

A: Whenever your tool needs LLM intelligence to shape its output (summarize, categorize, extract) and you'd rather not run inference on your side.

Q: Is Elicitation the same as "human-in-the-loop"?

A: It's the machinery that enables human-in-the-loop mid-tool. Vercel AI SDK generalizes this into an approval pattern for any tool call.

Q: If Roots are optional, why implement them?

A: Because responsible MCPs respect them. Servers that don't will fail enterprise reviews and get flagged in Glama.

Trust & sources

• Author: Mustafa Hasan.
• Last updated: {DATE}.
• References: MCP spec: Prompts, Resources, Sampling, Elicitation, Roots.
• Related: [What is MCP](/blog/what-is-mcp) · [Publish your MCP](/blog/publish-mcp-registry).