ADAM
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| SAP_URL | No | SAP system URL, e.g. https://my-sap-host:44300 | |
| SAP_USER | No | SAP user for basic authentication | |
| SAP_PROXY | No | Corporate proxy for SAP and the BTP login, e.g. http://proxy.example:8080 (http://user:password@proxy:8080 when it asks for a login); HTTPS goes through it as a tunnel | |
| SAP_CLIENT | No | Client, e.g. 100 (default: the system's default client) | |
| SAP_INSECURE | No | true skips TLS certificate checks — test systems only | |
| SAP_LANGUAGE | No | Logon language (default EN) | EN |
| SAP_PASSWORD | No | SAP password for basic authentication | |
| SAP_COOKIE_FILE | No | Netscape cookie file, re-read when SAP rejects the session | |
| SAP_ABAP_RELEASE | No | SAP_BASIS release (e.g. 758): the ABAP grammar used to locate methods in classic code | |
| SAP_DISABLE_SAML | No | true asks SAP not to redirect to SAML single sign-on | |
| SAP_COOKIE_STRING | No | Inline cookies: name=value; name2=value2 | |
| ABAP_DEBUGGER_HOST | No | Bind address (default 127.0.0.1, 0.0.0.0 on Cloud Foundry) | 127.0.0.1 |
| ABAP_DEBUGGER_PORT | No | Port (default 8080, PORT on Cloud Foundry) | 8080 |
| SAP_BTP_DESTINATION | No | BTP destination of the SAP system: PrincipalPropagation (on-premise, Cloud Connector) or OAuth2UserTokenExchange (BTP ABAP Environment) — each user as themselves | |
| SAP_BTP_SERVICE_KEY | No | BTP ABAP Environment service key inline JSON; URL and client come from it | |
| ABAP_DEBUGGER_API_KEYS | No | Comma-separated API keys (20+ characters each), besides XSUAA OAuth when an XSUAA instance is bound | |
| ABAP_DEBUGGER_LOG_LEVEL | No | debug, info (default), warn or error — logs go to stderr | info |
| ABAP_DEBUGGER_TRANSPORT | No | Set to http to run the server over HTTP (same as --http) instead of stdio | |
| ABAP_DEBUGGER_PUBLIC_URL | No | Public URL for the OAuth metadata behind a reverse proxy (default: the Cloud Foundry route) | |
| SAP_BTP_SERVICE_KEY_FILE | No | BTP ABAP Environment service key file; URL and client come from it | |
| ABAP_DEBUGGER_MAX_SECONDS | No | Ceiling of a call's maxSeconds (10-3600, default 600) | 600 |
| ABAP_DEBUGGER_IDLE_SECONDS | No | An interactive session is released after this long without a call (10-3600, default 120) | 120 |
| ABAP_DEBUGGER_MAX_RESULT_KB | No | Ceiling of a call's maxResultKB (5-1000, default 200) | 200 |
| SAP_BTP_OAUTH_CALLBACK_PORT | No | Port of the local login callback (default: a free port) | |
| ABAP_DEBUGGER_ALLOWED_ORIGINS | No | CORS origins of browser MCP clients | |
| ABAP_DEBUGGER_SESSION_SECONDS | No | An interactive session is released after this long in all (60-14400, default 900) | 900 |
| ABAP_DEBUGGER_ALLOW_SHARED_USER | No | true accepts one SAP identity for every MCP user (SAP_URL + SAP_USER, a Basic destination) — they can then catch each other's runs | |
| ABAP_DEBUGGER_DCR_SIGNING_SECRET | No | 32+ characters: keeps the MCP clients' OAuth registrations valid across deployments |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| abap_debugA | RULE on an on-premise or private cloud system: trigger "none" needs a human action: relay the steps of the answer (userMessage) to the user and end your turn before calling wait. Pass runFrom "http" for a Fiori app (no SM51 steps). Debug ABAP code on the connected SAP system in ONE call: arm breakpoints (lines or class methods in CLAS, PROG or FUNC objects, optionally with an ABAP condition; or where a message is issued, a statement kind runs, an exception is raised; watchpoints, set at the first stop, then stop wherever a variable changes), run the code (its harmless ABAP Unit tests, an OData GET, or wait while you run it yourself as the same SAP user), and at every stop of that one run record the position, the call stack, the variables and optional steps — then release the program and remove the breakpoints. The program runs once, however many stops you ask for: a breakpoint in a loop with hits 5 shows five iterations of the same run. Nothing stays stopped after the call returns, so name every variable you need up front; to look again, run another capture — or start an interactive session (interactive: true) and decide each move with abap_debug_session. Lines are numbered as abap_source shows the ACTIVE source. Per capture: at most 20 breakpoints and 50 stops, and as many steps as the budgets allow — the run is followed until its result size (maxResultKB, default 40 KB) or inspection time (maxSeconds, default 120 s) runs out, then goes on without stopping. Past 20 steps from one stop, the steps come back as a compact trace; until ends them at a line or once a variable changed. Result: hit; breakpoints (set, with the hits they made, or refused with SAP's reason); debuggee; stops (at, stoppedAt, stack and variables on a breakpoint's first stop — its later stops carry only values, unchanged structures and tables marked so; steps, or a trace of a long run: path = the lines executed per frame, (9-12)×300 = a loop, changes = values where they changed); release; trigger; warnings. Without a stop: reason and hint. A call answers within ABAP_DEBUGGER_CALL_SECONDS (default 50 s). A capture still waiting for its stop or following its run then answers running: true with its session id, and goes on: abap_debug_session action wait picks up its result, action end stops it. trigger "none": on the BTP ABAP Environment or S/4HANA Cloud Public Edition, which have no SAP GUI, never ask about it or mention SM51. On an on-premise or private cloud system, from SAP GUI, only a NEW session opened through SM51 (select the application server, Goto → Remote Logon → Normal) once the breakpoints are armed stops at them — on some systems, a session opened before, or from SAP Logon or SAP Business Client, never does. When the user says they run it from a Fiori app or another HTTP call, pass runFrom "http": no SM51 steps. Otherwise, right after arming, the client shows the user these steps in a dialog where it can (MCP elicitation: accept goes on waiting, decline stops the capture); else the call answers at once with running: true, userMessage (the steps, for the user) and agentInstructions (for you): show userMessage to the user in their language, keeping its numbered steps, END YOUR TURN, and call abap_debug_session action "wait" once they ran the code. runFrom "http" answers at once the same way, telling the user to open the app. It never changes variables or the program flow, never debugs system code, and only debugs the session's own SAP user; it refuses when Eclipse or VS Code already debugs that user. |
| abap_debug_sessionA | One move of the program an interactive capture holds (abap_debug with interactive: true), then where it stands — its position, the code around it, the watched variables — so you decide the next move from what you see. step: statement by statement — stepMode over (default), into a call, out to the caller; count steps at once (past 20 they come back as a compact trace), until a line or until a variable changed. continue: run to the next breakpoint or watchpoint (each stop as in abap_debug), or to toLine. inspect: read any variables where it stands (or the whole frame), and the call stack. watch: set a watchpoint on a variable visible here — continue then also stops where it changes (optionally where a condition holds). end: let the program run to its end — or terminate: true to abort it, e.g. before it commits. wait: a move (or a capture) that outlasts its call — ABAP_DEBUGGER_CALL_SECONDS, default 50 s — answers running: true and goes on in the background; wait returns its answer once it is done. The program waits in a work process between calls, so end the session when you are done; it is also released after a while without a call (ABAP_DEBUGGER_IDLE_SECONDS, default 120 s) and after ABAP_DEBUGGER_SESSION_SECONDS (default 15 min). Every answer says how long it has left. Apart from terminate, it never changes variables or the program's flow. |
| abap_breakpointsA | list: your capture or interactive session on this server, the breakpoints a capture could not remove (its server process was killed, or SAP refused the removal — the next capture removes them too), and whether a debugger listener is registered for your SAP user on SAP. delete: end your capture or session and remove those leftovers; listener: true also removes the listener — SAP removes it by user, Eclipse's included. Use it when a capture is refused because a debugger listens, or the user's requests stop at odd places. SAP has no request that lists every breakpoint of a user: Eclipse's own are in Eclipse. |
| abap_sourceA | The ACTIVE source with its line numbers: of a class (main source or a local-class include), a program or a function module — numbered as abap_debug breakpoints use them — and of interfaces, includes, CDS views, behavior and service definitions. A service binding (SRVB) shows its service definitions: from a Fiori app's binding, follow SRVD → CDS views → BDEF → behavior pool to the code to debug. Narrow a source with method, lineStart/lineEnd or grep. |
| abap_searchA | Find repository objects of any type by name, name start or pattern: classes, interfaces, programs and includes, function groups and modules, CDS views, behavior definitions, service definitions and bindings, UI5 apps… — each with its exact name, type, what it is, package and description. E.g. the service binding and definition behind a Fiori app (then the CDS views and behavior pools they lead to), or the unit-test class to use as triggerName. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 5 tools
abap_debug and abap_debug_session share the debug prefix and can be confused: one runs a one-shot capture, the other performs a single interactive-session move. abap_breakpoints also overlaps with breakpoint arming in abap_debug, though the descriptions cross-reference each other and explain the boundaries.
All tool names use a consistent lower_snake_case abap_ prefix, making the set readable and predictable. The suffixes mix actions (debug, search) and nouns (breakpoints, source, session) rather than following a strict verb_noun pattern, but this is a minor deviation.
Five tools is well-scoped for complex ABAP debugging. Each tool maps to a distinct area: object search, source inspection, capture debugging, interactive stepping, and breakpoint cleanup.
The tool surface covers the debugging lifecycle end-to-end: finding objects, reading active source, arming and running captures, inspecting stops, stepping interactively, and cleaning up breakpoints/listeners. No significant gaps in ABAP debugging workflows are apparent.