Soprano Connect MCP Server

MCP办公协作

提供方 soprano-mcp

办公协作 未标注 OAuth 授权 社区 / 第三方 Claude DesktopClaudeCursorVS Code

Soprano Connect MCP Server enables you to build AI agents that can communicate, engage customers, and manage communications workflows through the Soprano Connect platform using the Model Context Protocol (MCP).

一句话选型结论

按资料字段整理

Soprano Connect MCP Server 属于办公协作类 MCP 服务器,传输方式未标注,OAuth 授权,可直接接入 Claude Desktop、Claude、Cursor 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

aimcpsms

安装与配置

未标注 OAuth 授权
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
日程与消息

查日程、发消息、约会议。

表单与审批

填表单、走审批流。

团队协作

同步任务、汇总进展。

选择建议

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

值得选的地方

  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在办公协作场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Soprano Connect MCP Server当前 未标注 未标注 未标注 无 未标注
CowAgent 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Karakeep MCP 未标注 未标注 未标注 无 2026-05-17
agentscope 未标注 stdio · 本地进程 本地部署 有 2026-04-11
note-gen 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Everywhere 未标注 stdio · 本地进程 本地部署 有 2026-04-12

服务器档案

办公协作
字段来自项目仓库与公开索引,中文说明由本站标注
提供方soprano-mcp上游标注的维护方 soprano-mcp
分类办公协作本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · python本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

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

Soprano Connect MCP Server

Soprano Connect MCP Server enables you to build AI agents that can communicate, engage customers, and manage communications workflows through Soprano Connect — a global Communications Platform as a Service (CPaaS) — using the Model Context Protocol (MCP).

The Soprano Connect MCP Server enables AI assistants, copilots, autonomous agents, and enterprise applications to securely interact with Soprano Connect's global CPaaS platform. Using natural language, AI agents can send messages, manage customer data, administer accounts, and orchestrate communications across multiple channels in a controlled, enterprise-grade environment.

No complex API integrations. No custom middleware. Simply connect your MCP-compatible AI client and start building intelligent communications workflows — connect any MCP-compatible client (Claude, VS Code Copilot, Cursor, etc.) to the Soprano MCP server and let your agent send messages and check delivery status across multiple channels, all through natural language.

💡 Why Soprano MCP?

Soprano Connect MCP transforms communications capabilities into AI-native tools that can be consumed directly by AI agents. With Soprano MCP, AI agents can:

  • Send omnichannel communications across all channels supported by Soprano Connect platform
  • Manage contacts and customer contact lists
  • Query messaging history and delivery status
  • Automate customer engagement workflows
  • Build AI-powered communications use cases without custom integration code
  • Operate within an enterprise-grade security and governance framework

🛠️ Key Features

  • Send communications through any channel supported by Soprano Connect such as SMS, RCS, WhatsApp, Viber, Email, Voice, Mobile Push
  • Rich content per channel — WhatsApp (media, interactive buttons/lists, templates, location, reactions), RCS (rich cards, carousels, suggestions), Voice (text-to-speech, pre-recorded audio, Call Control Objects), Push Notification
  • Broadcast sending, plus single/batch message status lookups
  • Read-only lookup of stored contacts, groups and lists, to find the ids a broadcast targets
  • WhatsApp Business (WABA) template listing, and media upload/delete
  • Pluggable upstream (Soprano) authentication — API Key, OAuth2 (client credentials), Basic, Legacy OAuth2, and a session-cookie outlier for WABA templates — selected per request, credentials supplied by the caller and never stored server-side

📋 Prerequisites

  • A Soprano Design Connect API account, provisioned with a license for each channel you want to use
  • Python 3.12+ and uv — only needed for the stdio transport (running the server locally as a subprocess). Connecting to an already-deployed streamable HTTP server needs no local Python install at all
  • AI agent or application with MCP client support

> Each tool/channel is only available if your Soprano account is subscribed to and provisioned for the corresponding service. Features outside your current subscription must be enabled via Soprano's onboarding or account management process before use.

