Remote MCP Server Integration Guide¶

Introduction¶

Remote MCP servers are external services that implement the Model Context Protocol (MCP) and expose tools over HTTP/HTTPS connections. Unlike stdio MCP servers that run as local processes, remote MCP servers:

Run independently on remote infrastructure
Are accessed via HTTP/HTTPS APIs
Support multiple concurrent connections
Can be shared across teams and organizations
Require network-based authentication (Bearer tokens, OAuth 2.0)

What Remote MCP Servers Enable

Remote MCP integration allows your ELITEA agents to:

Access cloud-based services like GitHub, Figma, Atlassian (Jira/Confluence)
Use enterprise tools deployed on corporate infrastructure
Share tool access across multiple ELITEA projects and teams
Scale tool usage without local resource constraints
Centralize authentication and access control

Benefits of Remote MCP Integration

✔️ Scalability: No local process management or resource limits
✔️ Reliability: Enterprise-grade hosting and availability
✔️ Security: Centralized credential management and OAuth flows
✔️ Collaboration: Shared access to tools across teams
✔️ Maintenance: Server updates don't require client changes

Remote vs Stdio MCP Servers¶

Key Differences

Aspect	Remote MCP	Stdio MCP
Connection	HTTP/HTTPS over network	Local process (stdin/stdout)
Transport	SSE or Streamable HTTP	Standard I/O streams
Location	Remote server (cloud/on-prem)	Local machine
Authentication	Bearer tokens, OAuth 2.0	Environment variables, local config
Scalability	High (server-managed)	Limited (local resources)
Setup Complexity	Lower (no local installation)	Higher (requires Node.js, npm, dependencies)
Latency	Network-dependent	Minimal (local)
Sharing	Multi-user, multi-project	Single user/machine
Use Case	Enterprise APIs, cloud services	Local tools, development utilities

When to Use Remote MCP

Choose Remote MCP when you need:

Cloud-based integrations (GitHub, Figma, Atlassian)
Enterprise SaaS tools requiring OAuth authentication
Team-wide tool access shared across multiple users
No local installation requirements
Centralized credential management

When to Use Stdio MCP

Choose Stdio MCP when you need:

Local development tools (file system, browser automation)
Custom tooling specific to your machine
Minimal network latency for time-sensitive operations
Tools requiring local system access

Prerequisites¶

Before configuring Remote MCP servers in ELITEA, ensure you have:

Required Information

✔️ Remote MCP Server URL: The HTTP/HTTPS endpoint for the MCP server
Example: https://api.githubcopilot.com/mcp/ or https://mcp.atlassian.com/v1/sse
✔️ Authentication Credentials: Depending on the server:
Bearer token (API key)
OAuth 2.0 client credentials (Client ID, Client Secret)
Custom authentication headers
✔️ ELITEA Project Access: Permissions to create and configure MCPs in your project
✔️ Network Access: Ability to reach the remote MCP server (check firewall/proxy settings)

Access Requirements

ELITEA account with toolkit creation permissions
Network connectivity to remote MCP endpoints
Valid authentication tokens for the MCP services you want to use

No Local Installation Required

Unlike stdio MCP servers, remote MCPs do not require Node.js, npm, or any local dependencies. All you need is network access and valid credentials.

Authentication Methods¶

Remote MCP servers support multiple authentication mechanisms. Choose the method based on your MCP server's requirements:

Bearer Token (API Key)¶

Most Common: Simple and straightforward for most APIs.

Configuration:

{
  "headers": {
    "Authorization": "Bearer your-api-token-here"
  }
}

UI Fields:

URL: MCP server endpoint (entered in separate field)
Headers: JSON object with Authorization header

When to use:

API key-based services
Internal corporate MCP servers
Development and testing environments

OAuth 2.0 Client Credentials¶

Enterprise Standard: Used by GitHub, Atlassian, and most SaaS providers.

Flow:

Click "Get / Sync tools" in ELITEA MCP configuration
If OAuth is required, authorization modal appears
User clicks "Authorize" and completes OAuth flow in browser
ELITEA stores access token and refresh token
Token automatically refreshed when expired

UI Fields:

URL: MCP server endpoint (entered in separate field)
Client ID: OAuth application client identifier
Client Secret: OAuth application secret
Scopes: OAuth permission scopes (space-separated or array)

