abap-mcp

# abap-mcp

[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_abap--mcp-0098FF?logo=githubcopilot&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=abap-mcp&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22abap-mcp%22%5D%7D)
[![Install in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Install-24bfa5?logo=githubcopilot&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=abap-mcp&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22abap-mcp%22%5D%7D&quality=insiders)
[![npm](https://img.shields.io/npm/v/abap-mcp?logo=npm)](https://www.npmjs.com/package/abap-mcp)

**Make your AI coding agent an expert SAP ABAP & RAP consultant — local by default. No SAP
system, no credentials, one command to install.**

abap-mcp is a [Model Context Protocol](https://modelcontextprotocol.io) server that gives any AI
coding agent — Claude Code, GitHub Copilot, Cursor, Codex, Windsurf — real ABAP senses, built on
[abaplint](https://abaplint.org) (the open-source ABAP parser/linter). The agent brings the
reasoning; abap-mcp brings ground truth: a deterministic parser, objective scores, and validated
generators that keep the AI honest. It works on ABAP source wherever your agent works — a git
checkout, an abapGit export, a code review, CI — long before anything reaches a system.

- **New to ABAP or RAP?** Your agent becomes the senior consultant looking over your shoulder:
  every snippet linted against Clean ABAP as you write (`lint_abap`), every finding explained with
  its rationale and examples (`explain_abap_rule`), and `scaffold_rap_bo` starts you from a
  canonical, self-validated RAP business object instead of a blank editor.
- **Senior ABAP consultant?** It's your assessment and task engine: point your agent at a repo and
  get a scored, categorized ABAP Cloud readiness report with an A–D tech-debt grade
  (`check_cloud_readiness`), a phased migration backlog with efforts and exit criteria
  (`plan_cloud_migration`), an objective before/after verdict on every rework (`compare_abap`),
  released-API replacements (`check_released_api`), and CI gates that hold the line while the
  migration proceeds.

The default stdio edition is 100% local: the analysis engine makes **zero network calls** and
reads **no user files**. Sources go in as text and structured findings come back. The released-API
list and abaplint rule data are package-bundled. An optional guarded Streamable HTTP edition makes
the same tools available to remote clients such as ChatGPT web; in that mode, source text is sent
to the machine you host. See [privacy and data handling](PRIVACY.md).

## Why this exists

Every other ABAP MCP server is either a **bridge to a live SAP system** (ADT/RFC — needs
credentials, a system, and trust) or a **documentation search**. But AI coding agents spend most
of their time where the *files* are — editing abapGit repos, reviewing diffs, generating code —
long before anything reaches a system. This server gives agents the missing feedback loop at that
layer:

- *"Does this ABAP parse? Is it clean? How does it perform?"* → `lint_abap` (+ focus packs)
- *"Fix this block automatically — casing, obsolete syntax."* → `fix_abap` (deterministic, parser-guaranteed)
- *"How far is this classic report from ABAP Cloud? Grade it."* → `check_cloud_readiness` (A–D)
- *"Plan the migration — what do we tackle first?"* → `plan_cloud_migration` (phased backlog)
- *"This class has no tests — start me a harness."* → `scaffold_abap_unit` (failing-by-default)
- *"What depends on what? Migrate which object first?"* → `get_object_dependencies` (+ Mermaid)
- *"Did this rework make the code better or worse?"* → `compare_abap`
- *"Is MARA a released API? What do I use instead?"* → `check_released_api`
- *"Start me a correct RAP business object."* → `scaffold_rap_bo`
- *"What's in this 4,000-line class? Draw it."* → `get_abap_outline` (+ Mermaid)

## Install — 60 seconds

The only requirement is [Node.js 20+](https://nodejs.org). No SAP system, no credentials, no
API keys. **New to AI tooling (or ABAP)?** Follow the from-zero walkthrough in
**[docs/INSTALL.md](docs/INSTALL.md)** — or let the installer do it:

```bash
npx abap-mcp setup     # detects VS Code / Claude Code and registers the server; guides Eclipse
```

Otherwise, pick your client:

**Codex CLI · Codex IDE extension · ChatGPT desktop** — one command configures all three on the
same Codex host:

```bash
codex mcp add abap-mcp -- npx -y abap-mcp
```

Restart ChatGPT desktop or the IDE extension, then use `/mcp` to confirm `abap-mcp` is connected.
In ChatGPT desktop you can alternatively open **Settings → MCP servers → Add server**, choose
**STDIO**, and enter command `npx` with arguments `-y abap-mcp`.

**Codex plugin (MCP server + review/mentor/migration skills)**

```bash
codex plugin marketplace add palimkarakshay/abap-mcp
codex plugin add abap-mcp@abap-mcp
```

**ChatGPT web** cannot start a local `npx` process. It needs a deployed HTTPS `/mcp` endpoint or
a secure development tunnel. This repository ships the HTTP entry point and hardening controls,
but does not operate a public service. Follow the [OpenAI setup and self-hosting guide](docs/OPENAI.md).

**Claude Code**

```bash
claude mcp add abap-mcp -- npx -y abap-mcp
```

**VS Code (Copilot agent mode)** — one click on the *Install in VS Code* badge above, or one command:

```bash
code --add-mcp '{"name":"abap-mcp","command":"npx","args":["-y","abap-mcp"]}'
```

For a whole team, commit [`examples/vscode/mcp.json`](examples/vscode/mcp.json) as `.vscode/mcp.json`
in your abapGit repo — everyone who opens the folder gets the server offered automatically.

**Eclipse (via the GitHub Copilot plugin)** — Copilot Chat in Eclipse speaks MCP: open the
Copilot menu → *Edit preferences* → *MCP*, and add the same `"abap-mcp"` server block
(command `npx`, args `["-y", "abap-mcp"]`). Steps and prerequisites:
[GitHub's MCP docs, Eclipse tab](https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp?tool=eclipse).
Stock ADT without Copilot has no MCP client today.

**Cursor · Windsurf · any MCP client** — add this to its
`mcp.json` / `.mcp.json` (project or global):

```json
{
  "mcpServers": {
    "abap-mcp": { "command": "npx", "args": ["-y", "abap-mcp"] }
  }
}
```

**Claude Desktop** — Settings → Developer → Edit Config, add the same `mcpServers` block to
`claude_desktop_config.json`, restart.

**From a clone** (contributing / hacking):

```bash
npm install && npm run build
claude mcp add abap-mcp -- node /path/to/abap-mcp/dist/cli.js
```

Connected? Ask your agent *"list your ABAP tools"* — you should see all thirteen, `lint_abap`
through `get_abap_outline`.

### First things to ask

- *"Here's my functional spec — build the RAP implementation from it."* (or run `/mcp__abap-mcp__abap-from-spec`)
- *"Lint this class against ABAP Cloud and explain the worst finding like I'm new to ABAP."*
- *"How cloud-ready is this repo? Grade it and plan the migration in phases."*
- *"Is MARA a released API? What do I use instead?"*
- *"Scaffold a RAP BO for entity Booking on table zbooking, draft enabled."*
- *"I reworked zcl_pricing — compare old vs new: did it actually get better?"*

### Guided workflows built in (MCP prompts)

The consultant's playbook ships both as four MCP prompts and as four Codex plugin skills. In
Claude Code the prompts appear as slash commands (`/mcp__abap-mcp__…`); prompt-capable clients
list them natively, while the Codex plugin discovers the corresponding skills:

| Prompt | What it sets up |
| --- | --- |
| `abap-from-spec` | **The blank-page killer.** Hand it a functional/tech spec — or a plain-language requirement — and the agent builds working, validated modern ABAP/RAP: spec → build plan with an ASSUMPTION register → deterministic `scaffold_rap_bo` foundation → behavior logic → every file gated through `fix_abap` + `lint_abap` until clean → filled unit tests → delivery in activation order. Nothing unlinted is ever delivered. |
| `abap-review` | A full senior-consultant code review: lint → triage → explain each finding's *why* → minimal fixes → prove the rework with `compare_abap`. Optional `focus` (Performance / Security / Styleguide). |
| `abap-mentor` | Over-the-shoulder mentoring mode for the rest of the session: every snippet is quietly linted and readiness-checked, findings become plain-language guidance, new objects start from validated scaffolds. |
| `abap-migration-plan` | A client-ready phased migration plan driven by `plan_cloud_migration` — current state, phases with S/M/L efforts and exit criteria, released-API work separated — then offers to execute phase 1. |

## CLI — same engine, no AI required

Every tool is also a subcommand, so it works in terminals and CI where no MCP client exists:

```bash
npx abap-mcp lint src/                          # lint files or whole directories
npx abap-mcp fix src/ --write                   # apply abaplint's deterministic auto-fixes in place
npx abap-mcp lint src/ --focus Performance      # themed pass: Performance | Security | Styleguide
npx abap-mcp lint src/ --rules-file org.json    # your org's abaplint rule pack, same engine
npx abap-mcp readiness src/ --fail-below 80     # repo-level ABAP Cloud readiness, scored + graded A–D
npx abap-mcp plan src/                          # phased migration backlog: work items, S/M/L efforts, exit criteria
npx abap-mcp unittest src/ --out tests/         # failing-by-default ABAP Unit skeletons for untested classes
npx abap-mcp deps src/ --mermaid                # dependency graph (+released-API flags) as a Mermaid diagram
npx abap-mcp compare old/ new/                  # rework verdict: findings resolved/introduced, grade movement
npx abap-mcp scaffold --entity Travel --table ztravel --key travel_id --out ./out
npx abap-mcp outline src/zcl_monster.clas.abap  # navigate big objects (--mermaid for a diagram)
npx