UBOS Asset Marketplace: MCP Aggregator - Unleash the Power of Unified Model Context

In the rapidly evolving landscape of AI-driven development, managing and orchestrating multiple Model Context Protocol (MCP) servers can quickly become a complex and cumbersome task. The UBOS Asset Marketplace introduces the MCP Aggregator, a revolutionary solution designed to unify your MCP server ecosystem, streamline workflows, and unlock the full potential of your AI agents.

The Challenge: Fragmented Model Context

Modern AI applications, particularly those leveraging Large Language Models (LLMs), rely heavily on context to deliver accurate, relevant, and insightful results. MCP, as an open protocol, standardizes how applications provide this crucial context to LLMs, enabling seamless integration with various data sources and tools. However, as development teams scale their AI initiatives, they often find themselves managing multiple MCP servers, each responsible for a specific set of data or functionalities. This fragmentation presents several challenges:

• Limited Concurrent Connections: Many MCP clients, such as Cursor, impose restrictions on the number of concurrent MCP server connections, hindering the ability to leverage diverse data sources simultaneously.
• Complex Configuration: Managing individual configurations for each MCP server can become a logistical nightmare, increasing the risk of errors and inconsistencies.
• Tool Name Conflicts: When multiple MCP servers expose tools with identical names, conflicts can arise, leading to unpredictable behavior and frustrating debugging experiences.
• Performance Bottlenecks: Processing requests across multiple MCP servers can introduce latency and impact overall application performance.
• Lack of Centralized Control: Without a unified management interface, it becomes difficult to monitor, manage, and optimize the performance of the entire MCP server infrastructure.

The Solution: MCP Aggregator – Your Unified MCP Control Center

The UBOS Asset Marketplace’s MCP Aggregator addresses these challenges head-on by providing a single, unified interface for managing and accessing multiple MCP servers. Functioning as both an MCP server (to the client) and an MCP client (to the backend servers), the aggregator acts as a bridge, seamlessly routing requests and aggregating responses, thereby eliminating the limitations of individual MCP server connections.

Key Features and Benefits:

• Unlimited MCP Server Connections: Overcome the limitations of client-side connection restrictions and connect to as many MCP servers as needed to access the full breadth of your data and tools.
• Simplified Configuration: Manage all your MCP server configurations in a single JSON file, streamlining the setup process and reducing the risk of errors.
• Automated Tool Name Sanitization: The aggregator automatically sanitizes tool names by replacing dashes with underscores, ensuring compatibility with clients like Cursor that may have issues with dashes in tool names. This eliminates potential conflicts and ensures smooth operation.
• Configurable Tool Filtering: Define allowed tools for each backend MCP server, enabling you to limit the number of exposed tools, avoid name conflicts, and improve performance.
• Centralized Logging and Monitoring: Monitor the activity and performance of all your MCP servers from a single location, facilitating troubleshooting and optimization.
• Flexible Deployment Options: Deploy the MCP Aggregator using various methods, including installation script, go install, Docker, or Makefile, ensuring compatibility with your existing infrastructure.
• Seamless Integration with UBOS Platform: The MCP Aggregator integrates seamlessly with the UBOS platform, enabling you to leverage the full power of UBOS for AI agent development, orchestration, and deployment.

Use Cases:

• Enhanced AI Agent Capabilities: Equip your AI agents with access to a wider range of data sources and tools, enabling them to perform more complex and sophisticated tasks.
• Streamlined AI Development Workflows: Simplify the management of multiple MCP servers, freeing up developers to focus on building and deploying AI applications.
• Improved AI Application Performance: Optimize the flow of data between AI models and external sources, resulting in faster response times and improved overall performance.
• Unified Data Access for LLMs: Provide LLMs with a single, consistent interface for accessing data from various sources, ensuring accuracy and relevance.
• Cursor Enhancement: Bypass Cursor’s limitation on the number of usable MCP servers at one time.

Deep Dive into Features

1. Streamlined Configuration

The MCP Aggregator employs a JSON-based configuration file, typically named config.json, to define and manage connections to multiple backend MCP servers. This file acts as the central nervous system of the aggregator, dictating how it interacts with each server and what tools are exposed. Here’s a breakdown of the configuration structure:

{ “mcpServers”: { “shortcut”: { “command”: “npx”, “args”: [“-y”, “@shortcut/mcp”], “env”: { “SHORTCUT_API_TOKEN”: “your-shortcut-api-token-here” }, “tools”: { “allowed”: [“search-stories”, “get-story”, “create-story”] } }, “github”: { “command”: “npx”, “args”: [“-y”, “@modelcontextprotocol/server-github”], “env”: { “GITHUB_TOKEN”: “your-github-token-here” } } } }

• mcpServers: This is the top-level object that contains definitions for each backend MCP server.
• shortcut and github: These are arbitrary names assigned to each MCP server. You can choose any name that is meaningful to you.
• command: Specifies the command to execute to start the MCP server. This is typically the path to an executable or a command-line interpreter.
• args: An array of arguments to pass to the command. These arguments are specific to each MCP server and may include flags, file paths, or other parameters.
• env: An object containing environment variables to set for the MCP server. These variables may include API keys, tokens, or other configuration settings.
• tools: An optional object that allows you to filter the tools exposed by the MCP server. The allowed array lists the names of the tools that you want to expose through the aggregator. If this object is omitted, all tools from the server will be exposed.

2. Automatic Tool Name Sanitization

Cursor, a popular code editor with built-in AI capabilities, has a known limitation: it struggles to properly detect or utilize tools with dashes in their names. The MCP Aggregator elegantly solves this issue by automatically sanitizing tool names, replacing dashes with underscores. This ensures that all tools are correctly recognized and accessible within Cursor.

For example, a tool named get-user from a backend MCP server would be automatically transformed into get_user by the aggregator. When a request is made to the aggregator using the sanitized name (get_user), the aggregator intelligently maps it back to the original name (get-user) before forwarding the request to the backend server. This process is entirely transparent to the user, ensuring a seamless and intuitive experience.

Furthermore, the aggregator prefixes each sanitized tool name with the name of the originating MCP server. This prevents name collisions when multiple servers expose tools with the same name. For instance, if both the shortcut and github servers expose a tool named get-user, the aggregator would transform them into shortcut_get_user and github_get_user, respectively.

3. Flexible Deployment Options

The MCP Aggregator offers a variety of deployment options to suit different environments and preferences:

• Installation Script: A convenient installation script is provided to automate the process of downloading, verifying, and installing the aggregator binary. This script is ideal for users who want a quick and easy setup.
• go install: Developers familiar with the Go programming language can use the go install command to build and install the aggregator directly from the source code. This option provides more control over the build process and allows for customization.
• Docker: Docker images are available for running the aggregator in a containerized environment. This approach offers excellent portability and isolation, making it ideal for production deployments.
• Makefile: A Makefile is included in the project to automate common tasks such as building, testing, and cleaning up build artifacts. This option is useful for developers who prefer to use Make as their build system.

4. Integration with UBOS Platform

The MCP Aggregator is designed to seamlessly integrate with the UBOS platform, providing a comprehensive solution for AI agent development and deployment. UBOS offers a range of features that complement the aggregator, including:

• AI Agent Orchestration: UBOS provides a visual interface for orchestrating AI agents, allowing you to define complex workflows and manage dependencies.
• Enterprise Data Connectivity: UBOS simplifies the process of connecting AI agents to enterprise data sources, enabling them to access the information they need to perform their tasks.
• Custom AI Agent Development: UBOS provides a powerful framework for building custom AI agents using your own LLMs and data.
• Multi-Agent Systems: UBOS supports the development of multi-agent systems, allowing you to create complex AI applications that involve multiple interacting agents.

Installation

Using install script (recommended)

You can install the latest version of combine-mcp using our installation script:

bash

Download and run the installation script

curl -fsSL https://raw.githubusercontent.com/nazar256/combine-mcp/main/install.sh | bash

Or install a specific version

curl -fsSL https://raw.githubusercontent.com/nazar256/combine-mcp/main/install.sh | bash -s – -v v1.0.0

The script will:

• Detect your operating system and architecture
• Download the appropriate pre-compiled binary
• Verify the checksum
• Install it to a suitable location in your PATH
• Make it executable

Using go install (alternative)

bash

Install directly from GitHub (binary will be placed in $GOPATH/bin)

go install github.com/nazar256/combine-mcp/cmd/combine-mcp@latest

Ensure $GOPATH/bin is in your PATH

For example, add this to your .bashrc or .zshrc:

export PATH=$PATH:$(go env GOPATH)/bin

Using Docker (alternative)

You can run combine-mcp directly using Docker without installing it locally:

bash

Run the latest version

docker run --rm -v ~/.config/mcp:/config ghcr.io/nazar256/combine-mcp:latest

Run a specific version

docker run --rm -v ~/.config/mcp:/config ghcr.io/nazar256/combine-mcp:v1.0.0

Set environment variables

docker run --rm -v ~/.config/mcp:/config -e MCP_CONFIG=/config/config.json -e MCP_LOG_LEVEL=debug ghcr.io/nazar256/combine-mcp:latest

To use it with Cursor, you’d need to configure the MCP server to use Docker:

{ “mcpServers”: { “aggregator”: { “command”: “docker”, “args”: [“run”, “–rm”, “-v”, “~/.config/mcp:/config”, “ghcr.io/nazar256/combine-mcp:latest”], “env”: { “MCP_CONFIG”: “/config/config.json” } } } }

Using the Makefile

The project includes a Makefile for common tasks:

bash

Build the binary

make build

Run tests

make test

Clean up build artifacts

make clean

Conclusion

The UBOS Asset Marketplace’s MCP Aggregator is an essential tool for any team working with multiple MCP servers. By providing a unified interface, simplified configuration, and automated tool management, the aggregator streamlines AI development workflows, improves application performance, and unlocks the full potential of AI agents. Integrate the MCP Aggregator with UBOS today and experience the future of AI development.