Transports
io.Intelligence MCP can be deployed in different environments depending on your infrastructure and application architecture. The transport layer handles communication between AI assistants and your applications, and choosing the right transport ensures optimal performance and compatibility with your existing systems.
Deployment Paths
Choose the MCP transport that matches your environment, infrastructure, and integration style.
The transport does not change what io.Intelligence MCP can do. It changes how those capabilities are connected and operated in Desktop, Browser, or custom environments.
Transport Options at a Glance
HTTP Transport
Use a Node.js server application for io.Connect Desktop scenarios and backend-oriented deployments.
Web Transport
Run MCP capabilities directly in the browser for io.Connect Browser environments and lighter-weight web integrations.
Custom Transports
Use @interopio/mcp-core directly when you need a specialized communication layer or custom client integration.
Understanding Transport Layers
A transport layer is the communication mechanism that connects AI assistants to io.Intelligence MCP. It manages how messages are sent and received, handles connection lifecycles, and ensures secure, reliable communication. The transport you choose depends primarily on your deployment environment and technical requirements.
Available Transport Options
io.Intelligence provides ready-to-use transport implementations for the most common deployment scenarios:
| Transport | Environment | Use Case |
|---|---|---|
| HTTP Transport | Node.js server | io.Connect Desktop deployments |
| Web Transport | Browser | io.Connect Browser applications |
| Custom Transports | Any | Specialized requirements using mcp-core directly |
Transport Comparison
| Consideration | HTTP Transport | Web Transport |
|---|---|---|
| Deployment Environment | Node.js server | Browser |
| Best For | io.Connect Desktop, backend services | io.Connect Browser, web applications |
| Infrastructure Needs | Requires Node.js server process | No external server required |
| Communication Method | HTTP endpoints with SSE streaming | io.Connect Browser interop messaging |
| Multi-User Support | Multiple concurrent sessions | Instance-specific connections |
| Security Model | DNS rebinding protection, CORS configuration | io.Connect Browser security model |
| Typical Use Cases | Enterprise desktop deployments, microservices | Browser-based workflows, lightweight integrations |
HTTP Transport
The HTTP Transport enables io.Intelligence MCP deployment as a Node.js server application, making it ideal for io.Connect Desktop environments and enterprise backend integration scenarios.
The HTTP transport is designed to work locally on the user's machine, NOT for deployment to a remote server or cloud. It interacts with the io.Connect Desktop runtime of the local user. While it does NOT support multiple users, it DOES support multiple MCP client connections from the same local environment.
What It Provides
| Feature | Description |
|---|---|
| Standard HTTP Communication | Exposes io.Intelligence MCP capabilities through standard HTTP endpoints that AI assistants can connect to. Uses proven web technologies including Server-Sent Events for real-time streaming and REST APIs for message exchange. |
| Multi-Session Architecture | Supports multiple AI assistant connections simultaneously, with each connection managed as an independent session. Essential for enterprise environments where multiple users or AI instances need concurrent access. |
| Enterprise Security | Includes DNS rebinding protection and configurable CORS policies to ensure secure communication. IT administrators can control which clients can connect and what origins are permitted. |
| Production-Ready Infrastructure | Built on Express.js with support for custom middleware, allowing integration with existing authentication, logging, and monitoring systems. |
When to Choose HTTP Transport
- Deploying io.Connect Desktop - HTTP transport is the recommended approach for Desktop environments
- Running Backend Services - Your infrastructure includes Node.js servers for application logic
- Supporting Multiple Users - Enterprise deployments where many users need concurrent AI assistance
- Requiring Enterprise Security - Need fine-grained control over access, CORS, and security policies
- Integrating with Existing Infrastructure - Have established Node.js backend systems and want to add AI capabilities
Common Deployment Scenarios
- Enterprise desktop application ecosystems with centralized AI capabilities
- Backend microservices exposing domain-specific functionality to AI assistants
- Multi-user AI assistance platforms requiring session management
- Integration with existing enterprise authentication and security infrastructure
Web Transport
The Web Transport brings io.Intelligence MCP capabilities directly into the browser, eliminating the need for separate server infrastructure. It's ideal for io.Connect Browser environments and lightweight web-based AI integrations.
What It Provides
| Feature | Description |
|---|---|
| Browser-Based Deployment | Runs entirely within web browsers, using io.Connect Browser's interop messaging system for communication between AI assistants and applications. No separate server process or infrastructure is required. |
| Flexible Architecture | Can be deployed as a centralized io.Connect Browser plugin available to all applications, or embedded directly within individual web applications. Supports both server and client roles within the browser environment. |
| Simplified Infrastructure | Eliminates the operational complexity of managing separate MCP server processes. Ideal for organizations wanting AI capabilities without additional infrastructure requirements. |
| io.Connect Integration | Leverages io.Connect Browser's built-in security, messaging, and application management capabilities, ensuring seamless integration with existing browser-based workflows. |
When to Choose Web Transport
- Using io.Connect Browser - Your applications run in the io.Connect Browser environment
- Minimizing Infrastructure - Want to avoid deploying and managing separate server processes
- Building Browser Plugins - Creating centralized AI capabilities as an io.Connect Browser plugin
- Web-to-Web Communication - AI assistants and applications both operate within browsers
- Rapid Deployment - Need quick AI integration without infrastructure setup
Common Deployment Scenarios
- Centralized AI assistant deployed as an io.Connect Browser plugin serving all web applications
- Individual web applications exposing AI capabilities to other applications
- Browser-based workflow automation without backend infrastructure
- Self-contained applications acting as both MCP Server and Client within a single app (example)
- Development and testing environments where simplified deployment is valuable
Custom Transport Integration
For specialized requirements or integration with custom MCP-compliant clients, you can use the @interopio/mcp-core package directly to build your own transport layer.
When to Build a Custom Transport
- Unique Communication Requirements - Your infrastructure uses messaging systems or protocols not covered by HTTP or Web transports
- Custom MCP Clients - Integrating with specialized MCP clients that require specific transport implementations
- Protocol Flexibility - Need to support STDIO, custom networking protocols, or proprietary messaging systems
- Advanced Customization - Require transport-level features or behaviors beyond what standard transports provide
What the mcp-core Package Provides
The @interopio/mcp-core package is the foundation that powers both HTTP and Web transports. It provides:
| Capability | Description |
|---|---|
| Core MCP Server | Core MCP server functionality and tool management |
| Full Capabilities | All io.Intelligence MCP capabilities (application discovery, orchestration, context management) |
| Transport Agnostic | Transport-agnostic MCP server instances compatible with any MCP-compliant transport |
| Maximum Flexibility | Complete flexibility to connect using STDIO, HTTP, Web, or custom transport mechanisms |
Technical Implementation
Developers building custom transports will work directly with the mcp-core package API to create MCP server instances and connect them to custom transport implementations. This approach provides maximum flexibility while maintaining full io.Intelligence MCP capabilities.
Detailed technical documentation for custom transport implementation is available in the MCP Core API Reference.
Next Steps
- Capabilities - Understand what io.Intelligence MCP offers
- Overview - Review the complete feature set
- MCP HTTP Reference - Technical details for HTTP deployments
- MCP Web Reference - Technical details for browser deployments
- MCP Core Reference - Technical details for custom integrations