Skip to main content
Version: 18.x

Machine & Workload Identity with MCP Access

Report an Issue

Teleport protects and controls access to Model Context Protocol (MCP) servers. Machine & Workload Identity (MWI) can then be used to grant machines and workloads secure and short-lived access to these MCP servers without the need for long-lived static secrets.

In this guide, you will configure tbot to produce short-lived credentials that can be used by an MCP client to access MCP servers enrolled within your Teleport cluster.

This guide focuses on granting machines access to MCP servers. If you wish to grant human users access to MCP servers, you should instead refer to the MCP Access with Stdio MCP Server guide.

How it works​

The Teleport Application Access agent is deployed in front of the MCP server that you wish to protect access to. This agent is responsible for enforcing access control based on roles configured in Teleport.

The Machine & Workload Identity agent, tbot, is installed on the machine that will require access to the MCP server. It is responsible for authenticating to the Teleport cluster and producing an identity file that can be used by the MCP client to access the MCP server through the Teleport Proxy.

Prerequisites​

  • A running Teleport cluster. If you want to get started with Teleport, sign up for a free trial or set up a demo environment.

  • The tctl and tsh clients.

    Installing tctl and tsh clients

    1. Determine the version of your Teleport cluster. The tctl and tsh clients must be at most one major version behind your Teleport cluster version. Send a GET request to the Proxy Service at /v1/webapi/find and use a JSON query tool to obtain your cluster version. Replace teleport.example.com:443 with the web address of your Teleport Proxy Service:

      TELEPORT_DOMAIN=teleport.example.com:443
      TELEPORT_VERSION="$(curl -s https://$TELEPORT_DOMAIN/v1/webapi/find | jq -r '.server_version')"

    2. Follow the instructions for your platform to install tctl and tsh clients:

      Download the signed macOS .pkg installer for Teleport, which includes the tctl and tsh clients:

      curl -O https://cdn.teleport.dev/teleport-${TELEPORT_VERSION?}.pkg

      In Finder double-click the pkg file to begin installation.

      danger

      Using Homebrew to install Teleport is not supported. The Teleport package in Homebrew is not maintained by Teleport and we can't guarantee its reliability or security.

    Connecting with TLS routing disabled

    This guide's commands assume your Teleport cluster uses TLS routing (proxy_listener_mode: multiplex), where the tctl and tsh clients reach every Teleport service through the Proxy Service's web address on port 443. If you're not sure whether this applies to your cluster, check with whoever manages it.

    If your cluster uses separate listener ports instead, adjust ports as follows:

    • tsh commands (e.g., tsh login --proxy=...): continue using the Proxy Service web address on port 3080 (or 443 if behind a load balancer). Do not change these to port 3025.

    • Direct tctl or Auth Service API commands: use port 3025 for the Auth Service gRPC listener:

      tctl status --auth-server=teleport.example.com:3025
  • If you have not already connected your MCP server to Teleport, follow the MCP Getting Started guide.
  • Check that you can connect to your Teleport cluster and verify that you can run tctl and tsh commands using your current credentials.

    1. Assign teleport.example.com to the domain name of the Teleport Proxy Service in your cluster and [email protected] to your Teleport username.

    2. Authenticate to your Teleport cluster. This depends on whether your shell is interactive or not.

      In an interactive shell: Run the following command. By default, this triggers a multi-factor authentication prompt:

      tsh login --proxy=teleport.example.com --user=[email protected]
      tctl status
      Cluster  teleport.example.com
      Version  18.10.0
      CA pin   sha256:abdc1245efgh5678abdc1245efgh5678abdc1245efgh5678abdc1245efgh5678

      On non-interactive environments: If you are running tsh and tctl as an AI agent, in a CI/CD environment, or similar, make sure the TELEPORT_IDENTITY_FILE environment variable is assigned to a valid file path with credentials for your cluster. tsh and tctl read the file path from the environment variable and do not require a separate authentication step. If there is no identity file available, we recommend that you set up Machine ID to provision one automatically.

      When executing tctl commands with an identity file, you must pass the --auth-server flag to provide the Teleport Auth Service address, which is not included in the identity file. If you provide the Proxy Service address, tctl connects to the Proxy Service, which forwards traffic to and from the Teleport Auth Service. Update 443 to 3025 if you are contacting the Auth Service directly with tctl:

      tctl status --auth-server=teleport.example.com:443

      For tsh commands that read an identity file, you must pass the --proxy flag, which points tsh to the address of the Teleport Proxy Service:

      tsh status --proxy=teleport.example.com

      Ensure client commands can access your identity file. Replace path/to/identity/file with the path to your identity file:

      export TELEPORT_IDENTITY_FILE="${TELEPORT_IDENTITY_FILE:-path/to/identity/file}"

      Add the --auth-server or --proxy flags to all subsequent tctl and tsh commands.

    If you can connect to the cluster and run the tctl status command, you can use your current credentials to run subsequent tctl commands from your workstation. If you host your own Teleport cluster, you can also run tctl commands on the computer that hosts the Teleport Auth Service for full permissions.
  • tbot and tsh must already be installed and configured on the machine that will access MCP servers. For more information, see the deployment guides.

