OIC Monitoring MCP Server

用于 Oracle Integration Cloud (OIC) 的只读 MCP 服务器。将 MCP 客户端（Claude Code 等）连接到它，就能用自然语言询问关于集成、连接、运行时实例、错误和流程日志的问题——服务器会把这些请求转换为 OIC REST API 调用,并返回简洁、友好兼容 LLM 的 JSON。

基于 FastAPI + WebSocket 构建，通过 OAuth2 客户端凭据（IDCS/IAM）进行身份验证。

目录

• 要求

• 安装：Windows、macOS、Linux

• 配置（.env）

• 连接 MCP 客户端

• 从同一代码库运行多个环境

• 保持服务器运行

  • 方案 A：仅会话（关闭终端即退出）

  • 方案 B：永久后台服务（重启后仍存活）

• 工具

• 响应格式

• 工作原理

• 生产环境加固

• 故障排查

要求

磁盘占用很小：虚拟环境约为 120MB，日志总量约 60MB。

安装

每个平台的安装流程相同：

1. 安装 Python 3.10 及以上版本

2. 获取代码

3. 创建虚拟环境并安装依赖

4. 创建并填写 .env

5. 启动服务并验证

只有第 1 步和虚拟环境激活命令因操作系统不同而有所不同。

Windows

1. 安装 Python

最简单的方法是使用 PowerShell 执行安装命令：

winget install -e --id Python.Python.3.12

或者从 python.org/downloads/windows 下载安装包。如果你使用安装包方式，请在第一个界面勾选 "Add python.exe to PATH"。这个复选框正是后来大多数 "python is not recognized" 问题的主因。

关闭并重新打开 PowerShell，然后确认：

py -3 --version

你应该看到 Python 3.10.x 或更高版本。py 命令随官方安装包自带，在 Windows 上运行 Python 最可靠，所以下面的命令使用 py。

2. 获取代码

git clone <your-repo-url> oic-mcp
cd oic-mcp

3. 创建虚拟环境并安装依赖

py -3 -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
pip install -r requirements.txt

如果 PowerShell 因 "running scripts is disabled" 错误而禁止执行激活脚本，请允许签名脚本在你的用户中执行一次：

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

使用 cmd.exe？请通过 .venv\Scripts\activate.bat 激活。

4. 配置

Copy-Item .env.example .env
notepad .env

请根据 配置 中的说明填写各值。

5. 启动服务

.\scripts\run-local.ps1

macOS

1. 安装 Python

macOS 自带的系统 Python 不建议用于开发。请使用 Homebrew 安装你自己的 Python：

brew install python@3.12

然后检查：

python3 --version

没有 Homebrew？请先安装 Homebrew，或者从 python.org/downloads/macos 下载 macOS 安装包。

2. 获取代码

git clone <your-repo-url> oic-mcp
cd oic-mcp

3. 创建虚拟环境并安装依赖

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
pip install -r requirements.txt

4. 配置

cp .env.example .env
nano .env

5. 启动服务