UI Experience:

Initial discovery triggers OAuth flow
Authorization modal shows OAuth metadata
One-click authorization
Automatic token management
Re-authorization option available

Supported OAuth Features:

✔️ Authorization Code Flow
✔️ PKCE (Proof Key for Code Exchange)
✔️ Refresh Tokens
✔️ Dynamic Client Registration (DCR)
✔️ Automatic token refresh
✔️ Multiple MCP server authentication

OAuth Metadata Discovery

ELITEA automatically discovers OAuth endpoints using: - WWW-Authenticate header authorization_uri parameter - Resource metadata URLs from resource_metadata parameter - Standard OAuth discovery endpoints (.well-known/oauth-authorization-server)

Custom Authentication Headers¶

Flexible: For services with custom authentication schemes.

Configuration:

{
  "headers": {
    "X-API-Key": "your-custom-key",
    "X-Client-ID": "your-client-id",
    "X-Project": "project-name"
  }
}

UI Fields:

URL: MCP server endpoint (entered in separate field)
Headers: JSON object with custom authentication headers

When to use: - Internal tools with proprietary auth - Multi-header authentication requirements - Services requiring additional metadata headers

Remote MCP Configuration¶

Step-by-Step Setup in ELITEA¶

Step 1. Create Remote MCP

Navigate to MCPs in the left sidebar
Click + Create button
Select Remote MCP type from the form

Step 2. Configure Connection Settings

Name & Description:

Name: Give your MCP a descriptive name (e.g., "GitHub MCP", "Atlassian Integration")
Description: Optional - describe what this MCP provides

URL Configuration:

URL (required): Enter the full HTTP/HTTPS endpoint
- Example: https://api.githubcopilot.com/mcp/
- Example: https://mcp.atlassian.com/v1/sse

Headers Configuration:

Headers (optional): JSON object with authentication headers

For Bearer token:

{
  "Authorization": "Bearer ghp_yourGitHubTokenHere"
}

For custom headers:

{
  "X-API-Key": "your-key",
  "X-Custom-Header": "value"
}

Advanced Settings (optional):

Timeout (optional): Request timeout in seconds (default: 60, range: 1-3600)
Enable Caching: Cache tool schemas for better performance (default: enabled)
Cache TTL: Cache time-to-live in seconds (default: 300, range: 60-3600)

Step 3. Discover Tools

After entering URL (and headers if needed), click Get / Sync tools
ELITEA will connect to the remote MCP server
If OAuth is required:
- Authorization modal appears
- Click Authorize
- Complete OAuth flow in new browser tab
- Return to ELITEA - tools will load automatically
Available tools appear in the tools list

Step 4. Select Tools (Optional)

By default, all tools are enabled
Uncheck specific tools to exclude them
Use Selected Tools field to filter tools by name

Step 5. Save Configuration

Review your configuration
Click Save
MCP is now available for use in agents, pipelines, and chats

Configuration Fields Reference¶

Field	Type	Required	Description	Example
Name	String	Yes	Descriptive name for this MCP	"Atlassian MCP"
Description	String	No	What this MCP provides	"Jira and Confluence integration"
URL	String	Yes	HTTP/HTTPS endpoint for MCP server	`https://mcp.atlassian.com/v1/sse`
Headers	JSON Object	No	HTTP headers (auth, custom)	`{"Authorization": "Bearer token", "X-Atlassian-Cloud-Id": "cloud-id"}`
Client ID	String	No	OAuth 2.0 client identifier	`atlassian-client-id`
Client Secret	String	No	OAuth 2.0 client secret	`atlassian-client-secret`
Scopes	Array	No	OAuth 2.0 permission scopes	`["read:jira-work", "write:jira-work"]`
Enable Caching	Boolean	No	Cache tool schemas	`true`
Cache TTL	Integer	No	Cache duration (60-3600 seconds)	`300`

Example 1: GitHub Remote MCP Integration¶

Use Case

Automate GitHub workflows including: - Repository analysis and code review - Issue and pull request management - Automated PR creation and updates - Code search across repositories - Branch and commit operations

Prerequisites¶

GitHub Account with appropriate permissions
Authentication credentials (choose one):
Personal Access Token for Bearer token authentication, OR
GitHub Copilot MCP OAuth credentials (Client ID and Client Secret) for OAuth flow
Repository access for the tools you want to use

