Virtual MCPs

What Are Virtual MCPs?

In deco Studio, a Virtual MCP is a reusable package of capabilities—tools, resources, and prompts—remixed from multiple connections.

Instead of giving your AI agent access to everything from every connection, you compose virtual MCPs that expose exactly what’s needed for each use case. You can:

• Remix connections: Select specific tools and context from each connection
• Combine multiple sources: Package Shopify + inventory systems + databases into one unified MCP
• Add custom logic: Extend with inline tools, prompts, and resources
• Update dynamically: Change what’s included without reconfiguring your agents

Virtual MCPs are the backbone of deco Studio—powering Projects, Agents, and organizational boundaries for how capabilities are packaged and composed.

How Virtual MCPs Work

Virtual MCPs are built by remixing connections—selecting capabilities from external MCPs—and optionally extending with custom tools, prompts, and resources.

Remix from Connections

Remixing lets you select and combine tools, resources, and prompts from multiple connections.

A connection is how you wire up an external MCP server to deco Studio (see Connections for details). Once you have connections set up, remixing works like this:

1. Select specific capabilities from each connection—tools, resources, prompts
2. Combine them into a single virtual MCP package
3. Your agent gets aggregated access to all selected capabilities in one place

Example: An “order-fulfillment-ops” virtual MCP might remix:

• Shopify connection: Order management tools + product catalog
• ShipStation connection: Shipping label generation and tracking tools
• Email provider connection: Order confirmation and shipping notification tools

Your AI agent uses this one virtual MCP to orchestrate the entire order fulfillment process across all three systems.

Extend with Inline Capabilities

Inline creation lets you define tools, resources, and prompts directly within a virtual MCP—extending what connections provide.

Inline tools can call any MCP connection available in your deco Studio instance, enabling powerful patterns like orchestration, validation, and feature gating.

Inline tools can call other tools using callTool(connectionId:TOOL_NAME, params) , enabling orchestration, validation, and feature gating across your MCP infrastructure.

This remixing approach is perfect for:

• Custom prompts that guide agents through team-specific workflows
• Context resources like guidelines, documentation, or domain knowledge
• Orchestration tools that compose tools from multiple connections into higher-level operations
• Feature gating and validation that wrap connection tools with authorization logic (see Authorization and Roles)

Use Case: Feature Gating

Inline tools are ideal for feature gating—wrapping connection tools with validation, authorization, or custom behavior.

Example: A read-only database tool that validates queries before calling the underlying connection, blocking dangerous operations like DROP , DELETE , or UPDATE .

Use Case: Orchestration

Inline tools can coordinate multiple connections in a single operation.

Example: An order fulfillment tool that checks inventory (warehouse connection), creates a shipping label (ShipStation connection), sends order confirmation (SendGrid connection), and updates order status (Shopify connection)—all in one coordinated workflow.

These patterns enable authorization enforcement, input validation, audit logging (see Monitoring), and workflow orchestration across your MCP infrastructure.

Combine Both

The real power comes from combining both approaches—remixing capabilities from connections and extending them with inline definitions.

Example: A “customer-service-assistant” virtual MCP that combines:

• Shopify connection tools: Order lookup, refund processing
• Shopify connection resources: Product catalog and return policies
• Inline prompts: Custom customer communication templates
• Inline resources: Customer service guidelines and FAQ responses

One virtual MCP, multiple sources (connections + inline definitions), unified agent experience.

Tool Naming & Collision Handling

When aggregating tools from multiple connections, deco Studio uses a mapping-based approach to route tool calls to the correct connection.

How It Works

Tools keep their original names — no prefixes or namespacing is applied. Internally, deco Studio maintains a mapping of toolName → connectionId to know which connection to route each call to.

First-occurrence wins: If two connections expose a tool with the same name, the first one encountered is used and the duplicate is silently dropped. The order is determined by the connection aggregation list in the Virtual MCP configuration.

Example: If both a Shopify connection and a custom connection expose a GET_ORDERS tool, only the one from whichever connection appears first in the aggregation will be available.

To avoid collisions, either:

• Curate your tool selection using the selection filters to include only the tools you need from each connection
• Reorder connections in the aggregation to prioritize the version you want

Virtual Tools Take Precedence

Inline tools defined directly on the Virtual MCP always take precedence over tools from downstream connections.

Resources and Prompts

Resources and prompts follow the same mapping-based approach. Well-known protocol URIs ( http:// , https:// ) pass through unchanged.

Features Powered by Virtual MCPs

Virtual MCPs provide the foundational capability that powers specialized features across deco Studio. All of these inherit full monitoring capabilities for audit trails and observability.

MCP Client Compatibility: Virtual MCPs are callable by any MCP-compatible client—including Cursor, Claude Code, VS Code extensions, and any application that implements the Model Context Protocol. This makes your composed capability packages universally accessible across the AI tooling ecosystem.

Specialized features built on virtual MCPs:

• Agents: Single-purpose capability packages optimized for specific tasks
• Projects: Team-scoped capability packages for organizational boundaries

Use Cases & Benefits

Virtual MCPs turn fragmented MCP connections into unified, reusable capability packages:

Real-world applications:

• Order Fulfillment Operations: Package Shopify (orders) + ShipStation (shipping) + email provider (notifications) into one fulfillment MCP
• Customer Service Hub: Remix Shopify tools with inline customer service prompts and return policy guidelines
• Inventory Management: Combine warehouse APIs + Shopify inventory tools with inline stock alert workflows
• Multi-brand Store Management: Share access to a Shopify MCP connection across your team while filtering brand-specific operations—giving managers scoped access to their brand’s products and orders without exposing other brands
• Ecommerce Analytics: Package Shopify, Google Analytics, and Stripe tools for end-to-end sales and conversion tracking

Key benefits:

• Selective remixing: Choose exactly which tools, resources, and prompts to include from each connection
• Inline extensions: Add custom orchestration, validation, and feature gating logic
• Dynamic updates: Modify what’s included without reconfiguring agents
• Foundation for specialization: Building block for Projects and Agents

Next Steps

Ready to build? Follow the Quickstart for step-by-step setup.

Building for teams? Learn about Projects for team-scoped virtual MCPs, or Agents for single-purpose capability packages.

Need authorization controls? See Authorization and Roles for securing virtual MCP access with feature gating and policies.