Step 1/3. Configure RBAC​

First, Teleport must be configured to allow the credentials produced by the bot to access MCP servers in your infrastructure. This is done by creating a role that specifies label matchers for the MCP server that you want to grant access to, and, specifying with tools within the MCP server that should be accessible.

In our example, we will grant access to an MCP server that has been labelled with env: dev and allow access to all tools within that MCP server.

Create a file named role.yaml with the following content:

kind: role
version: v6
metadata:
  name: example-role
spec:
  allow:
    app_labels:
      'env': 'dev'
    mcp:
      tools: ['*']

Replace example-role with a descriptive name related to your use case, adjust the app_labels to match the labels of your MCP server, and modify the mcp.tools field to specify which tools you want to allow access to.

Use tctl create -f ./role.yaml to create the role.

tip

You can also create and edit roles using the Web UI. Go to Access -> Roles and click Create New Role or pick an existing role to edit.

Now, use tctl bots update to add the role to the Bot. Replace example with the name of the Bot you created in the deployment guide and example-role with the name of the role you just created:

tctl bots update example --add-roles example-role

Step 2/3. Configure tbot​

Next, you'll configure tbot to output an identity file. This identity file will then be used by the MCP client to authenticate to Teleport. This is done using the identity service type.

The service will need to be configured with a destination. In this example, the directory type will be used. This will write artifacts to the specified directory on disk. Ensure that this directory is writable by the user that tbot runs as, and that it can be read by the Linux user that the MCP client will be running as.

Modify your tbot configuration to add an identity service:

services:
  - type: identity
    allow_reissue: true
    destination:
      type: directory
      path: /opt/machine-id

Ensure that you replace /opt/machine-id with the directory you have chosen.

Apply your configuration. The command to execute depends on how you are running tbot.

If you are running tbot as a background service, execute the following command, which instructs tbot to reload its configuration:

sudo systemctl reload tbot

If you are running tbot in one-shot mode, before you attempt to access your credentials later, you must execute tbot, pointing it to the location of its configuration file (/etc/tbot.yaml in the example below):

tbot start -c /etc/tbot.yaml

Step 3/3. Connect your MCP client​

You can now configure your MCP client to use the credentials produced by tbot to access MCP servers. The exact steps you need to take will depend on the MCP client you are using.

For compatibility with LangGraph, use the langchain-mcp-adapters package. This package implements an MCP client and exposes the tools from an MCP server in the same way as tools defined natively in Python.

Instantiate a MultiServerMCPClient and configure it to call tsh mcp connect with the identity file produced by tbot:

    from langchain_mcp_adapters.client import MultiServerMCPClient
    client = MultiServerMCPClient({
        "my-mcp-server": {
            "command": "tsh",
            "args": [
                "mcp",
                "connect",
                "-i", "/opt/machine-id/identity",
                "--proxy", "example.teleport.sh:443",
                "my-mcp-server",
            ],
            "transport": "stdio",
        },
    })
    tools = await client.get_tools()

Modify the example values to match your environment:

  • /opt/machine-id/identity with the path to the identity file produced by tbot.
  • example.teleport.sh:443 with the address of your Teleport proxy.
  • my-mcp-server with the name of your MCP server as enrolled in Teleport.

See the LangGraph documentation for further details.

Next steps​