Free tools Windows power users keep installed
One-click scans. No signup required.
Short answer: an MCP client connects to an MCP server and sends protocol requests. The server advertises capabilities—tools, resources and prompts—and handles those requests. An AI host such as an editor or assistant usually contains the client; it is not automatically the same thing as the client.
The distinction becomes clear when you follow one request: a host’s client discovers a server’s lookup-order tool, calls it with an order ID, and receives the result. The same client can read an orders://recent resource or retrieve a prompt from that server.
What is the difference between an MCP client and an MCP server?
| Aspect | MCP client | MCP server |
|---|---|---|
| Primary role | Connects to a server and sends protocol requests | Advertises capabilities and implements request handlers |
| Typical operations | List tools, resources and prompts; call a tool; read a resource; get a prompt | Register or expose tools, resources and prompts; return results |
| Example | Calls lookup-order with {"id":"A-1041"} |
Runs lookup-order and returns the order result |
| Where it runs | Usually inside an AI host application | A local process or remote service that provides data or actions |
Think of the client as the connector and requester, and the server as the capability provider. This analogy is only a shortcut: the server is not necessarily the AI model, and the client is not the entire host application.
The MCP server specification and the TypeScript SDK v2 documentation describe the server side as exposing tools, resources and prompts. The client side discovers and invokes them.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Where does the MCP host fit?
An MCP host is the application context—an AI assistant, IDE or other program in which one or more client connections operate. The host owns the user experience and model interaction; an MCP client is the protocol connection used by that host.
Keeping the terms separate prevents a common diagramming error:
- The user interacts with the host.
- The host’s MCP client opens a connection to a server.
- The client negotiates capabilities and sends requests.
- The server executes its handlers and returns structured results.
- The host presents the result to the user or model.
MCP Apps adds another layer: the host can maintain a protocol connection to the server, fetch a UI resource, and communicate separately with an embedded view. The view does not replace the client or server roles; it is an additional presentation surface, as shown in the MCP Apps architecture overview.
What can an MCP server provide?
Tools: executable actions
Tools are functions that a model can use through the client. A server might expose lookup-order, order-total and export-orders. The server validates the input, performs the operation and returns the result.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsResources: contextual data
Resources are data identified by a URI. In the orders example, orders://recent is a resource that the client can read after discovering it. Resources are managed as contextual information rather than as executable functions.
Prompts: user-controlled templates
Prompts are reusable templates that the user or application can retrieve. They help standardize how a task is presented without turning the prompt itself into a server-side action.
A server may expose any combination of these capability types. A client should discover what is actually available instead of assuming that every server implements all three.
Step-by-step orders example
The official SDK calling example uses an illustrative order service. These names and results are documentation examples, not a live order system or an independent test.
- Connect. The host starts its client connection using the transport configured for that server.
- Discover tools. The client lists available tools and sees
lookup-order,order-totalandexport-orders. - Call a tool. It sends
lookup-orderwith{"id":"A-1041"}. - Handle the request. The server runs the registered handler and returns
A-1041: 3 items, shipped. - Read a resource. The client lists resources, then reads
orders://recent; the illustrative contents areA-1041andA-1042. - Retrieve a prompt. If the server publishes a prompt, the client requests it and supplies the returned template to the host or model.
Wire-level shape
Regardless of language, the conversation has the same direction:
Client → Server: list tools
Server → Client: lookup-order, order-total, export-orders
Client → Server: call lookup-order {"id":"A-1041"}
Server → Client: "A-1041: 3 items, shipped"
Client → Server: read resource "orders://recent"
Server → Client: "A-1041nA-1042"The important point is ownership: the client initiates these requests, while the server supplies the capability descriptions and results.
Implementing the example with the TypeScript SDK
The official TypeScript SDK documentation currently identifies v2 as the stable line implementing the 2026-07-28 specification. Its server package is @modelcontextprotocol/server; use the v2 documentation and package names together rather than copying imports from v1.
The following sketch mirrors the SDK guide’s operations. Keep the exact import paths and registration signatures aligned with the version you install by checking the v2 overview and the server package reference.
Server responsibilities
// TypeScript structure (SDK v2)
// 1. Create an MCP server instance.
// 2. Register a lookup-order tool that accepts an order id.
// 3. Register the orders://recent resource.
// 4. Register an optional prompt.
// 5. Attach a transport and start serving requests.
const lookupOrder = ({ id }: { id: string }) => {
if (id === "A-1041") return "A-1041: 3 items, shipped";
return "Order not found";
};
// Register lookupOrder as the server's `lookup-order` tool.
// Register a resource handler that returns:
// A-1041
// A-1042
// Then start the configured stdio or Streamable HTTP transport.This shows what the server must implement: registration, input handling and a response. The server does not decide when the host calls the tool; it waits for the client request.
Client responsibilities
// TypeScript structure (SDK v2 client flow)
// Connect the client to the chosen transport, then:
const tools = await client.listTools();
const result = await client.callTool({
name: "lookup-order",
arguments: { id: "A-1041" }
});
const resources = await client.listResources();
const recent = await client.readResource({ uri: "orders://recent" });
const prompt = await client.getPrompt({ name: "order-summary" });The method names above reflect the operations shown in the SDK calling example. A production program must also handle connection setup, errors and the actual result types defined by the SDK version you install. Do not combine v1 imports with v2 package instructions: v1 uses the older monolithic @modelcontextprotocol/sdk package and has separate examples documented at the v1 overview.
Rank #3
Transport: how they connect, not who they are
Transport changes the connection mechanism, not the protocol roles.
stdio for local integrations
With stdio, a host starts or connects to a local process and exchanges MCP messages through standard input and output. This is suitable when the server runs on the same machine as the host.
Streamable HTTP for remote servers
Streamable HTTP is the documented option for a remote server. The client sends requests over HTTP while the server returns protocol responses through that transport.
HTTP plus SSE for backward compatibility
The v1 overview lists HTTP plus server-sent events (SSE) as a backward-compatibility option. Choose it because a deployment requires it, not because HTTP changes a server into a client.
For transport-specific setup, follow the matching SDK documentation: client operations and calling for v2, or the v1 overview for legacy examples.
Common mistakes and fixes
Calling the host a server
Symptom: a diagram labels the IDE or assistant as “the MCP server.”
Fix: label the application host, its client connection, and the server process separately. The host may contain the client while the server provides capabilities.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Assuming every server has tools, resources and prompts
Symptom: the client tries to read a resource or fetch a prompt that was never advertised.
Fix: discover each capability type first and branch on what the server reports.
Using the wrong SDK generation
Symptom: imports or package names do not match the example you copied.
Fix: pin the SDK line in your project. v2 documentation uses the stable 2026-07-28 specification line and the @modelcontextprotocol/server package; v1 documentation uses the monolithic @modelcontextprotocol/sdk package.
Blaming the transport for a role problem
Symptom: switching from stdio to HTTP is expected to make a client provide tools.
Fix: keep role and transport as separate decisions. A client still requests and a server still exposes capabilities over either transport.
Ignoring illustrative data boundaries
Symptom: the order IDs in the guide are treated as production records.
Fix: replace the handlers and data with your own service; A-1041, A-1042 and the returned text are illustrative documentation values.
Recommended Free Tools
Using an MCP screenshot server without writing browser glue
If your host needs screenshots, ScreenshotNeo provides an MCP server with take_screenshot, get_page_info and capture_pdf tools for Claude, Cursor and other MCP clients. It also exposes a direct HTTP API, so you can choose a normal client call when an MCP connection is unnecessary.
Or skip the browser setup
One GET request returns a PNG, JPEG or WebP (or a PDF):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for parameters. Equivalent 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)And 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}`);Before capture, ScreenshotNeo can accept cookie or consent banners and remove more than 60 known consent platforms, newsletter popups and chat widgets; each step can be disabled. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and each response identifies the page verdict and billing status with X-Page-Verdict and X-Billed headers. The MCP server lets an AI agent take screenshots directly. A free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
ScreenshotNeo options and plans
The API supports 63 options, including full-page capture with lazy images loaded, CSS-selector element capture, dark mode, 12 device presets plus custom viewports, retina scale, PDF paper size/margins/orientation/page ranges, HTML/CSS rendering, custom JavaScript and CSS, pre-capture clicks, hidden selectors, selector or network-idle waits, ad/tracker/request/resource blocking, custom headers, cookies, user agents and Authorization, timezone and geolocation, transparent backgrounds, resizing, selectable cache TTLs, signed links, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, a usage API and an OpenAPI specification. Parameter names used by other screenshot APIs also work, which can simplify migration.
Best Value
| Plan | Allowance | Price |
|---|---|---|
| Free | 1,000 shots/month | $0, no card |
| Starter | 3,000 shots | $5 |
| Growth | 15,000 shots | $15 |
| Pro | 60,000 shots | $39 |
| Scale | 250,000 shots | $99 |
| Business | 1,000,000 shots | $249 |
Every feature is included on every plan, and yearly billing gives two months free. Details and current parameter names are at ScreenshotNeo.
How to choose the right side to implement
- Build a server when you own the data or action that should become a reusable MCP capability.
- Build or configure a client when your application must connect to existing servers and present their capabilities to a user or model.
- Build a host when you are creating the complete AI application that manages users, models, UI and one or more client connections.
- Select stdio for a local process, Streamable HTTP for a remote deployment, or the documented HTTP-plus-SSE compatibility path when required by an existing integration.
When debugging, first identify which component sent the request, which component advertised the capability and which transport carried the message. That three-part check resolves most “client versus server” confusion before you inspect application code.
Frequently Asked Questions
Can a single host connect to more than one MCP server?
Yes. A host can use client connections to discover capabilities from multiple servers; keep each connection’s advertised tools, resources and prompts associated with the server that provides them.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows 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 reinstallDoes using HTTP make an MCP component a server?
No. HTTP, Streamable HTTP, stdio and the backward-compatible HTTP-plus-SSE path describe transport. The client remains the requester and the server remains the capability provider.
Which SDK documentation should a new TypeScript project follow?
Use the v2 documentation and its matching packages. The v2 line is documented as stable for the 2026-07-28 specification; v1 examples use the older monolithic package and should not be mixed with v2 instructions.
The Bottom Line
An MCP client connects and requests; an MCP server advertises and fulfills. The host contains the client, while tools, resources and prompts belong to the server’s capability surface. Transport determines how they communicate, not which role each component has.
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.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →
