Connect your agent

Claude Code

Verified 2026-09-07 on Claude Code 2.1.263.

claude mcp add --transport http plexarm https://api.plexarm.com/mcp \
  --header "Authorization: Bearer $PLEXARM_TOKEN"

/plugin marketplace add natalabs/plexarm-plugin
/plugin install plexarm@plexarm

Add -s user to make it available in every project rather than the current one.

claude mcp add stores the expanded token value in ~/.claude.json — the shell expands the variable before Claude sees it. That is this client's documented behaviour.

The plugin reads PLEXARM_TOKEN from your environment each time it starts and stores nothing. If Claude Code offers to configure an API token after the install, skip it — that field is a legacy fallback.

Vendor documentation

LangChain and LangGraph

Verified 2026-09-07 on langchain-mcp-adapters 0.3.2.

import os
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "plexarm": {
        "transport": "streamable_http",
        "url": "https://api.plexarm.com/mcp",
        "headers": {"Authorization": f"Bearer {os.environ['PLEXARM_TOKEN']}"},
    }
})
tools = await client.get_tools()

Run as written, then ainvoke on the plexarm_whoami tool returned person and account. The README now spells the transport "http"; "streamable_http" is what was run on 0.3.2.

Vendor documentation

OpenAI Agents SDK

Verified 2026-09-07 on openai-agents 0.22.0.

import os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(
    name="plexarm",
    params={"url": "https://api.plexarm.com/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['PLEXARM_TOKEN']}"}},
) as plexarm:
    agent = Agent(name="Assistant", instructions="Record what you do in Plexarm.", mcp_servers=[plexarm])
    print((await Runner.run(agent, "Who am I in Plexarm?")).final_output)

Connects and calls tools — verified; the agent loop is OpenAI's. The Agent and Runner lines need an OpenAI key.

Vendor documentation

Any stdio-only client, including JetBrains

Verified 2026-09-07 on mcp-remote 0.8.3.

{
  "mcpServers": {
    "plexarm": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.plexarm.com/mcp",
               "--header", "Authorization:${PLEXARM_AUTH}"],
      "env": { "PLEXARM_AUTH": "Bearer <your token>" }
    }
  }
}

The bridge was registered in Claude Code as a stdio server and reached plexarm_whoami through it.

JetBrains AI Assistant documents a remote server with no headers key, so it cannot send a bearer token natively. The bridge is the route.

The header is passed through an environment variable because some hosts split arguments on spaces.

Vendor documentation

Codex CLI

From the vendor's documentation, 2026-09-07.

codex mcp add plexarm --url https://api.plexarm.com/mcp --bearer-token-env-var PLEXARM_TOKEN

[mcp_servers.plexarm]
url = "https://api.plexarm.com/mcp"
bearer_token_env_var = "PLEXARM_TOKEN"

Or write the same server into ~/.codex/config.toml.

Codex reads the token from the environment at runtime. Nothing lands on disk — the cleanest credential story of any client here.

Vendor documentation

Gemini CLI

From the vendor's documentation, 2026-09-08.

gemini mcp add -s user -t http plexarm https://api.plexarm.com/mcp \
  -H 'Authorization: Bearer $PLEXARM_TOKEN'

The single quotes are deliberate. Gemini stores the header literally and expands the variable at runtime; with a wrong token the same command reads Disconnected.

The configuration connects — gemini mcp list reads Connected.

Vendor documentation

VS Code

From the vendor's documentation, 2026-09-07.

{
  "inputs": [
    {
      "id": "plexarm-token",
      "type": "promptString",
      "description": "Plexarm API token",
      "password": true
    }
  ],
  "servers": {
    "plexarm": {
      "type": "http",
      "url": "https://api.plexarm.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:plexarm-token}"
      }
    }
  }
}

code --add-mcp '{"name":"plexarm","type":"http","url":"https://api.plexarm.com/mcp","headers":{"Authorization":"Bearer ${input:plexarm-token}"},"inputs":[{"id":"plexarm-token","type":"promptString","description":"Plexarm API token","password":true}]}'

vscode:mcp/install?%7B%22name%22%3A%22plexarm%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A//api.plexarm.com/mcp%22%2C%22headers%22%3A%7B%22Authorization%22%3A%22Bearer%20%24%7Binput%3Aplexarm-token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22plexarm-token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Plexarm%20API%20token%22%2C%22password%22%3Atrue%7D%5D%7D

VS Code prompts for the token once and keeps it in its own secret store — nothing on disk, nothing in the environment. Prefer this over an environment variable.

Use vscode-insiders: for Insiders.

MCP servers run in agent mode, which needs a Copilot sign-in.

