Matthewhand MCP

MCPAI代理

提供方 未标注

AI代理 HTTP · 远程 API Key 社区 / 第三方
查看接入方式

全面解析MCP Openapi ProxyMCP Server的核心功能、安装配置和实用案例。作为顶级Model Context Protocol服务器,MCP Openapi Proxy能让AI助手访问实时数据、执行操作,为您提供更智能的工作体验和自动化解决方案。

一句话选型结论

按资料字段整理

Matthewhand MCP 属于AI代理类 MCP 服务器,HTTP · 远程,API Key,有可直接复制的远程端点配置。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类AI代理 传输方式HTTP · 远程 鉴权API Key 部署方式远程部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

AI代理
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

安装与配置

HTTP · 远程 API Key
连远程 HTTPS 端点,通常为 Streamable HTTP
pip install mcp-openapi-proxy\"

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    确认你的客户端支持远程端点,并拿到服务地址。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。

先想清楚的地方

  • 远程端点依赖网络与服务方可用性,注意密钥与调用额度。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在AI代理场景里让模型直接调用外部能力的人。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Matthewhand MCP当前 未标注 HTTP · 远程 远程部署 有 2026-05-17
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

AI代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类AI代理本站按上游分类展示
连接方式HTTP · 远程连远程 HTTPS 端点,通常为 Streamable HTTP
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Python本地安装时用到的包标识与运行时
部署类型远程部署上游给出的部署形态
最近核验2026-05-17上游最后核验时间

详细介绍

44.5 KB
来自项目仓库与上游目录的原文,未做删改

mcp-openapi-proxy

mcp-openapi-proxy is a Python package that implements a Model Context Protocol (MCP) server, designed to dynamically expose REST APIs—defined by OpenAPI specifications—as MCP tools. This facilitates seamless integration of OpenAPI-described APIs into MCP-based workflows.

v0.4.0 — tagged September 6, 2026; GitHub Release published October 15, 2026 (AEDT): MCP SDK 2.x / protocol 2026-07-28, with native stateless Streamable HTTP and legacy stdio support.

What's New in 0.4.0

MCP 2026-07-28 (SDK 2.x). The proxy is dual-stack: modern clients send
self-contained requests (no initialize, no Mcp-Session-Id) and list results
carry ttlMs / cacheScope. Legacy stdio clients that still handshake keep
working. Native Streamable HTTP is available with MCP_TRANSPORT=streamable-http
and is stateless — round-robin load balancing needs no sticky sessions.

See docs/MIGRATION-0.4.md for breaking changes, new
env vars, and gateway cutover notes. 0.3.4 remains the last release on
mcp 1.x (mcp>=1.2.0,<2).

What's New in 0.2.0

Works with every modern MCP-enabled client we tested. Strict MCP clients can now discover and call tools — the low-level server advertises correct capabilities and no longer crashes during resource/prompt discovery, and a slow spec download no longer crash-loops short-timeout clients. Verified live against the full list of mainstream agent CLIs:

  • ✅ Codex, Gemini, Qwen, Kilocode, opencode — native tool calls over stdio
  • ✅ Vibe — native discovery and read calls (writes were CLI-flaky, not a proxy issue)
  • ✅ Letta — Cloud (via a remote streamable-HTTP MCP URL) and self-hosted (via stdio)

See the client matrix for attach mechanisms, models, and exact results.

> 📄 Full write-up: Verification case study — what the proxy is, the API + client matrices, and every defect found & fixed.

Prompts and resources are real now — including custom resources. Both MCP surfaces are functional and tested: the summarize_spec / whimsical_blog prompts and the spec_file resource, plus a new ADDITIONAL_RESOURCES env var that serves your own use-case documents (e.g. a NetBox naming policy or an Asana project-layout guide) as MCP resources — see examples/resources/.

Bug fixes (every one live-verified):
- MCP client discovery: empty capability set + a crash in resource discovery left strict clients seeing zero tools (#23) — fixed, with a full stdio-handshake test harness.
- IGNORE_SSL_TOOLS was ignored by the low-level dispatcher (#14) — fixed (original patch by @robbycochran, #15).
- Server crash-loop when a slow spec fetch outran a client's connect timeout (#28) — handshake now answers immediately, spec loads lazily, closed streams exit cleanly.
- API_AUTH_TYPE custom schemes (e.g. NetBox Token) sent no auth header at all (#24) — fixed.
- TOOL_WHITELIST never matched Slack-style dot paths like /users.list (#27) — fixed.
- TOOL_NAME_MAX_LENGTH was not respected, and name-truncation collisions silently dropped tools (#11) — fixed.
- Array parameters were emitted without items, which the OpenAI API rejects (#16) — fixed.
- EXTRA_HEADERS now accepts a JSON array and literal \n separators, not just real newlines (#17).
- Dead Render spec URL (#26) and incomplete ElevenLabs example (#29) — fixed; the GetZep example is documented for self-hosted Zep CE since the hosted endpoint now 401s (#38).
- Added a Dockerfile + glama.json for the Glama listing (#13); collapsible README examples + a verified-client/API matrix (#35).

Full environment-variable reference is in Environment Variables.

Table of Contents

  • Overview
  • Features
  • Installation
  • MCP Ecosystem Integration
  • Modes of Operation
  • FastMCP Mode (Simple Mode)
  • Low-Level Mode (Default)
  • Environment Variables
  • Verified Clients & Live Results (2026-06-12)
  • Tips
  • Examples — Glama, Fly.io, Render, Slack, GetZep, Virustotal, Notion, Asana, APIs.guru, NetBox, Box, WolframAlpha, WordPress (collapsed)
  • Troubleshooting
  • License

Overview

The package offers two operational modes:

  • Low-Level Mode (Default): Dynamically registers tools corresponding to all valid API endpoints specified in an OpenAPI document (e.g. /chat/completions becomes chat_completions()).
  • FastMCP Mode (Simple Mode): Provides a streamlined approach by exposing a predefined set of tools (e.g. list_functions() and call_function()) based on static configurations.

Features

  • Dynamic Tool Generation: Automatically creates MCP tools from OpenAPI endpoint definitions.
  • Tool Annotations: Every OpenAPI-derived tool includes MCP annotations (title, plus readOnlyHint / idempotentHint for GET and clearly read-ish POST, or destructiveHint for other methods) so clients such as Gemini Spark see the same fingerprint as Notion/Linear.
  • Simple Mode Option: Offers a static configuration alternative via FastMCP mode.
  • OpenAPI Specification Support: Compatible with OpenAPI v3 with potential support for v2.
  • Flexible Filtering: Allows endpoint filtering through whitelisting by paths or other criteria.
  • Payload Authentication: Supports custom authentication via JMESPath expressions (e.g. for APIs like Slack that expect tokens in the payload not the HTTP header).
  • Header Authentication: Uses Bearer by default for API_KEY in the Authorization header, customizable for APIs like Fly.io requiring Api-Key.
  • MCP Integration: Seamlessly integrates with MCP ecosystems for invoking REST APIs as tools.

Installation

Install the package directly from PyPI using the following command:```bash
uvx mcp-openapi-proxy


### MCP Ecosystem Integration

To incorporate **mcp-openapi-proxy** into your MCP ecosystem configure it within your `mcpServers` settings. Below is a generic example:```json
{
    "mcpServers": {
        "mcp-openapi-proxy": {
            "command": "uvx",
            "args": ["mcp-openapi-proxy"],
            "env": {
                "OPENAPI_SPEC_URL": "${OPENAPI_SPEC_URL}",
                "API_KEY": "${API_OPENAPI_KEY}"
            }
        }
    }
}

Refer to the Examples section below for practical configurations tailored to specific APIs.

Modes of Operation

FastMCP Mode (Simple Mode)

  • Enabled by: Setting the environment variable OPENAPI_SIMPLE_MODE=true.
  • Description: Exposes a fixed set of tools derived from specific OpenAPI endpoints as defined in the code.
  • Configuration: Relies on environment variables to specify tool behavior.

Low-Level Mode (Default)

  • Description: Automatically registers all valid API endpoints from the provided OpenAPI specification as individual tools.
  • Tool Naming: Derives tool names from normalized OpenAPI paths and methods.
  • Behavior: Generates tool descriptions from OpenAPI operation summaries and descriptions.

Environment Variables

  • OPENAPI_SPEC_URL: (Required) The URL to the OpenAPI specification JSON file (e.g. https://example.com/spec.json or file:///path/to/local/spec.json).
  • OPENAPI_SIMPLE_MODE: (Optional) Set to true to enable FastMCP mode.
  • TOOL_WHITELIST: (Optional) A comma-separated list of endpoint paths to expose as tools.
  • ADDITIONAL_RESOURCES: (Optional) Comma-separated name=/path/to/file entries served as extra MCP resources (use-case docs such as naming policies or layout conventions; see examples/resources/).
  • TOOL_NAME_PREFIX: (Optional) A prefix to prepend to all tool names.
  • API_KEY: (Optional) Authentication token for the API sent as Bearer in the Authorization header by default.
  • API_AUTH_TYPE: (Optional) Overrides the default Bearer Authorization scheme. api-key sends the key in the header named by API_AUTH_HEADER; any other value is used as a custom scheme prefix (e.g. Token for NetBox → Authorization: Token).
  • STRIP_PARAM: (Optional) JMESPath expression to strip unwanted parameters (e.g. token for Slack).
  • DEBUG: (Optional) Enables verbose debug logging when set to "true", "1", or "yes". Native Streamable HTTP also emits one INFO line per inbound JSON-RPC method (mcp rpc method=tools/list, mcp rpc method=tools/call name=…) without arguments or Authorization.
  • EXTRA_HEADERS: (Optional) One or more outgoing HTTP headers. Accepts a JSON array (["X-A: 1","X-B: 2"]), one Header: Value per line, or literal \n-separated entries (for configs that cannot embed newlines).
  • SERVER_URL_OVERRIDE: (Optional) Overrides the base URL from the OpenAPI specification when set, useful for custom deployments.
  • TOOL_NAME_MAX_LENGTH: (Optional) Truncates tool names to a max length.
  • Additional Variable: OPENAPI_SPEC_URL_ – a variant for unique per-test configurations (falls back to OPENAPI_SPEC_URL).
  • IGNORE_SSL_SPEC: (Optional) Set to true to disable SSL certificate verification when fetching the OpenAPI spec.
  • IGNORE_SSL_TOOLS: (Optional) Set to true to disable SSL certificate verification for API requests made by tools.
  • API_AUTH_HEADER: (Optional) Header name used when API_AUTH_TYPE=api-key (e.g. x-apikey for VirusTotal, xi-api-key for ElevenLabs). Defaults to Authorization.
  • OPENAPI_SPEC_FORMAT: (Optional) Set to yaml to parse file:// specs as YAML (remote specs auto-detect). Default json.
  • OPENAPI_SPEC_CACHE_TTL_SECONDS: (Optional) Live-first disk cache for remote specs: the cached copy is served only when the live fetch fails or stalls (and respawned servers fail fast to it). Default 86400; set 0 to disable.
  • ENABLE_TOOLS / ENABLE_PROMPTS / ENABLE_RESOURCES: (Optional) Feature gates for the three MCP surfaces in low-level mode; each defaults to enabled. Disabling a feature removes its handlers and its capability advertisement.
  • PROMPT: (Optional) JSON object that registers one extra MCP prompt next to summarize_spec and whimsical_blog, in both low-level and simple mode. Example: {"name":"asana_prompt","description":"Asana helper","messages":[{"user":"What is Asana?","assistant":"Asana is a work management platform."}]}. Each message may include user, assistant, or both. Invalid JSON is logged and ignored. summarize_spec and whimsical_blog are reserved names. Restart the server after changing it. Low-level mode also requires prompts to stay enabled (ENABLE_PROMPTS, default on). Custom prompt content is returned to connected MCP clients: do not put credentials or other private data in PROMPT, and protect public HTTP ingress with authentication and host/origin controls.
  • CAPABILITIES_TOOLS / CAPABILITIES_PROMPTS / CAPABILITIES_RESOURCES: (Optional) Advertise listChanged on the corresponding capability (for clients that key on it). Default false.
  • MCP_SERVER_NAME: (Optional) Identity advertised in serverInfo / server/discover. Set this to the proxied API (e.g. gpt-terminal-plus, flyio) so multiple instances are not all called openapi-proxy. Falls back to the OpenAPI file stem or spec-URL host, then openapi-proxy.
  • MCP_SERVER_TITLE / MCP_SERVER_DESCRIPTION: (Optional) Display title and description alongside the name.
  • MCP_TRANSPORT: (Optional) stdio (default) or streamable-http for native stateless Streamable HTTP (MCP 2026-07-28; no Mcp-Session-Id).
  • MCP_HOST / MCP_PORT / MCP_PATH: (Optional) HTTP bind address (127.0.0.1), port (8000), and path (/mcp) when MCP_TRANSPORT=streamable-http. Native Streamable HTTP also serves GET /healthz → {"ok":true,"name":,"port":} without taking the MCP request lock (no spec fetch, no initialize).
  • MCP_JSON_RESPONSE: (Optional) true (default) returns JSON instead of SSE on Streamable HTTP.
  • MCP_LIST_TTL_MS / MCP_READ_TTL_MS: (Optional) ttlMs for list results (default 60000) and resources/read (default 5000).
  • MCP_ALLOWED_HOSTS: (Optional) Comma-separated Host allow-list for DNS-rebinding protection. Default * (protection off — typical behind nginx).
  • MCP_REQUEST_STATE_KEY: (Optional) Shared HMAC key so MRTR requestState verifies across instances. Unset = process-local.
    Unreleased on main (not in tagged/PyPI v0.4.0): The next two raw-command logging settings are available only in newer source.

  • MCP_LOG_RAW_COMMANDS: (Optional, default off) 1/true/yes adds one extra INFO record per shell-execution tool call, emitted before the command runs:text mcp raw-command tool=post_command_execute_shell cd /srv/app && npm run build # <- the verbatim command, unmodified

The command is logged byte-for-byte — whitespace, blank lines, tabs and quoting are preserved; nothing is normalised, reconstructed, or redacted. The existing mcp rpc method=… name=… line is unchanged and still the only record when this is off. ⚠️ This can write secrets into your logs: shell commands routinely carry credentials (export TOKEN=…, curl -H 'Authorization: Bearer …', ssh/psql invocations). It is opt-in for that reason — enable it only where the log sink is trusted, and scrub or rotate the log afterwards. Only the command body is dumped, never Authorization headers or unrelated tool arguments. Scoped to the allow-list below; not a general tool-argument dump.
- MCP_LOG_RAW_COMMAND_TOOLS: (Optional) Comma-separated tool names eligible for raw-command logging, overriding the default post_command_execute_shell,executeShell. Entries that are not valid tool names are ignored. Use this when a new terminal-style upstream lands.

Verified Clients & Live Results (2026-06-12)

The example configurations below were exercised against the live APIs, and the proxy was attached to a range of agent CLIs over stdio MCP. Results from that verification run:

API example results

API example Tools Sample call proven Extra env needed
glama 6 get_v1_attributes none
apis.guru 7 get_metrics_json none
wolframalpha 2 get_v1_llm_api API_KEY
virustotal 4 IP report API_KEY + API_AUTH_TYPE=api-key + API_AUTH_HEADER=x-apikey
asana 73 (whitelist /workspaces,/projects,/tasks) created project + 11 tasks SERVER_URL_OVERRIDE + API_KEY
render 52 get_services API_KEY (NEW spec URL render-public-api-1.json)
notion 4–5 (whitelist /v1/users,/v1/search or /v1/pages) page create + title read-back SERVER_URL_OVERRIDE + EXTRA_HEADERS (Notion-Version) + API_KEY
elevenlabs 19 TTS mp3 generated SERVER_URL_OVERRIDE + API_AUTH_TYPE=api-key + API_AUTH_HEADER=xi-api-key
flyio 34–35 apps + machine health API_KEY
slack 7 (exact dot-path whitelist until #27 fix) auth.test + postMessage API_KEY
netbox 9 (whitelist /ipam/ip-addresses) IPAM write + read API_KEY + API_AUTH_TYPE=Token
homeassistant 21 get_config (200) + call_service (light.turn_on, 200) SERVER_URL_OVERRIDE + API_KEY (${HA_TOKEN}, sent as Bearer)

Client matrix

Agent CLI Model used (live test) MCP attach mechanism Tool calls Prompts/Resources surfaced to model?
opencode (CLI default) ~/.config/opencode/opencode.json mcp ✅ native prompts: ✅ (slash) · resources: ✅ — most complete ‖
Codex gpt-5-codex (OpenAI API) codex exec -c mcp_servers.* ✅ native prompts: ❌ low-level · ✅ fastmcp (via call_function→get_prompt) · resources: ✅ (read_mcp_resource) ‖
Kilocode kilo-auto/free global settings/mcp_settings.json ✅ native prompts: ❌ (no prompt mechanism) · resources: ✅ (access_mcp_resource) ‖
Qwen agent group via local LiteLLM gateway project .qwen/settings.json ✅ native (live invoke auth-blocked) prompts: ✅ (slash /summarize_spec) · resources: ❌ (no client support) ‖
Gemini Google OAuth free tier (CLI default model) project .gemini/settings.json mcpServers ✅ native prompts: interactive slash only · resources: interactive @ only (neither reaches the model headless) ‖
Vibe mistral-medium-3.5 ~/.vibe/config.toml [[mcp_servers]] ✅ discovery + reads prompts: ❌ · resources: ❌ (tools-only client) ‖
agy — — ❌ headless cannot enable MCP n/a
letta (cloud / self-hosted) Letta Cloud / PUT /v1/tools/mcp/servers streamable-HTTP / stdio ✅ (per prior sweep) unknown — needs a running Letta server to test ‡

> How to read the prompts/resources column. MCP has three surfaces — tools, prompts,
> resources. mcp-openapi-proxy serves all three, advertised by default since 0.3.0.
> Whether they reach the model is up to the client, and that varies:
>
> - ‖ re-verified 2026-06-15 against the published 0.3.3 release with no flags set
> (validating the default-on advertising), driving each real client binary, in
> both server modes (low-level and FastMCP simple). Per-client results were the
> same across modes except where noted.
> - Tools work on every client tested. Prompts→model: opencode & Qwen (slash
> commands); Gemini interactive-only. Resources→model: opencode, Codex, Kilocode.
> opencode is the only client that surfaces all three in any mode.
> - FastMCP simple mode exception: a client with no native prompt surface can still
> reach prompts through the static call_function→get_prompt indirection. Observed
> with Codex (prompts ❌ in low-level, ✅ in FastMCP simple mode). Vibe stays
> tools-only regardless of mode.
> - ‡ unknown — Letta can't be exercised without standing up a Letta server + model;
> left untested rather than guessed.
> - Every cell on the proxy side was confirmed via a raw stdio handshake (initialize
> advertises tools+prompts+resources; prompts/get and resources/read return content).
> The remaining ❌ are client-side gaps, not proxy limitations.
>
> (All pre-0.3.0 prompt/resource findings were voided — they were measured while
> advertising defaulted off, so they reflected the server default, not the clients.)

Minimal sanitized configs per client (the no-auth Glama spec is used as the smallest working example; substitute your own spec URL and $YOUR_KEY as needed):

Codex — inline -c mcp_servers.* overrides```bash
codex exec \
-c 'mcp_servers.glama.command="uvx"' \
-c 'mcp_servers.glama.args=["mcp-openapi-proxy"]' \
-c 'mcp_servers.glama.env.OPENAPI_SPEC_URL="https://glama.ai/api/mcp/openapi.json"' \
"list the available tools"


Gemini — project .gemini/settings.json```json
{
  "mcpServers": {
    "glama": {
      "command": "uvx",
      "args": ["mcp-openapi-proxy"],
      "env": { "OPENAPI_SPEC_URL": "https://glama.ai/api/mcp/openapi.json" }
    }
  }
}

Qwen — project .qwen/settings.json```json
{
"mcpServers": {
"glama": {
"command": "uvx",
"args": ["mcp-openapi-proxy"],
"env": { "OPENAPI_SPEC_URL": "https://glama.ai/api/mcp/openapi.json" }
}
}
}


Kilocode — global settings/mcp_settings.json (use a clean workspace)```json
{
  "mcpServers": {
    "glama": {
      "command": "uvx",
      "args": ["mcp-openapi-proxy"],
      "env": { "OPENAPI_SPEC_URL": "https://glama.ai/api/mcp/openapi.json" }
    }
  }
}

opencode — ~/.config/opencode/opencode.json mcp block```json
{
"mcp": {
"glama": {
"type": "local",
"command": ["uvx", "mcp-openapi-proxy"],
"environment": { "OPENAPI_SPEC_URL": "https://glama.ai/api/mcp/openapi.json" }
}
}
}


Vibe — ~/.vibe/config.toml [[mcp_servers]]```toml
[[mcp_servers]]
name = "glama"
command = "uvx"
args = ["mcp-openapi-proxy"]

[mcp_servers.env]
OPENAPI_SPEC_URL = "https://glama.ai/api/mcp/openapi.json"

agy (headless) and letta cloud could not attach a stdio MCP server at all, so no config snippet applies: agy provides no way to enable MCP in headless mode, and letta cloud only accepts remote MCP servers.

Tips

  • Big specs need TOOL_WHITELIST. Large APIs (Asana, Render, Fly.io, Slack, NetBox) expose dozens of endpoints; whitelist the paths you need to keep the tool count manageable for clients.
  • Dot-style paths need exact whitelist entries for now. Slack-style paths like /chat.postMessage are not matched by prefix whitelisting — list each path exactly (issue #27 / PR #32).
  • Slow remote specs can crash-loop short-timeout clients. If a client kills the server before a large spec finishes downloading, fetch the spec once and point OPENAPI_SPEC_URL at a local file:// copy (issue #28).
  • Custom auth schemes are handled via API_AUTH_TYPE (PR #25), e.g. Token for NetBox, or api-key with API_AUTH_HEADER for Virustotal/ElevenLabs-style header keys.

Examples

For testing you can run the uvx command as demonstrated in the examples then interact with the MCP server via JSON-RPC messages to list tools and resources. See the "JSON-RPC Testing" section below.

Each example below is collapsed — click to expand.

Glama Example — the most minimal config: just OPENAPI_SPEC_URL, no auth

Glama offers the most minimal configuration for mcp-openapi-proxy requiring only the OPENAPI_SPEC_URL environment variable. This simplicity makes it ideal for quick testing.

1. Verify the OpenAPI Specification

Retrieve the Glama OpenAPI specification:```bash
curl https://glama.ai/api/mcp/openapi.json


Ensure the response is a valid OpenAPI JSON document.

#### 2. Configure mcp-openapi-proxy for Glama

Add the following configuration to your MCP ecosystem settings:```json
{
    "mcpServers": {
        "glama": {
            "command": "uvx",
            "args": ["mcp-openapi-proxy"],
            "env": {
                "OPENAPI_SPEC_URL": "https://glama.ai/api/mcp/openapi.json"
            }
        }
    }
}

3. Testing

Start the service with:```bash
OPENAPI_SPEC_URL="https://glama.ai/api/mcp/openapi.json" uvx mcp-openapi-proxy


Then refer to the JSON-RPC Testing section for instructions on listing resources and tools.

Fly.io Example — machines API with an API token

Fly.io provides a simple API for managing machines making it an ideal starting point. Obtain an API token from Fly.io documentation.

#### 1. Verify the OpenAPI Specification

Retrieve the Fly.io OpenAPI specification:```bash
curl https://raw.githubusercontent.com/abhiaagarwal/peristera/refs/heads/main/fly-machines-gen/fixed_spec.json

Ensure the response is a valid OpenAPI JSON document.

2. Configure mcp-openapi-proxy for Fly.io

Update your MCP ecosystem configuration:```json
{
"mcpServers": {
"flyio": {
"command": "uvx",
"args": ["mcp-openapi-proxy"],
"env": {
"OPENAPI_SPEC_URL": "https://raw.githubusercontent.com/abhiaagarwal/peristera/refs/heads/main/fly-machines-gen/fixed_spec.json",
"API_KEY": "<your_flyio_token_here>"
}
}
}
}


- **OPENAPI_SPEC_URL**: Points to the Fly.io OpenAPI specification.
- **API_KEY**: Your Fly.io API token (replace ``).
- **API_AUTH_TYPE**: Set to `Api-Key` for Fly.io’s header-based authentication (overrides default `Bearer`).

#### 3. Testing

After starting the service refer to the JSON-RPC Testing section for instructions on listing resources and tools.

Render Example — manage hosted services with a tool whitelist

Render offers infrastructure hosting that can be managed via an API. The provided configuration file `examples/render-claude_desktop_config.json` demonstrates how to set up your MCP ecosystem quickly with minimal settings.

#### 1. Verify the OpenAPI Specification

Retrieve the Render OpenAPI specification:```bash
curl https://api-docs.render.com/openapi/render-public-api-1.json

Ensure the response is a valid OpenAPI document.

2. Configure mcp-openapi-proxy for Render

Add the following configuration to your MCP ecosystem settings:```json
{
"mcpServers": {
"render": {
"command": "uvx",
"args": ["mcp-openapi-proxy"],
"env": {
"OPENAPI_SPEC_URL": "https://api-docs.render.com/openapi/render-public-api-1.json",
"TOOL_WHITELIST": "/services,/maintenance",
"API_KEY": "your_render_token_here"
}
}
}
}


#### 3. Testing

Launch the proxy with your Render configuration:```bash
OPENAPI_SPEC_URL=&quot;https://api-docs.render.com/openapi/render-public-api-1.json&quot; TOOL_WHITELIST=&quot;/services,/maintenance&quot; API_KEY=&quot;your_render_token_here&quot; uvx mcp-openapi-proxy

Then refer to the JSON-RPC Testing section for instructions on listing resources and tools.

Slack Example — payload token stripping via JMESPath (STRIP_PARAM)

Slack’s API showcases stripping unnecessary token payload using JMESPath. Obtain a bot token from Slack API documentation.

1. Verify the OpenAPI Specification

Retrieve the Slack OpenAPI specification:```bash
curl https://raw.githubusercontent.com/slackapi/slack-api-specs/master/web-api/slack_web_openapi_v2.json


Ensure it’s a valid OpenAPI JSON document.

#### 2. Configure mcp-openapi-proxy for Slack

Update your configuration:```json
{
    &quot;mcpServers&quot;: {
        &quot;slack&quot;: {
            &quot;command&quot;: &quot;uvx&quot;,
            &quot;args&quot;: [&quot;mcp-openapi-proxy&quot;],
            &quot;env&quot;: {
                &quot;OPENAPI_SPEC_URL&quot;: &quot;https://raw.githubusercontent.com/slackapi/slack-api-specs/master/web-api/slack_web_openapi_v2.json&quot;,
                &quot;TOOL_WHITELIST&quot;: &quot;/chat,/bots,/conversations,/reminders,/files,/users&quot;,
                &quot;API_KEY&quot;: &quot;&lt;your_slack_bot_token, starts with xoxb&gt;&quot;,
                &quot;STRIP_PARAM&quot;: &quot;token&quot;,
                &quot;TOOL_NAME_PREFIX&quot;: &quot;slack_&quot;
            }
        }
    }
}
  • OPENAPI_SPEC_URL: Slack’s OpenAPI spec URL.
  • TOOL_WHITELIST: Limits tools to useful endpoint groups (e.g. chat, conversations, users).
  • API_KEY: Your Slack bot token (e.g. xoxb-..., replace ``).
  • STRIP_PARAM: Removes the token field from the request payload.
  • TOOL_NAME_PREFIX: Prepends slack_ to tool names.

3. Testing

After starting the service refer to the JSON-RPC Testing section for instructions on listing resources and tools.

GetZep Example — project-generated spec with Api-Key auth

> Note (2026): GetZep's hosted endpoint (api.getzep.com) returns 401 for previously-working keys — the hosted free tier no longer accepts API keys. The example now targets a self-hosted Zep CE: see examples/zep-ce/docker-compose.yml (zep built from source tag v1.0.2 + pgvector/pgvector:pg17; the delisted zepai/zep image must be rebuilt via the official Dockerfile.ce). Auth quirk: Zep's scheme is literally Api-Key, which collides with the proxy's special api-key mode — use API_AUTH_TYPE=api-key with API_KEY=&quot;Api-Key &quot;. Live-verified: 8 tools via TOOL_WHITELIST=/sessions; session create + read-back through the bridge.

GetZep offers a free cloud API for memory management with detailed endpoints. Since GetZep did not provide an official OpenAPI specification, this project includes a generated spec hosted on GitHub for convenience. Users can similarly generate OpenAPI specs for any REST API and reference them locally (e.g. file:///path/to/spec.json). Obtain an API key from GetZep's documentation.

1. Verify the OpenAPI Specification

Retrieve the project-provided GetZep OpenAPI specification:```bash
curl https://raw.githubusercontent.com/matthewhand/mcp-openapi-proxy/refs/heads/main/examples/getzep.swagger.json


Ensure it’s a valid OpenAPI JSON document. Alternatively, generate your own spec and use a `file://` URL to reference a local file.

#### 2. Configure mcp-openapi-proxy for GetZep

Update your configuration:```json
{
    &quot;mcpServers&quot;: {
        &quot;getzep&quot;: {
            &quot;command&quot;: &quot;uvx&quot;,
            &quot;args&quot;: [&quot;mcp-openapi-proxy&quot;],
            &quot;env&quot;: {
                &quot;OPENAPI_SPEC_URL&quot;: &quot;https://raw.githubusercontent.com/matthewhand/mcp-openapi-proxy/refs/heads/main/examples/getzep.swagger.json&quot;,
                &quot;TOOL_WHITELIST&quot;: &quot;/sessions&quot;,
                &quot;API_KEY&quot;: &quot;&lt;your_getzep_api_key&gt;&quot;,
                &quot;API_AUTH_TYPE&quot;: &quot;Api-Key&quot;,
                &quot;TOOL_NAME_PREFIX&quot;: &quot;zep_&quot;
            }
        }
    }
}
  • OPENAPI_SPEC_URL: Points to the project-provided GetZep Swagger spec (or use file:///path/to/your/spec.json for a local file).
  • TOOL_WHITELIST: Limits to /sessions endpoints.
  • API_KEY: Your GetZep API key.
  • API_AUTH_TYPE: Uses Api-Key for header-based authentication.
  • TOOL_NAME_PREFIX: Prepends zep_ to tool names.

3. Testing

After starting the service refer to the JSON-RPC Testing section for instructions on listing resources and tools.

Virustotal Example — YAML spec + custom x-apikey auth header

This example demonstrates:
- Using a YAML OpenAPI specification file
- Using custom HTTP auth header, "x-apikey"

1. Verify the OpenAPI Specification

Retrieve the Virustotal OpenAPI specification:```bash
curl https://raw.githubusercontent.com/matthewhand/mcp-openapi-proxy/refs/heads/main/examples/virustotal.openapi.yml


Ensure that the response is a valid OpenAPI YAML document.

#### 2. Configure mcp-openapi-proxy for Virustotal

Add the following configuration to your MCP ecosystem settings:```json
{
    &quot;mcpServers&quot;: {
        &quot;virustotal&quot;: {
            &quot;command&quot;: &quot;uvx&quot;,
            &quot;args&quot;: [&quot;mcp-openapi-proxy&quot;],
            &quot;env&quot;: {
                &quot;OPENAPI_SPEC_URL&quot;: &quot;https://raw.githubusercontent.com/matthewhand/mcp-openapi-proxy/refs/heads/main/examples/virustotal.openapi.yml&quot;,
                &quot;EXTRA_HEADERS&quot;: &quot;x-apikey: ${VIRUSTOTAL_API_KEY}&quot;,
                &quot;OPENAPI_SPEC_FORMAT&quot;: &quot;yaml&quot;
            }
        }
    }
}

Key configuration points:
- By default, the proxy expects a JSON specification and sends the API key with a Bearer prefix.

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Matthewhand MCP 怎么安装?

在客户端按下面的安装命令接入:pip install mcp-openapi-proxy\"。装完在客户端配置里引用同一个包或端点。

Matthewhand MCP 怎么在客户端里配置?

它的传输方式未标注,在客户端 MCP 配置里按官方文档填写启动命令和参数,保存后重启客户端生效。

Matthewhand MCP 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Matthewhand MCP 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Matthewhand MCP 能提供哪些能力?

资料显示能力标签包括 API代理、Python、API集成、API密钥。具体工具清单以官方文档为准。

Matthewhand MCP 需要什么运行环境?

运行时为 Python;属于远程端点,不需要在本地装运行时。

Matthewhand MCP 是本地还是远程?

它是远程端点,连服务地址即可。传输方式为HTTP · 远程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-05-17。