Abap Adt MCP

Retrieves an ATC exemption proposal.

List the quickfix proposals available at an ATC finding location. Pass the source URL and position from an atcWorklists finding. Apply a proposal with atcApplyQuickfix. Read-only.

Requests an ATC exemption.

Aggregated view of an ATC result: totals by priority, by check and by object, top findings with location and quickfix availability. Pass runResultId from createAtcRun, or mainUrl (+ variant) to run ATC and summarize in one call. mainUrl accepts an object URL, a package URL (/sap/bc/adt/packages/zfin) or a transport URL (/sap/bc/adt/cts/transportrequests/DEVK900123).

Retrieves a list of ATC users.

Retrieves ATC worklists. For runs covering many objects, use startIndex/maxItems to page through the findings-per-object list instead of retrieving it all at once.

Retrieves details of a service binding from an already-parsed ServiceBinding object. If you only have the binding name, use fetchServiceDetails instead.

CDS entity by name in one call: element info (fields with types, associations, extension views, secondary objects) and optionally the DDL source. Pass the entity name (ZI_PRODUCT), not a URL.

Execute a change package refactoring previewed with changePackagePreview. Pass the refactoring returned by the preview as JSON.

Preview moving an object to another package (change package refactoring). Returns the refactoring proposal with affected objects; pass it unchanged to changePackageExecute. Needs a transport when the target package is transportable.

Checks a Git repository.

List class components (methods, attributes, types). For large classes, use startIndex/maxComponents to page through the top-level component list instead of retrieving it all at once.

URLs of the includes of a class (main, definitions, implementations, testclasses, macros) to use with getObjectSource/editObjectSource as they are (no /source/main suffix).

Get code completion suggestions

Retrieves code completion element information.

Performs full code completion.

Retrieves details for a given collection feature.

List the object types createObject supports, with per-type required fields, label and max name length (SAP-style get_object_type_details). Filter with typeId. For the system-reported creatable catalog see loadTypes.

Creates an ATC run. Flow: atcCustomizing (system check variant name) -> atcCheckVariant (returns a worklistId) -> createAtcRun -> atcWorklists (findings). Passing a check variant NAME here also works: it is resolved to a worklistId via atcCheckVariant automatically.

Create a new ABAP object skeleton. Recommended flow: pick objtype (e.g. CLAS/OC, PROG/P, INTF/OI; creatableTypeDetails lists what the system can create) -> validateNewObject to check name/package -> resolveTransport if the package is not local ($TMP) -> createObject. Afterwards write the source with setObjectSource and activate=true (it locks and unlocks by itself), then run unitTestRun. The creation is sent outside the stateful session so the new object can be read at once; when locks are held it stays inside, and the answer carries a note: the object then answers 400 to reads until its sourc…

Creates a test include for a class.

Create a new transport request. Required before creating or changing objects in transportable (non-$TMP) packages; pass the returned transport number to createObject / setObjectSource. Use transportInfo to find existing transports for an object first.

Creates transport configurations.

Retrieves information about a DDIC element. For complex objects the child element list (fields/associations/secondary objects) can be large; use startIndex/maxItems to page through it instead of retrieving it all at once.

Accesses the DDIC repository. This can return a large list of object references; use startIndex/maxItems to page through it instead of retrieving it all at once.

Attaches the debugger.

Retrieves child variables of a debugger variable. If the parent is a large structure/table, use startIndex/maxItems to page through the returned child rows instead of retrieving them all at once.

Deletes breakpoints.

Stops a debug listener.

Navigates to a specific stack entry in the debugger.

Listens for debugging events.

Retrieves a list of debugger listeners.

Saves debugger settings.

Sets breakpoints.

Sets the value of a debugger variable.

Retrieves the debugger stack trace.

Performs a debugger step.

Retrieves debugger variables. If an inspected parent is a large internal table, use startIndex/maxItems to page through the returned variable list instead of retrieving it all at once.

