# What Is an MCP Server and What Is It For in a Store?

> What an MCP server is, what it offers an AI assistant, how a local one differs from a remote one and which MCP servers an online store can have.

URL: https://clione.ai/glossary/mcp-server/
Lang: en

An [MCP (Model Context Protocol)](/glossary/mcp/) server is not a machine or a hosting plan: it is a role within the protocol. It is **the program that offers capabilities to an AI assistant**, wherever it runs: on your computer or in a vendor's cloud.[^mcp-architecture] If a platform announces that "your store now has an MCP server", or a vendor offers to "connect your catalog to Claude or ChatGPT", this is what they mean. A store should care because it is **the door through which an [AI agent](/glossary/ai-agent/) queries its catalog or prepares a cart without opening the site**, and because whoever controls that door decides what the agent can do inside.

## How it works

The protocol's documentation defines servers as programs that expose specific capabilities to AI applications through standardized interfaces, and gives everyday examples: file, database, GitHub, Slack or calendar servers.[^mcp-server-concepts] A server offers three kinds of piece, and each is controlled by someone different:[^mcp-server-concepts]

- **Tools**, controlled by the model: functions it decides to call based on what the user asks, such as searching products or creating a cart.
- **Resources**, controlled by the application: read-only data that serves as context, such as a document or a database schema.
- **Prompt templates** (_prompts_), chosen by the user: ready-made flows for a task.

On the other side is the AI application (the _host_), which creates one client for each server it connects to and keeps a dedicated connection with it.[^mcp-architecture] Tools are what an integration uses most: each has a name, a description and a JSON schema with its parameters. The client asks for the list with `tools/list` and calls one with `tools/call`.[^mcp-tools] And the server's responsibility is written into the specification: **it must validate all inputs, control access, rate-limit calls and sanitize what it returns**.[^mcp-tools]

### Local or remote

A server is called **local** when the application launches it on the same machine and they communicate over standard input and output (_stdio_); it usually serves a single client. It is called **remote** when it lives somewhere else and is reached over HTTP (_Streamable HTTP_); it usually serves many.[^mcp-architecture] The meaning of the messages is the same in both cases: the transport only decides how they travel.[^mcp-transports] OpenAI, for the servers that give tools to a ChatGPT _plugin_, asks that they be deployed at a stable HTTPS address with _Streamable HTTP_, and protected with the specification's authorization if they touch private data or act on someone's behalf.[^openai-plugins-mcp]

Authorization is optional in the protocol, but it has rules: an HTTP server that uses it should follow the flow the specification defines, based on OAuth 2.1, and a local one should not follow it but take credentials from the environment.[^mcp-authorization]

### What changed for whoever operates one

The July 28, 2026 version of the specification mainly changed the life of the remote server. There is no longer an initial handshake or sessions: each request carries its protocol version and the client's details, so **any instance behind a load balancer can serve it** without shared storage. HTTP requests carry the method and the tool name in headers, so a gateway or a web application firewall can route and measure without reading the body, and tool lists say how long they can be cached.[^mcp-blog-2026]

## In a store

A store has three ways of being behind an MCP server, and they are not mutually exclusive:

| Who operates it  | What it offers                                   | Example                                                                                                                                                                                                                                                                                                |
| ---------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| The platform     | Generic tools over each store's catalog and cart | Shopify serves catalog search, product detail and cart at `https://{store}/api/ucp/mcp`, with the [UCP (Universal Commerce Protocol)](/glossary/ucp/), and asks for an agent profile on every request; the policies and frequently asked questions tool remains at `/api/mcp`[^shopify-storefront-mcp] |
| A vendor         | Tools over the data that vendor manages          | Clione has its own on the way, so an assistant can read the catalog and send back answers and enrichments; it is not available yet                                                                                                                                               |
| The store itself | Whatever its team decides to expose              | A server built with the official kits that gives a ChatGPT _plugin_ access to live data[^openai-plugins-mcp]                                                                                                                                                                                           |

This is what a client would see when asking `tools/list` of a store's own server, a **made-up example**. The format is the specification's; the name, the description and the parameters are decided by whoever writes the server:[^mcp-tools]

```json
{
  "name": "search_products",
  "title": "Catalog search",
  "description": "Searches in-stock products by free text and maximum price",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "What the customer is looking for" },
      "max_price": { "type": "number", "description": "Maximum price in dollars" }
    },
    "required": ["query"]
  }
}
```

The description is not decoration: it is **what the model reads to decide when to call the tool**, and OpenAI lists it among the fields that help it choose.[^openai-plugins-mcp] A vague description produces wrong calls, and a tool that returns outdated data produces outdated answers, however well built the protocol is.


Treating a local MCP server as a harmless extension. **A local server is a program that gets downloaded and run on your machine**, often with direct access to the system. The protocol's security guide lists what can happen with one of untrusted origin or without restrictions: execution of any command with the client's privileges, lack of visibility into what runs, commands disguised to look legitimate, data theft and data loss.[^mcp-security] And the specification asks clients to treat the annotations that describe a tool as untrusted unless they come from a trusted server.[^mcp-tools]


## How to check it

1. **Review which servers each AI application your team uses has connected** and whether each one is local or remote.[^mcp-architecture]
2. **Look for the server in the official MCP registry.** Names are tied to a verified GitHub account or domain, although the registry is in preview and leaves security analysis of the code to the package registries and the catalogs that consume it.[^mcp-registry]
3. **Ask for the list of tools and read each description and each schema**: what it can read, what it can write and with what parameters.[^mcp-tools]
4. **If the server is remote and touches store data, check that it requires authorization** with the flow the specification defines.[^mcp-authorization]
5. **If you are the one operating it, test that it rejects out-of-schema inputs** and that it rate-limits calls, as the specification asks.[^mcp-tools]

## Related concept: MCP

MCP is the protocol, the shared rules; the MCP server is one of its parts, the one that offers capabilities, just as the client is the one that uses them.[^mcp-architecture] The [MCP](/glossary/mcp/) entry covers the protocol and its history. Above the two are the [agentic commerce](/glossary/agentic-commerce/) protocols, such as UCP or [ACP (Agentic Commerce Protocol)](/glossary/acp/), which set how an agent creates a cart and gets to payment. Shopify, for example, offers its cart and checkout for agents with UCP over MCP.[^shopify-storefront-mcp] And below is [_tool calling_](/glossary/tool-calling/), the model's ability to ask for a function to be run.

To go further, [ChatGPT Shopping](/glossary/chatgpt-shopping/) shows how products reach an assistant today, and the [agentic commerce reading path](/learn/agentic-commerce/) orders the rest of the protocols.