An MCP server is an infrastructure, not a brain.

People often assume the server in MCP is smart. It is not. It gives an AI app a safe way to reach tools and data, and that is all it does. Let's see who does what.

Picture this: A college builds one tool, get_student_marks(student_id), on top of its records database. Someone asks the AI app, "What are John Doe's DBMS marks?" and gets the right answer from a live record.

What a server is, exactly

An MCP server is a program. It lists the tools, data and prompt templates it offers, using a standard set of rules, so that an AI app can find them and use them. It does not read the user's question, work out what they meant, or write the answer they finally see. It just takes structured requests and gives back structured results. You can write one in Python, TypeScript, Go or any language you would pick for a normal backend service, because that is mostly what it is.

So, did the server understand the question about John Doe? It looks that way, but no. By the time the request reached the server, the sentence was gone. The server only saw a neat instruction: get_student_marks("john_doe_01"), already resolved before the request left the model. It ran a database query and sent back a row. It never read English.

✕ ASSUMED✓ ACTUALLY
"The server figured out what I meant."
tap to check
The model worked it out before the request ever reached the server. What arrived was already a clean call, just a function name and its inputs, with no sentence left in it.
✕ ASSUMED✓ ACTUALLY
"It must run some kind of AI model inside."
tap to check
Most servers have no model at all. A typical one is a thin layer: take a call, run a query or an API request, and return the result.
A server offers capabilities. It supplies no thinking.

A quick picture: the restaurant

A restaurant is the easiest way to get started. Switch between the two views.

Customerasks for food
→
Waitercarries the order
→
Kitchencooks it

The customer says what they want in plain words. The waiter doesn't cook. He passes the order on and brings back whatever the kitchen makes.

This is a scaffold, not a specification, and it's worth retiring quickly. It compresses two separately specified roles — the model that reasons, and the client that manages the connection — into a single "waiter." The actual architecture keeps them apart, and the next section is where they come apart.

Five parts, five different jobs

In everyday talk we just say "the AI" and "the server". In reality, five separate parts are involved, and most of the confusion about MCP comes from mixing them up. Tap each one to see what it does, and what it doesn't.

The model — Claude, GPT, or any other LLM — is the component responsible for understanding what the user is asking, reasoning about which capabilities might help, and generating the final response. This is the only place in the whole chain where anything resembling "thinking" happens.

Critically, the model does not automatically gain access to your database, your file system, or your internal APIs just because MCP exists somewhere in the stack. Access has to be explicitly wired up through a client and a server. MCP makes that wiring standardized — it doesn't make it automatic or implicit.

Not responsible for: knowing how your database, API, or filesystem is actually implemented underneath.

The application the model runs inside — Claude Desktop, an IDE, a custom agent. It's related to the model but is not the model itself: it provides the surrounding runtime, manages conversation and application state, and holds the MCP client connections the model relies on.

Not responsible for: reasoning about the request — that's the model's job, even though it happens inside the host.

The MCP client is the connector. It lives inside the host application and maintains the link to a specific MCP server: sending requests, receiving results, and handling protocol-level details like capability negotiation. If a host wants to talk to three different servers — say, a filesystem server, a Git server, and your internal student-database server — it typically maintains three separate client connections, one per server.

Not responsible for: deciding why a tool should be called. It's the plumbing that carries the call and its result back and forth.

The MCP server is the component most people misunderstand, so it's worth stating plainly: an MCP server is not inherently an AI model. It's an application or service that exposes capabilities — tools, data resources, prompt templates — through the MCP protocol. Underneath, it can be a thin wrapper around a SQL query, a REST API call, a filesystem read, or a call to some internal microservice.

Concretely, an MCP server is a program that:

  • Advertises a set of capabilities (tools, resources, prompts) in a format the MCP spec defines
  • Listens for requests from an MCP client, usually over stdio or an HTTP-based transport
  • Executes whatever logic backs each capability — a query, an API call, a file read
  • Returns structured results back to the client
Not responsible for: interpreting natural language or deciding what a user wants. Both stay upstream, with the model.

This is whatever sits behind the server: a database, a REST API, a file system, a GitHub account. It stores the data or carries out the actual operation, and sends the result back up the chain to the server.

