MCP Servers: Tools, Resources and Prompts

9 min read

310
MCP Servers: Tools, Resources and Prompts

MCP Servers In Plain Terms

MCP stands for Model Context Protocol. An MCP server exposes tools, resources, and structured data to an AI client so the client can request actions or fetch content in a consistent way.

In practice, an AI app does not “know” how to call every system on your network. With MCP, the AI client asks the MCP server for a tool list, then sends a tool call with arguments. The MCP server runs the tool or returns the requested resource, and the client turns the result into text.

A practical example: a research assistant wants to summarize a set of internal clinical guidelines stored as documents. Instead of pasting everything into the chat, the assistant can request those documents through an MCP resource endpoint, then ask for a summary with citations to the returned text. Another example: a workflow bot can call a ticketing tool through an MCP server, then write a status update based on the tool response.

One detail that trips people up: MCP is a protocol, not a single product. You still choose the server implementation, the tool runtime, and the authentication model. I saw teams assume “MCP enabled it” meant “security came for free,” and that assumption rarely survives the first audit.

Common Pain Points And Misreads

People often treat MCP servers like a magic wrapper around any API. In reality, the server must translate between MCP’s tool and resource schema and the target system’s API, data formats, and error behavior.

Another frequent misread involves dependencies. An MCP server typically depends on a runtime (often Node.js or Python), a transport layer (commonly stdio for local setups, or HTTP/WebSocket for remote setups), and a tool execution layer that can run commands or call external services. If any of those layers fail, the AI client sees tool errors that look like “model issues,” even when the root cause is transport timeouts or missing environment variables.

Prompting also causes confusion. Tool calls require argument names and types that match the server’s declared schema. If the prompt asks for “the latest policy” without specifying which identifier or date field to use, the model may invent a parameter value. That invention can lead to the server returning “not found,” or worse, returning the wrong record.

Finally, health-adjacent use cases add constraints. If you connect an MCP server to clinical content, you need a plan for provenance, access control, and redaction. MCP does not automatically enforce HIPAA or GDPR rules; your server and surrounding systems must.

Solutions And Advice

Start With Tool Discovery Tests

Before writing prompts, test the MCP server’s discovery flow. Most clients can request the tool list and resource list, then show schemas. Run a minimal tool call with fixed arguments and verify the server returns structured output. If you are using a local setup, record the exact tool names and argument keys from the schema, because prompts that guess those keys tend to fail.

For a quick sanity check, create one “echo” tool in your MCP server that returns the received arguments. When I tested a sample server on 2026-10-14, the echo tool immediately revealed a mismatch between the client’s expected argument name and the server’s schema, which would have caused silent failures later.

Write Prompts That Bind To Schemas

Use prompts that instruct the model to call tools with explicit parameters derived from user input. A practical pattern is: ask the model to extract identifiers (document ID, date range, patient-safe token, or record key) and then call the tool with those extracted values. Avoid vague requests like “get the latest” unless the tool schema includes a clear “latest” selector or you define the selection rule.

When you need citations, require the model to quote or reference the exact resource snippets returned by the MCP server. If the server returns text chunks with IDs, ask the model to include those IDs in the final answer. This reduces hallucinated references because the model must work from returned content.

Control Errors And Timeouts

Tool calls fail for predictable reasons: authentication errors, rate limits, missing permissions, schema mismatches, and timeouts. Add structured error handling in the MCP server so the client receives machine-readable error codes and messages. Then prompt the model to respond with a “cannot complete” message when the tool returns a non-success status, rather than trying to guess.

Set realistic timeouts for external calls. For example, if your MCP server calls a document store, a 5 to 15 second timeout often matches typical retrieval latency, while longer waits can cause user-facing delays and retries that amplify load. If you see repeated retries, it usually means the client or server is treating transient errors as recoverable.

Use Resource Boundaries For Safety

For health-related content, treat MCP resources as a controlled interface. Implement access control at the MCP server layer, not only in the downstream system. Redact or filter sensitive fields before returning resource text to the AI client, and log access decisions for auditing.

