Provides tools for interacting with SAP ABAP systems via the ADT API, enabling full ABAP development lifecycle including source editing, object creation/activation, transport management, quality checks, data queries, unit tests, debugging, refactoring, and more.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@dassian-adt Create a new ABAP class ZCL_TEST in package $TMP"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for SAP ABAP development via the ADT API. Connect AI assistants to your SAP system — read, write, test, and deploy ABAP code without SAP GUI.
The AI can create objects, write source, activate, manage transports, run code, query tables, and check quality. Full development lifecycle, not just read-only or code generation.
Based on mcp-abap-abap-adt-api by Mario Andreschak and the abap-adt-api library by Marcello Urbani.
Dassian's fork adds input validation, error intelligence, MCP elicitation, session recovery, and a test suite. See CHANGES.md for the full list.
Related MCP server: dassian-adt
85 tools covering the full ABAP development lifecycle:
Category | Tools | What They Do |
Source (8) |
| Read/write source for any object type; surgically edit a single method without touching the rest; write a specific class include (definitions, implementations, macros, testclasses); read class-local includes (CCDEF/CCIMP/CCMAC/CCAU — incl. RAP behavior handler bodies); format via SAP Pretty Printer; revision history; fetch a whole function group (top include, user includes, all FMs) in one call. |
Objects (6) |
| Full object lifecycle. Create in $TMP or real packages (BDEF supported). Delete, activate single or in batch, search by name pattern (trailing wildcards only), get metadata (package, transport layer, active/inactive status, upgrade flag). |
Transports (14) |
| Full SE09/SE10 workflow: create requests (incl. clean Transport of Copies via FM TR_INSERT_NEW_COMM), check transport requirements, assign objects via no-op save, release with pre-release inactive-objects check and optional auto-activation, list open requests, per-object assignment info, request contents (E071), delete, change owner, add users, set description, read CTS import/activation logs on any system in the landscape, search E07T by description fragment, and copy E071/E071K rows from source transports into a ToC (point-fix snapshot pattern). |
Quality (6) |
| Syntax check with errors/warnings; ATC runs with variant diagnostics and silent-fallback detection; where-used lists (incl. class methods via |
Data (2) |
| Read tables/CDS views with WHERE/LIKE/BETWEEN. Execute OpenSQL queries. |
Run (3) |
| Create a temp class in $TMP, run code via IF_OO_ADT_CLASSRUN, capture output, clean up. Auto-detects ~run vs ~main across SAP releases. Large outputs are paginated — fetch continuation pages with |
Unit tests (2) |
| Run ABAP Unit tests with per-method failure detail (assertion message, stack trace); scaffold a test class include (CCAU) for an existing class. |
System (6) |
| Session management, connectivity + SAP_BASIS release check, ST22 short dumps, list inactive objects, CDS annotation definitions, raw ADT HTTP for anything not covered by dedicated tools (SITO, SICF, ...). |
DDIC (2) |
| DDIC metadata for CDS views/data elements (fields, types, key flags, labels, annotations, association targets); list all objects referencing a CDS entity or data element. |
RAP (2) |
| Inspect published OData service bindings (service URL, entity sets, navigation properties); publish/unpublish bindings. |
RFC (2) |
| Call RFC-enabled function modules directly via SAP NW RFC (pyrfc-based); create DDIC structures/tables via RFC (requires ZFM_DDIC_CREATE on the target system). |
Traces (8) |
| Runtime tracing (SAT-style): create trace configurations, set parameters, capture runs, and analyze hit lists, statement-level detail, and DB access; delete run results and configurations. |
Debugger (13) |
| Full remote debugging: register a debug listener, set/delete breakpoints (incl. conditional), attach to a debuggee, read the call stack, inspect variables (with structure/table drill-down), step (into/over/return/continue/terminate), switch stack frames, and change variable values at runtime. |
Refactoring (6) |
| Server-side refactorings: rename a symbol across all where-used objects (evaluate → preview → execute), and extract a source range into a new method (evaluate → preview → execute). |
BSP / UI5 (3) |
| Read files from BSP/UI5 applications or list an app's filetree; search a string across an app's text files (find the file owning a component ID or OData service); look up UI5 Application Index metadata (component ID → BSP app, libraries, timestamps). |
Git (2) |
| gCTS repository listing and pull (imports commits into the SAP system). |
Four ready-made prompt templates are registered alongside the tools:
fix-atc — Run ATC on an object, read all P1 findings, fix each one, activate.
transport-review — List transport contents, syntax-check all objects, report issues.
class-overview — Compact class interface summary plus where-used count.
release-transport — Check, syntax-validate, then release a transport.
Node.js 18+
Access to an SAP system with ADT enabled (port 44300)
SAP user with development authorization
(optional) Python 3 + pyrfc — only needed for abap_rfc_call / abap_ddic_create; abap_ddic_create additionally requires the ZFM_DDIC_CREATE function module (RFC-enabled) on the target system
git clone https://github.com/DassianInc/dassian-adt.git
cd dassian-adt
npm install
npm run buildThis repository holds no credentials and no connection data. All SAP connection settings are supplied by the MCP client at launch time via environment variables — see the next section for concrete examples.
Env Var | Required | Description |
| yes (single-system) |
|
| yes (single-system) | Basic-auth credentials |
| no | Logon client (e.g. |
| multi-system | JSON array of system configs: |
| no | Default system id (first entry if omitted) |
| no | Comma-separated system ids to include |
| no | Landscape definition (URL or |
| no | Legacy (SAP_BASIS ≤ 731) transport RFC proxy — see |
| no | Only for self-signed certificates (dev) |
Without any credentials the server fails fast with SAP_URL is required. — nothing is baked in.
Works with any MCP client (ZCode, Claude Code, Cline, Cursor, Claude Desktop). The client passes the credentials as environment variables when launching the server — for example the workspace .mcp.json:
{
"mcpServers": {
"abap": {
"command": "node",
"args": ["/path/to/dassian-adt/dist/index.js"],
"env": {
"SAP_URL": "https://your-sap-server:44300",
"SAP_USER": "YOUR_USER",
"SAP_PASSWORD": "YOUR_PASSWORD",
"SAP_CLIENT": "100",
"SAP_LANGUAGE": "EN"
}
}
}
}Multiple systems? Add one entry per system:
{
"mcpServers": {
"abap-dev": {
"command": "node",
"args": ["/path/to/dassian-adt/dist/index.js"],
"env": { "SAP_URL": "https://dev-system:44300", "SAP_USER": "...", "SAP_PASSWORD": "..." }
},
"abap-qa": {
"command": "node",
"args": ["/path/to/dassian-adt/dist/index.js"],
"env": { "SAP_URL": "https://qa-system:44300", "SAP_USER": "...", "SAP_PASSWORD": "..." }
}
}
}For team-wide access, run the server as a centralized HTTP service:
MCP_TRANSPORT=http MCP_HTTP_PORT=3000 \
SAP_URL=https://your-sap-server:44300 \
SAP_USER=SERVICE_USER \
SAP_PASSWORD=... \
node dist/index.jsEach client gets its own MCP session (and SAP session). Health check at http://your-server:3000/health.
Connect from Claude Code using the remote URL:
{
"mcpServers": {
"abap": {
"type": "url",
"url": "http://your-server:3000/mcp"
}
}
}Or register as a team integration on claude.ai for the whole org.
Env Var | Default | Description |
|
| Transport mode: |
|
| HTTP server port |
|
| MCP endpoint path |
npm test # 260 unit tests, <10 seconds, no SAP needed
npm run test:live # Integration tests against live SAP (needs env vars)
npm run test:e2e # Write-path lifecycle test (create -> write -> activate -> delete)The server is workflow-oriented: most tools complete their lock → write → unlock cycle atomically, so the AI orchestrates at task level instead of managing ADT primitives.
abap_get_source (compact=true for classes)
→ abap_edit_method (surgical single-method edit; survives CRLF sources)
→ abap_syntax_check
→ abap_activateabap_set_source replaces whole sources and auto-prompts for a transport when the object sits in a non-$TMP package (elicitation).
transport_create (workbench; or let abap_create auto-generate one)
→ abap_create (type CLAS/PROG/INTF/FUGR/DDLS/BDEF/TABL/TTYP/DEVC..., package, transport)
→ abap_set_source
→ abap_syntax_check → abap_activate → abap_activate_batch (with dependents)transport_check (what transport does this object need?)
→ transport_assign (no-op save mounts object onto the request)
→ transport_contents (review E071)
→ transport_release (pre-checks inactive objects, releases tasks then request, asks for confirmation)
→ transport_log (read the import/activation log on the target system)Point-fix snapshot: transport_create transportType="toc" → transport_bundle_into_toc copies E071 rows from several source requests into one ToC.
abap_ddic_create (objectType=TABL|STRU, fields with data elements;
derives LENG/DECIMALS automatically via ZFM_DDIC_CREATE)ddic_element (structure of a CDS view / data element)
→ abap_table (WHERE clause) or abap_query (full OpenSQL)
→ abap_run (one-off SELECT/report logic; abap_fetch_page for large output)debuggerListen (register terminal for user X)
→ debuggerSetBreakpoints
→ (user triggers the process) debuggerAttach
→ debuggerStackTrace → debuggerVariables / debuggerChildVariables
→ debuggerStep (into/over/return/continue), debuggerSetVariableValue
→ debuggerDeleteBreakpoints + debuggerDeleteListener (cleanup)renameEvaluate (symbol at uri:line:col) → renamePreview → renameExecute
extractMethodEvaluate (uri + range) → extractMethodPreview → extractMethodExecuteRenames propagate across every where-used object in one atomic call; activate afterwards.
/fix-atc — ATC run, fix every P1 finding, activate
/transport-review — contents + syntax-check everything on a request
/release-transport — validate then release
/class-overview — compact interface + where-used summary
Centralized validation middleware checks every tool's required parameters before any handler logic runs. Missing name? Missing type? The error names exactly what's missing. No stack traces, no Cannot read properties of undefined.
When the AI forgets a required parameter, instead of failing, the server asks the user directly:
Missing package on abap_create -> "Which package?" form with $TMP default
Missing transport on abap_set_source -> "Which transport?" prompt, then retries
Transport release -> "Release D25K900161? This is IRREVERSIBLE" confirmation
Leftover class on abap_run -> "Delete ZCL_TMP_ADT_RUN and retry?" prompt
Inactive dependents on abap_activate -> "Activate them too?" with list
Falls back gracefully on clients that don't support elicitation.
Every SAP error is classified and annotated with actionable hints:
Locked object -> "Check SM12 for active locks"
Upgrade mode -> "Run SPAU_ENH to clear the upgrade flag"
Opaque I::000 code -> "The URL path is wrong -- check the object type"
Transport number passed as object name -> "Use transport_contents instead"
Pipe characters in string templates -> "Escape with \| or use CONCATENATE"
The AI reads these hints and self-corrects on the next call.
Every ADT call is wrapped in withSession(). If the SAP session expires mid-operation, the server re-logs in automatically and retries. Users never see a session timeout.
abap_run auto-detects whether the system uses IF_OO_ADT_CLASSRUN~run (<=2023) or ~main (2024+) by reading the interface source after login. Works on any S/4HANA release without configuration.
healthcheck reports the target's SAP_BASIS release. On legacy ECC 6.0 systems (BASIS 731 and earlier) program creation and transport creation automatically route through a compatibility layer (lib/legacyAdt.ts), optionally backed by the rfc-proxy service (see appendix). Modern systems use the standard ADT API untouched.
Client (Claude Code, VS Code, etc.)
|
| MCP protocol (stdio)
|
AbapAdtServer (index.ts)
|
+-- BaseHandler (session mgmt, validation, elicitation)
| |
| +-- SourceHandlers (get/set source, edit method, function groups)
| +-- ObjectHandlers (create, delete, activate, search)
| +-- TransportHandlers (create, assign, release, list)
| +-- QualityHandlers (syntax check, ATC, where-used)
| +-- DataHandlers (table read, SQL query)
| +-- RunHandlers (temp class execution, unlock)
| +-- SystemHandlers (login, healthcheck, dumps, raw HTTP)
| +-- GitHandlers (gCTS repos, pull)
| +-- TestHandlers (ABAP Unit tests, test includes)
| +-- RapHandlers (service binding publish/details)
| +-- TraceHandlers (runtime traces)
| +-- DdicHandlers (DDIC metadata, references)
| +-- RfcHandlers (RFC calls, DDIC via RFC)
| +-- BspHandlers (BSP/UI5 files, UI5 app index)
| +-- DebugHandlers (remote ABAP debugging)
| +-- RefactorHandlers (rename, extract-method)
|
+-- lib/urlBuilder.ts (ADT URL construction for 30+ object types)
+-- lib/errors.ts (SAP error classification + hints)
+-- lib/logger.ts (JSON structured logging)
+-- lib/legacyAdt.ts (SAP_BASIS <= 731 compatibility layer)rfc-proxy/ contains a standalone experimental Python service (pyrfc-based) used by the legacy transport path on SAP_BASIS <= 731 systems. The MCP server does not require it on modern systems. It reads its own config — copy rfc-proxy/config.example.json to rfc-proxy/config.json and fill in your RFC details (that file is gitignored; the repo ships no credentials). Enable via RFC_PROXY_URL / RFC_PROXY_ENABLED.
abap_rfc_call / abap_ddic_create do not use the proxy — they call scripts/rfc_call.py directly and take their connection parameters from the server's environment-injected credentials.
Contributions are welcome. Please:
Fork the repository
Create a feature branch
Run npm test and ensure all tests pass
Open a pull request
Mario Andreschak -- original mcp-abap-abap-adt-api server scaffold
Marcello Urbani -- abap-adt-api library powering all ADT HTTP communication
Dassian Inc. -- fork maintainer
MIT -- see LICENSE.
This server cannot be deployed
Let AI agents query data and act across all your business apps via MCP.
List, read, edit, and deploy your GenMB AI-generated apps from any MCP client.
Unified MCP Server is a remote MCP connector for AI agents and vertical AI products that provides access to 22,000+ authorized SaaS tools across 400+ integrations and 24 categories directly inside LLMs (Claude, GPT, Gemini, Cohere). Tools operate only on explicitly authorized customer connections, enabling agents to safely read and write against live third-party systems.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
