Ciltress Sap Abap

MCP开发工具

提供方 未标注

开发工具 stdio · 本地进程 未标注 社区 / 第三方 ClaudeCursorVS CodeCodex
查看接入方式

SAP ABAP MCP - ADT and JSON RPC Browse Ciltress Sap Abap MCP Server for Claude, Cursor, VS Code, and other AI agents.

一句话选型结论

按资料字段整理

Ciltress Sap Abap 属于开发工具类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude、Cursor、VS Code 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

Development

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
npx mcp-abap-abap-adt-api

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

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

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

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Ciltress Sap Abap当前 未标注 stdio · 本地进程 本地部署 有 未标注
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类开发工具本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

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

SAP ABAP MCP Server (ADT and JSON RPC)

An MCP server that gives an AI agent full read/write access to an
SAP ABAP system through ADT (ABAP Development Tools), authenticated with SPNEGO/Kerberos single
sign-on
, an X.509 client certificate or an OAuth 2.0 bearer token — no password anywhere in
the configuration. User and password is still available as fallback but not recommended!

It wraps abap-adt-api and adds one thing ADT itself
cannot do: calling RFC-enabled function modules, over the SAP Gateway JSON-RPC 2.0 service.

128 tools — object CRUD, source editing, locks, transports, activation, syntax checks, code
completion, ABAP Unit, ATC, DDIC, abapGit, refactoring, traces, the debugger, and RFC calls.

How many a client actually sees is smaller, twice over. Profiles (ABAP_MCP_PROFILE) trade surface
for context: core lists 9 tools where all lists 129, which is ~2,700 tokens against ~17,800 on
every turn for a client that cannot fetch tool schemas on demand. And the server asks the system what
it supports
before listing anything, so a release without the abapGit plugin is never offered the 10
tools that would answer 400. On DEV that leaves 116.

> This is the SSO fork of mcp-abap-abap-adt-api
> by mario-andreschak. The main differences: Kerberos SSO instead of Basic Auth, the JSON-RPC/RFC
> tools, tool routing derived from the tool definitions, and a documented tool reference.


Documentation

Document What it covers
AGENTS.md Working on this repository: layout, conventions, how to test. Read this before changing code.
docs/Tool-Router.md What you want to do → the tool that does it. Hand-written, in the words people use. Start here if you know the job but not the tool.
docs/Tool-Reference.md All 128 tools with their arguments, grouped by family. Generated from the tool definitions, so it cannot drift from the code.
docs/MCP-Tools.md How the server behaves. The profiles, golden-path workflows, ADT URI and lock semantics, the response/error model, and a troubleshooting matrix. Written for humans and for agents driving the server.
docs/ABAP-Skills.md The 20 SAP/ABAP skills and how they map onto these tools.
docs/Development-Skills.md The 38 bundled general engineering skills.
docs/JSON-RPC.md Design and protocol notes for the JSON-RPC / RFC tools, read from the ABAP source of /IWBEP/CL_JSRPC_*: the wire protocol, the LUW guarantee behind batches, and the traps.
docs/Authentication.md All four logon modes — Kerberos SSO, X.509 certificates, OAuth 2.0 and password — what SAP needs configured for each, and per-connection sessions over Streamable HTTP.