Deletes an ABAP object from the system

Clear local session cache

Full formatted analysis of one ABAP short dump as plain text (header, what happened, error analysis, where terminated, source extract, variables, call stack). Pass the dumpId from dumps (or the full self link). Page long dumps with startLine/maxLines.

List recent ABAP short dumps (runtime errors). By default returns a compact summary per dump (runtime error, exception, program, user, time, where it terminated with source URL and line, top of the call stack) instead of the raw HTML. Filter with from/to (timestamps), user, or a substring in program/runtime error. Use dumpDetails(dumpId) for the full analysis of one dump. This is the root-cause path when the debugger toolset is unavailable on the destination (see systemProfile; some cloud tenants and users lack it). Filters apply to the dumps the feed returns (the recent window, not the whole …

Applies a targeted edit to an ABAP object without sending the full source. Always re-fetches the current source from SAP first, so the edit lands on the latest remote version. Two modes: (a) replacements: a JSON array of {oldText, newText} where each oldText must occur exactly once in the current source (0 or several matches fail with the candidate lines, so re-read and refine); this is robust to line-number drift after earlier edits. (b) line range: replace lines [startLine, endLine] (inclusive, 1-based) with newText; endLine = startLine - 1 inserts; empty newText deletes; pass expectedText (…

Write the sources of a package (and sub-packages) to a local directory in abapGit file layout (zcl_x.clas.abap, zcl_x.clas.testclasses.abap, zi_x.ddls.asddls, zrep.prog.abap …) so local tools (grep, editors, code review, documentation pipelines) can work on them. Read-only on SAP; writes only to the given directory (must be absolute; restricted to MCP_EXPORT_ROOT when set). Classes, interfaces, programs/includes, CDS, access controls, metadata extensions, behavior and service definitions are exported; other types are listed as skipped.

Evaluates an extract method refactoring.

Executes an extract method refactoring.

Previews an extract method refactoring.

Retrieves details for a given feature.

Retrieves a list of feeds.

Fetch the OData services of a service binding BY NAME: service URLs, entity sets, navigations and preview URLs. Resolves the binding internally, so no prior objectStructure call is needed (name-based equivalent of bindingDetails).

Finds a collection by its URL.

Find symbol definition

Find path for an object

Applies fix edits.

Retrieves fix proposals.

Release every lock this server holds on the destination (or one objectUrl). With dropSession=true also drops the SAP session afterwards, which frees locks whose handles are already invalid. Use after failed writes left objects locked.

Retrieves fragment mappings.

Read a DDIC data element: type (domain or built-in), length, field labels (short/medium/long/heading), search help and flags. Pass the data element URL (/sap/bc/adt/ddic/dataelements/zde).

Read a DDIC domain: data type, length, decimals, output settings and fixed values / value table. Pass the domain URL (/sap/bc/adt/ddic/domains/zdom) and optionally version=inactive.

Source of one method of a class (METHOD … ENDMETHOD block with its line range) instead of the whole class. Pass the class name or URL and the method name (interface methods as if_x~m). include selects main (default: definition and implementations), implementations (local classes), testclasses, definitions or macros. When the method is not found, the methods present in that include are listed.

Retrieves source code for ABAP objects. Omit startLine/maxLines to get as much as fits the response budget (about 40,000 characters, several hundred lines); larger sources are paged automatically and report hasMore, then continue with startLine. Pass version=inactive to see what you wrote before activating.

Read the text elements of an object: text symbols (TEXT-001), selection texts or list headings. Pass the object URL (e.g. /sap/bc/adt/programs/programs/zreport or /sap/bc/adt/oo/classes/zcl_demo).

Retrieves a specific transport configuration.

Creates a new Git repository.

Retrieves information about an external Git repository.

Pulls changes from a Git repository. For repos with many changed objects, use startIndex/maxItems to page through the list of imported/changed objects returned in the response instead of retrieving it all at once.

Retrieves a list of Git repositories.

Unlinks a Git repository.

Client-side grep over the sources of a package (classes, interfaces, programs, includes, CDS, behavior definitions, service definitions, function modules): downloads each source once (cached), applies the pattern and returns matches with line numbers and context. Works on every system, including S/4HANA Cloud. Bounded by maxObjects/maxMatches; recursive=true descends into sub-packages.

Check if transport configuration exists

Check server health and list configured destinations.

Get list of inactive objects. For systems with many inactive objects across users, use startIndex/maxItems to page through the list instead of retrieving it all at once.

Checks if a given object is a proposal message.

List the ADT locks this server currently holds on the destination (object, lockHandle, when, whether acquired automatically). Use it when a write fails with a lock/lockHandle error or before forceUnlock.

List the configured ABAP systems (destinations) this server can reach. Call this first to pick the destination to pass to all other tools.

List the ABAP object types creatable on this system (version-aware). Use BEFORE createObject to pick a valid objtype value such as CLAS/OC. For the raw ADT type catalog see objectTypes.

Lock an ABAP object for editing and keep the lock across calls. Returns the lockHandle; the server also records it, so setObjectSource/editObjectSource/deleteObject/createTestInclude/atcApplyQuickfix on the same object may omit lockHandle while it is held. Not needed for a single write: those tools lock and unlock by themselves when no lock is held. Always unLock when done.

Authenticate with ABAP system

Terminate ABAP session

Retrieves the main programs for a given include.

Retrieves the contents of a node in the ABAP repository tree. For large packages/namespaces, use startIndex/maxItems to page through the node list instead of retrieving it all at once.

Unified diff between two revisions of an object (default: latest against the previous one). Revisions are selected by index in the list returned by revisions (0 = newest), by version string, or by revision URI. Use it to review what a transport or a colleague changed before touching the object.

Enhancement implementations (implicit/explicit enhancement points, BAdI-free source enhancements) active on an ABAP source object, with optional source of each implementation. Use before editing standard-adjacent code to see what customer enhancements already hook in.

Get registration information for an ABAP object

Get object structure details. For large/complex objects (e.g. classes with many includes), use startIndex/maxItems to page through the structure's top-level array instead of retrieving it all at once.

Flat list of the members (methods, attributes, events, types, fields…) of an object with name, type, visibility and flags, cheaper than objectStructure/classComponents when you only need an outline. version=inactive reads the inactive version.

Retrieve the ADT object type catalog reported by the system. For picking an objtype to pass to createObject, prefer loadTypes (creatable types).

Performs a package search help.

Package hierarchy with its objects in one call: sub-packages (to maxDepth) and, per package, the objects with name, type, URL and description. Cheaper than repeated nodeContents calls; use objectTypes to keep only e.g. CLAS/OC,DDLS/DF.

Formats ABAP code using the pretty printer. For large sources, use startLine/maxLines to page through the reformatted result instead of retrieving it all at once.

Retrieves the pretty printer settings.

Publishes a service binding.

Pushes changes to a Git repository.

Generate the RAP repository objects (CDS views, behavior definition, service definition/binding) on the system. Requires a transport (createTransport). Validate with rapGenValidateContent and inspect rapGenPreview first. Activate the generated objects afterwards with activateObjects.

Get the proposed default generator content (names for CDS entities, behavior class, service definition/binding) for a reference object. Adjust and pass to rapGenValidateContent / rapGenGenerate.

Get the JSON schema describing the input content of a RAP generator. Use it to build the content for rapGenValidateContent / rapGenPreview / rapGenGenerate.

Check whether RAP repository-object generators are available on this system. Call before the other rapGen* tools.

Preview the list of repository objects a generation would create (CDS views, behavior definition, service definition/binding) without creating anything.

Publish a generated service binding so its OData service becomes callable (alternative to publishServiceBinding for rapGen-created bindings).

Validate a full generator content (names, package, conflicts) BEFORE generating. Recommended flow: rapGenGetContent -> adjust -> rapGenValidateContent -> rapGenPreview -> rapGenGenerate.

Validate that generation can start from the given reference object and package (run before rapGenGetContent).

Retrieves an SAP reentrance ticket. WARNING: the ticket is a live logon credential and will appear in the conversation/host logs. Disabled unless the server is started with SAP_ALLOW_REENTRANCE_TICKET=1.

Retrieves information about a remote Git repository.

Evaluates a rename refactoring.

Executes a rename refactoring.

Previews a rename refactoring.

Decide which transport request to use for changing an object, in one call: (1) the transport that already records/locks the object, else (2) the newest modifiable transport of the current user for that package, else (3) none for local ($TMP / non-recording) packages, else (4) create one when createIfMissing=true. Returns {transport, needsTransport, reason, candidates}. Call before lock/setObjectSource/createObject instead of interpreting transportInfo yourself.

Retrieves revisions for an object.

Runs a class.

Description is built at runtime.

Run a piece of ABAP once and return its console output: wraps the code in a temporary IF_OO_ADT_CLASSRUN class (the "out" parameter is available: out->write( ... )), creates it in packageName (default $TMP; on S/4HANA Cloud use a customer package with ABAP for Cloud Development plus its transport, $TMP is refused there), activates, runs it, and deletes it again unless keep=true. A full CLASS … DEFINITION/IMPLEMENTATION implementing if_oo_adt_classrun is accepted as well. Activation errors are returned with messages instead of running. Pass responsible (your SAP user) on cloud systems. Needs de…

Search for objects

Write a DDIC data element (type, field labels, search help…). Read it first with getDataElementProperties, modify the returned properties/metaData objects and pass them back as JSON. Requires lock (lockHandle) and a transport for transportable packages; activate afterwards with activateByName.

Write a DDIC domain (type, length, fixed values, value table…). Read it first with getDomainProperties, modify the returned properties/metaData objects and pass them back as JSON. Requires lock (lockHandle) and a transport for transportable packages; activate afterwards with activateByName.

Replace one method of a class without touching the rest: re-reads the include from SAP, swaps the METHOD … ENDMETHOD block (pass the full block, or only the body to keep the existing header/footer), writes it back under an automatic lock and optionally activates. Use for focused fixes in large classes.

Write the full source code of an ABAP object. Locks, writes and unlocks in one call when no lockHandle is given (pass activate=true to also activate); pass a lockHandle from lock only when you hold the lock across several calls. Run syntaxCheckCode before writing to catch errors early. For a targeted change to a large object, prefer editObjectSource (unique text anchors) or setMethodSource instead of resending the full source, and objectDiff afterwards to review. Message classes (/sap/bc/adt/messageclass/<name>) are written as the whole ADT XML: every message lands in the transport and masterL…

Sets the pretty printer settings.

Write text elements (text symbols, selection texts or list headings) of a locked object. Pass the full list for the category: elements missing from the list are removed. Requires lock (lockHandle) and, for transportable packages, a transport. Not available where ADT has no text element resources (SAP_BASIS 7.40 and 7.53, for example): the tool reports it and writes nothing.

Sets transport configurations.

Search source code by content using the ADT repository text search index (server-side, fast). Returns matching objects with line and snippet when the backend provides them. Restrict with packages/objectTypes/objectName. Use this before reading whole sources when you need to find where a table, message, method or literal is used. If the backend has no text search (older releases), the call falls back to grepPackage when packages are given.

Stages changes in a Git repository. For a large initial package push, use startIndex/maxItems to page through the staged/unstaged/ignored object lists instead of retrieving them all at once.

Switches the branch of a Git repository.

Perform ABAP syntax check with CDS URL

ABAP syntax check of a source against the context of an existing object: url is the source URL of that object (…/source/main), required because the check resolves types and includes in its context; it is not a standalone check of free text. Provide the source in "code" (alias: source), or omit it to reuse the source last read/written for "url" this session. Returns line, offset, severity and text per finding. To try free ABAP without an object, use runSnippet on a development system.

Retrieves syntax check types.

Capability profile of a destination: platform (S/4HANA Cloud vs on-prem), system information, which ADT features the backend exposes (debugger, traces, abapGit, ATC, RAP generator, text search, API releases…) and therefore which toolsets/tools will not work there. Cached per destination; pass refresh=true to rebuild. Call it once before using debugger/traces/abapGit/RAP tools on an unfamiliar system.

Retrieves a list of system users. For large results, use startIndex/maxItems to page through the user list instead of retrieving it all at once.

Description is built at runtime.

Creates a trace configuration.

Retrieves database access information for a trace. For many DB accesses, use startIndex/maxItems to page through the access list instead of retrieving it all at once.

Deletes a trace.

Deletes a trace configuration.

Retrieves the hit list for a trace. For a large hit list, use startIndex/maxItems to page through the entries instead of retrieving them all at once.

Retrieves a list of traces.

Retrieves a list of trace requests.

Sets trace parameters.

Retrieves statements for a trace. For many statements, use startIndex/maxItems to page through the statement list instead of retrieving it all at once.

Adds a user to a transport.

Retrieves transport configurations.

Deletes a transport.

Get the contents of a transport request: tasks, owners, status and the full list of objects it records. Use transportInfo / userTransports to find transport numbers first.

Get transport information for an object source

Retrieves a transport reference.

Releases a transport.

Retrieves transports by configuration. For large results (many transports/tasks), use startIndex/maxItems to page through the flattened list of transport requests instead of retrieving them all at once.

Sets the owner of a transport.

Generate a unified diff of the source-code objects recorded on a transport request: for each object it compares the version predating the transport against the current source. Covers whole objects (R3TR CLAS/PROG/INTF/FUGR/DDLS/BDEF/DCLS/DDLX/SRVD) and sub-objects (LIMU CINC class includes such as the CCIMP of a RAP behavior pool, METH/CLSD/CPUB/CPRO/CPRI class parts, REPS includes, FUNC function modules). Messages (LIMU MESS), DDIC and customizing entries have no source history and are listed in skipped with the reason.

Type hierarchy (subtypes or supertypes) of the class/interface at a given source position. Pass the source URL (…/source/main) and the 1-based line/column of the type name; the current source is re-read from SAP unless you pass it in "source". superTypes=true lists the inheritance chain upwards, false (default) lists implementers/subclasses.

Evaluates unit test results. For large results (many test methods), use startIndex/maxItems to page through the top-level test-method list instead of retrieving it all at once.

Retrieves unit test occurrence markers.

Run ABAP unit tests for an object. ALWAYS run after adding tests or changing and activating source code. Tests live in the testclass include (see createTestInclude). For large results (many test classes), use startIndex/maxItems to page through the top-level test-class list.

Unlock an ABAP object previously locked with lock (requires its lockHandle).

Unpublishes a service binding.

Find symbol references (system-wide "where used"). For widely-used symbols this can return hundreds/thousands of hits; use startIndex/maxItems to page through the result instead of retrieving it all at once.

Retrieves usage reference snippets (source excerpts) for a list of usage references, e.g. from usageReferences. For large input lists the returned snippets can be large; use startIndex/maxItems to page through the result instead of retrieving it all at once.

Retrieves transports for a user. For large results (many transports/tasks), use startIndex/maxItems to page through the flattened list of transport requests instead of retrieving them all at once.

Validate name, package and type for a new ABAP object BEFORE calling createObject. Returns field-level validation errors. Use loadTypes to discover valid objtype values first.

Where-used list by object name: resolves the name with searchObject and returns the usage references (using object, its URL, kind of usage). No URL or source position needed.