Obtaining GitHub Credentials¶

Option 1: Personal Access Token (Simpler Setup)

Go to GitHub Settings → Developer settings → Personal access tokens
Click Generate new token → Generate new token (classic)
Configure token:
Note: "ELITEA MCP Access"
Expiration: Choose appropriate duration
Select scopes:
- ✔️ repo (Full control of private repositories)
- ✔️ read:org (Read org and team membership)
- ✔️ workflow (Update GitHub Actions workflows)
- ✔️ read:user (Read user profile data)
Click Generate token
Copy the token immediately - you won't see it again!

Option 2: GitHub Copilot MCP OAuth (Enterprise/Team Use)

Contact GitHub or your organization's GitHub administrator to obtain:
Client ID: OAuth application client identifier
Client Secret: OAuth application secret
Ensure the OAuth app has appropriate scopes (same as above)
Note the Callback URL configured for the OAuth app (must match ELITEA's OAuth redirect URL)

Authentication Priority

If you provide a valid Bearer token in Headers, the system will connect automatically using token authentication. If Headers are empty or invalid, the system will fall back to OAuth flow using Client ID and Client Secret.### Step-by-Step Setup

Configure GitHub MCP¶

1. Basic Settings

Name: GitHub MCP
Description: GitHub repository management and automation tools

2. Connection Configuration

URL: https://api.githubcopilot.com/mcp/

3. Advanced Settings

Timeout: 90 seconds (GitHub operations can be slower)
Enable Caching: ✔️ Enabled
Cache TTL: 600 seconds (10 minutes)

4. Authentication (choose one method)

Method 1: Bearer Token (recommended for individual use)¶

Configuration:

Headers:

{
  "Authorization": "Bearer ghp_your_github_token_here"
}

Client ID: Leave empty
Client Secret: Leave empty
Scopes: Leave empty

Test Connection and Discover Tools:

Click Get / Sync tools button
ELITEA connects directly to GitHub MCP server
Tools load immediately if token is valid
No additional authorization required

Method 2: OAuth (recommended for team/enterprise)¶

Configuration:

Headers: {} (leave empty)
Client ID: Your GitHub OAuth application client ID
Client Secret: Your GitHub OAuth application client secret
Scopes: Define required OAuth scopes based on your needs:

e.g.,

admin:repo_hook, admin:ssh_signing_key, audit_log, codespace, copilot, delete:packages, delete_repo, gist, notifications, project, repo, user, workflow, write:discussion, write:network_configurations, write:packages

Scope Selection

Only include scopes your application needs. For basic GitHub MCP operations, repo, workflow, and user are typically sufficient.

Test Connection and Discover Tools:

Click Get / Sync tools button
Authorization modal appears automatically where you can provide or modify:
- Client ID: OAuth application client identifier
- Client Secret: OAuth application secret
- Scopes: Required OAuth permission scopes
Click Authorize to proceed
GitHub OAuth page opens in new browser tab
Review and approve requested permissions
GitHub redirects back to ELITEA
Tools load automatically after successful authorization

5. Review Available GitHub Tools

Common GitHub MCP tools include:

Tool Name	Description	Use Case
`create_issue`	Create a GitHub issue	Bug reports, feature requests
`create_pull_request`	Create a new pull request	Submit code changes
`list_repositories`	List accessible repositories	Repository discovery
`get_repository`	Get repository details	Repository information
`list_pull_requests`	List PRs in a repository	PR review workflows
`get_pull_request`	Get PR details	Review specific PR
`create_comment`	Add comment to issue/PR	Automated responses
`search_code`	Search code across repositories	Code analysis
`get_file_contents`	Read file from repository	Code review, analysis
`list_commits`	List commits in repository	History tracking

6. Save Configuration

Click Save to create the GitHub MCP.

Example 2: Atlassian Remote MCP Integration¶

Use Case

Automate Atlassian workflows including: - Jira issue tracking and project management - Sprint planning and board management - Confluence documentation generation - Cross-platform reporting (Jira + Confluence) - Automated ticket creation from incidents

Prerequisites¶

✔️ Atlassian Account with access to Jira and/or Confluence
✔️ Atlassian Cloud site with Jira, Confluence, and/or Compass
✔️ Site access to your Atlassian cloud instance
✔️ Product access: Users need access to Atlassian products they want to integrate
✔️ First-time setup: The first user to complete OAuth consent flow must have access to all requested products
✔️ Appropriate permissions for the operations you want to perform
✔️ Modern browser for completing OAuth 2.1 authorization flow

No Pre-Configuration Required

You don't need to create OAuth applications or obtain credentials in advance. Simply log in with your Atlassian account credentials when prompted during the OAuth flow.

Configuring Atlassian Rovo MCP Server Domain Access¶

Domain configuration is only required for organization admins who want to control which AI tools can connect to their Atlassian organization.

Step 1: Access Rovo MCP Server Settings

Go to Atlassian Administration
Select your organization if you have more than one
Navigate to Apps → AI settings → Rovo MCP server

Step 2: Add Custom Domain

By default, Atlassian-supported domains (ChatGPT, Claude, Google Gemini, etc.) are automatically allowed.

To add your custom domain (e.g., ELITEA):

Click Add domain
Enter your domain with required protocol format: (e.g, https://next.elitea.ai/**)
Click Add to save

Step 3: (Optional) Block Atlassian-Supported Domains

If your security policy requires restricting to only custom domains:

Deselect Allow Atlassian supported domains
Only your manually added domains will be allowed

Admin Requirements

Role required: Organization admin
Available for: Atlassian Cloud (Free, Standard, Premium, Enterprise)

Step-by-Step Setup¶

Configure Atlassian MCP

1. Basic Settings

Name: Atlassian MCP
Description: Jira and Confluence integration for project management and documentation

2. Connection Configuration

URL: https://mcp.atlassian.com/v1/mcp

!!! note "Atlassian Rovo MCP Endpoint" The official Atlassian Rovo MCP endpoint is https://mcp.atlassian.com/v1/mcp (recommended). The legacy /sse endpoint is still supported but Atlassian recommends updating to /mcp for new configurations.

3. Advanced Settings

Timeout: 120 seconds (Atlassian operations can be slow)
Enable Caching: ✔️ Enabled
Cache TTL: 300 seconds (5 minutes)

4. Authentication

Configuration:

Headers: {} (leave empty)
Client ID: (leave empty)
Client Secret: (leave empty)
Scopes: (leave empty)

Test Connection and Discover Tools:

Click Get / Sync tools button
Authorization modal appears automatically
Click Authorize to proceed
Atlassian OAuth page opens in new browser tab
Select your site and approve requested permissions
Atlassian redirects back to ELITEA
Tools load automatically after successful authorization

5. Review Available Atlassian Tools

Common Atlassian MCP tools include:

Jira Tools:

Tool Name	Description	Use Case
`jira_create_issue`	Create new Jira issue	Bug reports, tasks, stories
`jira_get_issue`	Get issue details	Issue analysis
`jira_update_issue`	Update existing issue	Status changes, assignments
`jira_search_issues`	Search with JQL	Finding related issues
`jira_get_board`	Get board information	Sprint planning
`jira_get_sprint`	Get sprint details	Sprint management
`jira_list_projects`	List accessible projects	Project discovery
`jira_add_comment`	Add comment to issue	Collaboration
`jira_get_transitions`	Get available transitions	Workflow automation
`jira_transition_issue`	Change issue status	Workflow progression

Confluence Tools:

Tool Name	Description	Use Case
`confluence_create_page`	Create new page	Documentation generation
`confluence_get_page`	Retrieve page content	Reading documentation
`confluence_update_page`	Update existing page	Documentation updates
`confluence_search_content`	Search Confluence	Finding documentation
`confluence_list_spaces`	List Confluence spaces	Space discovery
`confluence_get_space`	Get space details	Space information
`confluence_create_attachment`	Upload file	Document attachments

6. Save Configuration

Click Save to create the Atlassian MCP.

Testing MCP Tools¶

After configuring and saving your Remote MCP, you can test individual tools directly in ELITEA to verify they work correctly.

How to Test MCP Tools

Navigate to MCPs → Click on your configured MCP
Locate the TEST SETTINGS panel displaying all available tools
Select a tool from the list to open its parameter form
Fill in required parameters (e.g., for github_create_issue: repository, title, body)
Click Run to execute the tool with your configured authentication
Review results in the output panel and verify in the target system

Testing Best Practices

Test with non-production data when possible
Start with read-only tools (e.g., list_repositories, get_issue) before testing write operations
Use the test panel to verify authentication and permissions are working correctly

Use Remote MCP in Agents, Pipelines, and Chat¶

Once your Remote MCP is created, you can use it in various ELITEA features:

In Agents:¶

Navigate to Agents: Open the sidebar and select Agents.
Create or Edit Agent: Click + Create for a new agent or select an existing agent to edit.
Add Remote MCP:
- In the "TOOLKITS" section of the agent configuration, click the "+MCP" icon
- Choose your Remote MCP from the list (e.g., "GitHub MCP", "Atlassian MCP")
- The MCP will be added to your agent with all configured tools available
Authorization (if required): * If the MCP requires OAuth authentication and you're not already connected, a Log In button will appear next to the MCP * Click Log In to open the authorization modal * Complete the OAuth flow without leaving the agent editor * Once authorized, the MCP is ready to use

Your agent can now interact with the remote MCP server using the configured tools.

In Pipelines:¶

Navigate to Pipelines: Open the sidebar and select Pipelines.
Create or Edit Pipeline: Either create a new pipeline or select an existing pipeline to edit.
Add Remote MCP:
- In the "TOOLKITS" section of the pipeline configuration, click the "+MCP" icon
- Choose your Remote MCP from the list (e.g., "GitHub MCP", "Atlassian MCP")
- The MCP will be added to your pipeline with all configured tools available for use in pipeline nodes
Authorization (if required): * If the MCP requires OAuth authentication and you're not already connected, a Log In button will appear next to the MCP * Click Log In to open the authorization modal * Complete the OAuth flow without leaving the pipeline editor * Once authorized, the MCP is ready to use in pipeline nodes

In Chat:¶

Navigate to Chat: Open the sidebar and select Chat.
Start New Conversation: Click +Create or open an existing conversation.
Add Toolkit to Conversation:
- In the chat Participants section, look for the MCP element
- Click "+MCP" to add the MCP
- Choose your Remote MCP from available options (e.g., "GitHub MCP")
- The MCP will be added to your conversation with all tools available
Authorization (if required): * If the MCP requires OAuth authentication and you're not already connected, a Log In button will appear next to the MCP in the Participants section * Click Log In to open the authorization modal * Complete the OAuth flow without leaving the chat interface * Once authorized, the MCP is ready to use in your conversation
Use MCP in Chat: You can now directly interact with your remote MCP by asking questions or requesting actions that will trigger the MCP tools.

Best Practices¶

When working with Remote MCP servers, follow these best practices to ensure secure, efficient, and reliable integration:

Security

Authentication & Credentials:

Use OAuth 2.0 when available instead of static API keys
Store sensitive tokens and credentials securely (never commit to version control)
Rotate API keys and tokens regularly according to your security policy
Use the principle of least privilege - request only necessary OAuth scopes
Monitor token expiration and renewal processes

Access Control:

Limit MCP access to authorized team members only
Review and audit MCP configurations periodically
Implement proper logging for security monitoring

Performance

Optimization:

Enable caching to reduce redundant API calls
Set appropriate cache TTL values based on data freshness requirements
Configure reasonable timeout values (avoid too short or too long timeouts)
Use tool filtering to expose only necessary operations to agents

Rate Limiting:

Be aware of API rate limits from your MCP provider
Implement retry logic with exponential backoff for transient failures
Monitor usage patterns to avoid hitting rate limits

Reliability

Error Handling:

Test MCP configurations thoroughly before production use
Use the TEST SETTINGS panel to verify tools work correctly
Start with read-only operations before enabling write operations
Monitor MCP connectivity and tool execution success rates

Documentation:

Document OAuth scopes and their purposes for your team
Maintain clear descriptions for each MCP configuration
Document agent instructions that reference MCP tools
Keep track of MCP server endpoints and version changes

Agent Design

Tool Usage:

Provide clear agent instructions that explain available MCP tools
Include conversation starters to guide users on how to interact with MCP tools
Implement confirmation steps for destructive operations (delete, update)
Design agents to handle tool failures gracefully

Testing:

Test agents in non-production environments first
Verify OAuth flows work correctly for all team members
Test edge cases and error scenarios
✔️ Validate that agent instructions align with available tool capabilities