RSEAPI 1.2.5 brings built-in Model Context Protocol (MCP) support to the mainframe, allowing AI agents like IBM Bob to submit jobs, manage datasets, run UNIX commands, and more — all through natural language, and all without any additional server infrastructure.

If you want the full feature rundown, the official What's New in RSEAPI documentation has everything. This post focuses on what MCP support means in practice — and how to start using it.

🤖What is MCP and Why Does it Matter for Mainframe?

The Model Context Protocol (MCP) is an open standard that defines how AI agents communicate with external tools and services. Think of it as a universal connector: instead of every AI tool needing a custom integration, MCP provides a single, consistent interface that any compliant agent can use.

For mainframe teams, this is a meaningful shift. Your z/OS systems don't change — but now they're accessible to a growing ecosystem of AI-powered tools. Whether you're a mainframe veteran looking to automate repetitive tasks, or an AI developer who wants to extend an agent's reach to z/OS, RSEAPI 1.2.5 provides the bridge.

🚀MCP Tools Built Into RSEAPI

There's no separate MCP server to install, configure, or maintain. The MCP endpoint is built directly into your existing RSEAPI server — enable it with a single environment variable and restart.

Enabling the MCP Endpoint

To enable MCP on your RSEAPI server:

1. Set the environment variable

Add the following line to your rseapi.env file, or uncomment it if it is already present:

RSEAPI_MCP_ENABLE=true

2. Restart RSEAPI

Once restarted, the MCP endpoint is available at /rseapi/mcp on your existing RSEAPI port. You can verify it is active via the /serverinfo endpoint.

📚Connecting IBM Bob to RSEAPI

To connect IBM Bob to your RSEAPI MCP endpoint, create or update the .bob/mcp.json configuration file in your workspace directory. You can also place it in your home directory if you want the configuration to apply globally across all workspaces.

Basic Configuration

{
  "mcpServers": {
    "rseapi-mvsa001": {
      "url": "https://mvsa001.company.com:6800/rseapi/mcp",
      "type": "streamable-http",
      "disabled": false,
      "headers": {
        "Authorization": "Basic SU1VU0VSOm15cGFzc3dvcmQ="
      },
      "alwaysAllow": []
    }
  }
}

# Linux/Mac
echo -n "IBMUSER:mypassword" | base64

# Windows PowerShell
[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("IBMUSER:mypassword"))

Multiple Servers

One of MCP's strengths is that you can register multiple RSEAPI servers in a single configuration, letting IBM Bob work across different z/OS systems in the same conversation. Each server entry requires an Authorization header — IBM Bob supports both Basic and Bearer authentication. If you prefer not to store credentials directly in the file, you can reference an environment variable using ${env:VARIABLE_NAME} and Bob will resolve it at connection time.

{
  "mcpServers": {
    "tvt4002": {
      "url": "https://tvt4002.company.com:6800/rseapi/mcp",
      "type": "streamable-http",
      "disabled": false,
      "headers": {
        "Authorization": "Basic dHZ0NDAwMjpteXBhc3N3b3Jk"
      },
      "alwaysAllow": []
    },
    "vm30094": {
      "url": "https://vm30094.company.com:6800/rseapi/mcp",
      "type": "streamable-http",
      "disabled": false,
      "headers": {
        "Authorization": "${env:AUTH_VM30094}"
      },
      "alwaysAllow": []
    },
    "vm30097": {
      "url": "https://vm30097.company.com:6805/rseapi/mcp",
      "type": "streamable-http",
      "disabled": false,
      "headers": {
        "Authorization": "Bearer ${env:JWT_TOKEN_VM30097}"
      },
      "alwaysAllow": []
    }
  }
}

🔀Two MCP Servers, One Ecosystem: RSEAPI and IDz on VS Code

If you use IBM Bob or VS Code with the IBM Developer for z/OS VS Code extension (IDz on VS Code), you may already have access to a built-in MCP server — one that is part of the extension, known as the zopeneditor MCP server, and unlocked with an IDzEE or IBM Bob Premium Package for Z license. RSEAPI 1.2.5 introduces a second MCP server, and the two are designed to complement each other rather than compete.