Features

  • Two password-less logon modes — SPNEGO/Kerberos with the logged-on Windows user's ticket, or an
    X.509 client certificate for a service or technical user that has no Kerberos identity. No SAP
    password is stored or sent either way, and both self-heal when the session expires.
  • Streamable HTTP transport, for a team sharing one container — set ABAP_MCP_TRANSPORT=http and
    each connecting MCP client authenticates with its own SAP OAuth 2.0 bearer token, so every session
    gets its own SAP logon rather than everyone sharing one technical user. stdio remains the default
    for a single, locally-started client. See §12
    and Running over HTTP below.
  • Read any object by name — readAbapObject resolves a name to its source in one call; no ADT URL
    to discover or hand-craft.
  • Describe a table — describeAbapTable returns fields, DDIC types, key flags and check tables.
  • Object management — search, read, create, modify, delete and activate ABAP objects.
  • Survey a naming convention — searchPackages finds packages by pattern (["ZPP_*","Z_PP*"])
    and expands each into its objects grouped by type, in one call.
  • Source workflow — lock → edit → syntax check → unlock → activate, with transport handling.
  • Code intelligence — completion, definitions, usage references, ABAP Doc, pretty printer, ATC,
    ABAP Unit, refactoring (rename, extract method).
  • Call RFC function modules — callFunctionViaJsonRpc executes an RFC-enabled function module and
    validates the request against its real signature, read from the system.
  • Batch RFC calls in one LUW — callFunctionsViaJsonRpc sends several function modules in a single
    request, which is what lets an update BAPI and its BAPI_TRANSACTION_COMMIT share one LUW.
  • Data access — tableContents and ad-hoc runQuery SELECTs.
  • See the running system — listLoggedOnUsers answers "who is logged on" from TH_USER_LIST, the
    data behind SM04; readProfileParameters reads RZ11 values in one round trip; and
    checkLogonConfiguration says which authentication the system actually accepts.
  • Bundled agent skills — 58 skills under skills/, for ABAP (Clean ABAP, RAP, CDS, ATC,
    abapGit…) and general engineering (TDD, code review, diagnosing bugs), served as resources and via
    readSkill.
  • Self-documenting — the guides below are served by the server itself, as MCP resources
    (abap-adt://guides/…) and through the readServerGuide tool, so an agent can look up a workflow or
    an argument mid-task without leaving the session.

Prerequisites

  • An SAP ABAP system reachable over ADT. /sap/bc/adt must be active in SICF. For the RFC tools,
    /sap/gw/jsonrpc must be active as well (SAP_GWFND), and your user needs S_RFC for the function
    groups you call.
  • A way to log on without a password, one of:
  • A working Kerberos login — the SAP system must accept SPNEGO and you must hold a valid ticket
    (klist). This is the default, and it needs Windows as shipped: the bootstrap shells out to
    C:\Windows\System32\curl.exe --negotiate, which needs curl's Schannel/SSPI backend. On other
    platforms point SSO_CURL_PATH at a curl built with GSS-API support.
  • An X.509 client certificate — for a service or technical user that has no Kerberos identity.
    Needs neither curl nor Windows. SAP has to be set up for it: the ICM port must request a
    certificate (VCLIENT in icm/server_port_, which overrides icm/HTTPS/verify_client), the
    issuing CA trusted in STRUST, and a CERTRULE mapping to the user. Full setup — including how
    to check those from this server — in docs/Authentication.md.
  • An OAuth 2.0 client — for an SAP BTP ABAP environment, where there is no Kerberos realm and
    no ICM to configure, or for an on-premise system that publishes ADT through SOAUTH2. A BTP
    service key is already one of these. See §11.
  • Node.js (LTS) and npm — verify with node -v and npm -v.

Installation```bash

git clone --recurse-submodules https://github.com/Ciltress/sap-abap-mcp.git
cd sap-abap-mcp
npm install
npm run build


> `--recurse-submodules` matters: the general engineering skills live in a submodule, and without it
> that directory is empty and the server offers 38 fewer skills. Already cloned? Run
> `git submodule update --init --recursive`.

> The `npx mcp-abap-abap-adt-api` package on npm is the **upstream** server and does _not_ include the
> SSO bootstrap or the RFC tools. Build this repository from source instead.

### Configure

Copy `.env.example` to `.env` and fill in your system:```env
SAP_URL=https://your-sap-server.example.com:44301
SAP_USER=YOUR_SAP_USER
SAP_CLIENT=100
SAP_LANGUAGE=EN

SAP_URL and SAP_USER are required; SAP_CLIENT and SAP_LANGUAGE are optional but recommended.
Three of the four logon modes need no SAP_PASSWORD at all.

Never commit .env; it is already in .gitignore.

Optional variable Effect
SAP_SYSTEM_ID The system id, as in sy-sysid (e.g. DEV). Announced at connect time so a client can pick between several servers by name. See More than one system.
NODE_TLS_REJECT_UNAUTHORIZED=0 Accept a certificate from an internal/unknown CA. Development only.
SSO_CURL_PATH Path to a curl binary with SPNEGO support, if not the Windows system one.
SAP_JSONRPC_PATH Override the JSON-RPC ICF path when the node is published under an alias.
ABAP_MCP_PROFILE Which tools this server lists — and therefore which it will answer. See below.
ABAP_MCP_MAX_RESPONSE_BYTES Ceiling on a single answer, in bytes. 0 removes it.
ABAP_MCP_GATE off skips the startup capability check that withholds tools this release cannot serve.
ABAP_MCP_RFC_FALLBACK Start even when SAP refuses this user the ADT node, keeping the RFC tools. See docs/Authentication.md.
SAP_FALLBACK_BOOTSTRAP_PATH Which ICF node that fallback logs on to. Only needs to issue a session cookie and a CSRF token.
ABAP_MCP_TRANSPORT stdio (default) or http. See Running over HTTP.
ABAP_MCP_HTTP_PORT Port for the Streamable HTTP endpoint. Default 3000. Only read in http mode.
ABAP_MCP_HTTP_HOST Address to bind in http mode. Default 0.0.0.0.
ABAP_MCP_HTTP_ALLOWED_ORIGINS Browser origins allowed to call /mcp, comma-separated; * allows any. Empty (the default) serves none. Clients that send no Origin are unaffected.
ABAP_MCP_HTTP_ALLOWED_HOSTS Host values this server answers to in http mode, comma-separated. Empty accepts any.
ABAP_MCP_HTTP_RATE_LIMIT Requests per minute per MCP session in http mode. 0 (the default) is off.

Sizing the server for its client

The three ABAP_MCP_* variables exist for one reason: a client that cannot fetch tool schemas on
demand pays for the entire tool list on every single turn.
Claude Code defers schemas and should stay
on the default; an 8B model with a 128k window is spending a sixth of its context before the
conversation starts, and that is where "the same prompt works half the time" comes from.

ABAP_MCP_PROFILE — unset means all, so an existing setup is unchanged.

profile tools/list cost per turn for
core 9 ~2,737 tokens reading a system and completing one edit
analyst 18 ~3,982 tokens read-only: dictionary, table data, RFC calls
rfc 10 ~2,900 tokens a user with RFC rights but no S_DEVELOP, where ADT tools cannot work
dev 49 ~8,034 tokens the edit cycle plus tests, ATC, transports, refactoring
all 129 ~17,759 tokens the default; right for clients that fetch schemas on demand

Counts include healthcheck, which sits outside every profile because it is the tool that answers
"which profile am I running?".

A profile is not a convenience filter. A tool outside the active profile is not listed and not
routed, so it cannot be called — which is what makes analyst a guarantee that nothing edits source
rather than a smaller menu. Out-of-profile calls get an error that says so, instead of "unknown tool",
so there is no point retrying. An unrecognised profile name stops the server at startup rather than
falling back to all — silently serving 129 tools to something that asked for 9 is the exact failure
profiles exist to prevent.

core is small because one tool, editAbapSource, is the write cycle: lock, write, unlock, activate,
releasing the lock even when a step fails. The four separate steps stay in dev and all.

ABAP_MCP_MAX_RESPONSE_BYTES — the tool list is a fixed cost a profile can shrink; an answer is
unbounded. On core the whole tool list is ~11KB while one adtDiscovery is ~42KB. Unset follows the
profile (core 24,000 bytes, analyst 32,000, dev 48,000, all no ceiling); 0 removes it.

An over-budget answer is withheld and replaced by valid JSON — status:"truncated", the original
bytes, the budget, a 2,000-byte preview and a nextStep — never by a cut-off fragment, which
would not parse and would just invite the identical retry.

ABAP_MCP_GATE — before listing anything the server asks the system what it supports, and withholds
the tools whose ADT collections are absent. On DEV that is the 10 abapGit tools and the 3
service-binding tools, which would otherwise answer HTTP 400. It costs one discovery round trip per
process, can only ever shorten the list, and any failure leaves every tool listed. ABAP_MCP_GATE=off
skips it.

healthcheck reports all three: the active profile, responseBudgetBytes, and anything withheld.

A certificate instead of Kerberos

For a service or technical user, add a certificate — that alone switches the mode:```env
SAP_USER=CLAUDEAGENT # the user CERTRULE maps the certificate to
SAP_CERT_FILE=C:\Users\svc_agent\SNC\sec\claudeagent.p12
SAP_CERT_PASSPHRASE=<PKCS#12 password / PSE PIN>


| Optional variable   | Effect                                                                                                       |
| ------------------- | ------------------------------------------------------------------------------------------------------------ |
| `SAP_AUTH_MODE`     | `kerberos`, `certificate`, `oauth` or `password`. Only needed to force one mode while another is configured. |
| `SAP_CERT_KEY_FILE` | The private key, when it is not in `SAP_CERT_FILE`.                                                          |
| `SAP_CA_FILE`       | CA bundle for verifying SAP&#x27;s own certificate, instead of disabling TLS verification.                        |

&gt; This is **mutual TLS, not SNC** — ADT is HTTPS. A certificate that already works for RFC/SNC can be
&gt; reused and its `CERTRULE` mapping carries over, but the `SNC0` ACL plays no part and the ICM needs
&gt; `icm/HTTPS/verify_client`. `docs/Authentication.md` covers the differences,
&gt; the `sapgenpse export_p12` / OpenSSL 3 trap, and how to read a rejected certificate.

#### An OAuth 2.0 client, for BTP and for SOAUTH2

For an SAP BTP ABAP environment, or an on-premise system that publishes ADT behind an authorisation
server. Setting the client id switches the mode:```env
SAP_OAUTH_TOKEN_URL=https://your-tenant.authentication.eu10.hana.ondemand.com/oauth/token
SAP_OAUTH_CLIENT_ID=sb-abap-agent!t1234              # &#x27;clientid&#x27; in a BTP service key
SAP_OAUTH_CLIENT_SECRET=&lt;&#x27;clientsecret&#x27;&gt;

On-premise the endpoint is on the SAP host itself — https://:/sap/bc/sec/oauth2/token —
and the client is the one registered in SOAUTH2.

Optional variable Effect
SAP_OAUTH_GRANT client_credentials (default), refresh_token, password or static.
SAP_OAUTH_SCOPE Scopes to request. Unset asks for the client's defaults, which is usually right.
SAP_OAUTH_REFRESH_TOKEN For the refresh_token grant; selects it by itself.
SAP_OAUTH_TOKEN A token minted elsewhere, used as-is. Nothing can renew it.
SAP_OAUTH_CLIENT_AUTH basic (default) or post, when a server rejects a secret that is right.

> The token logs on once. After that the SAP session cookie carries every request, as in the
> other modes — so a token that expires in five minutes is not a problem. Note that an OAuth 2.0
> client on AS ABAP is a user in SU01: a wrong SAP_OAUTH_CLIENT_SECRET counts against
> login/fails_to_user_lock like a password, so a refused token request is never retried. The
> authorization-code flow is not implemented — it needs a browser, which a server started over stdio
> has no way to open; complete it once by hand and pass the refresh token in.
> docs/Authentication.md §11 has the detail, including which failures are
> latched and why.

A password, when there is nothing else

For a system with neither Kerberos nor certificates — a sandbox, a trial, anything off the domain:```env
SAP_USER=CLAUDEAGENT
SAP_PASSWORD=<the password>


&gt; **The last resort, and not interchangeable with the other two.** A missing ticket or an unmapped
&gt; certificate is simply refused; a _wrong password_ counts against `login/fails_to_user_lock` and
&gt; locks that user for every consumer of it, not just this server. The implementation refuses to retry
&gt; a rejected password for that reason — one failed logon, latched, however many tools are called.
&gt; Prefer a certificate for anything unattended. `docs/Authentication.md` §10
&gt; has the detail.

### Register with an MCP client

Point the client at the built entry point with absolute paths:```json
{
  &quot;mcpServers&quot;: {
    &quot;sap-abap-dev-100&quot;: {
      &quot;command&quot;: &quot;node&quot;,
      &quot;args&quot;: [&quot;C:/path/to/sap-abap-mcp/dist/index.js&quot;],
      &quot;env&quot;: {
        &quot;SAP_URL&quot;: &quot;https://your-sap-server.example.com:44301&quot;,
        &quot;SAP_USER&quot;: &quot;YOUR_SAP_USER&quot;,
        &quot;SAP_SYSTEM_ID&quot;: &quot;DEV&quot;,
        &quot;SAP_CLIENT&quot;: &quot;100&quot;,
        &quot;SAP_LANGUAGE&quot;: &quot;EN&quot;
      }
    }
  }
}

The client's env block wins over .env. Run npm run start to launch the server by hand, or
npm run dev to drive it through the MCP Inspector.

For a client that carries every tool schema on every turn, add a profile to that same block:```json
"env": { "…": "…", "ABAP_MCP_PROFILE": "core" }


### In Docker

By default the server speaks MCP over **stdio**, so there is no port to publish — the client starts
the container and talks to it over stdin/stdout. This section covers that default; for a container
several team members connect to over the network instead, see Running over HTTP
below.```bash
docker build -t abap-adt-mcp .
``````json
{
  &quot;mcpServers&quot;: {
    &quot;sap-abap-dev-100&quot;: {
      &quot;command&quot;: &quot;docker&quot;,
      &quot;args&quot;: [
        &quot;run&quot;,
        &quot;-i&quot;,
        &quot;--rm&quot;,
        &quot;--env-file&quot;,
        &quot;C:/path/to/.env&quot;,
        &quot;abap-adt-mcp&quot;
      ]
    }
  }
}

All four logon modes work in here, but a credential is something the container has to be given,
and --env-file is not dotenv — Docker strips no quotes, reads no export, and drops no trailing
# comment, so a value dotenv would have cleaned up arrives verbatim. Windows paths in .env have
to be replaced by the mounted ones. Kerberos is the mode that needs the most from the container and
OAuth the least: a token is fetched over the network, so nothing has to be mounted at all.

Certificate mode — mount the key material read-only, and the CA that signs SAP's certificate
with it:```bash
docker run -i --rm --env-file .env \
-v /host/certs:/certs:ro \
-e SAP_CERT_FILE=/certs/agent.p12 \
-e SAP_CA_FILE=/certs/corporate-root.pem \
abap-adt-mcp


**Kerberos mode** — the image carries a curl built against GSS-API and `kinit`, so what is left is a
realm and a credential:```bash
docker run -i --rm --env-file .env \
  -v /etc/krb5.conf:/etc/krb5.conf:ro \
  -v /host/agent.keytab:/krb5/agent.keytab:ro \
  -e SAP_KRB_KEYTAB=/krb5/agent.keytab \
  -e SAP_KRB_PRINCIPAL=SVC_AGENT@CORP.EXAMPLE.COM \
  abap-adt-mcp

OAuth 2.0 mode — nothing to mount; the credential is fetched:```bash
docker run -i --rm --env-file .env \
-e SAP_OAUTH_TOKEN_URL=https://your-tenant.authentication.eu10.hana.ondemand.com/oauth/token \
-e SAP_OAUTH_CLIENT_ID='sb-abap-agent!t1234' \
-e SAP_OAUTH_CLIENT_SECRET=<clientsecret> \
abap-adt-mcp


**Password mode** — Last resort!```bash
docker run -i --rm --env-file .env \
  -e SAP_USER=YourUser \
  -e SAP_PASSWORD=YourPassword \
  abap-adt-mcp

Three things to know before you reach for it:

  • A keytab, not your own ticket. A container cannot borrow the session's credential the way an
    interactive logon does. On a Linux host you can mount the ticket cache you already have
    (-v /tmp/krb5cc_1000:/krb5/ccache:ro -e KRB5CCNAME=FILE:/krb5/ccache), but it expires with the
    host's. From a Windows host neither works: the TGT lives in the LSA cache and cannot be written
    to a file — use certificate mode, which needs none of this. The keytab is the only credential that
    runs unattended, and the only one that outlives the ticket lifetime.
  • Verify SAP's certificate, or know that you are not. The image trusts only the public CA bundle,
    so an internal CA the host trusts is unknown in here and the handshake fails with
    UNABLE_TO_GET_ISSUER_CERT_LOCALLY. Mount the root CA and point SAP_CA_FILE at it. Carrying a
    desktop .env in wholesale hides this instead: NODE_TLS_REJECT_UNAUTHORIZED=0 is a development
    setting and has no business in a deployed image.
  • Build from a --recurse-submodules clone. skills/Development is a submodule; without it the
    image ships 38 fewer skills.

The image is Debian rather than Alpine for one reason: Alpine's curl is built without GSS-API, and
such a curl does not fail — it simply never sends a token, and SAP answers the same 401 an expired
ticket produces. What is missing is named at startup, on stderr, before a session is attempted. To ask
the container what credential it ended up with, give it a command instead of the server:```bash
docker run --rm --env-file .env -v /host/agent.keytab:/krb5/agent.keytab:ro \
-e SAP_KRB_KEYTAB=/krb5/agent.keytab abap-adt-mcp klist


`docs/`, `skills/` and `AGENTS.md` are copied into the image on purpose — the server reads them at
runtime to serve `readServerGuide`, `readSkill` and the `abap-adt://` resources.
`docs/Authentication.md` §7 has the full container setup, mode by mode.

### Running over HTTP

Everything above starts one server for one client over stdio. Set `ABAP_MCP_TRANSPORT=http` instead to
run a long-lived container that a whole team connects to over the network, using the SDK&#x27;s Streamable
HTTP transport at `/mcp`.

HTTP mode changes _who logs on_, not what a session can do once logged on: none of the four modes
above — `SAP_AUTH_MODE`, `SAP_CERT_FILE`, `SAP_OAUTH_CLIENT_ID`, `SAP_PASSWORD` — apply here, because
there is no single shared logon to configure. Instead, **every MCP client authenticates with its own
SAP OAuth 2.0 bearer token**: it sends `Authorization: Bearer ` on `initialize`, and that token
becomes that session&#x27;s own SAP identity — its own ADT logon, its own locks, its own audit trail. Two
team members connecting at once get two independent sessions, never one shared technical user.```bash
docker build -t abap-adt-mcp .
docker run --rm -p 3000:3000 \
  -e SAP_URL=https://your-sap-server.example.com:44301 \
  -e SAP_USER=CLAUDEAGENT \
  -e SAP_CLIENT=100 \
  -e ABAP_MCP_TRANSPORT=http \
  abap-adt-mcp

SAP_USER is still required (every non-password mode needs a placeholder username to construct the
ADT client) but is never transmitted and has no bearing on who a given session actually is — SAP
decides that from each session's own token, same as in §11.

Variable Effect
ABAP_MCP_TRANSPORT=http Switches from stdio to Streamable HTTP.
ABAP_MCP_HTTP_PORT Port to listen on. Default 3000.
ABAP_MCP_HTTP_HOST Address to bind. Default 0.0.0.0.
ABAP_MCP_HTTP_ALLOWED_ORIGINS Browser origins allowed to call /mcp, comma-separated; * allows any. Empty (default) serves none.
ABAP_MCP_HTTP_ALLOWED_HOSTS Host values answered to, comma-separated. Empty accepts any.
ABAP_MCP_HTTP_RATE_LIMIT Requests per minute per session. 0 (default) is off.

Register a client the same way as any remote Streamable HTTP MCP server, pointing it at /mcp and
supplying that user's own SAP OAuth token:```json
{
"mcpServers": {
"sap-abap-dev-100": {
"url": "http://your-host:3000/mcp",
"headers": { "Authorization": "Bearer <your SAP OAuth access token>" }
}
}
}


A request with no credential is rejected with `401` before any SAP traffic; a token SAP itself refuses
is also `401`, with SAP&#x27;s own message. There is no separate shared secret to configure for the
transport itself — the SAP token _is_ the access control.

A client that would rather not be disconnected each time its access token expires can send its own
refresh token as `X-SAP-Refresh-Token` instead, and the session renews itself on the `refresh_token`
grant. That needs `SAP_OAUTH_TOKEN_URL` and `SAP_OAUTH_CLIENT_ID` on the container — the client
registration a refresh token is redeemed against is the deployment&#x27;s, while the refresh token, and
therefore the SAP identity, stays the caller&#x27;s.

Browser origins are refused unless `ABAP_MCP_HTTP_ALLOWED_ORIGINS` names them: that is the
DNS-rebinding guard the MCP spec asks the server to apply itself, since a rebinding request never
passes through the proxy in front. Allow-listed origins get the matching CORS headers. Clients that
send no `Origin` — every MCP client that is not a web page — are unaffected.

The container&#x27;s `docker-entrypoint.sh` skips its Kerberos setup automatically when
`ABAP_MCP_TRANSPORT=http` is set, since `resolveAuthMode()`&#x27;s pick describes nothing real once every
session logs on with its own token. TLS termination is left to whatever sits in front of the container
(a reverse proxy or ingress), the same as for any other internal HTTP service. Full detail, including
the OAuth grant mechanics this reduces to, is in
`docs/Authentication.md` §12.

### More than one system

A server is bound to one system and one client for its whole life — neither can be switched at
runtime. So register one entry per system/client and give each its `SAP_SYSTEM_ID`:```json
&quot;sap-abap-dev-100&quot;: { &quot;env&quot;: { &quot;SAP_SYSTEM_ID&quot;: &quot;DEV&quot;, &quot;SAP_CLIENT&quot;: &quot;100&quot;, &quot;…&quot;: &quot;…&quot; } },
&quot;sap-abap-dev-200&quot;: { &quot;env&quot;: { &quot;SAP_SYSTEM_ID&quot;: &quot;DEV&quot;, &quot;SAP_CLIENT&quot;: &quot;200&quot;, &quot;…&quot;: &quot;…&quot; } },
&quot;sap-abap-q01-100&quot;: { &quot;env&quot;: { &quot;SAP_SYSTEM_ID&quot;: &quot;Q01&quot;, &quot;SAP_CLIENT&quot;: &quot;100&quot;, &quot;…&quot;: &quot;…&quot; } }

Each server then announces itself in the MCP instructions it returns at connect time:

> This server is bound to SAP system DEV, client 100 (https://…:44301).
> It cannot switch system or client at runtime — both are fixed by the environment it was started

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

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Ciltress Sap Abap 怎么安装?

在客户端按下面的安装命令接入:npx mcp-abap-abap-adt-api。装完在客户端配置里引用同一个包或端点。

Ciltress Sap Abap 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Ciltress Sap Abap 收费吗?

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

Ciltress Sap Abap 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Ciltress Sap Abap 支持哪些客户端?

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

Ciltress Sap Abap 能提供哪些能力?

资料显示能力标签包括 Development。具体工具清单以官方文档为准。

Ciltress Sap Abap 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Ciltress Sap Abap 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

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

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