It has no idea an AI is involved. To the database, the server is just another program asking for rows.

Doesn't know: about MCP, the model, or the question the user asked.
QUICK CHECK
Who decides what to do?
Who runs the app the model lives in?
Who manages the connection to a server?
Who offers the tool being called?
Who stores the data or does the real work?
An MCP server doesn't become the AI. It becomes a standardized gateway through which the AI application can reach capabilities outside the model itself.

Try it yourself

Pick a student and a subject. You'll see what the model sends to the server, and what comes back. Notice there is no sentence in the middle.

Mini marks server

1. What the server receives:

(waiting)

2. What the server returns:

(waiting)

3. The model then turns it into a sentence:

(waiting)

Watch a single call happen

Back to our example: one tool, get_student_marks(student_id), on top of a small database of students, marks and courses.

"What are John Doe's DBMS marks?"
Tracing: get_student_marks("john_doe_01")
Step 1 / 10
USER

Only one part here ever touches the database, and only one part ever works with human language. They are never the same part.

AI MODEL↓understands
and reasons
MCP CLIENT↓connects
MCP SERVER↓offers
capabilities
EXTERNAL SYSTEM↓stores and
carries out the work
Putting a smart model behind a server doesn't make the server smart. Each part stays what it was built to be.

Three kinds of things a server can expose

A server's surface area breaks down into three primitives. None of them require the server to understand anything — they just have to be described well enough for the model to use them correctly.

"DO SOMETHING."

Tools

query_database()
create_ticket()
send_email()
get_student_marks()

Callable capabilities with defined inputs and outputs. The model decides to invoke one; the server runs the underlying logic and can have real side effects.

"GIVE ME SOMETHING."

Resources

student_records.csv
config.yaml
docs/architecture.md

Contextual data sources the host can pull in — closer to a GET than an action. Application-controlled: the host decides what to load, and when.

"USE THIS TEMPLATE."

Prompts

summarize_grades
weekly_report
onboarding_flow

Reusable, structured prompt templates the server hands to the host. They shape how a request gets phrased — they don't make the server that stores them any smarter.

What a server does not do

A server can still have normal program logic, like checks, business rules and retries. What it can't have is the reasoning of a language model.

Is a server just an API?

Not quite, though the comparison is worth making — both define a contract, both usually run over a network, both separate what a system can do from who's calling it.

Application
↓ HTTP / REST
Backend

A fixed, application-specific contract. Every consumer has to know the endpoints in advance — there's no standard way for a new kind of client to discover what's callable.

Normal APIMCP
PurposeOffer what one app can doGive AI apps one standard way to reach tools and data
InterfaceDifferent for every serviceSame shape on every server
Finding toolsRead the docsAsk the server directly
Who can use itClients built for itAny MCP-ready client

In real life, plenty of MCP servers are simple wrappers around REST APIs that already existed.

And how is this different from function calling?

Function calling is how a model asks for one function to be run. MCP is the common set of rules around it, so an app can find, connect to and use tools from any server without custom code each time.

One model, several systems

This is where standardization starts to pay for itself: one host, several servers, each specialized.

AI HOST
one MCP client per connection
MCP Server
Database
→ Postgres
MCP Server
GitHub
→ Git / REST API
MCP Server
Files
→ Filesystem

Each server exposes only what's relevant to its own domain — the database server has no idea GitHub exists, and shouldn't need to. The model sees one merged catalog of tools and picks whichever ones a given request calls for. Without a shared protocol, this is N bespoke integrations. With it, it's N servers implementing the same contract.

Common misconceptions, once more

Answer yes or no for each.

0 / 6 answered

The whole thing in one stack

AI MODELthinks and reasons
↓
MCP CLIENTconnects
↓
MCP SERVERoffers the abilities
↓
EXTERNAL SYSTEMdatabase, API or files: stores and does the work

The model thinks. The client connects. The server offers abilities. The external system (database, API or files) does the actual work.

THE VERDICT

So, is a server an AI?

NO.

The model thinks, the client connects, the server offers tools, and the external system does the work. The server never reads your question or decides anything, and that clear split is what makes MCP easy to build, fix and plan around.

MCP connects intelligence to capability.Nothing more. Nothing less.