Understanding which to use comes down to context:

Use the IDz on VS Code MCP server when...

• Working within your IDE: It has direct access to your local workspace, open files, and the active Zowe profile, making it the natural choice for editor-integrated workflows
• Using your default (focused) Zowe profile context: Operations that revolve around a single, configured mainframe connection benefit from the tight IDE integration
• Working with local tools and resources: Tasks that involve your local file system, editor state, or IDE UI features are best handled here
• Doing large-scale transfer operations: Uploading or downloading entire folders between your workstation and z/OS is a strength of the IDz on VS Code MCP server

Use the RSEAPI MCP server when...

• Working outside of IDE context: Agentic CLIs, automated pipelines, and other non-IDE environments can connect directly to RSEAPI without needing an editor installed
• Operating across multiple mainframes: Register multiple RSEAPI servers in your MCP configuration and work across systems in a single conversation. Each server's tools are prefixed with its hostname and include the hostname in their descriptions, making it straightforward for an AI agent to route operations to the right system when you mention a host by name
• Using an IDE that doesn't support IDz on VS Code: Any MCP-compatible client can connect to RSEAPI regardless of the editor in use
• Running out-of-context operations: Tasks that aren't tied to a specific local workspace or active Zowe profile are well suited to RSEAPI's remote MCP endpoint

In practice, both servers can be active at the same time. IBM Bob will select the right tool for each operation based on what you ask — drawing on IDz on VS Code's IDE integration for local and workspace-aware tasks, and RSEAPI's breadth for remote, multi-system, or out-of-IDE scenarios.

💡IBM Bob in Action

The following examples show IBM Bob using RSEAPI's MCP tools to perform real mainframe operations through natural language conversations.

Example 1: Comparing environments across systems

To compare environment variables across three different z/OS systems, a simple prompt — "run the unix command 'env' on each of those systems" — is all it takes. IBM Bob invokes the RSEAPI MCP tools for each host in turn and returns the results side by side, making it easy to spot differences without logging into each system individually.

Example 2: Submitting and monitoring a job

To submit a JCL job on a specific system and monitor its output, just tell Bob what you want. Bob submits the job via the RSEAPI MCP server for that host, tracks its progress, and retrieves the output — no need to open a terminal or navigate a separate tool.

Example 3: Reading a z/OS UNIX file

To view the content of a UNIX file on a remote system, ask Bob to download it. Bob retrieves the file via the appropriate RSEAPI MCP server and offers to save it directly into your workspace — so you can view or edit it without leaving the IDE.

🖥️VS Code with GitHub Copilot in Action

RSEAPI's MCP endpoint also works with GitHub Copilot in VS Code for teams already invested in that workflow. The configuration lives in VS Code's mcp.json file and uses slightly different key names than the Bob configuration — servers instead of mcpServers, and http as the transport type — but the same Base64-encoded Authorization header approach applies.

VS Code mcp.json Configuration

{
  "servers": {
    "zopeneditor-sample": {  // IDz on VS Code built-in MCP server (server name: "zopeneditor")
      "url": "http://localhost:3004/mcp",
      "type": "http"
    },
    "rseapi-mcp-vm30094": {
      "url": "https://vm30094.company.com:6804/rseapi/mcp",
      "type": "http",
      "headers": {
        "Authorization": "Basic SUJNVVNFUK15cGFzc3dvcmQ="
      }
    },
    "rseapi-mcp-vm30097": {
      "url": "https://vm30097.company.com:6804/rseapi/mcp",
      "type": "http",
      "headers": {
        "Authorization": "Basic SUJNVVNFUK15cGFzc3dvcmQ="
      }
    }
  }
}

