Short answer. An MCP server is a bridge between an AI assistant (Claude, Cursor, Zed) and external tools or data. It implements the Model Context Protocol — an open standard that lets a model call functions, read resources, and get results in real time. Instead of hallucinating an answer, the assistant queries the server, runs a real check, and returns trustworthy data.
The problem MCP solves
A large language model is isolated on its own: it only knows what was in its training data and cannot perform a single action in the outside world. Ask Claude "what SSL certificate does example.com use," and without tools it will either refuse or invent an answer. The Model Context Protocol, introduced by Anthropic in late 2024, standardizes how an assistant connects to data sources and executable functions.
MCP is often called "USB-C for AI tools": one protocol instead of a dozen incompatible integrations, one per assistant.
Before MCP, every "model ↔ tool" pairing needed its own custom code. Now any MCP-compatible client works with any MCP server — decoupling tool development from assistant development.
How MCP works: three key concepts
- Tools — functions the model can call: "check SSL," "run a DNS query," "scan security headers." Each tool is described by an input schema.
- Resources — data the server returns on request: files, database records, documents.
- Prompts — prepared templates the server offers the client for common scenarios.
Transport varies: local over stdio (the server runs as a process on your machine) and remote over streamable HTTP (the server lives in the cloud, reachable by URL). The second option is more convenient — nothing to install locally.
Minimal client setup
To connect a remote MCP server to Claude Desktop or Cursor, you add it to the client config. The enterno.io diagnostic server also needs an API key: it's free on any plan and issued after you sign up, in the Integrations section. In Cursor the server connects by URL and the key goes in a header — this block goes into your project's mcp.json and reads the key from the ENTERNO_API_KEY environment variable:
{
"mcpServers": {
"enterno": {
"url": "https://enterno.io/mcp",
"headers": { "Authorization": "Bearer ${env:ENTERNO_API_KEY}" }
}
}
}Claude Desktop connects a remote server with a key through the mcp-remote bridge (requires Node.js). This block goes into claude_desktop_config.json; replace ent_your_key with your key:
{
"mcpServers": {
"enterno": {
"command": "npx",
"args": ["-y", "mcp-remote@0.15.1", "https://enterno.io/mcp", "--header", "Authorization:${ENTERNO_AUTH}"],
"env": { "ENTERNO_AUTH": "Bearer ent_your_key" }
}
}
}After restarting the client, the server's tools become available to the assistant. Ready-made configs for other clients are in the examples repository.
What changes in practice
Once connected, you write a normal natural-language request, and the assistant decides which tool to call:
Check the SSL chain and DNS records for example.com,
and tell me if there are any security header issues.This prompt makes the assistant call the SSL tool, the DNS tool, and the header scanner in sequence, then merge the results into one analysis — no copy-pasting between separate utilities.
MCP server vs. REST API
It may look like MCP duplicates an ordinary REST API. The difference is the audience and the description format.
| Criterion | REST API | MCP server |
|---|---|---|
| Audience | Code (a developer writes the integration) | AI assistant (it calls on its own) |
| Description | OpenAPI / docs | Self-describing tool schema |
| Auth | API key required | Depends on the server; enterno.io uses a free API key |
| Call style | Manual HTTP request | Natural language → auto-call |
Rule: use a REST API when you write the code yourself; use an MCP server when you want an AI agent to act for you, picking tools on the fly.
Example: the enterno.io diagnostic MCP server
enterno.io exposes an MCP server at https://enterno.io/mcp (streamable HTTP) that surfaces 49 site-diagnostic tools: HTTP header checks, DNS, SSL/TLS, ping, IP geolocation, WHOIS, SEO audit, a security scanner, and an AI-readiness score. The server is free on any plan, but every tool call needs an API key — you get one free after you sign up, in the Integrations section. For programmatic access, call the server directly over JSON-RPC 2.0 (POST https://enterno.io/mcp, methods tools/list and tools/call) or use the REST API v4.
This turns Claude or Cursor into a full network-diagnostics console: you never leave the chat, and the assistant runs the real checks. For more on giving assistants tools, see our piece on API security best practices.
FAQ
Is MCP only for Claude?
No. MCP is an open standard. It's supported by Claude Desktop, Cursor, Zed, and a growing list of other clients. One server works with all of them at once.
Do I need to install anything locally?
For a remote server over streamable HTTP — usually not. Just add the URL and API key to your client config. The exception is Claude Desktop: it connects a remote server with a key through the mcp-remote bridge, which runs via npx and requires Node.js. Local stdio servers run as a process on your machine.
Is it safe to give an AI access to tools?
Tools only do what their schema describes. The enterno.io diagnostic tools make outbound checks against third-party sites and have no access to your data. Always review which actions a server exposes before connecting.
How is MCP different from plugins?
Plugins are usually tied to one platform. MCP is a cross-platform protocol: the same server serves any compatible client with no rewriting.
Can I check whether my site is ready for AI agents?
Yes — there's a dedicated AI-readiness check that analyzes how accessible your content is to crawlers and assistants.