chmod +x scripts/*.sh
./scripts/run-local.sh

Linux

1. 安装 Python

Debian / Ubuntu：

sudo apt update
sudo apt install -y python3 python3-venv python3-pip git

python3-venv 在 Debian 系发行版中是独立包，安装时很容易被遗漏。没有它时，python3 -m venv 会抛出 ensurepip is not available 错误。

RHEL / Rocky / Alma / Fedora：

sudo dnf install -y python3.12 python3.12-devel git

请确认：

python3 --version

如果你的发行版自带的 Python 低于 3.10（例如 RHEL 8，自带 3.6），请额外安装更新版本的 Python（如从 AppStream 或 deadsnakes 中安装 python3.11 或 python3.12），并在创建虚拟环境时使用该明确版本号，例如 python3.12 -m venv .venv。

2. 获取代码

git clone <your-repo-url> oic-mcp
cd oic-mcp

3. 创建虚拟环境并安装依赖

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
pip install -r requirements.txt

4. 配置

cp .env.example .env
nano .env

5. 启动服务

chmod +x scripts/*.sh
./scripts/run-local.sh

验证安装

默认情况下，服务监听在 ws://127.0.0.1:8085/ws。请在另一个终端中：

python3 scripts/ws-call.py tools/list

在 Windows 上：

.\.venv\Scripts\python.exe scripts\ws-call.py tools/list

你会看到包含约 40 个工具的 JSON 列表。除了 WebSocket 之外，还有一个纯 HTTP 健康检查接口，无需 WebSocket 客户端：

curl http://127.0.0.1:8085/healthz
# {"status": "ok"}

如果出现连接错误或 401，请参考 故障排查。

修改主机和端口

run-local.sh 和 run-local.ps1 都会读取 PORT 变量，并且默认仅绑定到 loopback：

# Linux / macOS
PORT=8086 ./scripts/run-local.sh
HOST=0.0.0.0 PORT=8086 ./scripts/run-local.sh

# Windows
$env:PORT="8086"; .\scripts\run-local.ps1
$env:MCP_HOST="0.0.0.0"; $env:PORT="8086"; .\scripts\run-local.ps1

或者直接调用 uvicorn（这两个脚本实际就是调用它）：

uvicorn mcp_server.main:app --host 127.0.0.1 --port 8085 --ws websockets

绑定到 0.0.0.0 会将未认证的 WebSocket 暴露到你的网络环境。请仅在 TLS 和防火墙之后使用，详见 生产环境加固。

环境配置 (.env)

复制 .env.example 为 .env，然后填写：

你的 OAuth 应用还需要在 IDCS/IAM中将 OIC 实例的“资源应用”上分配 ServiceUser 应用角色（不是分配给客户端应用本身）。否则即使拿到的是有效的 token，每次请求仍会返回 401。详见 故障排查。

另外，.env 及 .env.* 都被 gitignore 了（仅 .env.example 被追踪），这样你的密钥就不会进入仓库。

连接 MCP 客户端

Claude Code：

claude mcp add-json oic '{"type":"ws","url":"ws://127.0.0.1:8085/ws"}'

任何支持原始 JSON 配置的客户端，把它添加到该客户端的 MCP servers 配置中（例如 .mcp.json，或复制 mcp.json.example）：

{
  "mcpServers": {
    "oic": {
      "type": "ws",
      "url": "ws://127.0.0.1:8085/ws"
    }
  }
}

该服务器仅支持 WebSocket 传输，不是 stdio 服务器，因此 "type": "stdio" 或调用命令行的配置方式在此不适用。请先以独立进程启动它，然后让客户端指向该 URL。

连接成功后，直接使用自然语言提问即可，例如 "列出已启用的集成" 或 "展示 INTEGRATION_CODE 的最后 20 个运行时实例"——无需手动调用工具名。

从同一份代码库运行多个环境

你不需要克隆第二套代码库来监控 Dev、Test 和 Prod。同一个检出目录可以运行任意数量的进程，只需通过 OIC_ENV_FILE 将各个进程指向不同的环境文件，并使用不同端口。

mcp_server/settings.py 在启动时会读取 OIC_ENV_FILE，然后加载该配置文件而不是 .env。其他部分（代码、工具）完全相同。

1. 为每个环境创建配置文件

cp .env.example .env.dev
cp .env.example .env.test
cp .env.example .env.prod

为每个文件填写该环境自己的 OIC_BASE_URL、OIC_INSTANCE_NAME 以及 OAuth 凭据。同时为每个进程分配不同的日志文件以避免日志混淆：

# in .env.prod
MCP_LOG_FILE=mcp_server.prod.log

2. 为每个环境启动一个进程，且各自使用独立端口

Linux / macOS：

OIC_ENV_FILE=.env.dev  PORT=8085 ./scripts/run-local.sh
OIC_ENV_FILE=.env.test PORT=8086 ./scripts/run-local.sh
OIC_ENV_FILE=.env.prod PORT=8087 ./scripts/run-local.sh

Windows PowerShell（在各自的终端中执行，因为会设置不同的环境变量）：

$env:OIC_ENV_FILE=".env.prod"; $env:PORT="8087"; .\scripts\run-local.ps1

或者直接调用 uvicorn：

OIC_ENV_FILE=.env.prod uvicorn mcp_server.main:app --host 127.0.0.1 --port 8087 --ws websockets

3. 在客户端中分别注册，赋予不同名称

{
  "mcpServers": {
    "oic-dev":  { "type": "ws", "url": "ws://127.0.0.1:8085/ws" },
    "oic-test": { "type": "ws", "url": "ws://127.0.0.1:8086/ws" },
    "oic-prod": { "type": "ws", "url": "ws://127.0.0.1:8087/ws" }
  }
}

之后你的 agent 会看到三组名称清晰分开的工具集，便可以在同一个对话中比较同一集成在不同环境中的差异。

建议的部署布局：

几点需要了解的事项

• OIC_ENV_FILE 只在进程启动时读取。修改它或直接编辑配置文件本身，需要重新启动相关进程。

• 真实的环境变量优先于文件中的任何值。如果你在 shell 配置中导出了 OIC_BASE_URL，那么所有进程都会使用该值，而不管它加载的是哪个配置文件。因此建议不要将这类变量写入 shell 配置。

• 每个进程需要独立的端口。若两个进程占用同一端口，会提示 "address already in use"。

• 在 Docker 下，--env-file 会注入真实的环境变量，因此 OIC_ENV_FILE 并不必要。只需将 --env-file 指向正确文件即可。

• 这里的每个工具都是只读的，但仍建议最小权限：只需给各环境的 OAuth app 分配 ServiceUser 角色。

保持服务器运行

支持以下两种方式。请有意选择一种，因为两者在退出登录时的行为差异很大。

方案A：仅会话（关闭终端即终止）

适合开发、临时排查这类场景，适合任何你不希望因遗忘而导致进程长期持有凭据过夜的情况。

在前台终端窗口中直接运行：

# Linux / macOS
./scripts/run-local.sh

# Windows
.\scripts\run-local.ps1

这就是全部内容。该进程是该终端窗口的子进程：

• 按 Ctrl+C 可立即停止。

• 关闭终端窗口、结束 SSH 会话或注销系统，该进程都会退出。

• 不会自动重启，即使在重启后也不会自动恢复。

日志会同时输出到终端和 mcp_server.log，同时也是最易调试的方式。

如果你希望获得提示符的同时又在会话结束后能马上释放终端，请将该进程放到后台启动，而不是作为守护进程：

./scripts/run-local.sh > uvicorn.log 2>&1 &
echo "started as PID $!"

# later, from the same shell
kill %1

Do not wrap it in nohup, setsid, disown, screen, or tmux if session-scoped behaviour is what you want. All of those exist specifically to detach a process from your session and will keep it alive after you log out.

To confirm nothing is left behind after you close the session:

# Linux / macOS
pgrep -af "mcp_server.main"

# Windows
Get-CimInstance Win32_Process -Filter "Name='python.exe'" |
  Where-Object { $_.CommandLine -like "*mcp_server.main*" } |
  Select-Object ProcessId, CommandLine

Option B: permanent background service (survives reboot)

Best for a shared server, or a workstation where the team expects the MCP endpoint to always be there. In every case below the service starts at boot and restarts automatically if it crashes.

Do not use nohup ... & for this. It survives logout but not a reboot, and nothing restarts it if the process dies. Use your OS's service manager.

Linux (systemd)

Create /etc/hd/system/oic-mcp.service:

[Unit]
Description=OIC Monitoring MCP Server
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=oicmcp
Group=oicmcp
WorkingDirectory=/opt/oic-mcp
Environment=OIC_ENV_FILE=/opt/oic-mcp/.env.prod
ExecStart=/opt/oic-mcp/.venv/bin/uvicorn mcp_server.main:app --host 127.0.0.1 --port 8085 --ws websockets
Restart=always
RestartSec=5

# Basic hardening
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full

[Install]
WantedBy=multi-user.target

Then:

sudo useradd --system --home /opt/oic-mcp --shell /usr/sbin/nologin oicmcp
sudo chown -R oicmcp:oicmcp /opt/oic-mcp
sudo chmod 600 /opt/oic-mcp/.env.prod

sudo systemctl daemon-reload
sudo systemctl enable --now oic-mcp
sudo systemctl status oic-mcp

enable is what makes it come back after a reboot. Restart=always is what makes it come back after a crash. You need both.

Logs go to the journal:

journalctl -u oic-mcp -f

For a second instance, copy the unit to oic-mcp-test.service, change the line Environment=OIC_ENV_FILE= and the --port, then sudo systemctl enable --now oic-mcp-test.

Preferring to run it as your own user? Put the same unit at ~/.config/systemd/user/oic-mcp.service, enable it with systemctl --user enable --now oic-mcp, and run sudo loginctl enable-linger $USER so it starts at boot rather than at your first login.

macOS (launchd)

Create ~/Library/LaunchAgents/com.oic.mcp.plist, replacing /Users/you/oic-mcp with your actual path:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>com.oic.mcp</string>

  <key>ProgramArguments</key>
  <array>
    <string>/Users/you/oic-mcp/.venv/bin/uvicorn</string>
    <string>mcp_server.main:app</string>
    <string>--host</string><string>127.0.0.1</string>
    <string>--port</string><string>8085</string>
    <string>--ws</string><string>websockets</string>
  </array>

  <key>WorkingDirectory</key>
  <string>/Users/you/oic-mcp</string>

  <key>EnvironmentVariables</key>
  <dict>
    <key>OIC_ENV_FILE</key>
    <string>/Users/you/oic-mcp/.env.prod</string>
  </dict>

  <key>RunAtLoad</key><true/>
  <key>KeepAlive</key><true/>

  <key>StandardOutPath</key>
  <string>/Users/you/oic-mcp/launchd.out.log</string>
  <key>StandardErrorPath</key>
  <string>/Users/you/oic-mcp/launchd.err.log</string>
</dict>
</plist>

Load it:

launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.oic.mcp.plist
launchctl print gui/$(id -u)/com.oic.mcp | head -20

RunAtLoad starts it immediately and again at every login. KeepAlive restarts it if it exits.

To stop it, or to reload after editing the plist:

launchctl bootout gui/$(id -u)/com.oic.mcp
launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.oic.mcp.plist

A LaunchAgent in ~/Library/LaunchAgents starts when you log in. If the machine must serve the endpoint before anyone logs in, put the same plist in /Library/LaunchDaemons/ instead (owned by root:wheel, mode 644), add a UserName key so it does not run as root, and load it with sudo launchctl bootstrap system /Library/LaunchDaemons/com.oic.mcp.plist.

For a second instance, duplicate the plist with a new Label (com.oic.mcp.test), a different port, and a different OIC_ENV_FILE.

Windows (NSSM, recommended)

NSSM wraps any executable as a proper Windows service. Install NSSM with winget install nssm or choco install nssm, then in an Administrator PowerShell:

$proj = "D:\oic_mcp_git"

nssm install OicMcp "$proj\.venv\Scripts\uvicorn.exe" "mcp_server.main:app --host 127.0.0.1 --port 8085 --ws websockets"
nssm set OicMcp AppDirectory $proj
nssm set OicMcp AppEnvironmentExtra "OIC_ENV_FILE=$proj\.env.prod"
nssm set OicMcp Start SERVICE_AUTO_START
nssm set OicMcp AppStdout "$proj\service.out.log"
nssm set OicMcp AppStderr "$proj\service.err.log"
nssm set OicMcp AppExit Default Restart
nssm set OicMcp AppRestartDelay 5000

nssm start OicMcp

SERVICE_AUTO_START is what brings it back after reboot, and AppExit Default Restart is what brings it back after crash.

Manage it like any other service:

Get-Service OicMcp
nssm restart OicMcp
nssm stop OicMcp
nssm remove OicMcp confirm

For a second service, install another service under a different name (OicMcpTest) with its own port and OIC_ENV_FILE.

Windows (Task Scheduler, no extra tooling)

If you cannot install NSSM, Task Scheduler can start it at boot. First create start-prod.bat in the project folder, because a scheduled task cannot easily set a working directory inline:

@echo off
cd /d D:\oic_mcp_git
set OIC_ENV_FILE=D:\oic_mcp_git\.env.prod
".venv\Scripts\python.exe" -m uvicorn mcp_server.main:app --host 127.0.0.1 --port 8085 --ws websockets

Then register it in an Administrator PowerShell:

schtasks /Create /TN "OIC MCP Server" /TR "D:\oic_mcp_git\start-prod.bat" /SC ONSTART /RU SYSTEM /RL HIGHEST /F
schtasks /Run /TN "OIC MCP Server"
schtasks /Query /TN "OIC MCP Server"

This starts at boot but does not restart on crash by default. Add that in Task Scheduler under the task's Settings tab: "If the task fails after 1 minute, retart it", up to 3 times; otherwise. NSSM handles this better, which is why it is the recommended option.

Docker (any platform)

The restart policy does the same job as a service manager, including across host reboots, as long as the Docker daemon itself starts at boot:

docker build -t oic-mcp:latest .

docker run -d \
  --name oic-mcp-prod \
  --restart unless-stopped \
  -p 8085:8080 \
  --env-file .env.prod \
  oic-mcp:latest

The container listens on a port, so map whichever above, map the port:

docker run -d --name oic-mcp-test --restart unless-stopped \
  -p 8086:8080 --env-file .env.test oic-mcp:latest

Check on it with docker ps and docker logs -f oic-mcp-prod.

Which one should I use?

Tools

All tools are discoverable via tools/list and are read-only. Many accept version; if omitted, the latest version is resolved automatically.

Integrations

• list_integrations - optional onlyActivated, limit, page

• list_activated_integrations

• get_integration - by identifier and version

• get_integration_auto - design-time details by code or code|version, auto-resolves latest

• search_integration_by_name - full-catalogue search (auto-paginated), exact or partial match, always returns a list

• list_integrations_search - client-side paged search across code/name/description

• export_integration - download the integration zip as base64, or listOnly of entries + previews

Runtime monitoring

• list_instances - optional integrationId, status, startTime/endTime, timewindow, limit

• get_instance - full detail by instanceId

• get_instance_activity_stream - step-by-step flow/execution log for one instance

• list_errors - optional integrationId, timewindow, limit

• list_metrics - historical tracking metrics, hourly or daily

• list_schedules / get_schedule - schedule info per integration

Connections, packages, and building blocks

• list_connections / get_connection / get_connection_detail

• list_packages / get_package

• list_lookups / get_lookup

• get_library

• list_adapters / get_adaptor

• list_agents / list_agent_groups

• list_endpoints - end points with role and connection

Design-time analysis

• summarize_integration - trigger/targets/tracking variables at a glance

• summarize_integration_with_steps - the above plus selected step I/O summaries

• summarize_flow_controls - count and sample Switch/ForEach/Route/Fault/Scope constructs

• summarize_mappings - extract mapping steps

• deep_flow_outline - compact textual outline of the whole flow

• get_integration_step - raw JSON subtree(s) matching a stepName (exact + fuzzy), plus matching endpoints

• summarize_step_io - suspected SQL/query snippets and parameters for a stepName, fallbacks to endpoint match if no step is found

Utility

• fetch_raw_path - fetch any relative OIC path

• search_json - substring search over any JSON-like structure

Design-time tools accept an optional designJsonPath to read a previously-downloaded design JSON from disk instead of calling OIC - useful for offline analysis or avoid repeat calls while iterating.

Response format

Every tools/call result follows the MCP spec envelope: {"content": [{"type": "text", "text": "<json-or-plain-text>"}], "isError": false}. The actual tool payload is JSON-serialized inside text - parse it once more to get structured data:

python3 scripts/ws-call.py tools/call '{"name":"list_integrations","arguments":{"limit":3}}' \
  | python3 -c "
import json, sys
resp = json.load(sys.stdin)
payload = json.loads(resp['result']['content'][0]['text'])
print(json.dumps(payload, indent=2))
"

Tool execution errors (e.g. OIC unreachable, bad identifier) come back the same way with isError: true - check that flag rather than assuming success. Same for genuine protocol errors (unknown side, unknown tool name) use a real JSON-RPC error object. Large payloads are capped at 100,000 characters and clearly marked [TRUNCATED ...] when cut - never silently.

How it works

• The server exposes one WebSocket endpoint speaking JSON-RPC 2.0 / MCP. Clients call tools/list to discover tools and tools/call to run them.

• On each call it fetches from OIC's REST API via an authenticated httpx.AsyncClient. The OAuth token is cached and refreshed automatically.

• The WebSocket handshake negotiates mcp subprotocol when a client offers it, and initialize prefers spec-compliant protocolVersion and object-typed capabilities - required for strict clients like Claude Code to accept the connection.

• Redirects are followed manually rather than via httpx's built-in handling: OIC's design-time gateway redirects to a different host than OIC_BASE_URL, and httpx strips the Authorization header on any cross-host redirect by default. Manual handling usagers it for this known, trusted hop.

Logging

Logs go to mcp_server.log (override with MCP_LOG_FILE), rotated at 10MB per file with 5 backs (～60MB) - it will never grow beyond. No logrotate, cron, or sudo needed - app manages its own log size on every write.

When running one process per environment, set a distinct MCP_LOG_FILE in each env file so logs stay separate.

Production hardening

• Run behind TLS (reverse proxy like Ngnix/Traeik) and restrict network access. The WebSocket endpoint has no authentication of its own, so never expose it directly to an untrusted network.

• Keep bind address on 127.0.0.1 unless specific reason.

• Store secrets in a vault; never commit .env. On Linux, chmod 600 the env file and own it as the service user.

• Grant the OAuth client the minimum role needed (ServiceUser is read-level; avoid ServiceDeveloper unless you specifically need create/import tools).

• Use a process manager (systemd, launchd, NSSM) so it survives reboots, see Option B.

• Watch payload sizes on large catalogues - prefer list_integrations_search with narrow terms and paging over pulling entire lists.

Troubleshooting

Install and startup

• python or py is not recognized (Windows) - Python was installed without "Add python.exe to PATH". Re-run the installer, choose Modify, and enable it, or reinstall via winget install -e --id Python.Python.3.12. Open a new terminal afterwards.

• **running scripts is disabled on this system - Windows** - PowerShell's execution policy is blocking virtual environment activation. Run Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned, or use cmd.exewith.venv\Scripts\activate.bat`.

• ensurepip is not available (Debian/Ubuntu) - install the separate venv package: sudo apt install python3-venv.

• TypeError: unsupported operand type(s) for | - you are on Python 3.9 or older. Install 3.10+ and recreate the virtual environment with the newer interpreter.

• ValidationError on startup naming OWS_BASE_URL or OAUTH_* - the env file was not found or incomplete. Confirm you copied .env.example to .env, that you started the process from the project directory, and that OIC_ENV_FILE (if set) points at a file that exists.

• address already in use - another process holds the port. Find it with lsof -i :8085 (Linux/macOS) or netstat -ano | findstr :8085 (Windows), else start on a different PORT.

Authentication

• 401/403 from the token URL - check OAUTH_CLIENT_ID/OAUTH_CLIENT_SECRET and that OAUTH_TOKEN_URL is correct for your IDCS/IAM domain.

• Token request succeeds (200) but every OIC call still 401s - almost always a missing IDCS role, not a bad token. In OCI Console → Identity & Security → Domains → your domain → find the OIC instance's own resource app (not your confidential client app) → Application roles → ServiceUser → assign your confidential client app. Get a fresh token after assigning it - an existing token won't gain the role retroactively.

Connecting

• 连接被拒绝 / 无法访问 WebSocket — 确认服务器进程确实在运行（pgrep -af mcp_server.main、systemctl status oic-mcp 或 Get-Service OicMcp），并且没有其他进程占用同一端口。curl http://127.0.0.1:8085/healthz 是最快的检查方式。

• Claude Code 将服务器显示为“仍在连接”，或其工具始终无法加载 — 服务器必须已经在客户端会话之前运行；如果当时尚未启动，它不会自动重试。请确认服务器健康后重启客户端。

• 返回了错误环境的数据 — 真实的 OS 环境变量会覆盖你的 env 文件，因为它们的优先级更高。请使用 env | grep OIC_（Linux/macOS）或 Get-ChildItem Env:OIC_*（Windows）检查，并清除 shell 配置中过期的内容。

使用工具

• 某些流程/设计路径返回 404 — 优先使用设计期工具（get_integration_auto、summarize_*），而不是直接获取原始路径；它们会为你处理版本解析和已知端点怪癖。

• 响应过大或过慢 — 使用list_integrations_search/search_integration_by_name和分页（perPage、maxPages）来缩小范围，而不是拉取完整目录。

• 健康检查 — 当进程本身运行时，GET /healthz 返回{"status": "ok"}（不验证 OIC 连接）。

许可证

MIT