Also separate “research” resources from “action” tools. A read-only resource endpoint that returns guideline text should not share the same permissions as a tool that can trigger changes in a workflow system. This separation reduces blast radius when a prompt goes wrong, which happens more often than teams expect.

Case Examples

Guideline Summaries With Provenance

An anonymized team builds an MCP server that exposes a “getGuidelineChunk” resource. The client asks for a summary of a specific guideline section by document ID and section number. The server returns the chunk text plus a chunk ID. The prompt instructs the model to summarize only the returned chunk and to list the chunk ID next to each key claim.

The pain point appears when users request “the most recent version.” The team resolves it by adding a “getGuidelineVersion” tool that maps a guideline name to a version date, then the client calls that tool first. After this change, the model stops guessing version dates and the server returns consistent results.

Ticket Triage With Tool-First Prompts

A support workflow uses an MCP server that exposes a “searchTickets” tool and an “updateTicketStatus” tool. The client prompt asks the model to extract a ticket ID from the user message, then call “searchTickets” with that ID. If the search returns zero results, the prompt instructs the model to ask for clarification rather than inventing a ticket.

A mild frustration shows up when users paste partial IDs. The team adds a validation step: the MCP server returns a “formatError” when the ID does not match the expected pattern. The client then asks the user to resend the full ID. This reduces wrong updates and keeps the audit trail clean.

Comparison Checklist For MCP Setup

Decision Point Local Stdio Server Remote HTTP Server Hybrid With Read-Only Resources
Primary Use Development and controlled environments Shared services across clients Safe access to documents plus limited actions
Security Surface Lower network exposure, still needs local auth Requires auth, rate limiting, and transport hardening Reduced risk by separating read and write paths
Latency Often lowest for local calls Network round trips add delay Read calls can be cached; actions remain gated
Operational Overhead Simpler deployment Monitoring, scaling, and incident response More design work, fewer safety surprises

Step-by-step checklist for a first reliable run:

  1. Confirm the MCP server advertises the exact tool names and argument schemas you expect.
  2. Run one tool call with fixed arguments and verify the returned structure matches the client’s parsing.
  3. Test one resource fetch and confirm the returned text includes stable IDs for citation.
  4. Introduce one failure case (wrong ID, missing permission) and verify the client does not “guess” a replacement.
  5. Set timeouts and retry rules, then measure end-to-end latency for a typical request.
  6. For health content, verify redaction and access control before returning resource text.

Common Mistakes That Break Trust

One recurring mistake is writing prompts that ask for “the answer” without constraining the model to tool outputs. When the model can answer from general knowledge, it may do so even when the MCP server returned partial or conflicting data.

Another mistake is treating tool schemas as optional. If the server expects an argument named “document_id” and the prompt asks for “doc id,” the model may send the wrong key. The result can look like a model failure, but the schema mismatch is the real issue.

Teams also over-share. Returning full internal documents through resources without filtering can leak sensitive fields into the AI client context. Even if the final answer is careful, the intermediate context can still be logged or stored by client tooling.

Finally, people skip versioning. If you update tool behavior or resource formats, old prompts can break. A small aside from a common workflow: teams that track tool schema changes in a changelog (for example, “tool v1.3.2”) reduce debugging time when a client update lands.

FAQ

What Does An MCP Server Expose?

An MCP server exposes tools (callable actions with typed arguments) and resources (retrievable content) to an MCP client, typically with structured responses and error details.

Do MCP Servers Replace API Integrations?

MCP servers do not remove the need to integrate with the underlying systems. They add a standard interface so the AI client can discover and call your tools consistently.

How Do I Test Tool Calls Safely?

Start with a local or staging MCP server, add an echo or read-only tool, run fixed-argument calls, and test failure modes like missing permissions before connecting any write actions.

What Prompt Patterns Reduce Hallucinated Parameters?

Extract identifiers from the user message, then instruct the model to call the tool using the schema’s exact argument keys and to stop when the tool returns a non-success status.