Vendor documentation

Cursor

From the vendor's documentation, 2026-09-07.

{
  "mcpServers": {
    "plexarm": {
      "url": "https://api.plexarm.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:PLEXARM_TOKEN}"
      }
    }
  }
}

cursor://anysphere.cursor-deeplink/mcp/install?name=plexarm&config=eyJ1cmwiOiJodHRwczovL2FwaS5wbGV4YXJtLmNvbS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgJHtlbnY6UExFWEFSTV9UT0tFTn0ifX0=

Write this to .cursor/mcp.json in a project, or ~/.cursor/mcp.json for every project.

Cursor documents the install link and the environment-variable form separately. Whether the variable survives the install link is not documented — the JSON above is the form to trust.

Vendor documentation

Windsurf

From the vendor's documentation, 2026-09-07.

{
  "mcpServers": {
    "plexarm": {
      "serverUrl": "https://api.plexarm.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:PLEXARM_TOKEN}"
      }
    }
  }
}

The key is serverUrl, not url.

Vendor documentation

Zed

From the vendor's documentation, 2026-09-07.

{
  "context_servers": {
    "plexarm": {
      "url": "https://api.plexarm.com/mcp",
      "headers": { "Authorization": "Bearer <your token>" }
    }
  }
}

Zed's documentation shows a literal token and documents no environment interpolation. Without the header Zed starts an OAuth flow, which Plexarm does not support. Paste the token, and keep settings.json private.

Vendor documentation

Cline

From the vendor's documentation, 2026-09-07.

{
  "mcpServers": {
    "plexarm": {
      "type": "streamableHttp",
      "url": "https://api.plexarm.com/mcp",
      "headers": {
        "Authorization": "Bearer <your token>"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

The type matters. Omitted, Cline falls back to legacy SSE, which we do not serve.

Vendor documentation

Continue

From the vendor's documentation, 2026-09-07.

mcpServers:
  - name: plexarm
    type: streamable-http
    url: https://api.plexarm.com/mcp
    requestOptions:
      headers:
        Authorization: Bearer <your token>

No vendor page shows a header on an HTTP server, so the token is written literally here rather than through Continue's secrets syntax.

Vendor documentation

LM Studio

From the vendor's documentation, 2026-09-07.

{
  "mcpServers": {
    "plexarm": {
      "url": "https://api.plexarm.com/mcp",
      "headers": {
        "Authorization": "Bearer <your token>"
      }
    }
  }
}

This is also the answer for Ollama and local models. Ollama has no MCP client of its own; LM Studio — or Cline or Continue pointed at a local model — is how an open-weights model reaches Plexarm.

Vendor documentation

Grok Build

From the vendor's documentation, 2026-09-08.

grok mcp add --transport http plexarm https://api.plexarm.com/mcp \
  --header 'Authorization: Bearer ${PLEXARM_TOKEN}'

[mcp_servers.plexarm]
url = "https://api.plexarm.com/mcp"
headers = { "Authorization" = "Bearer ${PLEXARM_TOKEN}" }

Grok expands ${VAR} in headers at runtime, so the single quotes keep the variable in the file and your token never lands on disk. That is documented behaviour, not a guess.

grok.com and the Grok apps are not MCP clients. Grok Build is the terminal answer; the xAI API tool below is the answer from code.

Check it with grok mcp doctor plexarm before asking for anything.

Vendor documentation

OpenCode

From the vendor's documentation, 2026-09-08.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "plexarm": {
      "type": "remote",
      "url": "https://api.plexarm.com/mcp",
      "enabled": true,
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:PLEXARM_TOKEN}" }
    }
  }
}

Set oauth to false. OpenCode detects OAuth on remote servers and will start a flow Plexarm does not support instead of sending your header.

{env:PLEXARM_TOKEN} is substituted at runtime, so nothing lands on disk. Check it with opencode mcp list.

Vendor documentation

Crush

From the vendor's documentation, 2026-09-08.

{ "$schema": "https://charm.land/crush.json",
  "mcp": { "plexarm": { "type": "http", "url": "https://api.plexarm.com/mcp",
    "header": "Authorization: Bearer $PLEXARM_TOKEN" } } }

The key is header, singular, and it is one string rather than a map. That is the form Crush's own README uses.

Crush expands $VAR in the header at runtime, so nothing lands on disk.

Vendor documentation

Amp

From the vendor's documentation, 2026-09-08.