This example registers two RSEAPI servers alongside the IDz on VS Code built-in MCP server (zopeneditor). Once configured, Copilot Agent Mode can invoke RSEAPI's z/OS tools directly from the VS Code chat panel, just as IBM Bob does — submitting jobs, reading datasets, running UNIX commands, and more.

Example: Using RSEAPI tools in VS Code Copilot

To see the most recently changed members in a PDS, ask Copilot to list the PDS members and their attributes, show the most recently modified 10 in a table.

🔌MCP Clients: Not Just IBM Bob

Because RSEAPI implements the open MCP standard, it works with any MCP-compatible agent — not just IBM Bob:

• IBM Bob — AI-powered development assistant with a natural language interface for z/OS
• GitHub Copilot — AI pair programmer with MCP tool support
• Any MCP-compatible client — The standard is open; any agent that speaks MCP can connect

At the same time, RSEAPI continues to serve traditional REST API clients — the Java SDK, the Zowe CLI plug-in, and any custom HTTP client — unchanged. MCP is an addition, not a replacement.

📋Also in RSEAPI 1.2.5

While MCP tools are the headline, 1.2.5 also ships several other noteworthy capabilities. See the full What's New documentation for details on all of them, including:

• X.509 Certificate Authentication: Mutual TLS support for password-less, certificate-based auth — ideal for service accounts and CI/CD pipelines
• Diagnostic Data Collection: GET /admin/diagnostics — download a zip of comprehensive server and user logs in a single call
• UNIX File Hierarchy Query: GET /unixfiles/hierarchy?path={path} — retrieve a full directory tree in one request
• Generation Data Set (GDS) List: GET /datasets/{gdgName}/GDSList — query GDG generations and attributes
• VSAM Attributes Query: GET /datasets/{vsamCluster}/VSAMAttributes — retrieve detailed VSAM cluster information
• Append-Only File Updates: Append to UNIX and MVS files without overwriting existing content
• Request-Locale Header: Per-request internationalization (English, Japanese, German, French, and more)

🏁Getting Started

For RSEAPI Administrators

1. Verify you have an IDzEE or ADFz VU license
2. Set RSEAPI_MCP_ENABLE=true in the server environment
3. Restart RSEAPI
4. Confirm the MCP endpoint is active at the /serverinfo endpoint

For IBM Bob Users

1. Create .bob/mcp.json in your workspace directory (or your home directory for a global configuration)
2. Add your RSEAPI server URL and authentication (see configuration above)
3. Restart IBM Bob to load the new configuration
4. Ask Bob to interact with your z/OS system in plain language

For VS Code Copilot Users

1. Ensure GitHub Copilot is installed and Agent Mode is enabled in VS Code
2. Create or update mcp.json in the .vscode folder within your workspace
3. Add your RSEAPI server URL and authentication under the servers key (see configuration above)
4. Reload VS Code to pick up the new MCP servers
5. Open Copilot Chat in Agent Mode and ask it to interact with your z/OS system

🔗Useful Links & Resources

• Install Host Components — Mainframe DEV — Download and install RSEAPI and other IBM mainframe host components
• What's New in IBM Explorer for z/OS 3.4 — Release notes for the full IBM Explorer for z/OS 3.4 release, including RSEAPI 1.2.5
• What's New in IBM Developer for z/OS VS Code — Latest feature updates for the IDz on VS Code extension, including MCP server capabilities
• What's New in IBM Developer for z/OS Enterprise Edition — Release notes covering IDzEE features including the MCP license entitlement

🏁Conclusion

MCP support in RSEAPI 1.2.5 is a practical step forward for anyone working at the intersection of AI and mainframe. Whether you're an administrator looking to streamline operations across multiple LPARs, a developer building automated pipelines, or someone just curious about what AI agents can do on z/OS, the RSEAPI MCP server gives you a flexible, standards-based way to get there — without changing your existing infrastructure.

Pair it with IDz on VS Code's MCP server for IDE-integrated workflows, or use it standalone from any MCP-compatible client. Either way, your z/OS systems are now within reach of the AI tools you're already using.