sap-adt
Read-only integration with an SAP ABAP system (S/4HANA or ABAP Platform) over the ADT REST API. Provides tools to search objects, read source and its stored versions, resolve where-used and symbol definitions, inspect package trees and Clean Core/annotation state, run ATC and syntax checks, read transport contents and routes, runtime errors (ST22), a closed set of customizing tables, and SAP Launchpad OData services — all without writing to the system or requiring the IDE to be open.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
sap-adt-readonly-mcp
Read-only MCP server over the SAP ADT REST API. Gives an AI coding agent the answers that otherwise require leaving the editor: does this object exist? what is its real source? who calls it? what is in this package? does it pass the ATC? does it consume anything that is not released? Everything is read from the SAP system itself — no local checkout, no copy of SAP sources, no IDE file.
Why this exists
SAP ships an official ADT MCP server inside the IDE (Eclipse on localhost:2234, VS Code
on localhost:2236). It covers the write side — activate, unit tests, transports,
generators — and it only runs while the IDE is open. It does not search the repository,
read source, or answer where-used; and its ATC answer, measured, is "error" and nothing else.
This server covers the read side of that gap, and never the write side:
Official SAP ADT MCP |
| |
Activate, ABAP Unit, create/change objects, release transports | ✅ | ❌ by design |
ATC on one object, findings legible, several variants | "error" (measured) | ✅ |
Syntax check of the stored source, active or inactive | — | ✅ |
Search objects, read source and its stored versions, where-used, package tree | ❌ | ✅ |
Clean Core and annotation scans of a package, value-help recommendation | ❌ | ✅ |
Transport contents and history, runtime errors (ST22), customizing reads, launchpad content | ❌ | ✅ |
Works with the IDE closed | ❌ | ✅ |
Can change the SAP system | yes | no |
The official server covers writing and runs only with the IDE open; this one covers reading and runs with the IDE closed. The two coexist: this one never touches ports 2234/2236 or the IDE token.
Related MCP server: abapsmith
What it does
20 MCP tools for an AI agent (Claude Code or any MCP client that speaks Streamable HTTP), every one of them read-only and reading from the SAP system:
objects —
adt_search,adt_read_source,adt_object_info,adt_where_used,adt_package_tree,adt_find_definition(where the symbol at a position is defined),adt_used_objects(what a class uses, with each object's release state);package scans —
adt_clean_core_scan(what the CDS views consume, at which Clean Core level),adt_annotation_scan(which annotation reaches an element, from which layer),adt_package_health(the Clean Core scan and the syntax check on one listing, and optionally one ATC run over the package);CDS and services —
adt_value_help,adt_annotation_chain,adt_contract_check;change and runtime —
adt_transport,adt_transport_routes,adt_runtime_errors,adt_atc_run,adt_syntax_check;configuration and UI —
adt_customizing(a closed list of tables),adt_launchpad(SAP-standard launchpad OData services).
A journal and a report: every call, finding and limit hit is recorded (no payload, ever), and read back as a report from the terminal.
A configuration CLI over a local SQLite store, so nothing of your landscape lives in the code, and a catalogue sync that keeps SAP's Clean Core release catalogue current outside the repository.
Every tool is listed in Tools and described in docs/tools.md; every npm script in Scripts; what it
cannot do in Limitations.
Safety model
Read-only by absence of capability. The tools reach the system through a proxy (
lib/guard.mjs) built on an allowlist of the 13 reads oflib/adt-reads.mjs; anything else throws before a request is issued — each read justified indocs/security.md. Every GET goes through a closed table of named routes (lib/adt-get.mjs), every POST through a module with a fixed path and a body built from validated values, and no generic HTTP call exists. There is no client library between this server and the system: the logon, the cookie and the CSRF token arelib/adt-http.mjs, onnode:https. Covered bynpm run test:guard, which runs offline.The session is stateless. A stateful ADT session is what holds locks and enqueues; switching it is refused at runtime.
The SAP password is never stored by this server. It is typed once per server start and lives only in memory. There is no
.env, no keyring, no fallback to an environment variable. A server without a terminal reads it from one file the operator names (passwordFile), and never sends twice a password the system refused (docs/security.md).One login attempt per start. On
401the server refuses to retry: repeated failed logons lock the SAP user, and a locked user takes the IDE, abapGit and transports down with it.Nothing sensitive lands in the repository. The environment store, the loopback token, the catalogue and the audit log live in
%LOCALAPPDATA%\sap-adt\. The server refuses to start if that path resolves inside a git work tree.The MCP endpoint is loopback-only by default: bound to
127.0.0.1,HostandOriginchecked on every request (DNS-rebinding protection, required by the MCP transport specification), and a bearer token compared in constant time. A hosted installation names the address to bind and the host names it answers to (bindHost,publicHosts); theHostcheck then holds against that closed list.No value of your landscape is hard-coded. Closed lists of SAP-standard entries ship as reviewable JSON (
data/defaults/); everything your installation chooses lives in the environment store and passes the same validation on the way in and on the way out (see Configuration).
Requirements
Node.js ≥ 22.13 (the environment store uses the built-in
node:sqlite; no extra npm dependency). Node prints no warning for it: the oneExperimentalWarningis filtered.An ABAP system (S/4HANA or ABAP Platform, on-premise or private cloud) whose
/sap/bc/adtICF node is active and reachable over HTTPS with Basic authentication (user + password). SSO-only nodes (SAML, X.509,MYSAPSSO2) are not supported.An SAP user with the authorizations your ADT IDE already uses. The data preview (
adt_customizing,adt_launchpadsemantic objects), the ATC run and the launchpad OData services need the SAP authorizations for those functions too; a missing one comes back as the SAP error, never as an empty answer.A terminal (TTY) for every command that logs on: the password is typed, never read from an environment variable. Without a terminal, set
passwordFileto a file only the service account can read (npm run config -- set passwordFile <absolute path>).Internet access once a month (or a manual download) for the Clean Core catalogue — see The Clean Core catalogue. The server itself never goes online.
Developed and tested on Windows. On Linux/macOS the state directory is
~/.local/share/sap-adt.SAP_ADT_STATE_DIR=<absolute path>names another place (a service account, a mounted volume); wherever this README writes%LOCALAPPDATA%\sap-adt\, read that directory.
Install and first run
This section installs it for one developer. To host one instance for a team, under an SAP
service user, read docs/deployment.md instead.
git clone <this repository> && cd sap-adt-readonly-mcp
npm ci --ignore-scripts # third-party code, no lifecycle scripts
npm run test:guard # proves the read-only guard, offline
npm run probe -- --host my-sap-host --port 44300 # reachability + auth scheme, NO credentialsConfigure the connection (nothing is read from an IDE or any other file):
npm run config -- set host my-sap-host.example.com npm run config -- set client 001 npm run config -- set user MYUSER npm run config -- set system DEV # the system id the host must answer asOr copy
config.example.json, replace the invented values and load it once withnpm run config -- import my-env.json.Get the Clean Core catalogue for the release of your system:
npm run sync:catalog -- --list # the releases SAP publishes npm run config -- set catalog.release PCE2023_0 # the one matching your system npm run sync:catalog # downloads it into the state directory npm run config -- doctor # what is set, what is missing, what is staleStart the server in a terminal and leave it running:
npm run adtBefore asking for anything it prints the MCP endpoint (
http://127.0.0.1:2237/mcp), the catalogue's age, and the exactclaude mcp addline for your machine, in PowerShell and bash form, with the bearer token read from%LOCALAPPDATA%\sap-adt\tokenby the shell (never pasted).Register it once in Claude Code, from a second terminal, with the printed line, and check with
claude mcp list. Any other MCP client works the same way: Streamable HTTP transport, that URL, headerAuthorization: Bearer <token>.Type the SAP password in the first terminal. Nothing is echoed while you type — no asterisks, no cursor movement. That is the terminal, not a hang: type it and press Enter. An empty password is refused locally, but a wrong one is a failed SAP logon, and repeated failures lock the user. The endpoint starts listening only after the logon succeeds. A refused logon is written to the audit trail, and the next start prints how many are on record since the last successful one, before it asks for the password.
To see the server the way a client does, the official MCP Inspector works against it:
npx @modelcontextprotocol/inspector, transport Streamable HTTP, URL
http://127.0.0.1:2237/mcp, header Authorization: Bearer <token>.
What the probe proves is in docs/phase0-report.md. What the ADT
API itself accepts, and the measured shape of every read used here, is in
docs/adt-api-reference.md — SAP publishes no endpoint
reference, so that file records a service document as measured instead of guesses.
Tests
npm test runs the whole suite offline — no SAP system, no credentials, no network: the ADT
client and GitHub are doubled. It includes a protocol test that drives the server with the
SDK's own MCP client over a real loopback connection (tests/mcp-protocol.test.mjs).
npm run coverage runs it again with the line, branch and function thresholds set in
package.json (tests themselves excluded from the count). Those numbers are a ratchet, not a target: they
sit just under what the suite already reaches, so a change that quietly stops exercising a path
fails the run. What the suite is actually for is the two things that cannot be checked by
reading: that no blocked ADT method is reachable, and that a recommendation is never emitted for
an entity the catalogue does not release.
There is no prettier and no linter here, and formatting is manual — on purpose. This
server has zero devDependencies: everything it needs to be tested and audited ships with
Node. Style is kept by hand (100 columns, single quotes); npx prettier will complain, and
that complaint is not a finding.
Configuration
Everything an installation chooses lives in one SQLite file outside any git work tree,
%LOCALAPPDATA%\sap-adt\sap-adt.db, written only by npm run config. Every value is
validated when it is written and again when the server reads it at start, with the same rules
the runtime fence applies — a value the CLI accepts can never make the server refuse to start,
and a value the fence would refuse can never be stored. Nothing else on the machine is read.
npm run config -- <command> [--json] [--db <file>]
keys every setting, its group, default and meaning
list the settings this installation has
get <key> one setting (or its default)
set <key> <value> validate and store one setting (a list: "a;b;c" or JSON)
unset <key> remove one setting (back to its default)
table list customizing tables: standard + this installation's
table add <NAME> <why> [--key A,B] [--routine COL=GROUP ...]
table remove <NAME>
atc list | atc add <NAME> <why> | atc remove <NAME>
token list | token add <name> | token remove <name>
the callers of a hosted server; add prints the token once
import <file.json> [--replace] validate a whole file (config.example.json shape) and store it;
merges by default, --replace drops what the file does not name
export [--out <file.json>] the whole environment in that shape
doctor validate the store and say what is missing or staleFor example:
npm run config -- table add ZMY_TABLE "why the data preview needs it" --key FIELD1,FIELD2
npm run config -- atc add ZMY_DEV_PRACTICE "development practices: naming, performance, robustness"
npm run config -- export --out my-env.json # backup / review; `import` reads it backEvery command takes --json and answers { "ok": true, "data": … } or
{ "ok": false, "error": { "code", "message", "key" } }, exiting 0 / 1 (refused value) /
2 (usage error) — a stable contract for tools that drive the CLI. --db points the CLI at
another store file (to prepare or inspect one; the server reads only the default).
config.example.json shows every block with invented values.
Switching environments. import merges: it writes what the file names and keeps everything
else. To move to another system without leftovers, back up the current one and replace:
npm run config -- export --out dev.json
npm run config -- import qas.json --replace # settings, tables and variants not in the file are droppedAn import is validated whole. A refused value writes nothing and says so. A standard table listed
in the file (or in table add) is skipped with a warning, since it needs no registration.
Group | Keys (default) | Used by |
connection |
| the session |
server |
|
|
catalogue |
|
|
fences | customizing tables ( |
|
journal |
| the journal, |
value help |
|
|
npm run config -- keys prints the meaning of each one. The SAP-standard half of every fence
ships in data/defaults/ and changes only by commit; the reason the fences
have two layers is recorded in docs/security.md (The list has two layers).
ATC variants. SAP's DEFAULT is always available, and so is the system's own check variant:
the server reads systemCheckVariant from atc/customizing at start, admits it and makes it the
default (the start-up line names it). Nothing to configure. If that read fails, the server starts
without it and the journal says so (ATC_SYSTEM_VARIANT_NOT_READ). List further variants with
atc add, such as a variant for development practices, and set atc.defaultVariant only to
override the system's choice. adt_atc_run runs up to three of them on one object in one call,
each with its own worklist and findings, and announces every variant with its purpose to the
client. A name the system does not have is answered with DEFAULT's findings (measured), so
remove a variant from the store when it is deleted on the system.
The Clean Core catalogue
adt_clean_core_scan and adt_value_help decide what is released with SAP's Cloudification
Repository (SAP/abap-atc-cr-cv-s4hc,
Apache-2.0): one release file (objectReleaseInfo_<release>.json) plus
objectClassifications_SAP.json (the classic APIs, Level B). These are the files the ATC Cloud
Readiness check itself reads.
Outside the repository.
npm run sync:catalogresolves the upstream commit, downloads both files at that commit, validates them, and swaps them into%LOCALAPPDATA%\sap-adt\catalog\(the previous copy stays ascatalog.prev).PROVENANCE.jsonrecords release, commit, sha256, rows and date.Refreshed on purpose. The catalogue changes when SAP publishes, and the answers change with it, so the server never downloads anything. Monthly is a sensible cadence; the server banner,
doctorand every answer of the two tools state the catalogue's age, anddoctorwarns past 35 days. To schedule it on Windows:schtasks /Create /SC MONTHLY /TN sap-adt-catalog /TR "cmd /c cd /d <repo> && npm run sync:catalog".No internet, or a proxy? Download the two files by hand from the repository's
src/folder and runnpm run sync:catalog -- --from <folder>. Behind a proxy, Node'sfetchusesHTTPS_PROXYwhenNODE_USE_ENV_PROXY=1is set.Without a catalogue the two tools refuse and file
CATALOG_MISSING— never "released".For people: SAP's viewer, https://sap.github.io/abap-atc-cr-cv-s4hc/, shows the same data; the answers link to it for a manual check.
npm run sync:catalog -- --check prints what is installed and how old it is, without network.
MCP conformance
The server follows the MCP specification (2025-06-18) and the official TypeScript SDK:
Transport: Streamable HTTP, stateless, loopback unless configured,
Host/Originvalidated, bearer token (no OAuth is advertised: a401carries noWWW-Authenticate, so clients do not start a discovery flow this server does not implement).POST /mcponly:GETandDELETEanswer405, since a stateless server offers no stream to open and no session to end. HTTP rather than stdio because the SAP password is typed in the server's terminal, and the specification forbids asking for it through the client (elicitation must not request sensitive information).Health, beside the protocol:
GET /healthzanswers while the process does andGET /readyzwhile it holds a SAP session and is not stopping (503otherwise). Neither needs the token, says anything of the system, or sends a request to it.Initialize:
serverInfowith name, title and version, andinstructionsthat tell the model how to use the tools well.Tools: every definition has a
title, behaviourannotations(readOnlyHint: true,destructiveHint: false,idempotentHint— false only foradt_atc_run, which leaves a worklist — andopenWorldHint: true), and a closed input schema (additionalProperties: false) that is enforced before the handler runs (type, enum, ranges, items, unknown arguments). Answers carrystructuredContentnext to the same JSON as text. NooutputSchemais declared on purpose: the answers are rich and shaped by what the system returned, and a client must reject an answer that does not match a declared schema.Errors: a tool failure is a result with
isError: true, never a protocol error. It is structured like an answer:{system, error: {code, message, next?}}, wherecodeis one an agent can branch on (INVALID_ARGUMENTS,NOT_APPLICABLE,NOT_FOUND,RATE_LIMITED,HTTP_403, ...; the closed list isERROR_CODESinlib/tool-error.mjs) andnext, when there is one, is the call that would answer instead.Long calls: the package scans and a multi-variant ATC run send progress notifications when the client asks for them, and stop between reads when the call is cancelled.
Tools
Twenty read-only tools. What each one guards against, pages and refuses -- the measured traps
included -- is in docs/tools.md; read it before trusting an empty or a
short answer.
Tool | What it answers |
| Which objects match this name pattern? |
| What is the real source in the system? — and, with |
| Package, owner, dates, API state, structure |
| Who calls this? |
| What does this package contain? |
| What do the CDS views of this package consume that is not released, and what should replace it? |
| Which annotations reach this element and from which layer — and which elements have layers that contradict each other? |
| Which released value help CDS fits this field, and what do I bind? |
| Which annotation reached this element, and from where? |
| Which OData expose aliases of this service are frozen contracts? |
| Which objects moved together, when, and by whom? |
| Where does a request released here go? Which systems has the transport domain, which layer does each develop in, and what is the consolidation and delivery path per layer? |
| What dumped (ST22), where, on which line -- and what the gateway logged |
| Does this object pass the check variants -- Clean Core governance, development practices, SAP's DEFAULT -- and if not, which finding, which check, which line? |
| Which pricing-procedure step calls routine 953? Which copy control carries requirement 653? |
| Which tiles and target mappings does catalog X carry, which groups show them, which catalogs does role Y get, and is the semantic object registered? |
| Does the source the system stores for this class, program, behaviour definition, CDS view or metadata extension compile — the active version, or the inactive one waiting to be activated? |
| How healthy is this package for Clean Core, in one answer? |
| Where is the symbol at this line and column of a class defined? |
| What does this class use, and is each of those objects released? |
Scripts
Every entry point is an npm script. Logon means the script opens one SAP session: it needs a
TTY (or passwordFile), asks for the password once per run, never stores it and never retries a
failed logon.
None of them commits anything to git.
Script | Logon | What it does | Writes |
| yes | the MCP server | audit log, journal |
| no credentials | is | nothing |
| no | the configuration CLI (Configuration) | the store |
| no (GitHub) | downloads or refreshes SAP's Clean Core catalogue (details) |
|
| no | the offline suite / the read-only guard alone / the suite with thresholds | nothing |
| no | reads the journal back: cost, findings backlog, the server's own gaps | stdout |
| no | trims the journal (and, opt-in, the audit log); a dry run without | the journal |
| yes | evidence (delivery class, fields) for adding a table to the customizing fence; decides nothing | stdout only |
| yes | checks the annotation-definition parser against what the system serves | state directory |
| no | checks one commit message against Conventional Commits (CONTRIBUTING.md) | nothing |
| no | the next SemVer version and its CHANGELOG entry, from the commits since the latest tag; a dry run without | the version files and |
Each script prints its full option list in the header comment of its file under
scripts/.
The journal
Every tool call, every defect a scan found and every limit the server hit is written to logs/
— three JSONL streams, one file per day, git-ignored. npm run report reads them back as
three blocks: how much of the work cost the SAP system nothing (measured from the read budget,
not asserted), a findings backlog grouped by package with first seen / last seen / how many
times, and the server's own gaps ranked by how often each one actually bit. The fingerprint is
what makes it a backlog rather than a log: re-running a scan accumulates occurrences instead of
duplicating rows, and a later complete scan of the same package (nothing left unread, no cap
reached, no filter) is what retires a row that is no longer filed.
npm run report # [--since YYYY-MM-DD] [--json] -> Markdown by default
npm run logs:prune -- --days 90 [--apply] [--audit]The journal carries no credential, no SAP source and no payload, and that is enforced by a
field allowlist rather than promised — see docs/security.md. It is a different artefact from
the audit trail, which stays outside the repository.
No silent errors
A journal is only worth reading if a quiet answer means nothing was there rather than nobody
looked. Two rules keep that true, and both are enforced by tests/no-silent-errors.test.mjs
rather than by review:
Every registered code has an emitter. A code in
lib/journal-codes.mjsthat no module ever writes is an intention the server does not keep. The reverse direction is checked too: a code emitted but not registered fails the build instead of failing at runtime on whichever path happens to run.A
catchthat discards its error must be listed, with a reason. Everywhere else has to report — to the journal, to the answer, or to stderr. The list is the few places where the thrown thing genuinely carries nothing a caller could act on (git absent when absence is the wanted outcome, a socket already closed, a day file not created yet).
The concrete case this closed: a scan used to skip what it could not read with a bare
continue, and a lower count always reads as cleaner. Now every object a package scan could
not read, and every package it could not list, is a SOURCE_NOT_READ gap, a reached cap is
SCAN_AT_CAP, and the answer says complete: false. And at the bottom of the stack: if the
journal itself cannot write, it warns once on stderr that an empty report from then on means
unrecorded, not clean.
Where an answer was read
Every answer starts with system: the system id, the client, the category the system holds for
that client (T000-CCCATEGORY: production, test, customizing, ...), and the role you give the
system with npm run config -- set systemRole DEV. The category is read once at start; a read
that failed says so in every answer instead of leaving the field out.
Complete or not, in fields
Every answer says whether it is complete, in fields a client can test. complete is true only
when incomplete is empty; each entry of incomplete names the list it is about, a code and
what is known about it:
Code | Meaning |
| this server cut the list; |
| the system answered a full page and gives no total; |
| items or parts that failed, with the reason |
| a reply whose shape was not recognised (drift) |
| the call was cancelled before this part |
| the call budget ran out ( |
| a depth limit left sub-packages or hops unwalked, named |
| types or parts the tool does not cover, counted |
No cut is final: a list cut by a size parameter pages (offset, rowsOffset, findingsOffset,
fieldsOffset, objectsOffset, keysOffset, releaseOffset, checksOffset, payloadOffset, or
the system's own skip), and next gives the value to pass; where nothing can page, narrowBy
names the filters that make the answer smaller. A part not asked for says asked: false and
is not incompleteness. An empty list is "none" only when complete is true.
Every call is also written to %LOCALAPPDATA%\sap-adt\audit.log — tool, target, result size,
and the caller when the server knows several (npm run config -- token add <name>).
Never the payload.
Limitations
By design — what it will never do
Write anything to SAP. No activation, no ABAP Unit, no object change, no lock, no transport release, no ATC exemption. It cannot prove that code activates or that a test passes; that is the official MCP server's job, from the IDE. (ATC it can run, on one object at a time:
adt_atc_run; each run leaves an ATC result worklist on the server, as the IDE does. And it can say whether the stored source compiles:adt_syntax_check.)Read business data. It reads the repository and a closed list of configuration tables (SAP-standard ones plus those you add with
table add), through a generatedSELECTthat cannot name anything else.runQuery/tableContentsare a closed decision, not a backlog item (docs/security.md): a free table read would make the audit trail's "no payload, ever" untrue by construction.Call a customer (Z) HTTP service. Outside
/sap/bc/adtit reaches only the SAP-standard launchpad OData services under/sap/opu/odata/UI2/.Store the password or retry a failed logon. Download at run time: only
sync:catalog, run by you, goes online.
Scope — what it does not cover
It is meant for a development system. Pointing it at quality or production is outside its design.
The ADT REST API is the protocol of SAP's own tools, not a published interface. Confirm with your SAP contact that this use is admissible before adopting the server (
docs/security.md, Scope limits that are also safety limits).One SAP system per installation (one store, one session). The server always reads the store in the state directory;
--dbexists only on the configuration CLI.Basic authentication over HTTPS only. No SSO, SAML, X.509 or OAuth, so no SAP BTP ABAP environment.
adt_contract_checkreads only the Fiori apps you name. The UI5 repository cannot be searched by service (the list ignores every filter). A data source behind a system alias (;o=) or a destination is reported as not read. Relative bindings, payloads built in variables andFilterobjects are not checked. CPI integrations live in another system (SAP BTP) that this server does not reach.PFCG roles are not read.
adt_launchpadanswers which catalogs FDM resolves for a role (roleCatalogs), but no SAP-standard service lists roles, so it cannot say which roles open a catalog.It answers nothing about SM30/SE54 maintenance, the CPI graphical editor, or Fiori deploy.
Commands that log on need an interactive terminal, or a password file. With
passwordFileset the server runs as a service; its state directory must then be persistent storage, because the rule that protects the user from a lock reads the audit trail of earlier starts.Windows first. The state directory follows Windows conventions; elsewhere it is
~/.local/share/sap-adt.
Cost and accuracy — what an answer can and cannot prove
A package scan costs one ADT call per object (capped, default 100, at most 300) and counts against the read budget. Scan a sub-package when the root is large.
An empty
adt_searchis not proof of absence: the quick search does not index every object (see the tool row). By-name tools fall back to the direct URI where the name allows it.The release catalogue is a snapshot at a recorded upstream commit; refresh it with
npm run sync:catalog(monthly). Its age is in every answer that relies on it.adt_annotation_scanreads the source, so it cannot see a switch, a kernel layer or anIS_ACTIVEflag. It ranks what deserves anadt_annotation_chaincall; it never replaces it. An upstream view is read for its inline annotations only — its own DDLX is not looked up.@UI.hiddenand@Consumption.hiddenare both crossed against display roles, and the finding carrieshiddenKeyto say which one hid the field — they do not have the same remedy.⚠️ The blind spots that do remain, both declared by
adt_annotation_scanin its own reply: a hide bound to a field (@UI.hidden: 'SomeFlag') is skipped as deliberate design, and a hide reached over more than one propagating hop is matched on element name — so a row with a highdepthis the weaker claim, anddepthis reported for exactly that reason.
Contributing
How to set up, the rules a change must keep and the commit convention are in
CONTRIBUTING.md. A vulnerability is reported privately: see
SECURITY.md.
Versioning
The version follows Semantic Versioning. The MCP server reports the version
from package.json as its server info, so there is no second copy to keep in step. The public
surface is what an MCP client depends on: the tool names, their input schemas, and the shape of
their results.
Change | Commit | Bump |
a tool removed or renamed, an input schema narrowed, a result field removed or changed in meaning |
| major (minor while the major is 0) |
a new tool, input, result field, route or script |
| minor |
a bug, performance or revert, with the surface unchanged |
| patch |
docs, tests, refactors, chores |
| none on their own |
npm run release reads the commits since the latest v* tag, prints the next version and its
CHANGELOG entry, and with --apply writes package.json, package-lock.json and CHANGELOG.md,
commits those three files as chore(release): vX.Y.Z and tags that commit vX.Y.Z. It refuses,
before writing anything, when something is already staged, when one of the three files has
changes of its own, or when the tag exists. It never pushes. The first release needs a baseline
tag, v0.1.0, on the last commit that belongs to that version.
Project layout
Path | What is there |
| starts the server: config, SAP logon, loopback HTTP listener, shutdown |
| the MCP plumbing: server info and instructions, tool handlers, the |
| titles, behaviour annotations, the input-schema check, |
| a failed call as a structured answer: its code (a closed set for the server's own refusals) and the call to make instead |
| the ADT's documents in plain fields: identity, unprefixed properties, outline positions as numbers, the object a URI names, times in ISO 8601 with their measured zone |
| a service binding and the detail of each version: parsers, and the read |
| the virtual folders of a package: the third POST (fixed path, body built from one package name) and its parser |
| the syntax check: the fourth POST (fixed path, body built from one object URI and a version, no source) and its parser |
| the objects a class uses: the Relation Explorer's network POST (fixed path, body naming one class) and its parser |
| go to definition: the navigation POST (fixed path and filter, the position in the uri, the stored source as body) and its parser |
| the APLO and CHKV objects the ADT does not publish (SLG0, SCI), read from their tables for |
| a stored version of a class or program (active, inactive, a history number) and the local unified diff of two |
| the outline of a class (components and their positions) and the slice of one method |
| the API release state of one object, per contract, and its parser |
| the system confirmed before the password prompt: one GET without credentials, the SID and client its 401 names |
| the 20 MCP tools |
| the HTTP client and the logon ( |
| the npm scripts above, each with its usage in its header comment |
| the SAP-standard half of every fence: customizing tables, ATC variant |
|
|
| the offline suite and its synthetic fixtures ( |
| an invented environment in the shape |
| one entry per release, generated by |
| the |
| the container image and example units for a hosted server (Kubernetes, systemd); how to use them is |
| the offline suite on every push, Linux and Windows |
| how Claude Code works in this repository (PDCA, invariants) and the Stop hook that keeps |
License
MIT. The one runtime dependency, @modelcontextprotocol/sdk, is pinned to an exact
version and installed with --ignore-scripts.
Third-party data. The Clean Core catalogue that npm run sync:catalog downloads is SAP's
Cloudification Repository, SAP/abap-atc-cr-cv-s4hc,
© SAP SE or an SAP affiliate company and contributors, Apache-2.0. It is not redistributed with
this repository; each installation downloads it from SAP's repository.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Read-only AI coding tools for change verification, release readiness, capacity, and guidance.
Read-only search of 2,189 AI agent tools (MCP servers, x402 APIs) with daily automated trust scores.
Searchable catalog of 74 agent-ready APIs and tools. Search by task, get pricing model, agent controls and a tracked link for each tool, or list categories. Read-only, no auth.
Live data for AI agents. Search the catalog, read the price, call the tool; keys stay server-side.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to work with SAP ABAP systems through the ADT REST API, supporting repository search, source code read/write, activation, syntax checks, and transport request management.1Apache 2.0
- AlicenseBqualityAmaintenanceEnables LLMs to develop, debug, test, and manage SAP ABAP objects on a live system through the ABAP Development Tools (ADT) protocol.2911MIT
- AlicenseBqualityBmaintenanceLets Claude and other MCP hosts do real ABAP development on SAP systems through ADT: search objects, read and write source, transports, activation, ABAP Unit, ATC, short dumps, debugger and SQL queries. 173 tools, multi-system (S/4HANA Cloud and on-prem), with server-side guard rails and an audit log.2284 npm15MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to access and work with an SAP ABAP system through the ABAP Development Tools (ADT) REST API. It supports searching and browsing the repository, reading, writing, activating and deleting source code and objects, running syntax checks, unit tests, ATC and SQL queries or classes, inspecting short dumps, and managing transport requests.335 PyPIMIT