Free tools Windows power users keep installed
One-click scans. No signup required.
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
MCP is the protocol; an MCP server is a program or service that implements it. The protocol defines how an AI application connects to external capabilities. A server makes particular tools, data, or reusable prompts available through that connection. They are related, but they are not interchangeable terms.
What MCP means
MCP stands for Model Context Protocol. The Model Context Protocol documentation defines it as “an open-source standard for connecting AI applications to external systems.” Those systems can include data sources, such as local files or databases; tools, such as search or calculation functions; and workflows supported by reusable prompts.
Think of MCP briefly as a standardized connector, like USB-C: the standard describes how compatible components communicate, not what a particular connected device does. More concretely, MCP specifies shared communication rules. It is not itself an AI model, an agent, a database, or a server.
Recommended Free Tools
What an MCP server is
An MCP server is the provider side of an MCP connection. It implements the protocol and exposes capabilities that an MCP client can discover and use. A server might connect to a database, a file system, or another service; the capabilities and the underlying system depend on that implementation.
#1 Best Overall
“Server” describes a logical role, not necessarily a separate physical machine. Depending on the implementation and transport, a server can run locally or be reached remotely. The defining distinction is that it provides MCP capabilities to a client.
Host, client, and server: who does what?
Keep the roles separate when planning an integration:
AI host/application → MCP client → MCP server → external system or capability
Rank #2
- Host: The AI application in which the user works. It manages the broader experience and establishes connections to servers through MCP clients.
- Client: The component in the host that communicates with an MCP server using the protocol. It can discover available capabilities and relay requests and results.
- Server: The implementation that describes and provides capabilities to the client, often by interacting with an external system.
A host may connect to one or more servers through MCP clients. Saying that a product “uses MCP” does not, by itself, tell you whether that product is acting as a host, a client, a server, or more than one of those roles.
What servers can expose: tools, resources, and prompts
An MCP server can expose different kinds of capability. They serve different purposes; not everything a server provides is a tool call.
| Capability | What it is for | Database-server example |
|---|---|---|
| Tools | Operations a model can call through the client, using structured inputs. | A tool that accepts a query and runs it against the database. |
| Resources | Content or data that a client can read. | A resource containing the database schema. |
| Prompts | Reusable templates that can guide an interaction. | A prompt with examples for working with the database tools. |
OpenAI’s developer documentation describes a tool as having a name, description, and input schema, with an output schema where applicable. That structure helps a client and model understand the intended inputs and result. A tool’s description and schema explain its interface; they do not, on their own, guarantee that the operation is safe or appropriate.
For a concrete example of the distinction, ScreenshotNeo is a website screenshot API and MCP server. Its MCP tools include take_screenshot, get_page_info, and capture_pdf. The protocol is MCP; ScreenshotNeo is an implementation offering particular capabilities through that protocol. Learn more at ScreenshotNeo.
How a typical MCP tool call works
- Discover: The client discovers the tools provided by the server, including their descriptions and input schemas.
- Select and construct inputs: The model chooses a tool when it is relevant and supplies arguments shaped to match that tool’s input schema.
- Validate and execute: The server validates the request and performs the operation it implements.
- Return the result: The client makes the result available to the model, which can use it to continue the conversation.
This flow does not make an MCP server an autonomous agent. The server provides capabilities; it is the client/model interaction that determines whether a tool is selected. Nor does a tool being available mean it will be called on every turn.
What changed in the 2026-07-28 specification
The current specification reviewed here is dated 2026-07-28. Its basic protocol describes MCP as stateless: each request carries the information needed to process that request. A server must not infer application context simply from earlier requests over the same connection. In particular, an open connection—such as a running stdio process—is not automatically a conversation or application session.
If an application needs state to persist across requests, that state must be referenced explicitly, for example through an identifier supplied by the client. This matters when designing a server: connection lifetime alone should not be treated as a substitute for application-level context.
The July 28, 2026 release announcement describes additional revision-specific changes: a stateless protocol core, Multi Round-Trip Requests, header-based routing, cacheable list results, authorization hardening, a formal extensions framework, and updated Tier 1 SDKs. It also says the previous initialize/initialized exchange and MCP session-ID header were retired in this revision, and describes optional server/discover capability discovery.
These are version-specific details, not a safe assumption about every existing client or server. When building or integrating, verify the exact specification revision and SDK supported by each side. A feature or migration step described for the 2026-07-28 revision may not match an implementation targeting another version.
Best Value
Choosing how to deploy and connect a server
Decide where the server should run and how the client will reach it based on the application, data, and supported protocol versions. The protocol documentation distinguishes HTTP-based authorization from credential handling for stdio. OpenAI’s developer guidance recommends a stable HTTPS endpoint and Streamable HTTP for production server deployment; that is a recommendation in that guidance, not a universal rule that every MCP server must use one transport.
- Local use: Consider whether the client and server are intended to run together and whether the chosen implementation supports the required local transport and credential handling.
- Remote production use: Consider endpoint stability, network access, supported transport, and whether the deployed server and clients agree on the specification revision.
- Private data or user actions: OpenAI’s guidance says servers that access private data or perform user actions should be protected by the authorization flow defined by the MCP specification.
For HTTP-based transports, the current specification provides an authorization framework. For stdio implementations, it says credentials should be retrieved from the environment instead. Choose credential handling that matches the transport and implementation rather than assuming that one mechanism applies everywhere.
Developer checklist before building or integrating
- Identify the role: Is your component the host, the client inside a host, the server, or an external system behind the server?
- List the capabilities: Decide which operations belong as tools, which information should be exposed as resources, and whether reusable prompts add value.
- Check the schemas: Ensure tool names, descriptions, and input schemas make the intended operation and required arguments clear. Define an output schema where useful and supported.
- Check version compatibility: Confirm the protocol revision and SDK support on the host/client and server. Pay particular attention to implementations that may not include the 2026-07-28 changes.
- Choose transport and deployment deliberately: Account for local versus remote use, endpoint stability, client support, and the credential model.
- Make state explicit: Under the 2026-07-28 specification, do not rely on previous requests or an open connection to supply context. Pass an explicit reference for state that must carry across requests.
- Protect sensitive capabilities: If the server accesses private data or takes user-directed actions, use the applicable authorization approach and assess the operation before exposing it.
Common misconceptions
- “MCP is the server.” No. MCP is the shared protocol; a server implements it and offers capabilities.
- “The server is the AI model.” No. A server may provide operations or data to an AI application, but the server and model have different roles.
- “Every capability is a tool.” No. Servers can also expose readable resources and reusable prompts.
- “A connection is a session.” Not under the stateless 2026-07-28 specification. Requests carry their own relevant information, and state that persists must be referenced explicitly.
- “A tool will always run when it is available.” No. Availability is not the same as selection; a tool call depends on the client/model interaction.
Or skip the browser setup
If your MCP integration needs website screenshots, ScreenshotNeo offers an MCP server with take_screenshot, get_page_info, and capture_pdf. It also offers a one-request screenshot API; see the ScreenshotNeo documentation for API details. For example, with cURL:
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.webpBefore capture, it accepts cookie or consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each of those steps can be turned off. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, and each response reports the page verdict and billing status in headers. AI agents can use its MCP server, and the free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots.
Sign up for ScreenshotNeo’s free plan to try it without a card.
Frequently Asked Questions
Does an MCP server have to run on a different machine from the AI application?
No. “Server” identifies its role in the MCP connection; the physical deployment depends on the implementation and transport.
Is MCP tied to one AI model or application?
MCP is a standard for connecting AI applications to external systems. A particular client, host, and server still need compatible implementations.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
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.
