S
SAP ABAP MCP
Develop, test, analyze, and operate SAP ABAP systems through ADT from AI coding agents.
Quick Install
Automated & IDE SetupCopy the AI prompt to install this server into Claude Code, Cursor, or another agent — or use 1-click editor setup below.
Not yet automatically verified
We haven't yet run this listing's install command through our automated sandbox check. This isn't a red flag — we're steadily working through the catalog.
Manual Client & Custom JSON ConfigExpand JSON ▾
Install Config Generator
Choose your client
💡 Paste into ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows)
Documentation Overview
sap-abap-mcp
The headless, client-neutral, governance-first MCP server for SAP ABAP development across multiple systems.
SAP ABAP MCP lets Codex, Claude, and other local MCP hosts work with SAP ABAP through ABAP Development Tools (ADT) HTTP services. It can inspect and edit source, run quality checks, manage transports, use abapGit and the RAP generator, inspect runtime data, compare systems, and perform guarded refactorings without an IDE runtime, SAP GUI, or an ABAP FS virtual workspace.
Why this server
SAP now provides an official ADT MCP Server inside its ADT clients. This project serves a different operating model: headless automation from any supported local MCP host.
| SAP ABAP MCP | SAP ADT MCP Server | |
|---|---|---|
| Runtime | Independent Node.js process: local stdio, or self-hosted Streamable HTTP for a shared instance | Local HTTP server hosted by an ADT client |
| Agent hosts | Codex, Claude, and other MCP clients, locally or over HTTP | MCP hosts configured against the running ADT server |
| SAP sessions | Multiple named profiles in one process | SAP projects and sessions managed by ADT |
| Guardrails | Production profiles are read-only; writes support package restrictions and explicit confirmations; HTTP mode adds API key roles, rate limits, and a structured audit log | Governed by the installed ADT version, SAP authorizations, and client configuration |
| Assurance | Read-only transport assessment with JSON, SARIF, and JUnit evidence | SAP-provided in-IDE development workflows |
| Verification | Separates implemented, discovered, authorized, and live-verified capabilities | SAP product support and release documentation |
This is a deployment-model comparison, not a capability benchmark or a claim of SAP endorsement. Official behavior varies by ADT and SAP backend release.
90-second workflow
The animation contains synthetic object and transport names and no live SAP data. See the accessible transcript and exact workflow.
Quick start
You need Node.js 20 or later, network or VPN access to SAP, and an SAP HTTPS URL, three-digit client number, username, and ADT Basic Auth permission.
1. Configure SAP
Windows:
macOS or Linux:
The wizard calls the local connection alias Server name and the endpoint SAP URL. Windows and macOS validate SAP before saving and protect the password with DPAPI or Keychain. Linux saves only non-secret settings and prints the password environment-variable commands to run before starting the MCP client.
2. Register the MCP server
After setup, run the command for your client on Windows:
On macOS or Linux, replace npx.cmd with npx:
Replace DEV100 with the Server name selected in the wizard. Restart the client, then use codex mcp list, claude mcp get sap-abap, or /mcp to confirm that the process starts. The completed wizard already performs live SAP verification; /mcp alone does not prove that SAP authentication succeeded.
Prefer a plugin install? Follow Claude Code and Codex plugin marketplaces; the included setup skill guides the same local wizard without putting the SAP password in chat. See the detailed Windows, macOS, and Linux sections for platform-specific behavior and server management.
Community and adoption
- Read the public roadmap.
- Run or implement the open SAP ABAP MCP compatibility profile.
- Add an opt-in, sanitized entry to ADOPTERS.md.
- Use GitHub Discussions for implementation questions, compatibility evidence, and RFCs.
Need help evaluating it in a controlled SAP DEV/QAS environment? See the professional services and five-day pilot. Do not include SAP credentials, source code, hosts, tokens, or other confidential information in a public issue or discussion.
Current v1 surface
The unversioned serve command maps the 53 legacy capabilities to 115
action-free v1 tools and seven Resources, split across bounded core, write,
analysis, debug, operations, and artifacts toolsets. Omitting
--toolsets selects all 115 tools. Use --api-version v0 only for legacy
client compatibility, or select toolsets explicitly when a host should
advertise fewer schemas.
Normal clients should omit both --api-version and --toolsets.
| Invocation | Advertised surface |
|---|---|
serve --profile DEV100 | Current v1, all 115 tools and seven Resources |
serve --profile DEV100 --toolsets core,analysis | Selected v1 toolsets only |
serve --profile DEV100 --api-version v0 | Legacy 53-tool compatibility surface |
See the v1 migration guide for contracts, Resources, and the separate live-SAP verification boundary.
Live SAP evidence
Capabilities are reported as unverified until they succeed against a live
connection. docs/live-sap-evidence.md records the
current sanitized results — no credentials, no customer source, no host names.
| Area | ECC 758 | S/4HANA 758 |
|---|---|---|
$TMP-scoped v1 surface | 87 passed, 11 unsupported, 0 failed | 93 passed, 2 unsupported, 0 failed |
| Self-hosted HTTP mode, roles, and audit | 13 of 13 passed | not run |
| CI assurance gate and its artifacts | 7 of 7 passed | not run |
200 live checks in total: 180 tool-surface checks across two systems, plus 20 transport and CI checks on one. The tool-surface count counts each capability once per system, because release coverage is the claim; it is not 180 distinct capabilities.
On S/4HANA this includes the complete class-runner and debugger chain: a $TMP
class runner executed, a breakpoint on its own source suspended it, and the
attached debugger returned a 13-frame stack, variables, an evaluated expression,
and a completed step. On ECC the ADT class-run endpoint rejects the same class, so
the attached debugger is unreachable there; that difference accounts for the nine
extra unsupported results and is documented with its exact SAP message.
Reproduce the tool-surface run against your own development system:
The harness creates exactly one class in the local package $TMP under a
run-unique name, treats it as owned only after a create receipt and an immediate
exact read-back agree, refuses in code to mutate anything else, and deletes it
again. Existing objects are only ever read. The two unsupported results are
missing SAP-side prerequisites — the ABAP REPL and the abapGit ADT backend — not
defects.
ABAP FS parity status
The pinned ABAP FS 2.6.5 source exposes 43 MCP tools. This server provides a strict-compatible subset of 42; the omitted tool is manage_subagents, which depends on the VS Code agent host. With 10 headless feature extensions and read_deferred_result, this server advertises 53 tools in total.
The first development-parity slice implements BDEF source creation, one-request batch activation, class-runner execution, the ABAP FS REPL contract, and detailed semantic inspection. These SAP-dependent capabilities remain unverified until they succeed against the selected live connection; call get_sap_capabilities for per-connection evidence.
Snippet execution requires ZCL_ABAP_REPL and an active SICF service at /sap/bc/z_abap_repl. Generic report/program-console execution is not implemented.
What it supports
The server provides all 42 strict-compatible headless tools from the pinned ABAP FS baseline, ten grouped feature extensions, and one infrastructure tool for continuing oversized results.
| Area | Capabilities |
|---|---|
| Connections | Multiple SAP profiles, Basic Auth, opt-in OAuth client credentials, lazy login, system metadata, ADT discovery export |
| Repository reads | Search, metadata, source ranges, batch reads, URI reads, source search, enhancements |
| Semantic services | Completion details, definition lookup, documentation, type hierarchy, components, quick-fix discovery, SAP formatter preview |
| Source writes | Exact source replacement, BDEF source creation, syntax diagnostics, single- and one-request batch activation, text elements |
| Refactoring | Rename, package move, extract method, quick-fix application, formatting, deletion |
| Quality | ABAP Unit, ATC, diagnostics, test-include creation |
| Transports | List, details, objects, read-only release assessment, JSON/SARIF/JUnit evidence, compare, create, release, delete, owner/user management, object resolution |
| Versions | Active revision history, revision comparison, inactive source, guarded revision restore |
| abapGit | Repository list, remote information, create, pull, unlink, stage, push, check, branch switch (requires the abapGit ADT backend on the SAP system) |
| RAP | Availability, paged schema, defaults, validation, preview, generation, service binding details, and OData V2/V4 publication and unpublication |
| Runtime | Guarded class-runner and fixed-contract ABAP REPL execution, debugger, breakpoints, stack, variables, dumps, traces, heartbeat checks |
| Cross-system | Source comparison across configured SAP systems |
| Dependency analysis | Bounded where-used dependency graph |
| SAP GUI integration | Validated WebGUI transaction URL generation and optional local launch |
| Data | Read-only ADT SQL queries with bounded or file-based output |
| Artifacts | Mermaid validation/viewer and DOCX test documentation |
The ten grouped extension tools are:
inspect_abap_coderefactor_abap_codemanage_abapgitmanage_rap_generatormanage_abap_versionscompare_abap_systemsget_abap_dependency_graphrun_sap_transactionget_sap_capabilitiesrun_abap_application
Grouping related actions keeps the tool-schema footprint lower than exposing every operation as a separate MCP tool.
read_deferred_result is the additional infrastructure tool; it reads the remaining UTF-8 chunks of a large result without repeating the SAP operation.
Transport change assurance
manage_transport_requests keeps transport review inside the existing grouped tool. Its read-only assess_transport action can run ATC and ABAP Unit for each supported transport object, optionally compare the same objects with a target connection, and emit JSON, SARIF 2.1.0, and JUnit XML reports.
The returned gate is passed, failed, or incomplete. Truncated object coverage, truncated ATC findings, failed check execution, empty transports, and classes without discoverable tests prevent a pass. A target-system difference is recorded as landscape evidence rather than automatically treated as a failure. Assessment never releases the transport; release_transport remains a separate confirmed mutation.
The plugin includes sap-abap-change-assurance for this workflow. In Claude Code run /sap-abap-mcp:sap-abap-change-assurance; in Codex ask to use $sap-abap-change-assurance.
Gate a pipeline without an MCP host
Change assurance does not require an AI agent. The assure command runs the same
read-only assessment directly and turns the gate into an exit code:
| Exit code | Gate | Meaning |
|---|---|---|
| 0 | passed | Every assessed object passed every requested check |
| 1 | failed | A check produced a definite failure |
| 2 | incomplete | Safety could not be proven — truncated coverage, a check that could not run, an empty transport, or a class with no discoverable tests |
incomplete blocks by default. Pass --fail-on failed when only definite
failures should stop a build. assure never releases or modifies the transport.
GitHub Action
action.yml wraps the same command and uploads SARIF to GitHub code
scanning, so ABAP findings appear next to the rest of a repository's security
results:
The action outputs gate, report-json, report-sarif, and report-junit, and
writes a job summary. The SAP password is passed only through a
profile-specific environment variable, never as a command argument, so it does
not appear in a process list or a command echo. The runner needs network or VPN
access to SAP.
MCP directories and registries
The canonical registry identity is io.github.Coaspe/sap-abap-mcp, defined in server.json. Directory installs must run this package as a local stdio server; SAP profiles and credentials stay on the user's machine and are never hosted by a registry.
Before the first SAP-facing request, create and verify at least one local SAP profile using the commands in Quick start or llms-install.md. The Claude plugin may start successfully without a profile; after installation, run /sap-abap-mcp:sap-abap-setup to complete local SAP setup. A generic registry launch runs @coaspe/sap-abap-mcp with the serve argument and exposes all locally configured profiles; every SAP-facing tool still requires an explicit connectionId.
Registry publication does not change the live-evidence boundary. SAP-dependent development-parity capabilities remain unverified until they succeed against the selected live connection.
The public Smithery listing installs the validated local MCPB bundle. Its current catalog matches the default v1 runtime: 115 tools and seven Resources.
Privacy Policy
SAP ABAP MCP runs locally and does not send SAP profiles, credentials, source code, or tool results to a publisher-operated service. It communicates only with destinations selected by the user, including the configured SAP system and the user's MCP host. See the complete PRIVACY.md and TERMS.md.
Claude Code and Codex plugin marketplaces
This repository is also a dual-compatible plugin marketplace. The plugin starts the same npm latest package as a local stdio process, so SAP profiles, credentials, and ADT traffic stay on the user's computer. Profiles are user-scoped outside the plugin cache and survive plugin updates.
Claude Code:
Run the namespaced setup skill after reloading:
The skill reuses an existing profile or guides profile creation, local password entry, and live ADT verification. Use /mcp to confirm that the sap-abap process is connected, but do not treat that status as proof that an SAP profile is authenticated; the setup skill verifies SAP with doctor.
Codex:
Then install SAP ABAP MCP from the Coaspe SAP Developer Tools marketplace in the Codex app and start a new task. Ask Codex to set up SAP ABAP MCP; the included sap-abap-setup skill keeps passwords out of chat and guides profile creation, authentication, and live ADT verification.
The plugin also includes sap-abap-change-assurance, which assesses an existing transport without releasing it and returns CI-native evidence paths.
OAuth client credentials
The interactive setup wizard remains the Basic Auth path. OAuth client credentials are an explicit advanced profile type and do not change the defaults for newly created profiles. Create and verify one on Windows or macOS with:
The hidden prompt requests the OAuth client secret. The profile file stores the token URL, client ID, and optional scope, but never the client secret or access token. The token endpoint must use HTTPS and must not contain embedded credentials, query parameters, or a fragment. The client uses HTTP Basic client authentication, requires a Bearer token with a positive expires_in, and recreates the ADT client before the cached token expires because abap-adt-api 8.4.1 memoizes a bearer fetch.
For automation, pipe the client secret and add --password-stdin. On Linux, create the profile without --login, place the client secret in the printed profile-specific SAP_ABAP_MCP_PASSWORD_<PROFILE> environment variable, and start the MCP process from that environment. The variable name is retained for backward compatibility even when its value is an OAuth client secret.
Browser SSO, MFA flows, client certificates, Kerberos, and direct static-bearer profiles remain unsupported. OAuth implementation is still live-unverified for a particular SAP system until doctor succeeds there.
SAP BTP ABAP environment service keys
A service key downloaded from an ABAP environment service instance already contains the endpoint, client id, and client secret, so it can be imported directly:
The command reads url for the ABAP endpoint, composes the token endpoint from
uaa.url (or uses an explicit uaa.tokenurl when the key provides one), sets SAP
client 100, verifies the credentials against SAP, and stores the client secret
in the protected credential store. The secret is never typed into a terminal or
passed as a command argument.
Delete the service key file afterwards. BTP delivers it with the client secret in plain text, and importing it does not remove that copy.
Service keys that use X.509 client certificates instead of a client secret are
rejected with SERVICE_KEY_CERTIFICATE_UNSUPPORTED rather than producing a
profile that could never authenticate.
Prerequisites
Ask your SAP administrator for:
- The SAP HTTPS base URL, for example
https://sap-dev.company.com - The three-digit SAP client number
- Your SAP user name
- ADT development permissions required by the operations you intend to use
- Confirmation that
/sap/bc/adtand Basic Auth are enabled
Your machine needs:
- Node.js 20 or later
- Codex or Claude Code
- Network or VPN access to SAP
- npm registry access to install the public package
Verify Node.js first:
Detailed setup on Windows
1. Run interactive setup
The first run may ask whether npm may download the package; enter y to continue. The setup wizard collects the SAP URL, client, username, environment, and optional writable-package restriction. Server name is the local name used later as connectionId, for example DEV100. Keep production servers classified as production; they are read-only even if the package restriction is empty.
When SAP password: appears, enter the password and press Enter; the input remains hidden. The server configuration and password are stored only after the MCP validates the credentials against SAP. Windows protects the password with DPAPI and never writes it to the profile file.
The setup command is one line in both PowerShell and Command Prompt. For advanced multiline commands, PowerShell continues a line with a backtick (`), while Command Prompt (cmd.exe) uses a caret (^); do not mix them.
2. Verify ADT connectivity
A completed setup already performs this live check. Run doctor again whenever you want to recheck ADT connectivity; a successful response contains "ok": true.
3. Register the MCP server
Codex CLI:
Claude Code:
Restart the client after registration. Use codex mcp list, claude mcp get sap-abap, or the client's /mcp command to verify the connection.
The registration deliberately uses the moving npm tag @latest together with --prefer-online. Whenever Codex or Claude starts a new MCP process, npm checks which published version latest points to and runs that version. For example, a user who originally ran 0.4.7 will automatically run 0.4.8 after 0.4.8 is promoted to latest and the client is restarted. An already-running MCP process is not replaced in place. Maintainers should promote only tested releases to latest.
4. Change or remove a saved server
Edit a server with its current values as defaults. The wizard tests the updated settings and password before replacing the saved configuration:
Remove a server and its stored SAP and abapGit credentials:
Omit DEV100 to choose from the saved servers. Removal always shows the selected server and asks for confirmation; the default answer is No.
5. Start with read-only requests
Detailed setup on macOS
Use npx instead of npx.cmd:
The wizard tests the SAP connection and stores the password in macOS Keychain.
Linux and containers
Linux runs the same interactive setup, but it does not persist credentials:
The wizard saves the non-secret server configuration and prints the exact hidden-input and export commands for its profile-specific password variable. Run those commands in the same shell that starts the MCP client, then run the printed doctor command. For example, server name DEV-100 uses SAP_ABAP_MCP_PASSWORD_DEV_100. The Linux environment store is read-only, so auth login and auth logout are unavailable and no plaintext credential file is created.
Codex desktop setup
If the codex command is not available, add a stdio MCP server in Codex settings:
- Name:
sap-abap - Command on Windows:
npx.cmd - Command on macOS:
npx - Arguments:
Multiple SAP systems
Create one profile per SAP client, for example DEV100, QAS200, and PRD100. To expose all profiles through one MCP server, register serve without --profile:
Every SAP-facing tool requires an explicit connectionId, which prevents accidental cross-system routing. Cross-system comparison requires the same object to exist in both selected profiles.
abapGit credentials
Public repositories require no additional setup. Store credentials for each private repository URL separately:
Status and removal:
Credentials are selected by canonical repository URL so credentials for one remote cannot be sent to another. Passwords and tokens are not accepted as MCP tool arguments, and credentials embedded in a repository URL are rejected.
Write-safety model
Repository-changing operations enforce these rules:
- Profiles marked
productionreject writes. - A non-empty
allowedPackageslist restricts writes to those packages; an empty list allows all packages. - Packages other than
$TMPrequire a transport request. - Exact source replacement reads the current source, obtains an SAP lock, rechecks it under the lock, writes, runs syntax diagnostics, optionally activates, and unlocks.
- Rename, package move, method extraction, quick-fix application, formatting, deletion, and revision restore use a preview plan.
- Preview plans expire after ten minutes and require the exact returned confirmation value.
- Execution re-runs the SAP preview or source-state check and rejects stale plans.
- Multi-object quick-fixes perform syntax preflight and attempt rollback if a later write fails.
- RAP generation performs initial validation, content validation, and dry-run preview immediately before generation.
- abapGit push accepts only a fresh SAP staging snapshot and requires explicit object selection or
stageAll=true. - SAP transaction parameters use a restricted character set and are passed to the OS launcher as argument-array values rather than shell text.
- ADT SQL accepts only
SELECTandWITHstatements.
Transport release and deletion can be irreversible. Use a dedicated transport and verify the exact confirmation value before executing either action.
Audit log
Auditing is off by default and is enabled per server process. When enabled, every tool call and Resource read emits exactly one JSON Lines record:
Use --audit-log stderr to send the same records to the MCP host's server log
instead of a file. The equivalent environment variables are
SAP_ABAP_MCP_AUDIT_LOG, SAP_ABAP_MCP_AUDIT_LOG_FILE, and
SAP_ABAP_MCP_AUDIT_INCLUDE_ARGUMENTS=1, so a managed launcher can enable
auditing without changing the registered MCP command.
Each record carries the sap-abap-mcp.audit/v1 schema:
| Field | Meaning |
|---|---|
principal | Actor identity; local-process uses the OS user running the process |
kind, name | tool or resource, and the advertised capability name |
mutation | True when the capability is not advertised with readOnlyHint: true |
destructive | True when the capability advertises destructiveHint: true |
outcome | succeeded, denied for a guardrail refusal, or failed |
errorCode | Machine-readable code for a denied or failed outcome |
systemId, target | Selected SAP profile and scalar object identity only |
durationMs, timestamp, eventId | Timing and correlation |
argumentsDigest | SHA-256 prefix of the redacted arguments |
outcome: "denied" separates policy refusals such as
PRODUCTION_WRITE_BLOCKED, PACKAGE_NOT_ALLOWED, TRANSPORT_REQUIRED, and
QUERY_NOT_READ_ONLY from technical failures, so blocked attempts can be
counted independently.
Arguments are excluded unless --audit-include-arguments is set. Even then,
credential-shaped keys are replaced with [redacted], strings are truncated at
512 bytes so an ABAP source body is never written whole, arrays and recursion
depth are capped, and an oversized argument object is reduced to a byte count.
argumentsDigest is computed from the redacted arguments, so it correlates
repeated calls without recording their content.
A file sink creates its parent directory and the log file with owner-only permissions, and degrades to a single stderr warning rather than failing a tool call if the file becomes unwritable.
Two boundaries are deliberate. A request rejected by MCP input-schema
validation never reaches the capability and is not audited, because it never
reached SAP. In stdio mode the principal is the local process identity, not
the SAP user; the SAP user is determined by the profile named in systemId. In
HTTP mode the principal is the authenticated API key id.
Self-hosted HTTP mode
The default runtime is a local stdio process. serve --http runs the same
server over MCP Streamable HTTP so that one team can operate a single instance
per SAP system with central configuration, central API keys, and one audit
stream, instead of every developer holding SAP credentials on a laptop.
The HTTP listener is built directly on node:http. This mode adds no new
runtime dependency, so the supply chain and audited attack surface are the
same as the stdio runtime.
1. Create API keys
The command prints the key once together with a record object. Add the record
to the keys array of a key file; the file stores only the SHA-256 digest, so a
disclosed key file contains no usable credential.
Keys must come from apikey new or an equivalent CSPRNG. A generated key is 32
random bytes, which encode to 43 base64url characters, and the server rejects any
credential shorter than that or outside that alphabet. SHA-256 is the right
primitive for a 256-bit random token: iteration hardening does not change the
feasibility of searching that space, and deriving a key on every request would
let an unauthenticated caller consume CPU at will, because rate limiting applies
per principal and a caller has none until its credential is resolved.
Binding the key file to a server secret
A validator cannot measure entropy, so the rules above raise the floor rather than proving strength — a long but non-random key would still be attackable from a disclosed key file. Binding the digest to a server-side secret removes that residual risk entirely, and stays fast, so it does not reintroduce the denial-of-service concern a slow key-derivation function would:
That emits keyHmacSha256 instead of keySha256, and the server needs the same
secret:
Each record names its own algorithm, so a key file is never ambiguous about what
verifies it, and the two kinds may coexist during a migration. A keyHmacSha256
record without the secret is refused rather than downgraded to a plain hash, so a
missing secret denies access instead of weakening verification — and serve
refuses to start if the key file needs a secret that was not supplied.
Store the secret outside the key file's directory. Keeping them together
defeats the purpose, because one disclosure would yield both. The equivalent
environment variable is SAP_ABAP_MCP_API_KEY_PEPPER_FILE.
2. Start the server
--api-keys-file is mandatory: this mode never starts unauthenticated. Clients
connect with Authorization: Bearer <key>. GET /healthz needs no credential
and performs no SAP call. Auditing defaults to the stderr sink in HTTP mode
because a shared server should not run unaudited.
3. Roles
A role is bound to an API key and restricts the surface a session can even see; a hidden tool cannot be called by guessing its name.
| Role | Advertised surface |
|---|---|
viewer | Only tools advertised with readOnlyHint: true |
developer | Everything except the admin-only list below |
admin | The complete selected surface |
Admin-only tools are the irreversible or landscape-wide ones:
sap.transport.release, sap.transport.delete, sap.transport.owner.set,
sap.transport.user.add, sap.repository.delete.execute,
sap.version.restore.execute, sap.git.push, sap.git.unlink,
sap.git.branch.switch, sap.rap.binding.publish,
sap.rap.binding.unpublish, and sap.ui.transaction_launch.
Legacy --api-version v0 groups many actions behind one tool name, so on that
surface only the viewer restriction is meaningful. Use the default v1 surface
when roles matter.
4. OIDC/JWT instead of static keys
An existing identity provider can issue MCP credentials, so keys do not have to be distributed and rotated by hand:
Clients then present the provider's access token as Authorization: Bearer <jwt>.
API keys and OIDC can be enabled together; at least one is required.
| Control | Behaviour |
|---|---|
| Algorithms | RS256/384/512, PS256/384/512, ES256/384/512. HS* and none are refused, because verifying an HMAC would require the server to hold the signing secret |
| Keys | Fetched from --oidc-jwks-uri, defaulting to <issuer>/.well-known/jwks.json, cached for five minutes, refreshed once on an unknown kid so rotation is picked up |
| Claims | iss and aud must match, exp is required, nbf is honoured, and 60 seconds of clock skew is tolerated |
| Identity | sub becomes the audit principal; preferred_username is recorded when present |
| Role | Read from --oidc-role-claim, default scope, mapped through --oidc-role-map. When several mapped values are present the highest privilege wins. Unmapped tokens fall back to --oidc-default-role, default viewer |
Verification uses node:crypto only, so enabling OIDC still adds no dependency.
The equivalent environment variables are SAP_ABAP_MCP_OIDC_ISSUER,
SAP_ABAP_MCP_OIDC_AUDIENCE, SAP_ABAP_MCP_OIDC_JWKS_URI, and
SAP_ABAP_MCP_OIDC_ROLE_MAP.
5. Per-user SAP identity
By default every session reaches SAP through whichever profile it names. Assigning profiles per person makes SAP-side attribution per person too:
Register one SAP profile per developer, each with that person's own SAP user, and
list it in their systemIds. Then:
- SAP change documents attribute the work to that person's SAP user, not to one shared technical account.
- SAP authorization objects apply per person, so the SAP system itself becomes an enforcement layer rather than only this server.
sap.system.listshows a principal only its own systems, and naming another system returnsPROFILE_NOT_ALLOWEDwithout disclosing which systems others may use.
Omitting systemIds keeps every configured profile reachable, which is the
single-identity default. SAP logins stay pooled across sessions.
This is credential separation, not SAP principal propagation: the server still holds each person's SAP credential. Forwarding an end-user token into SAP requires the BTP token-exchange path tracked in the roadmap.
6. Transport security
| Control | Behaviour |
|---|---|
| Bind address | Defaults to 127.0.0.1; --host 0.0.0.0 is an explicit opt-in |
| TLS | Terminate TLS at a reverse proxy; this server speaks plain HTTP |
| Origin | A request carrying Origin is rejected unless listed in --allowed-origin, which blocks browser-based cross-site and DNS-rebinding access |
| Host | --allowed-host restricts accepted Host header values |
| Session binding | A session is bound to the API key that opened it; replaying its id under another key returns 403 |
| Rate limit | --rate-limit requests per principal per minute, default 240, reported through RateLimit-* and Retry-After |
| Concurrency | --max-concurrent bounds in-flight SAP requests, default 8 |
| Sessions | --max-sessions default 64, --session-timeout idle seconds default 1800 |
| Body size | Requests above 4 MiB are rejected with 413 |
| Headers | HSTS, nosniff, DENY framing, a default-src 'none' CSP, no-referrer, and no-store on every response |
| CORS | Off unless --allowed-origin is set |
Each session gets its own tool service, so preview plans, staged abapGit snapshots, and execution plans are never shared between principals. SAP logins stay pooled across sessions.
7. Container deployment
The image contains no SAP credentials and no API keys. It runs as a non-root user, and the Linux secret store is read-only, so SAP passwords are supplied only through profile-specific environment variables.
Current limitation: SAP principal propagation
Per-person SAP profiles give per-person SAP attribution and authorization, but the
server still holds each person's SAP credential. Forwarding an end-user token into
SAP — true principal propagation through Cloud Connector or the BTP
OAuth2UserTokenExchange flow — is tracked in the roadmap and is
not in this release. The HTTP listener also speaks plain HTTP; terminate TLS at a
reverse proxy.
Token-efficient operation
The server is designed to keep model context usage bounded without removing useful data:
- Related operations are grouped into action-based tools.
- The complete 53-tool schema is kept below a 64 KiB automated guardrail.
- Source, search, SQL, ATC, dump, trace, transport, version, Git, and RAP schema responses are paged or summarized.
- Unified diffs are limited by both line count and byte size.
- Large source responses are bounded by an inline byte budget.
- Discovery data and large download manifests can be exported to local files.
- Compact JSON is returned without pretty-print whitespace.
- Connection discovery returns only the profile ID, environment, and credential availability. Object-info reads normalize useful scalar metadata and return the raw ADT structure only when
includeStructure=true. - Source reads identify the resolved object by name and type without repeating its search description, package, and object URI;
sourceUriremains available for follow-up operations. search_abap_object_linesalways merges overlapping source windows intocontextBlocksand reports matches once inmatchLineNumbers, including enhancement source groups.get_sap_capabilitiesomits evidence by default; requestincludeEvidence=trueonly when auditing discovery or execution observations.- Semantic, refactoring, ATC, version, activation, navigation, and download responses reuse the same compact object identity policy. Batch reads omit the parent
connectionIdfrom each nested result. - ATC findings reference one response-level object catalog. Dump, trace, and heartbeat list/mutation responses omit raw details that are available through explicit detail actions or options.
- Compact JSON through 16 KiB is normally returned unchanged. Larger results return a bounded structural summary, an exact UTF-8 preview, and an in-memory
resultIdin acompact-v1envelope no larger than 12 KiB. search_abap_object_linesswitches to its bounded summary at 16 KiB and keeps the exact compact result behind the sameresultId.
The complete 53-tool, 150-variant review and fixture measurements are in docs/response-token-audit.md. Re-run npm run benchmark:surface for a machine-readable schema-cost report; see docs/compatibility-matrix.md for the live-evidence boundary.
Continue paged responses with fields such as nextStartIndex, nextLine, nextRowStart, and nextContentOffset.
For a response with format: "compact-v1", use summary first. Call read_deferred_result with its resultId and nextOffset only when omitted exact data is needed. A request may ask for up to 24 KiB, while the serialized chunk response remains within the 16 KiB inline budget; continue until done is true. Deferred results expire after ten minutes, are never written to disk, and reading them does not repeat the SAP request.
Hosts without automatic tool search can register only selected toolsets:
Available toolsets are core, write, analysis, debug, operations, artifacts, and all. The default is all.
Real SAP acceptance testing
Run acceptance tests first against a development system.
Existing SAP objects may be used for reads, searches, and analysis.
Creation, modification, activation, execution, restore, debugging mutation,
and deletion must target only objects created by the current test run in SAP
local package $TMP.
A name, prefix, search result, or $TMP package membership is not ownership
evidence. A candidate becomes RUN_OWNED only after both a successful create receipt and an immediate exact read-back confirm the same system, package,
object type, name, and canonical URI. Every subsequent mutation requires an
exact ledger match and another read-back. Cleanup may delete only those
RUN_OWNED entries, using a fresh preview and exact confirmation.
The strict B4D campaign records transport, abapGit remote, and RAP publication
mutations as SKIP-SCOPE: $TMP object ownership does not establish ownership
of those external or system-wide targets. It never converts a skipped mutation
into a pass.
For BDEF creation, batch activation, class execution, the fixed ABAP REPL contract, and detailed semantic inspection, follow the evidence and cleanup procedure in docs/live-sap-acceptance.md. Until those checks succeed on a selected connection, the capabilities remain unverified.
For the complete Windows B4D campaign, use the
115-tool v1 $TMP acceptance prompt
and the Windows clone and connection guide.
Recommended order:
- Connection, discovery, repository reads, semantic reads, versions, transports, and URL-only transaction generation.
- Create a dedicated test class and verify source write, diagnostics, activation, formatter, quick-fix, rename, extract method, inactive source, restore, package move, and guarded deletion.
- Test transport mutations only with a disposable transport.
- Test abapGit only with a disposable remote repository.
- Run RAP validation and preview before approving generation or service publication.
When reporting a failure, preserve the MCP error code, HTTP status, ADT endpoint, and SAP response text. Do not retry failed ADT operations with guessed parameter variants.
CLI reference
Removing a profile also removes its SAP password or OAuth client secret and stored abapGit credential vault.
Troubleshooting
| Problem | Check |
|---|---|
node is not found | Install Node.js 20 or later and reopen the terminal. |
| npm cannot download the package | Check internet access, proxy configuration, and npm registry policy. |
PROFILE_NOT_FOUND | Run setup again and verify the Server name. |
| SAP login fails | For Basic Auth, verify URL, client, username, password, VPN, and ADT activation. For OAuth, verify the token URL, client ID, client secret, scope, Bearer response, and ADT authorization. |
| Certificate or connection error | Check the corporate CA, proxy, VPN, and SAP HTTPS endpoint. |
MCP -32000 (ConnectionClosed) | The stdio process closed during initialization; this is not an SAP API status. Run npm run smoke:v1, then start node dist/src/index.js serve --profile <id> directly. If both work, inspect the saved command with claude mcp get <name> and start Claude with claude --debug mcp. |
| Tools are missing | Confirm that the MCP command contains @latest and --prefer-online, restart it, and inspect /mcp. |
Writes return PACKAGE_NOT_ALLOWED | The profile has a non-empty --packages restriction; add the target package or remove the restriction. |
Writes return TRANSPORT_REQUIRED | Supply an open transport for non-local packages. |
| RAP generator is unavailable | The SAP release or installed components may not expose the RAP generator endpoints. |
| Private Git access fails | Store credentials for the exact canonical repository URL. |
Browser SSO-only, MFA-only, certificate-only, and Kerberos-only SAP systems are not supported by this release. Use Basic Auth or an explicitly configured OAuth client-credentials client accepted by the ADT endpoint.
Local development
Register the current local build for pre-release testing:
The compatibility and toolset manifest is maintained in src/compat/abap-fs-tools.ts. ADT wrapper contract tests are in test/sap-client-contract.test.ts, and end-to-end in-memory MCP tests are in test/integration.test.ts.
Release status
- Package:
@coaspe/sap-abap-mcp - Current source version:
1.0.0 - Published npm version:
1.0.0 - Release channel: npm
latest(resolved automatically when the MCP process starts) - Runtime: Node.js 20 or later
- Transport: local MCP over stdio by default; opt-in self-hosted Streamable HTTP
- SAP authentication: SAP Basic Auth by default; opt-in OAuth client credentials
- HTTP client authentication: mandatory Bearer API keys with viewer/developer/admin roles
- Secret storage: macOS Keychain, Windows DPAPI, or read-only environment variables on Linux
- SAP API client:
abap-adt-api8.4.1 - ABAP FS compatibility baseline: 2.6.5, commit
3041418d35558e043993a4d7f9fa6b727fcf9cf1
The automated suite validates the MCP contract, ADT argument ordering, safety policies, stale-preview protection, output bounds, all 115 default v1 tools, all seven v1 Resources, and the legacy 53-tool v0 surface with an in-memory SAP implementation. Live SAP acceptance testing is still required because endpoint availability and authorization vary by SAP release and system configuration.
Known limitations
These reflect ADT behaviour that varies by SAP system. The tools fail safely and report an actionable message when a system does not support the operation.
- Transport release of requests/tasks that contain objects: some systems reject the synchronous ADT release endpoint for object-bearing transports and only run release as a background job from the GUI. In that case
release_transportreturnsTRANSPORT_RELEASE_UNSUPPORTEDwith guidance to release from SE10/SE09, and the error details carry the ADT endpoint, HTTP status, ADT error type, and the exact SAP response text. The asynchronous background-run path is not implemented because its ADT wire protocol is not publicly documented and is not exposed byabap-adt-api; implementing it by guessing endpoints is explicitly out of scope. If you can reproduce this, attach those preserved error details to an issue — they are the evidence the implementation needs. Empty and request-only transports release normally. - abapGit tools require the abapGit ADT backend: the git tools call
/sap/bc/adt/abapgit/*. Systems that only have the standalone abapGit report (SE38) do not expose these endpoints, and the tools returnABAPGIT_BACKEND_UNAVAILABLE. Install the abapGitADT_Backendto enable them. - Cross-system compare needs two configured systems:
compare_abap_systemsrequires two distinct registered connections. - RAP generation creates a full artifact set and requires a suitable reference object (for example a root CDS entity with a behavior definition).
Detailed Windows guide
See docs/localhost-mcp-end-to-end.md for the multi-system Windows setup, lifecycle, security model, and operational checklist.
Related MCP Servers
Frequently Asked Questions about SAP ABAP MCP
AllMCPs Directory Badge
Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.
Badge Style:
Live Dynamic SVG Preview
Markdown (GitHub README)
[](https://allmcps.com/mcp/sap-abap-mcp)HTML Embed
<a href="https://allmcps.com/mcp/sap-abap-mcp"><img src="https://allmcps.com/api/badge/sap-abap-mcp?style=directory" alt="SAP ABAP MCP on AllMCPs" /></a>