Peliqan has an out-of-the-box MCP Server. However, you can also build custom MCP Servers in Peliqan. You can use the Peliqan MCP Server template to get started. You can extend this template by adding your own “tools”, these are Python functions decorated with @mcp.tool().

Contents
How to build a Custom MCP Server in Peliqan
Configure your MCP Client
ChatGPT
Claude
Microsoft Copilot
Add intent detection
Build a custom MCP server with SSO using Microsoft Azure Entra (oAuth)

How to build a Custom MCP Server in Peliqan

Install the “MCP Server” script from the app templates:

Add an API endpoint (method POST) and link it to the “MCP Server” script (this is the API handler script). Click here for more info on how to publish an API endpoint in Peliqan.

Update the credentials (API key) in your script and store in the Peliqan Secret Store.

Configure your MCP Client

ChatGPT

In ChatGPT, click on your account name (bottom left corner) and click on Settings.

Go to Settings > Apps > Advanced Settings > Enable “Developer mode”.

Go to Settings > Apps > Create App.

Enter the URL of your MCP API endpoint, including the API key:

If you make updates to your MCP Server (e.g. you add tools), make sure to click the “Refresh” button on the detail screen of your app and check if the new actions are available for your app.

Claude

You can use Claude.ai (in the browser) or Claude Desktop, but you need a Paid plan (e.g. Claude Pro) to add a Remote MCP Server.

Go to Settings > Connectors > Add custom connector.

Enter the URL of your MCP API endpoint, including the API key:

Microsoft Copilot

In Copilot Studio, add an Agent and add a Tool of type “MCP Server” to the agent.

Select None or API key for the MCP Server authentication type (depending on how you implemented authorization in your custom MCP Server).

Publish your agent in Copilot Studio to make it available in Copilot chat. Next, you can access your Agent in Copilot chat and use it to access your MCP Server.

Troubleshooting in Copilot Studio

If you don’t have permissions to publish you agent, follow the below steps to allow a user to publish an agent:

‣

Click to expand

If you get an error “A custom connector with display name xxx already exists”, follow the below steps:

‣

Click to expand

Add intent detection

Intent detection (logging the original intent of the user) is useful to improve your MCP implementation. See example code below. Without intent detection you will only be able to log tool invokations, without knowing what the user (using the MCP) wanted to achieve.

‣

Click to expand code

TOOL_INTENT_DESCRIPTION = (
    "Explain the original intent of the user, taking into account previous instructions from the user,"
    "so that the full intent from the user and reason to invoke this tool is clear. Never include credentials"
)

# See below, add the "intent detection" section to this function, see highlighted code 
def tool(min_scope: int = 1):
    """Decorator: register a function as an MCP tool, gated by min_scope."""
    def decorator(func):
        sig = inspect.signature(func)
        type_hints = get_type_hints(func)

        raw_doc = func.__doc__ or ""
        param_docs = {}
        for line in raw_doc.splitlines():
            line = line.strip()
            if line.startswith(":param"):
                try:
                    _, rest = line.split("param", 1)
                    name, desc = rest.split(":", 1)
                    param_docs[name.strip()] = desc.strip()
                except ValueError:
                    pass

        type_map = {"str": "string", "int": "number", "float": "number", "bool": "boolean"}
        properties = {}
        required = []

        for name, param in sig.parameters.items():
            hint = type_hints.get(name, "any")
            type_str = hint.__name__ if isinstance(hint, type) else str(hint)
            prop = {
                "type": type_map.get(type_str, "string"),
                "description": param_docs.get(name, ""),
            }
            if param.default is not inspect._empty:
                prop["default"] = param.default
            else:
                required.append(name)
            properties[name] = prop

        # Intent detection: injected into every tool's schema here, rather
        # than added as a real parameter to each function individually.
        # _handle_tool_call strips it back out before calling the real
        # function, so none of the tool functions know this field exists.
        properties["tool_intent"] = {
            "type": "string",
            "description": TOOL_INTENT_DESCRIPTION,
        }

        MCP_TOOLS.append({
            "name": func.__name__,
            "description": raw_doc.strip().split("\n")[0] if raw_doc else "",
            "inputSchema": {"type": "object", "properties": properties, "required": required},
        })
        TOOL_PERMISSIONS[func.__name__] = min_scope
        TOOL_FUNCTIONS[func.__name__] = func
        return func
    return decorator

# Call _log_tool_intent() when invoking a tool, see below highlighted code
def _handle_tool_call(mcp_req, request_id):
    tool_name = mcp_req["params"]["name"]
    args = dict(mcp_req["params"].get("arguments", {}))  # copy: about to pop tool_intent out
    tool_intent = args.pop("tool_intent", "")
    _log_tool_intent(tool_name, tool_intent)

    required_scope = TOOL_PERMISSIONS.get(tool_name, 1)
    func = TOOL_FUNCTIONS.get(tool_name)  # only @tool-registered functions are reachable

    is_error = False
    if func is None:
        tool_response = f"Unknown tool: '{tool_name}'."
        is_error = True
    elif not require_scope(required_scope):
        tool_response = (
            f"Unauthorized: tool '{tool_name}' requires scope {required_scope}, "
            f"Your key has scope {CURRENT_USER.get('scope', 0)}."
        )
        is_error = True
    else:
        try:
            tool_response = func(**args)  # tool_intent already removed, real signature untouched
        except Exception as e:
            tool_response = str(e)
            is_error = True

    response_type = "text"
    response = mcp_response_tools_call(request_id, response_type)
    if is_error:
        response["result"]["isError"] = True

    response_format = get_tool_response_format(tool_name) if func else "str"
    if response_format == "str":
        response["result"]["content"][0][response_type] = tool_response
    else:  # list, dict, ...
        response["result"]["content"][0][response_type] = json.dumps(tool_response)
    return response

# Add this function to your MCP Server code
def _log_tool_intent(tool_name, tool_intent):
    """
    Best-effort: log the calling agent's stated intent for this tool call.
    A logging failure must never block the actual tool call.
    """
    if not tool_intent:
        return
    try:
        dbconn.insert(DW_NAME, "ts_prod", "tool_intent_log", {
            "logged_at": str(int(time.time())),
            "tool_name": tool_name,
            "user_id": CURRENT_USER.get("user_id"),
            "scope": CURRENT_USER.get("scope"),
            "tool_intent": tool_intent,
        })
    except Exception:
        pass

Build a custom MCP server with SSO using Microsoft Azure Entra (oAuth)

If you want to enforce permissions per user in your MCP Server, you have to use oAuth. This can be done for example in combination with SSO (single sign on) on Microsoft Azure (Entra ID).

More info on how to build a custom MCP Server with oAuth and SSO to Azure:

Build a custom MCP Server on Peliqan with oAuth and Azure SSO

Build a custom MCP Server on Peliqan

Contents