# What is an MCP Server?

### Quick answer:

**Model Context Protocol (MCP)** is an open framework that standardizes the interaction between AI models and external tools and data sources. Think of it as USB-C for AI—before USB-C, you needed different cables for different devices. Before MCP, developers built custom integrations for each AI model and service combination. MCP creates one universal connection that works across all compatible AI models.

**An MCP server** is a software service that exposes tools, data resources, and instruction templates to AI models through this standardized protocol. It acts as an intermediary layer between AI and your APIs, letting the AI autonomously choose which tools to use rather than following hard-coded logic.

[ Try Postman today →](https://identity.getpostman.com/signup)

 

### Table of Contents

- [A brief history of MCP](#a-brief-history-of-mcp)
- [What are MCP servers?](#what-are-mcp-servers)
- [How do MCP servers work?](#how-do-mcp-servers-work)
- [MCP vs APIs](#mcp-vs-apis)
- [How to set up an MCP server](#how-to-set-up-an-mcp-server)
- [Setting up an MCP server with Postman](#setting-up-an-mcp-server-with-postman)
- 
 
 

## A brief history of MCP

 In November 2024, [Anthropic launched MCP](https://www.anthropic.com/news/model-context-protocol) as an open standard that “enables developers to build secure, two-way connections between their data sources and AI-powered tools.” However, it didn’t gain much traction until March 2025 when the [CEO of OpenAI](https://x.com/sama/status/1904957253456941061) and the [CEO of Google](https://x.com/sundarpichai/status/1906484930957193255) both brought the MCP topic to X for discussion. Increased interest from key players in tech along with the rise of AI agentic AI and [AI agents](https://www.postman.com/product/ai-agent-builder/) has led to more and more companies and developers experimenting with MCP and MCP servers. ## What are MCP servers?

 MCP servers are a part of the Model Context Protocol (MCP) and act as the connection between different AI models, tools, and data sources. They standardize connections and communication, allowing AI to access different tools, databases, and services. Think of MCP servers like the USB-C cables of the AI world. Before USB-C came along, we dealt with a tangle of HDMI, Thunderbolt, and Lightning cables, along with various power adapters. Each device required its own cable type. Now, USB-C cables standardize connections for a wide range of electronics. MCP works in a similar way. Before MCP, developers had to build custom connections for every AI model and service they needed to integrate with, which was not only time-consuming but also locked developers into specific models or vendors. Now, MCP provides a universal connection to all tools, resources, and AI models. ## How do MCP servers work?

 First, let’s look at MCP architecture, which includes three components: the MCP host, the MCP client, and the MCP server. - **MCP hosts** are LLM applications like Claude Desktop or Integrated Development Environments (IDEs) that initiate the connections.
- **MCP clients** are what maintain the connections between the servers and the hosts and make data requests.
- **MCP servers** handle requests from clients by running commands or returning data in a standardized format that the client can understand.
 
 MCP hosts launch the MCP client, and clients send the request to MCP servers. From there, MCP servers typically provide three capabilities: tools, resources, and prompts. ### Three core capabilities of MCP servers

- **Tools** are actions AI can perform with permission, such as making API calls, executing commands, or pulling and analyzing data from an app.
- **Resources** are files and data that the server makes available to the AI to provide context. For example, a resource could be a database of product usage data that is then analyzed to create a report.
- **Prompts** are specialized and reusable instruction templates that tell LLMs how to interact or behave. For example, prompting the server to perform a code review or asking for an expert security analysis.
 
## MCP vs APIs

 MCP and APIs both enable communication, but they have different purposes and address specific problems. |  | MCP | Traditional APIs |
|---|---|---|
| **Purpose** | Standardized layer enabling AI models to discover and use tools autonomously | Direct communication between software applications |
| **Interaction** | Dynamic, autonomous: AI chooses which tools to use based on the task | Hard-coded, predefined logic: "If X happens, call endpoint Y" |
| **Standardization** | Universal protocol—build once, works with any MCP-compatible AI model | Each API has its own structure (REST, GraphQL, SOAP, etc.) |
| **Security** | MCP server manages authentication and permissions centrally for all exposed tools | Authentication handled per API (OAuth, API keys, tokens) |
| **Discovery** | AI discovers available tools automatically through MCP server's exposed capabilities | Developers must know endpoints exist and manually integrate them |
| **Integration** | Single integration works across all MCP-compatible models (Claude, GPT, Gemini, etc.) | Custom integration needed for each API + AI model combination |

Traditional APIs are direct communication channels between software applications. They require explicit instructions because the AI has no autonomy to choose its own actions.

**The traditional API integration pattern looks like this:**

 `If condition A is true → Call endpoint XIf condition B is met → Call endpoint Y with parameters ZIf response contains error → Execute fallback logic`With MCP servers, the server facilitates the interaction, providing a way for the AI to gather context and data in a way that the AI can easily consume. Instead of hard-coding how AI interacts with APIs, MCP servers expose available tools and let the AI decide what to use.

**The MCP pattern looks like this:**

 `MCP Server exposes: [Tool A, Tool B, Tool C, Tool D]AI receives task → Analyzes requirements → Selects appropriate tools → Executes in optimal sequence`The fundamental shift MCP represents is this:

**Traditional API integration:** "If the user asks X, then call API Y."**MCP:** "Here are the available tools; figure out how to accomplish the goal."

## How to set up an MCP server

Setting up an MCP server involves creating a software service that exposes tools, resources, and prompts to AI models through the standardized Model Context Protocol. Whether you're building from scratch or using a platform like Postman, the process follows a consistent pattern.

### General setup steps

Review the written instructions below or [watch the video](https://www.youtube.com/watch?v=Y4bpWRLdRoA&list=PLM-7VG-sgbtDSUz8LDWdDb141DxZciz9u&index=8 "https://www.youtube.com/watch?v=Y4bpWRLdRoA&list=PLM-7VG-sgbtDSUz8LDWdDb141DxZciz9u&index=8") (with accompanying [Github repo](https://github.com/SterlingChin/mcp-weather-server "https://github.com/SterlingChin/mcp-weather-server")) to follow along.

#### 1. Set up your environment

Before starting, ensure you have the necessary prerequisites:

- **Code editor:** Any JavaScript-friendly IDE (VS Code, Cursor, WebStorm, etc.)
- **Runtime environment:** Node.js and TypeScript
- **AI client:** Claude Desktop app or another MCP-compatible AI application
- **Development tools:** Terminal access and package manager (npm)
 
#### 2. Define your MCP server structure

Every MCP server consists of three core components:

- **Helper functions:** Where you call external APIs and format data that AI models will use. These handle the actual integration logic with your tools and services.
- **Server instance:** Where you define the server's metadata, including the capabilities, resources, and tools.
- **server.tool Methods:** Where you define what tools the AI can use, how to call them, and what parameters they accept. Each tool acts like a specialized instrument in a mechanic's toolbox.
 
#### 3. Connect to Claude Desktop

- Open your Claude Desktop configuration file: 
    - Mac: `~/Library/Application Support/Claude/claude_desktop_config.json`
    - Windows: `%AppData%\Claude\claude_desktop_config.json`
 
- 
- Add the following configuration (update the path to point to your repository):`{"mcpServers": {"weather": {"command": "node","args": ["/absolute/path/to/your/mcp-weather-server/build/index.js"]}}}`
- 
- Restart Claude Desktop
- Look for the hammer icon in Claude Desktop, indicating that MCP tools are available
 
#### 4. Test Your Implementation

Try asking Claude these questions:

- "What's the weather like in San Francisco right now?"
- "Are there any weather alerts in Texas today?"
- "What's the forecast for Chicago this weekend?"
 
## Setting Up an MCP Server with Postman

Postman dramatically simplifies MCP server creation through its MCP generator and public API network, allowing you to build an MCP server in minutes.

### Step 1: Access the Public API Network

1. Open Postman and navigate to the [**Public API Network**](https://www.postman.com/explore/ "https://www.postman.com/explore/")
2. Click **View all public APIs** to browse available integrations
3. Search for **MCP Generator** to access the server creation tool
 
### Step 2: Select APIs for Your Server

1. Browse through 100,000+ publicly available APIs in Postman's network
2. Select the API you want to integrate (e.g., CoinGecko for cryptocurrency data)
3. Choose specific endpoints you want to expose as MCP tools
4. Click **Add requests** to include them in your server
 
### Step 3: Generate your server

1. Click **Generate** to create your MCP server
2. Wait a few moments while Postman builds the server code
3. Click **Download** to save the generated server package
4. Unzip the downloaded file
 
**What Postman generates for you:**

- Complete MCP server code with all selected tools
- Helper functions for API authentication and data formatting
- Configuration files (package.json, tsconfig.json)
- Documentation (README with setup instructions)
 
### Step 4: Install

1. Open your terminal and navigate to the server folder, open in Cursor
2. Run npm install
3. Copy path from Cursor
 
### **Step 5:** Test in Postman's MCP Client

Before connecting to your AI application, test your server in Postman:

- **Create a new MCP connection:**
    
    
    - Go to your workspace
    - Click **New → MCP**
    - Select **Connect to MCP server**
- **Test available tools:**
    
    
    - View all tools exposed by your server
    - Select a tool and input test parameters
    - Click **Run** to execute
    - Verify the response data
 
For detailed instructions, visuals, and guidance on how to use your new MCP server, follow along with this video:

 ## MCP servers are connectors

MCP servers act as intermediaries between AI models and your external systems, helping to solve the fragmentation problems associated with AI application development.

The power of MCP servers lies in their simplicity: expose your tools, resources, and prompts once, and any MCP-compatible AI model can use them intelligently. Whether you're building a custom weather server from scratch or generating a cryptocurrency data server in minutes with Postman, you're creating reusable infrastructure that eliminates vendor lock-in and reduces maintenance overhead.

Explore [Postman’s MCP catalog](https://www.postman.com/explore/mcp-servers) to get started.