{ "amp.mcpServers": { "plexarm": { "url": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer ${PLEXARM_TOKEN}" } } } }

Amp expands ${PLEXARM_TOKEN} in headers at runtime, so nothing lands on disk. Check it with amp mcp doctor.

Amp's other route, amp mcp remote add, defaults to OAuth. Pass --auth none if you use it, or write the settings file above and skip the question.

Vendor documentation

Kimi Code CLI

From the vendor's documentation, 2026-09-08.

kimi mcp add --transport http plexarm https://api.plexarm.com/mcp \
  --header "Authorization: Bearer $PLEXARM_TOKEN"

{ "mcpServers": { "plexarm": { "url": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer <your token>" } } } }

Your shell expands the variable before Kimi sees it, so the token itself is written into ~/.kimi/mcp.json. Expansion inside the file is not documented. Keep that file private.

Check it with kimi mcp list.

Vendor documentation

Qwen Code

From the vendor's documentation, 2026-09-08.

qwen mcp add --transport http plexarm https://api.plexarm.com/mcp \
  --header "Authorization: Bearer $PLEXARM_TOKEN"

{ "mcpServers": { "plexarm": { "httpUrl": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer <your token>" } } } }

The key is httpUrl, not url. Qwen Code is a Gemini CLI fork, where url means the older SSE transport that we do not serve — a snippet with url connects to nothing.

The token is written literally because Qwen's documentation says variables are expanded in the env block only. Its parent, Gemini CLI, does expand a header at runtime, so this may be more cautious than it needs to be.

Vendor documentation

GitHub Copilot CLI

From the vendor's documentation, 2026-09-08.

copilot mcp add --transport http --header "Authorization: Bearer $PLEXARM_TOKEN" plexarm https://api.plexarm.com/mcp

{ "mcpServers": { "plexarm": { "type": "http", "url": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer <your token>" }, "tools": ["*"] } } }

Your shell expands the variable, so the token is written into ~/.copilot/mcp-config.json. Variables inside the header appear in community posts but not in GitHub's own documentation.

One open report on Copilot CLI says a configuration that works in Gemini CLI and Qwen Code errors here. Nothing on our side reproduces it. If the tools do not appear, that is the first thing to suspect.

Vendor documentation

Roo Code

From the vendor's documentation, 2026-09-08.

{ "mcpServers": { "plexarm": { "type": "streamable-http", "url": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer <your token>" }, "alwaysAllow": [], "disabled": false } } }

The type is required and it is spelled streamable-http with a hyphen. Roo cannot infer the transport from the URL and errors without it. Cline spells the same idea streamableHttp — the two are forks and they disagree.

The token is written into the settings file. Roo documents variable substitution for local servers only, not for headers.

Vendor documentation

Warp

From the vendor's documentation, 2026-09-08.

{ "plexarm": { "url": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer <your token>" } } }

Warp's documentation calls this field an SSE endpoint, and we do not serve SSE. Whether Warp negotiates the newer transport on the same URL is not stated in its documentation.

If it fails, use the mcp-remote bridge above instead — Warp's own examples pass a header that way, so that route is documented by Warp itself. Tell us which one worked.

Vendor documentation

iFlow CLI

From the vendor's documentation, 2026-09-08.

iflow mcp add --transport http plexarm https://api.plexarm.com/mcp \
  --header "Authorization: Bearer $PLEXARM_TOKEN"

{ "mcpServers": { "plexarm": { "httpUrl": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer <your token>" } } } }

Prefer the command line. The settings file shape is inferred from iFlow's Gemini CLI lineage rather than read on iFlow's own page; the command is what iFlow documents.

Your shell expands the variable, so the token is written into the settings file.

Vendor documentation

Mistral Vibe

From the vendor's documentation, 2026-09-08.

[[mcp_servers]]
name = "plexarm"
transport = "http"
url = "https://api.plexarm.com/mcp"
headers = { "Authorization" = "Bearer <your token>" }

The token is written into the file. Vibe documents fields for reading a credential from the environment, but not their exact spelling for an MCP server, so the literal is what is published here.

The config path is the shape community guides show. Vibe's own configuration page would not load.

Vendor documentation

Hugging Face MCPClient

From the vendor's documentation, 2026-09-08.

import os
from huggingface_hub import MCPClient

client = MCPClient(model="Qwen/Qwen3-235B-A22B", provider="auto")
await client.add_mcp_server(type="http", url="https://api.plexarm.com/mcp",
                            headers={"Authorization": f"Bearer {os.environ['PLEXARM_TOKEN']}"})

This is how an open-weights model on Hugging Face reaches Plexarm, alongside LM Studio. The token is read from the environment at call time and nothing lands on disk.

MCPClient is marked experimental by Hugging Face. The shape is explicit in its signature; its stability is not.

Vendor documentation

Raycast

From the vendor's documentation, 2026-09-08.

There is nothing to paste. Run the Install MCP Server command, choose transport HTTP, enter the URL above, then add an HTTP header with key Authorization and value Bearer and your token. Ask for it with @plexarm in AI Chat.

MCP in Raycast is a Pro feature, and there is no install link for it — unlike Cursor and VS Code, this one cannot be a one-click button.

Vendor documentation

Trae

From the vendor's documentation, 2026-09-08.

{ "mcpServers": { "plexarm": { "url": "https://api.plexarm.com/mcp",
    "headers": { "Authorization": "Bearer <your token>" } } } }

Open AI settings, then MCP, then Add, then Raw Config, and paste this.

Transcribed from Trae's Chinese documentation; the English page would not load. The example on that page uses this exact header.

Vendor documentation

Replit Agent

From the vendor's documentation, 2026-09-08.

There is nothing to paste. Open MCP Servers, add a server named plexarm with the URL above, open Advanced settings and add a header with key Authorization and value Bearer and your token, then Test and save.

Replit's own page would not load; these steps come from Replit's summary of it.

Vendor documentation

n8n

From the vendor's documentation, 2026-09-08.

There is nothing to paste. Add an MCP Client Tool node to an AI Agent, set the endpoint to the URL above, choose HTTP Streamable as the transport and Bearer Auth as the authentication, and put your token in the credential.

The token lives in n8n's encrypted credential store.

Vendor documentation

Dify

From the vendor's documentation, 2026-09-08.

There is nothing to paste. Open Tools, then MCP, then Add MCP Server; use the URL above with the name and identifier plexarm, and add a header with key Authorization and value Bearer and your token. The tools import when it connects.

Dify turns OAuth discovery on by default. The header is the path that works with a token, and it has to be filled in deliberately.

Vendor documentation

Zapier MCP Client

From the vendor's documentation, 2026-09-08.

There is nothing to paste. Add a connection for the MCP Client app, use the URL above, choose Streamable HTTP, say no to OAuth, and paste your token as the bearer token.

This is Zapier acting as a client of Plexarm, which is a different product from Zapier's own MCP server. It is in beta, and it is a Zap action rather than a chat — you run a tool, you do not ask a question.

Vendor documentation

Lovable

From the vendor's documentation, 2026-09-08.

There is nothing to paste. Open Connectors, add an MCP server named plexarm with the URL above, choose Bearer token or API key as the authentication and paste your token, then Add server.

The connector belongs to you, not to your project. It is never part of the app you publish.

Vendor documentation

Anthropic Messages API

From the vendor's documentation, 2026-09-08.

import os, anthropic

client = anthropic.Anthropic()
r = client.beta.messages.create(
    model="claude-opus-5", max_tokens=1000,
    messages=[{"role": "user", "content": "Call plexarm_whoami and tell me who I am."}],
    mcp_servers=[{"type": "url", "url": "https://api.plexarm.com/mcp", "name": "plexarm",
                  "authorization_token": os.environ["PLEXARM_TOKEN"]}],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "plexarm"}],
    betas=["mcp-client-2025-11-20"])

Anthropic's own cloud opens the connection to Plexarm — there is no client on your machine at all. The token is read from your environment.

The field is documented as an OAuth token. A static token is the same thing on the wire.

The connector is a beta and is not eligible for zero data retention.

Vendor documentation

OpenAI Responses API

From the vendor's documentation, 2026-09-08.

import os
from openai import OpenAI

r = OpenAI().responses.create(
    model="gpt-6-astra",
    tools=[{"type": "mcp", "server_label": "plexarm", "server_url": "https://api.plexarm.com/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['PLEXARM_TOKEN']}"},
            "require_approval": "never"}],
    input="Call plexarm_whoami and tell me who I am.")

OpenAI's own cloud opens the connection to Plexarm — there is no client on your machine at all. The token is read from your environment.

Use the headers map rather than the authorization field. Whether a static token in that field is sent with the Bearer prefix is not documented, and the map cannot fail quietly.

Vendor documentation

xAI API

From the vendor's documentation, 2026-09-08.

import os
from xai_sdk import Client
from xai_sdk.tools import mcp

chat = Client().chat.create(model="grok-4.6",
    tools=[mcp(server_url="https://api.plexarm.com/mcp", server_label="plexarm",
               authorization=os.environ["PLEXARM_TOKEN"])])

xAI's own cloud opens the connection to Plexarm — there is no client on your machine at all. This is the answer for Grok from code; Grok Build above is the answer from a terminal.

If this returns 401, pass the header directly instead: a headers map with Authorization set to Bearer and your token. xAI does not say whether it adds the Bearer prefix for you.

Vendor documentation