Connect APIs to AI Agents: Expose, Discover and Manage MCP Servers with Bijira

The API landscape is evolving rapidly with some protocols rising in popularity while others fade away. The journey that started with SOAP has now evolved into other protocols like REST, GraphQL, gRPC, AsyncAPIs, and more. With the emergence of large language models (LLMs), we are now in the era of AI agent/assistant integrations with APIs. 

LLMs are power utilities. However, they operate without contextual awareness. Despite being trained on a large amount of publicly available datasets, they often cannot make decisions based on real-time or proprietary data. The Model Context Protocol (MCP) addresses this limitation.

What is MCP?

MCP is a JSON RPC-based protocol that provides a standardized way for applications to share contextual information with LLMs, expose tools and capabilities to AI systems, and build composable integrations and workflows. This additional context you share with LLMs could be anything such as local files, databases, or even APIs. 

MCP has a host-client-server architecture that supports two main types of transports: stdio and streamable HTTP. While the stdio transport is popular when it comes to clients and servers that run on the same machine, streamable HTTP transport (which supports remote connections and communication over networks) is gaining more and more traction with the rapid adoption of MCP.

Remote MCP servers with Bijira

Bijira, WSO2’s AI-native API management SaaS platform, now supports MCP. It offers a comprehensive solution for converting existing APIs into intelligent, AI-ready tools. The platform’s centralized control plane streamlines the full lifecycle of MCP server management (from creation to discovery) while offering built-in quality of service (QoS) features such as security, rate limiting, and more. It provides a cohesive experience for both API developers and AI agent builders.

Effortless MCP server creation and management

If you're using external APIs or existing API proxies in Bijira, you can easily convert them into remote MCP servers in just a few clicks. Through an intuitive UI, developers can quickly select an existing OpenAPI definition, configure invocation metadata, and generate a fully compliant MCP server. This workflow eliminates the need for manual schema creation or external tooling, reducing time-to-integration significantly.

Intelligent tool definition generation

The quality of an MCP server often comes down to how well its tools are defined. Bijira takes that burden away from you by automatically generating tool definitions based on your API's OpenAPI schema. This definition includes the name, description, and input schema of each tool, with the option to customize names and descriptions later to better suit your specific needs.

Enterprise-grade security and governance

Securing MCP servers is critical for production readiness. Once a server is published, Bijira ensures its secure exposure to authorized AI agents through robust OAuth2 authorization. If you've enabled security for your MCP server before deployment, Bijira's gateway handles authorization automatically and AI agents cannot access your tools without valid access tokens. The platform applies the same comprehensive policies used for human clients, including OAuth2 scopes, token validation, rate limits, and access control, ensuring that agent interactions are fully governed and compliant with organizational standards.

Comprehensive API management for MCP servers

As a plus, your MCP server automatically gets all of Bijira's API management features; think rate limiting, subscriptions, lifecycle management, and more. And this is just the beginning. We've got some exciting MCP-specific management features in the works that will make things even better.

Test before you publish

Before making an MCP server publicly available, Bijira lets you test the functionality from the Bijira Console. You can:

• Simulate agent invocations of your MCP tools
• Validate tool routing, input schemas, and expected responses
• Ensure everything behaves as intended before moving to production

This testing phase helps eliminate surprises in production and ensures a smoother integration experience for downstream consumers.

The MCP Hub: a dedicated portal for agent discovery

For agent developers, discovery is the critical first step. To facilitate this, Bijira’s developer portal is being adapted to feature an MCP Hub, a dedicated marketplace exclusively for MCP servers.

While the standard developer portal lists all API types, the MCP Hub provides a curated and clutter-free environment for AI agent builders. This modification ensures that developers looking for MCP tools can find exactly what they need without sifting through REST, GraphQL, or other APIs. In the hub, MCP servers are clearly documented and discoverable, helping agent builders immediately understand their capabilities, invocation parameters, and intended use cases.

This focused experience accelerates the entire integration workflow. Developers can more efficiently find and subscribe to the tools their agents require, reducing trial-and-error and speeding up development. By presenting a tailored view of AI-ready tools, the MCP Hub makes it easier than ever to connect your APIs with the next generation of AI-driven applications.

From theory to practice

Let’s walk through a simple scenario that lets you understand how MCP servers work in Bijira. Assume you have an API that manages a reading list of books and you need to integrate this with an AI agent. 

With traditional APIs, you would need to manually call each resource to view your reading list or add books you plan to read. In contrast, MCP servers let you connect everything to an AI agent that can handle these tasks for you, just based on your prompts—like having your own personal assistant.

1. Let’s start by creating a new MCP server through the Bijira console. We will be using the API contract of the Reading List API.

2. Once the API has been created, you can view and modify tools through the Policy view. The tool definitions shown here will be generated based on the OpenAPI definition of our Reading List API. You will also have the option to link/unlink tools to resources of the API.

Furthermore, you can view and modify additional information related to the available tools. Modifying the tool schema is not allowed but you can modify tool name and description if needed.

3. We have our own version of the MCP Inspector built right into the Bijira console that can be used to test your MCP server before publishing it.

4. Like any other API, MCP servers can be published to the developer portal, making them discoverable to consumers. To access the API, consumers must subscribe using an application to obtain a valid token. Additionally, we can theme the developer portal to function as an MCP Hub, displaying only MCP servers for easier discovery and navigation.

5. Our developer portal provides the server configuration you can easily copy and use with an AI agent like VS Code Copilot. You’ll also need to obtain a valid token from your subscribed application and insert it in the relevant place.

6. To test this out through an AI agent, let’s set up the VS Code Copilot agent. We can use the configuration we obtained from the developer portal to set this up. (https://code.visualstudio.com/docs/copilot/chat/mcp-servers) 

7. Now, we can try out a simple scenario by asking the agent to retrieve the books in my reading list. The agent will use the listBooks tool to complete this task. 

Unlocking new use cases for developers and AI agents

With MCP server support in Bijira, API providers can now expose services that unlock entirely new consumption patterns, especially for autonomous AI agents and LLM-powered tools. This shifts integrations from developer-driven to agent-driven automation.

Some emerging use cases include:

• Agent-powered workflows: AI agents can invoke APIs directly to retrieve data, trigger actions, or orchestrate multi-step processes without requiring backend glue code.
• LLM copilot integrations: Exposing APIs as MCP tools allows them to be used in copilots (e.g., ChatGPT, Claude, or custom assistants), enabling tasks like ticket creation, order tracking, or device control via natural language.
• Zero-UI experiences: APIs become usable through voice, chat, or other natural interfaces without the need for frontend apps.
• Developer automation: Internal developer tools and CLI agents can now discover and invoke APIs using standardized schemas, reducing manual scripting and onboarding time.
• Composable AI agents: By defining when and why a tool should be used (via the MCP schema), developers can chain APIs together through intelligent agents that decide the best course of action based on context.

With MCP, Bijira users can extend their APIs to a new class of consumers — autonomous, intelligent, and always evolving — without sacrificing security or manageability.

Get started

Ready to see how Bijira helps to elevate your API integration experience through MCP? Head over to our documentation to get started.