An MCP server gives an AI application a standard way to access tools, data, and reusable prompts. To use one, connect an MCP client in the AI host to the server over a supported transport, inspect what it offers, and let the host call only the capabilities the task needs. The model is not the server: the host supplies the model, the client manages the connection, and the server exposes capabilities.
What an MCP server does—and what it does not do
The Model Context Protocol (MCP) standardizes how AI applications connect to systems that hold data or perform actions. An MCP server makes those capabilities available through a shared interface; it does not supply the AI model, the host application, or the underlying service. A host can connect to one or more servers through MCP clients.
![Claude AI for Beginners Bible: [5 in 1] The Ultimate Guide to Automate Your Work, Save Hours Every Week, and Use AI for Real-World Results](https://m.media-amazon.com/images/I/415+fSJacsL._SL160_.jpg)
For example, a server might expose a database lookup, a file operation, or a way to retrieve current information from an API. The host and model can then use those capabilities within the permissions and behavior implemented by the server.
Host, client, and server
- Host: the AI application that runs the model and manages the user interaction.
- Client: the part of the host that connects to an MCP server and exchanges protocol messages.
- Server: the component that makes tools, resources, or prompts available.
If you want your API or data source to be usable by multiple compatible AI hosts, build a server. If you are building an AI application that needs capabilities provided by existing MCP servers, build or configure a client.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minute#1 Best Overall
Choose tools, resources, and prompts for the right job
MCP capabilities have different roles and control patterns. The protocol’s server overview distinguishes them this way; the choice of primitive for a particular feature is an implementation decision.
| Capability | Best fit | Example | Control pattern |
|---|---|---|---|
| Tool | An operation the model may choose to invoke | Look up an order or create a file | Model-controlled executable function |
| Resource | Contextual data the application can supply | File contents or git history | Application-controlled data |
| Prompt | A reusable instruction or template the user can select | An interactive command template | User-controlled template or instruction |
Make tool names and descriptions specific, define an input schema, and return useful output. A read-only lookup can be a tool when the model should choose whether to perform it; it can instead be a resource when the application should supply it as context. Avoid treating descriptions or schemas as security controls: validate input and enforce permissions in the server.
Build a server or connect to one?
Build a server to expose your system
Use a server when an AI host needs to call your API or retrieve your data through MCP. The TypeScript SDK v2 supports server creation and integration with existing Express, Hono, Fastify, or Workers applications. The official Python SDK v2 documents server and client construction as well.
Build a client to use another server
Use a client when your application needs to connect to MCP servers and make their capabilities available to its host or model. A client connects using a transport, lists available capabilities, and calls a tool or reads a resource as needed.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Create a minimal MCP server in Python
The official Python SDK v2 requires Python 3.10 or newer and supports stdio, Streamable HTTP, and SSE transports. Its documented quick-start installation is uv add "mcp[cli]" or pip install "mcp[cli]". The example below defines a tool and a resource, then runs the Inspector for interactive development.
- Install the SDK: run
uv add "mcp[cli]"in your project, or usepip install "mcp[cli]". - Save as
server.py:from mcp.server.fastmcp import FastMCP mcp = FastMCP("Example server") @mcp.tool() def add(a: int, b: int) -> int: """Add two numbers.""" return a + b @mcp.resource("greeting://{name}") def greeting(name: str) -> str: """Return a greeting for a name.""" return f"Hello, {name}!" if __name__ == "__main__": mcp.run() - Start the development Inspector: run
uv run mcp dev server.py. Use the MCP Inspector interface to inspect the server, calladdwith valid and invalid inputs, and read a greeting resource.
The function annotations and docstrings make the example legible and provide the basic shape of the tool. In a real server, validate data against your application’s rules, handle expected failures, and avoid exposing operations the host does not need.
Connect a client to an MCP server
An SDK client uses a transport to reach a server. For a remote server, the TypeScript SDK documents StreamableHTTPClientTransport with the MCP endpoint URL; for a local process, use a stdio client transport to launch or communicate with that process. The exact client setup depends on the SDK and its version, so use the versioned SDK documentation that matches the server.
After connecting, the basic client workflow is:
- List the server’s tools, resources, or prompts.
- Choose the capability relevant to the user’s request.
- Call the tool with an arguments object, read the resource URI, or retrieve a prompt with its arguments.
- Check the returned result and handle errors before passing content onward.
SDK list helpers can aggregate paginated results. A tool failure may be returned as a result object rather than a thrown exception; inspect its isError field before relying on the content. If a tool advertises structured output, validate or narrow that output before consuming it.
Select a transport and deployment shape
| Setup | Use it when | Practical consideration |
|---|---|---|
| stdio | A host launches and controls a local server process | Check that the host and SDK support the expected launch configuration. |
| Streamable HTTP | A server is reached over a remote HTTP endpoint | Check endpoint authentication, host compatibility, and the protocol revision implemented. |
| SSE | An existing setup depends on the older HTTP+SSE transport | The July 28, 2026 MCP release describes legacy HTTP+SSE as deprecated with a year-long transition window; do not choose it for a new implementation without checking SDK compatibility guidance. |
The official MCP release dated July 28, 2026 describes a protocol revision that changes assumptions found in older setup guides. It removes the initialize/initialized exchange and Mcp-Session-Id, makes requests self-describing, and adds optional server/discover capability discovery. For Streamable HTTP, the revision requires Mcp-Method and Mcp-Name headers so gateways and rate limiters can route or meter requests without parsing the JSON body. Lists and resource reads carry cache hints, ttlMs and cacheScope.
Do not mix protocol assumptions from a legacy setup page with a server or SDK targeting a newer revision. Confirm the protocol version and compatibility of the exact host, server, and SDK you deploy. The TypeScript SDK v2 documentation describes its stable release line as implementing the 2026-07-28 specification; other SDKs and hosts may support different revisions.
Test the integration before relying on it
- Start the server using the selected transport and verify it stays available.
- Inspect advertised capabilities with the MCP Inspector or your client’s list methods.
- Exercise representative calls: include normal inputs, boundary values, malformed inputs, and expected service errors.
- Check results: distinguish tool errors from successful content and validate structured output if present.
- Test in the intended host: host configuration and protocol support can differ from what a development Inspector accepts.
The Python SDK’s documented development command opens MCP Inspector for interactive testing. It does not establish that every custom host integration will work unchanged; validate the actual combination you plan to deploy.
Security and reliability essentials
- Keep tools narrow: expose only the actions needed for the use case, and make side effects clear to the host and user.
- Enforce authorization at the server: tool names and input schemas do not restrict access by themselves.
- Validate arguments and handle errors: reject invalid input, check service responses, and return errors that callers can interpret safely.
- Treat returned content according to its source: data from external systems may be untrusted, even if it arrives through a valid MCP response.
- Review OAuth behavior for the deployed revision: under the latest release, clients must validate the authorization response’s
issparameter before redeeming a code; credentials are bound to the issuer that minted them. - Understand client registration choices: the release formally deprecates Dynamic Client Registration in favor of Client ID Metadata Documents while retaining DCR for backward compatibility.
Those OAuth changes are protocol details, not substitutes for reviewing what each tool can do or limiting its permissions.
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #4
Choose an SDK and protocol revision deliberately
The July 2026 release announcement names the official TypeScript, Python, Go, and C# SDKs as supporting that release. Rust support is described there as beta. Confirm package versions and host support before selecting an implementation, because SDK documentation and the protocol evolve.
The same release changes how some interactions work. Mid-call input uses multi-round-trip requests: a server can return input_required, and the client retries with responses attached. Long-running Tasks are now an extension with polling methods, rather than the earlier experimental core feature. These capabilities require matching client and server support.
Common MCP setup problems and fixes
- The host cannot find the server: check the local process command and working directory for stdio, or the endpoint URL and network access for remote HTTP. Verify the host supports the chosen transport.
- A tool call is rejected: compare the arguments object with the server’s input schema and test the same call in the Inspector. Validate required fields and types on the server as well.
- The call returns content but did not succeed: inspect the result’s
isErrorindicator and the server’s error details; do not treat any returned text as proof of success. - An older integration fails against a newer server: compare protocol revisions. In particular, avoid assuming an initialize handshake or session ID is required when targeting the July 28, 2026 revision.
- A remote call cannot authenticate: check the deployed authorization flow and issuer handling. For OAuth under the latest release, validate
issbefore code redemption and bind credentials to the issuing server. - Behavior differs between Inspector and the target AI host: test in the actual host and verify its SDK, transport, and protocol compatibility; the Inspector is a development aid, not a universal compatibility guarantee.
Or skip the browser setup
If an agent needs webpage screenshots, ScreenshotNeo provides an MCP server for Claude, Cursor, and other MCP clients, with take_screenshot, get_page_info, and capture_pdf. It is also a screenshot API: one GET request returns PNG, JPEG, WebP, or PDF output. Its pre-capture cleanup accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each cleanup step can be turned off. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers identify the page verdict and billing status.
For a direct API call, first create an access key, then run this cURL command. See the ScreenshotNeo API documentation for the request options and response details.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchcurl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpThe same request in Python:
import requests
r = requests.get(
"https://api.screenshotneo.com/v1/shot",
params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
timeout=90,
)
open("shot.webp", "wb").write(r.content)Or in Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);The API accepts familiar parameter names used by other screenshot APIs to ease switching. Available options include full-page capture with lazy images loaded, CSS-selector element capture, dark mode, 12 device presets or a custom viewport, retina scale, PDF paper size/margins/landscape/page ranges, HTML or CSS input, custom CSS and JavaScript, click-before-capture, hidden selectors, waits for a selector/delay/network idle, request and resource blocking, headers, cookies, user agent and Authorization, timezone, geolocation, transparent backgrounds, image resizing, configurable cache TTL, signed links for public image tags, async jobs with signed webhooks, bulk capture of 100 URLs per call, a usage API, and an OpenAPI specification.
Best Value
Free includes 1,000 shots per month with no card. Paid monthly plans are Starter at $5 for 3,000, Growth at $15 for 15,000, Pro at $39 for 60,000, Scale at $99 for 250,000, and Business at $249 for 1,000,000; yearly billing gives two months free. Every feature is on every plan. Learn about ScreenshotNeo, or sign up free for 1,000 screenshots a month with no card.
Frequently Asked Questions
Does an MCP server contain the AI model?
No. The AI host supplies the model; the MCP server exposes capabilities to the host through a client connection.
Can an MCP server expose only read-only information?
Yes. You can expose read-only tools or resources and omit operations that change data. Authorization and validation still belong in the server.
Which language should I use to build an MCP server?
Choose an SDK supported by your host and target protocol revision. The July 2026 release announcement names TypeScript, Python, Go, and C# SDK support, with Rust described as beta.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
