Skip to main content
Custom MCP Connectors connect to your own MCP servers. Ideal for proprietary tools, complex logic, or internal systems.

​
When to Use Custom MCP

Use Custom MCP when:
  • Building proprietary tools
  • Integrating internal systems
  • Need full control over implementation
  • REST doesn’t fit use case
  • Want to leverage MCP ecosystem

​
Custom MCP vs Alternatives

OptionControlSetupMaintenance
REST ConnectorMediumEasyLow
MCP RegistryNoneEasyNone
Custom MCPFullHardMedium
PluginFullMediumMedium

​
Creating Custom MCP Connector

1

Have MCP Server Ready

Your MCP server should be:
  • Running and accessible
  • On stable URL or local network
  • Properly authenticated
  • Implements MCP spec
2

Start Creation

  1. Connectors > Create Connector
  2. Choose Custom MCP
3

Configure Transport

Choose how to connect:
  • HTTP - Standard web connection
  • SSE - Server-Sent Events
  • Stdio - Direct process connection
Provide URL or connection details.
4

Set Environment

  1. Add environment variables if needed
  2. Configure authentication
  3. Test connection
5

Test Tools

  1. Connector auto-discovers tools
  2. Test each tool
  3. Verify responses
6

Save

Connector now ready to attach to agents/gateways.

​
MCP Server Setup

Your MCP server needs to:
  1. Implement MCP Protocol - Follow Model Context Protocol spec
  2. Expose Tools - Define available functions
  3. Handle Requests - Process incoming calls
  4. Return Results - Provide structured responses
  5. Be Accessible - Network accessible to Noorle

​
Minimal MCP Server (Node.js)

const { Server } = require("@modelcontextprotocol/sdk");

const server = new Server({
  name: "my-mcp",
  version: "1.0.0"
});

server.setRequestHandler("tools/list", async () => {
  return {
    tools: [
      {
        name: "greet",
        description: "Greet someone",
        inputSchema: {
          type: "object",
          properties: {
            name: { type: "string" }
          }
        }
      }
    ]
  };
});

server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "greet") {
    return {
      content: [{
        type: "text",
        text: `Hello, ${request.params.arguments.name}!`
      }]
    };
  }
});

server.start();

​
Minimal MCP Server (Python)

from mcp.server import Server

app = Server("my-mcp", "1.0.0")

@app.list_tools()
async def list_tools():
    return [
        {
            "name": "greet",
            "description": "Greet someone",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"}
                }
            }
        }
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "greet":
        return {
            "content": [{
                "type": "text",
                "text": f"Hello, {arguments['name']}!"
            }]
        }

if __name__ == "__main__":
    app.run()

​
Transport Options

​
HTTP

URL: https://your-mcp-server.com
Supports: All operations
Auth: Yes (headers, OAuth)

​
SSE (Server-Sent Events)

URL: https://your-mcp-server.com/sse
Supports: Streaming responses
Auth: Yes

​
Stdio

Command: /path/to/mcp-server
Supports: Direct process
Auth: Via environment vars

​
Authentication

Secure your MCP server: API Key: 
{
  "auth_config": {
    "type": "bearer",
    "token": "your-api-key"
  }
}
OAuth 2.0: 
{
  "auth_config": {
    "type": "oauth2",
    "authorization_url": "...",
    "token_url": "...",
    "client_id": "...",
    "client_secret": "..."
  }
}
Custom Headers: 
{
  "headers": [
    ["Authorization", "Bearer token"],
    ["X-Custom-Header", "value"]
  ]
}

​
Tool Discovery

Noorle automatically discovers tools from your MCP server:
  1. Connector initializes connection
  2. Requests tools/list
  3. Server returns tool definitions
  4. Tools immediately available
No manual tool definition needed.

​
Testing Tools

After creating connector:
  1. Click Test
  2. Select tool from list
  3. Enter sample input
  4. Execute
  5. View response
Verify all tools work as expected.

​
Environment Variables

Store sensitive config in environment variables: 
{
  "env": {
    "API_KEY": "encrypted_value",
    "DATABASE_URL": "encrypted_value"
  }
}
In your MCP server, access via: 
process.env.API_KEY

​
Cost

For current pricing details, see Pricing. Monitor in Account > Usage dashboard.

​
Best Practices

​
Tool Design

  • Clear, descriptive names
  • Complete descriptions
  • Comprehensive input schemas
  • Useful response formats

​
Error Handling

Return meaningful errors: 
{
  "isError": true,
  "content": [{
    "type": "text",
    "text": "Error: Invalid input"
  }]
}

​
Performance

  • Optimize tool execution
  • Handle timeouts gracefully
  • Return efficient responses
  • Consider caching

​
Security

  • Authenticate all requests
  • Validate inputs rigorously
  • Don’t expose secrets
  • Log activity

​
Troubleshooting

​
”Connection Failed”

  • Verify server is running
  • Check URL is accessible
  • Ensure firewall allows connection
  • Test with curl or mcp-cli

​
”Tool Not Found”

  • Verify tool registered in tools/list
  • Check tool name exactly
  • Restart MCP server
  • Re-create connector

​
”Authentication Failed”

  • Verify credentials are correct
  • Check auth method matches
  • Ensure token hasn’t expired
  • Review server auth config

​
”Timeout”

  • Server response too slow
  • Increase timeout setting
  • Optimize server performance
  • Check network latency

​
Hosting Options

Run your MCP server on any cloud platform or serverless provider that supports your runtime. Deploy to any service with:
  • Full control over infrastructure
  • Support for your language/framework
  • Network accessibility to Noorle
  • Proper monitoring and logging

​
Monitoring

Monitor custom MCP health:
  1. Connectors > Select connector
  2. View Activity tab
  3. Check recent calls
  4. View errors and latency

​
Next Steps