Create an MCP server with Postman Flows

In Postman Flows, you can create and deploy a flow that functions as a Model Context Protocol (MCP) server with MCP tools, prompts, and resources. When deployed to a public URL, the flow can process incoming requests and send the results as responses.

Create a deployable flow with an MCP block

To begin building an MCP server in Postman Flows, do the following:

1. Create a new flow.

2. In the Start block, click Change trigger and select MCP.

Add tools to the MCP block

In the MCP block, you define a schema that describes the tools your flow will expose as an MCP server, or you can create a schema with AI assistance. Meanwhile, in the flow canvas, you add blocks to work with the data that the MCP server will obtain through each tool.

1. In the MCP block’s text box, enter one or more tools using the MCP tool definition structure. For example, adding the following to the MCP block defines a tool that greets a user by name:

   1
   {
   2
     "tools": [
   3
       {
   4
         "name": "greeter",
   5
         "description": "Says hello to a person by their first name",
   6
         "inputSchema": {
   7
           "type": "object",
   8
           "properties": {
   9
             "first_name": {
   10
               "type": "string",
   11
               "description": "The person's first name"
   12
             }
   13
           },
   14
           "required": [
   15
             "first_name"
   16
           ]
   17
         }
   18
       }
   19
     ]
   20
   }
   Each item in the properties element of the tool definition will become an argument in calls to the tool.

2. Add blocks to the flow to perform the tool’s task. For the greeter tool, you can use a Template block to concatenate the user’s name to the message “Hello”:

   
   In the MCP block, the properties element defines a first_name property. The path to that property in the example Select block is arguments.first_name.

3. (Optional) For MCP servers that have multiple tools, you can use a Condition block to check which tool is being called in the request. Then a Select block can parse the tool’s arguments.

   

If you don’t want to add prompts or resources to your MCP server, go ahead and deploy the flow, then test your MCP server.

(Optional) Add prompts to the MCP server

You can add prompts to your MCP server in Flows. Servers with prompts can provide structured messages and instructions for interacting with language models. Clients can discover available prompts, retrieve their contents, and provide arguments to customize them.

The unique identifier for a prompt is in the name field. MCP requests will include this name field in the params section of the request body. Once it receives the request, the action strips away outer elements of the request body. What’s left for the action to process is a JSON object with two key-value pairs: one whose key is name and the other whose key is arguments. The value of arguments is one or more key-value pairs.

You can add one or more prompts to the Body section of a toolDefinition scenario with the structure shown in the following example prompt:

1
"prompts": [
2
  {
3
    "name": "example-prompt",
4
    "title": "Request Code Review",
5
    "description": "Asks the LLM to analyze data file to find anomalies",
6
    "arguments": [
7
      {
8
        "name": "file",
9
        "description": "The data file to review",
10
        "required": true
11
      }
12
    ]
13
  }
14
]

(Optional) Add resources to the MCP server

Resources enable servers to share data that provides context to language models. Each resource is uniquely identified by a URI (not a name as in a tool or a prompt). MCP requests will include this uri field in the params section of the request body. The action receives the internal content of the request body: the outer elements are stripped away.

For example, consider the following prompt that specifies a tool:

1
"params": {
2
    "name": "code_review",
3
    "arguments": {
4
      "code": "def hello():\n    print('world')"
5
    }
6
  }

The “unboxed” version of this prompt that a flow will process looks like this:

1
{
2
    "name": "code_review",
3
    "arguments": {
4
      "code": "def hello():\n    print('world')"
5
    }
6
}

Similarly, a prompt that specifies a resource might look like this:

1
{
2
  "params": {
3
    "uri": "file:///project/src/main.rs"
4
  }
5
}

A flow will process the “unboxed” version of the prompt, namely { uri }.

You can add one or more resources to your MCP block with the structure shown in the following example resource:

1
"resources": [
2
      {
3
        "uri": "http://example.com/data.json",
4
        "name": "data.js",
5
        "title": "Data file",
6
        "description": "File containing important data",
7
        "mimeType": "application/json"
8
      }
9
    ]

If you want to parameterize the resources your MCP server exposes, you can add one or more resource templates to the Body section of your MCP block. MCP resource templates are URI templates, structured as shown in the following example:

1
"resourceTemplates": [
2
      {
3
        "uriTemplate": "file:///{path}",
4
        "name": "Project Files",
5
        "title": "Project Files",
6
        "description": "Access files in the project directory",
7
        "mimeType": "application/octet-stream"
8
      }
9
    ]

Once it receives the request, the deployed flow strips some outer elements of the request body away. What’s left for the flow to process is a JSON object with two key-value pairs: one whose key is name and the other whose key is arguments. The value of arguments is one or more key-value pairs.

Deploy the MCP server

Given a flow with an MCP block that defines tools and (optionally) prompts and resources, you can deploy the flow. Once deployed, your flow will be an MCP server, meaning that the deployed flow’s URL will respond to MCP requests.

Test the MCP server

This topic assumes that your goal is to configure an AI application such as Claude, Cursor, or ChatGPT to use your new MCP server. Before you do that, you can use Postman to create and send an MCP request to the server.

To test your MCP server, do the following:

1. Click Deploy (even if you have already deployed the action) to open the Deploy dialog.

2. Click Current.

3. Next to the MCP URL, click Open in MCP request. A new MCP request opens.

4. In the MCP request, make sure HTTP is selected from the protocol dropdown list.

5. Click Connect. The MCP server’s tools appear in the Message section. Click a tool to view and enter any required arguments.

6. Click Run to send the request to the MCP server. The params element of the request body will include the tool name and the arguments. Below that you’ll find the response body in the Response section.

   

When you’re satisfied with the results of this test, you can move on to configuring your AI application of choice to use your new MCP server.