Table of Contents

  • 💡 Why Soprano MCP?
  • 🔌 Transports
  • Streamable HTTP
  • stdio
  • ✉️ Messaging Channels
  • 🧰 Available Tools
  • 🤖 Agent Permission and Access Control
  • 🔐 Authentication
  • 🔒 Client Authentication (optional)
  • 🚀 Installation & Running
  • 🛠️ Troubleshooting
  • 🤝 Contributing
  • 📄 License

🔌 Transports

The Soprano MCP server supports both of the transports defined by the MCP spec — unlike a hosted multi-tenant service, you run it yourself (locally or deployed), so there's a single endpoint/process rather than one per channel.

Streamable HTTP

Supports streamable HTTP transport for remote/deployable use (e.g. behind an ALB, Lambda Function URL, or API Gateway). Point your MCP client at the server's /mcp endpoint, replacing ` with wherever you've deployed it (orhttp://127.0.0.1:8000` if running locally).

If the server has Client Authentication (MCP_CLIENT_AUTH_MODE=oauth2.1) enabled with the Layer 2 fallback turned on — the recommended setup for hosted deployments — no X-Soprano-* headers are needed at all:```json
{
"servers": {
"mems-mcp (http)": {
"type": "http",
"url": "<mems-mcp-server-url>/mcp"
}
}
}


Your MCP client will redirect you through an OAuth login/consent page, where you enter your Soprano Connect **API ID** and **API KEY** — that&#x27;s the only credential you need to supply. The server uses it both to authenticate you (Layer 1) and, via the Layer 2 fallback, to authenticate its own calls to Soprano on your behalf, so per-request headers become unnecessary.

**Otherwise** (`MCP_CLIENT_AUTH_MODE=none`, or you want to pass different Soprano credentials per request regardless), supply Layer 2 credentials explicitly via `X-Soprano-*` headers instead:```json
{
  &quot;servers&quot;: {
    &quot;mems-mcp (http)&quot;: {
      &quot;type&quot;: &quot;http&quot;,
      &quot;url&quot;: &quot;&lt;mems-mcp-server-url&gt;/mcp&quot;,
      &quot;headers&quot;: {
        &quot;X-Soprano-Auth-Method&quot;: &quot;api_key&quot;,
        &quot;X-Soprano-Api-Id&quot;: &quot;${input:soprano-api-id}&quot;,
        &quot;X-Soprano-Api-Key&quot;: &quot;${input:soprano-api-key}&quot;
      }
    }
  }
}

X-Soprano-Domain-Url can usually be left out: if the server's own public hostname follows the mcp- naming convention (e.g. mcp-aus.sopranodesign.com), it derives your Soprano domain automatically by stripping that prefix (https://aus.sopranodesign.com). Set the header explicitly only if your deployment doesn't follow that convention, or to target a different domain than the one implied by the hostname.

The X-Soprano-* headers above are for the api_key method — swap them for any of the other supported auth methods (see Authentication below) by using the matching header set instead:```json
// oauth2 (client credentials)
"headers": {
"X-Soprano-Auth-Method": "oauth2",
"X-Soprano-Client-Id": "${input:soprano-client-id}",
"X-Soprano-Client-Secret": "${input:soprano-client-secret}"
}
json // basic &quot;headers&quot;: { &quot;X-Soprano-Auth-Method&quot;: &quot;basic&quot;, &quot;X-Soprano-Username&quot;: &quot;${input:soprano-username}&quot;, &quot;X-Soprano-Password&quot;: &quot;${input:soprano-password}&quot; }json
// legacy_oauth2
"headers": {
"X-Soprano-Auth-Method": "legacy_oauth2",
"X-Soprano-Username": "${input:soprano-username}",
"X-Soprano-Password": "${input:soprano-password}"
}


&gt; The legacy `sse` transport (append the server&#x27;s `--transport sse` flag, endpoint `/sse`) is also available for MCP clients that don&#x27;t yet support streamable HTTP.

### stdio

For local use (e.g. launched as a subprocess by VS Code, Claude Desktop, etc.), run with `--transport stdio`. Since stdio has no HTTP headers, Soprano credentials are supplied via `SOPRANO_*` environment variables instead:```json
{
  &quot;servers&quot;: {
    &quot;mems-mcp (stdio)&quot;: {
      &quot;type&quot;: &quot;stdio&quot;,
      &quot;command&quot;: &quot;uv&quot;,
      &quot;args&quot;: [&quot;run&quot;, &quot;--directory&quot;, &quot;${workspaceFolder}&quot;, &quot;mems-mcp&quot;, &quot;--transport&quot;, &quot;stdio&quot;],
      &quot;env&quot;: {
        &quot;SOPRANO_DOMAIN_URL&quot;: &quot;https://aus.sopranodesign.com&quot;,
        &quot;SOPRANO_AUTH_METHOD&quot;: &quot;api_key&quot;,
        &quot;SOPRANO_API_ID&quot;: &quot;${input:soprano-api-id}&quot;,
        &quot;SOPRANO_API_KEY&quot;: &quot;${input:soprano-api-key}&quot;
      }
    }
  }
}

Same as above, swap the env block for any other auth method:```json
// oauth2 (client credentials)
"env": {
"SOPRANO_DOMAIN_URL": "https://aus.sopranodesign.com",
"SOPRANO_AUTH_METHOD": "oauth2",
"SOPRANO_CLIENT_ID": "${input:soprano-client-id}",
"SOPRANO_CLIENT_SECRET": "${input:soprano-client-secret}"
}
json // basic &quot;env&quot;: { &quot;SOPRANO_DOMAIN_URL&quot;: &quot;https://aus.sopranodesign.com&quot;, &quot;SOPRANO_AUTH_METHOD&quot;: &quot;basic&quot;, &quot;SOPRANO_USERNAME&quot;: &quot;${input:soprano-username}&quot;, &quot;SOPRANO_PASSWORD&quot;: &quot;${input:soprano-password}&quot; }json
// legacy_oauth2
"env": {
"SOPRANO_DOMAIN_URL": "https://aus.sopranodesign.com",
"SOPRANO_AUTH_METHOD": "legacy_oauth2",
"SOPRANO_USERNAME": "${input:soprano-username}",
"SOPRANO_PASSWORD": "${input:soprano-password}"
}


## ✉️ Messaging Channels

All channels are exposed through one generic `send_message` tool (`channel` parameter selects the target) rather than one MCP server per channel — this keeps the tool surface (and token footprint) small while still giving access to every channel-specific rich content type the Connect API supports.

| Channel | `channel` value | Rich content supported |
|---|---|---|
| SMS | `sms` | Plain text only |
| WhatsApp | `whatsapp` | Media (image/video/document/audio), interactive buttons/lists, pre-approved templates, location, reactions, context (replies) |
| RCS | `rcs` | Rich cards, carousels, suggested replies/actions, media |
| Email | `email` | Plain text |
| Voice | `voice` | Text-to-speech, pre-recorded audio file, Call Control Objects |
| Viber | `viber` | Plain text (rich content not documented by the Connect API guide) |
| Mobile Push Notification | `pushnotification` | Title + body |

`send_message` sends to exactly one recipient per call (comma/semicolon-separated recipient lists are rejected). To reach many recipients, use `send_broadcast` against lists, contacts or groups already stored in your Soprano account — use `list_contacts`, `list_groups` and `list_lists` to find their ids.

## 🧰 Available Tools

Tool · Description · Maps to
**`send_message`** · Send a single real-time message to one recipient on any supported channel (SMS, WhatsApp, RCS, Email, Voice, Viber, Push).
_Example prompt_: &quot;Send a WhatsApp message to +33612345678 letting them know their order has shipped.&quot; · `POST /cgpapi/messages/{channel}`
**`get_message_status`** · Check the delivery status of a single previously-sent message.
_Example prompt_: &quot;What&#x27;s the delivery status of SMS message 123456?&quot; · `GET /cgpapi/messages/{channel}/{id}`
**`get_batch_status`** · Check delivery status for multiple SMS messages at once.
_Example prompt_: &quot;Check the delivery status of these 10 SMS message IDs.&quot; · `POST /cgpapi/batch/messages/status`
**`send_broadcast`** · Send a broadcast SMS order to lists, contacts, and/or groups already stored in your Soprano account (referenced by id; raw phone numbers are not accepted).
_Example prompt_: &quot;Broadcast a storm warning SMS to everyone in the &#x27;North Region&#x27; contact list.&quot; · `POST /cgpapi/broadcast/sms`
**`list_contacts`** · Look up stored contacts (id, name, mobile, email) to get the ids to use as `send_broadcast` endpoints. Read-only; filter by first name, last name, mobile or email; paged (max 100 per page).
_Example prompt_: &quot;Find the contact id for Jo Smith.&quot; · `GET /rest/contacts`
**`list_groups`** · Look up stored contact groups (id, name). Read-only; filter by name; paged.
_Example prompt_: &quot;Which groups do we have with &#x27;alert&#x27; in the name?&quot; · `GET /rest/groups`
**`list_lists`** · Look up stored recipient lists (id, name). Read-only; filter by name; paged.
_Example prompt_: &quot;What&#x27;s the id of our &#x27;Appointments&#x27; list?&quot; · `GET /rest/lists`
**`list_whatsapp_templates`** · List approved WhatsApp Business (WABA) message templates.
_Example prompt_: &quot;What WhatsApp templates do we have approved for order confirmations?&quot; · `GET /cgpapi/waba/templates`
**`upload_whatsapp_media`** · Upload media (image/video/document/audio) for use in WhatsApp messages.
_Example prompt_: &quot;Upload this product image so I can send it via WhatsApp.&quot; · `POST /cgpapi/waba/media/{source}`
**`delete_whatsapp_media`** · Delete previously uploaded WhatsApp media.
_Example prompt_: &quot;Delete the WhatsApp media file we just uploaded.&quot; · `DELETE /cgpapi/waba/media/{id}`

### Reading `list_contacts`, `list_groups` and `list_lists` results

Each returns `{items, page, limit, total, has_more}`. Filters are partial, case-insensitive matches, and when several are given on `list_contacts` all of them must match. `limit` defaults to 25 (max 100).

- An **empty `items`** means no matching record.
- To get the next page, call again with `page` + 1 (and the same filters and `limit`) while `has_more` is `true`. Prefer filtering over paging through everything.
- `total` is only known on page 1, and is `null` for `list_lists` whenever a `name` filter is used.
- `list_contacts` returns ordinary contacts only (the backend search is restricted to that contact type); records of other contact types, such as users, are not returned.
- Group and list names are not unique, so use the `id`.

## 🤖 Agent Permission and Access Control

Every tool is annotated with MCP&#x27;s standard tool annotations (`readOnlyHint`, `destructiveHint`, `openWorldHint`) so a client can apply governance before invoking it — e.g. `send_message`/`send_broadcast`/`upload_whatsapp_media` are non-read-only and reach an open world (real message delivery/spend), and `delete_whatsapp_media` is additionally flagged destructive. `list_contacts`, `list_groups` and `list_lists` are read-only, but `list_contacts` returns real mobile numbers and email addresses into the agent&#x27;s context, so scope the credentials you give an agent accordingly. Since sending messages has real-world cost and reputational impact, apply your MCP client/host&#x27;s permission controls (confirmation prompts, allow-lists, scoped credentials) to these tools rather than granting an agent unrestricted access — see the MCP spec&#x27;s own implementation considerations for guidance.

## 🔐 Authentication

Soprano credentials are supplied **per request**, never stored server-side or cached between calls. How you supply them depends on transport (HTTP headers for `streamable-http`/`sse`, environment variables for `stdio`):

| Auth method | stdio env vars | HTTP headers |
|---|---|---|
| API Key | `SOPRANO_AUTH_METHOD=api_key`, `SOPRANO_API_ID`, `SOPRANO_API_KEY` | `X-Soprano-Auth-Method: api_key`, `X-Soprano-Api-Id`, `X-Soprano-Api-Key` |
| OAuth2 (client credentials) | `SOPRANO_AUTH_METHOD=oauth2`, `SOPRANO_CLIENT_ID`, `SOPRANO_CLIENT_SECRET` | `X-Soprano-Auth-Method: oauth2`, `X-Soprano-Client-Id`, `X-Soprano-Client-Secret` |
| Basic | `SOPRANO_AUTH_METHOD=basic`, `SOPRANO_USERNAME`, `SOPRANO_PASSWORD` | `X-Soprano-Auth-Method: basic`, `X-Soprano-Username`, `X-Soprano-Password` |
| Legacy OAuth2 | `SOPRANO_AUTH_METHOD=legacy_oauth2`, `SOPRANO_USERNAME`, `SOPRANO_PASSWORD` | `X-Soprano-Auth-Method: legacy_oauth2`, `X-Soprano-Username`, `X-Soprano-Password` |
| Session cookie (`list_whatsapp_templates` only) | `SOPRANO_AUTH_METHOD=session_cookie`, `SOPRANO_SESSION_COOKIE` | `X-Soprano-Auth-Method: session_cookie`, `X-Soprano-Session-Cookie` |

Both transports also require the target domain — `SOPRANO_DOMAIN_URL` (stdio) or `X-Soprano-Domain-Url` (HTTP), e.g. `https://aus.sopranodesign.com`. For `streamable-http`/`sse`, this header can be omitted if the server&#x27;s own public hostname follows the `mcp-` naming convention (e.g. `mcp-aus.sopranodesign.com`) — the domain is then derived automatically by stripping that prefix.

## 🔒 Client Authentication (optional)

Everything above is Layer 2 (this server → Soprano). Independently, you can also require
authentication on incoming MCP requests (Layer 1 — client → this server), off by default:

| Env var | Required | Description |
|---|---|---|
| `MCP_CLIENT_AUTH_MODE` | — | `none` (default) or `oauth2.1` |
| `MCP_OAUTH_ISSUER_URL` | if `oauth2.1` | Your Authorization Server&#x27;s issuer URL(s) — comma-separated if this deployment fronts multiple domains. With the built-in self-hosted AS, this is derived automatically per-request from the caller&#x27;s own `Host` header and can be left unset. |
| `MCP_OAUTH_AUDIENCE` | if `oauth2.1` | Expected token `aud` claim(s), comma-separated — same per-request derivation as above with the self-hosted AS. |
| `MCP_OAUTH_RESOURCE_SERVER_URL` | if `oauth2.1` | This server&#x27;s own public URL — fallback default when a request&#x27;s `Host` doesn&#x27;t match any configured domain. |
| `MCP_OAUTH_JWKS_URI` | optional | Defaults to `{issuer}/.well-known/jwks.json` |
| `MCP_OAUTH_REQUIRED_SCOPES` | optional | Comma-separated required scopes |

Works with any standards-compliant OAuth2/OIDC Authorization Server (Auth0, Okta, Cognito, ...).

### Built-in self-hosted Authorization Server

Some MCP clients (confirmed: Zendesk Agent) require a full interactive OAuth 2.0 Authorization
Code + consent flow rather than just bearer-token verification. Rather than standing up a
separate IdP, this server can act as its own Authorization Server, using the caller&#x27;s Connect
API ID/API KEY as their identity — the routes below are always mounted, and become useful once
`MCP_CLIENT_AUTH_MODE=oauth2.1` points `MCP_OAUTH_ISSUER_URL` at this same deployment:

- `GET`/`POST /oauth/authorize` — login+consent form, validating the API ID/API KEY against the Connect API domain derived from the request&#x27;s own `Host` header (if it follows the `mcp-` convention), falling back to `MEMS_CONNECT_API_URL` otherwise
- `POST /oauth/token` — `authorization_code` (+ PKCE), `client_credentials`, and `refresh_token` grants
- `POST /oauth/register` — RFC 7591 Dynamic Client Registration; always registers a public (PKCE-secured) client, no `client_secret` issued
- `GET /.well-known/oauth-authorization-server` / `GET /.well-known/jwks.json` — RFC 8414/7517 discovery metadata

Most MCP clients discover required scopes automatically from that metadata. If yours doesn&#x27;t, check its `scopes_supported` list at `{your-deployment-url}/.well-known/oauth-authorization-server` and configure them manually in the client.

| Env var | Required | Description |
|---|---|---|
| `MEMS_CONNECT_API_URL` | Yes | Fallback Connect API domain, used when a request&#x27;s `Host` doesn&#x27;t derive one via the `mcp-` convention (e.g. multiple domains fronted by one deployment) |
| `MCP_OAUTH_SIGNING_KEY` (or `MCP_OAUTH_SIGNING_KEY_SECRET_ARN` for an AWS Secrets Manager ARN) | Recommended | PEM RSA private key used to sign issued JWTs; an ephemeral key is generated (with a warning) if neither is set — fine for a single local process only |
| `MCP_OAUTH_CLIENTS_TABLE` / `_CODES_TABLE` / `_CONSENTS_TABLE` / `_AUDIT_TABLE` / `_REFRESH_TOKENS_TABLE` | optional | DynamoDB table names backing client/code/consent/audit/refresh-token storage (default to `mems-mcp-oauth-*`) — requires AWS credentials for `boto3` |
| `MCP_OAUTH_LAYER2_FALLBACK` / `MCP_OAUTH_LAYER2_CREDENTIALS_TABLE` | optional | Lets clients that can&#x27;t send `X-Soprano-*` headers reuse the Connect identity they authenticated with at Layer 1 for Layer 2 calls too (opt-in; caches the real API KEY server-side, TTL-bounded) |

## 🚀 Installation &amp; Running```bash
git clone https://github.com/soprano-mcp/mcp.git
cd mcp
uv sync

# stdio (local subprocess, e.g. launched by an MCP client config)
uv run mems-mcp --transport stdio

# streamable-http (remote/deployable)
uv run mems-mcp --transport streamable-http
# host/port: MEMS_MCP_HOST (default 127.0.0.1), MEMS_MCP_PORT (default 8000)

🛠️ Troubleshooting

Authentication issues
- Confirm the X-Soprano-* headers (or SOPRANO_* env vars) match one of the 5 supported auth methods exactly, including the domain URL.
- list_whatsapp_templates is the one outlier requiring session_cookie auth — every other tool accepts the other 4 methods.

Message delivery issues
- Make sure the recipient's destination is valid for the channel (a phone number for SMS/WhatsApp/RCS/Voice/Viber, an email address for Email).
- Check get_message_status (or get_batch_status for SMS) — a successful send_message response only means Soprano accepted the request (ENROUTE), not that it was delivered.
- Some channels/accounts require an explicit license/provisioning on the Soprano side (e.g. Viber client connection) — a clean auth/payload but a licensing-style error back from the API means checking with Soprano support.

Other issues
- Errors from the Connect API are surfaced via the tool's error text (Soprano's errorDescription field). For deeper HTTP-level detail, see the Connect API guide's response/error format documentation.

🤝 Contributing

Issues and pull requests are welcome on the repository.

📄 License

MIT

常见问题

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

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Soprano Connect MCP Server 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Soprano Connect MCP Server 收费吗?

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

Soprano Connect MCP Server 需要 API Key 吗?

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

Soprano Connect MCP Server 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Soprano Connect MCP Server 能提供哪些能力?

资料显示能力标签包括 ai、mcp、sms、rcs、whatsapp、message。具体工具清单以官方文档为准。

Soprano Connect MCP Server 需要什么运行环境?

运行时为 python。

热门专题

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

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