How Should Health Content Be Handled?

Apply access control and redaction in the MCP server, return only the minimum resource text needed for the task, and keep audit logs of which resources were accessed.

Author's Insight

MCP servers work best when teams treat them like an interface contract, not a chat feature. Tool schemas, error codes, and resource IDs shape how reliably the AI client can produce grounded outputs.

For health-adjacent workflows, the biggest risk comes from permissions and data boundaries, not from the model. A server that returns unfiltered documents or mixes read and write permissions tends to create avoidable safety and compliance problems.

When debugging, focus on the chain from schema discovery to tool execution to structured results. If the returned payload does not match the client’s expectations, prompt changes rarely fix the root cause.

I also recommend keeping a small set of regression prompts and running them after any server or schema update, since small argument name changes can break tool calls.

Key Takeaways

  • MCP servers standardize how AI clients discover and call tools and fetch resources, but they do not remove integration or security work.
  • Reliability comes from schema-aligned prompts, tested tool calls, and predictable error handling.
  • Health-related content needs access control, redaction, and provenance through resource IDs.
  • Use a decision checklist to choose local, remote, or hybrid server designs based on latency and security surface.

Was this article helpful?

Your feedback helps us improve our editorial quality

Latest Articles

AI Tools 10.11.2026

AI Tool Calling: Arguments and Validation

AI tool calling lets a model request external actions by sending structured arguments to software. This matters for people who want reliable, auditable results from assistants used in health-adjacent workflows. You will learn how argument schemas work, where validation fails, how to design checks for types, ranges, and required fields, and how to test tool calls with realistic examples and a practical checklist.

Read » 383
AI Tools 16.11.2026

MCP Servers: Tools, Resources and Prompts

MCP servers connect AI apps to external tools through a standard protocol. This guide explains what MCP servers do, which dependencies matter, and how to test prompts and tool calls without guessing. It is for developers and health-adjacent teams who want reliable tool access for research, documentation, and workflow automation. You will learn practical setup checks, prompt patterns, example scenarios, and a decision checklist to reduce errors and avoid unsafe tool use.

Read » 310
AI Tools 13.11.2026

API Data Retention: Training vs Storage

API data retention affects how long providers keep your requests, how they separate training from storage, and what rights you have when data is reused. This article explains retention terms in plain English for people evaluating health-adjacent apps, analytics, and AI features. You will learn how training differs from storage, which clauses to look for, what technical signals matter, and how to reduce risk when an API vendor keeps logs.

Read » 144
AI Tools 12.10.2026

AI Privacy: Training Data vs API Data Retention

AI privacy shapes what happens to health-related information both when models are trained on large datasets and when you type sensitive details into an app or send them through an API. This guide is written for patients, caregivers, and anyone using health trackers or symptom-checker apps who wants clearer answers. It breaks down the difference between “training data” and “prompt/API data,” explains what vendors may store and for how long, and lists the right questions to ask before sharing anything personal. You’ll also get practical steps to limit exposure, spot common retention and logging pitfalls, and read privacy policies and data-processing terms with more confidence—without having to rely on guesswork.

Read » 437
AI Tools 03.11.2026

AI Errors: Measuring Hallucination Rates

This article explains how to measure hallucination rates in AI systems that generate text, summaries, or answers. It’s for readers who want reliable evaluation beyond vague claims, including people reviewing AI outputs for health-adjacent information. You’ll learn how to define “hallucination,” choose test sets, score factuality with human and automated checks, and interpret results with uncertainty. Practical examples show how measurement choices change the numbers.

Read » 369
AI Tools 01.11.2026

AI Agents: Tool Calls per Task

AI agents can call tools (search, databases, code, calendars) while they work on a task. This article explains how “tool calls per task” affects cost, latency, reliability, and safety. It’s for readers evaluating agent demos, writing prompts, or setting internal rules for automated workflows. You’ll learn how to measure tool-call counts, what failure modes look like, and how to design tasks that finish with fewer calls without losing correctness.

Read » 212