sap-ai-mcp-servers is a directory that regenerates itself, not a server

A catalog of pointers rather than a program you run

The first thing to understand about marianfoo/sap-ai-mcp-servers is that it contains no server, no client and no integration code. It is a list. The project description calls it a complete list of SAP MCP Servers and SAP AI Skills, and the README frames the scope as open source or source-available repositories, primarily on GitHub but with non-GitHub git hosts such as Gitea and GitLab also accepted. The scope of what qualifies is narrower than that: SAP-related MCP servers, MCP SDKs, Claude plugins and skills, and adjacent SAP AI developer assets.

The reader it serves is a SAP developer who has just been handed a task such as generating a Fiori app or wiring an agent to SAP BTP and does not know which of a dozen possible servers exists. The reader it does not serve is someone looking for a dependency to add. The repository's own `package.json` makes that clear: the package is named `sap-mcp-list`, it is marked `private`, and its description is a generated overview. Nothing in it can be installed by a downstream project. What you get is a table of rows, each naming a project, its purpose, its license, a star count, a last change date, and a link that points somewhere else.

Validation, enrichment and rendering, wired as npm scripts

The interesting engineering sits in the `scripts/` folder, and the entry points are exposed as npm scripts in `package.json`. The pattern is that every public task runs the validator first, so a malformed data file fails before anything is written. The four scripts are:

  "scripts": {
    "validate:catalog": "node scripts/validate-catalog.mjs",
    "update:data": "npm run validate:catalog && node scripts/enrich-data.mjs",
    "build:readme": "npm run validate:catalog && node scripts/render-readme.mjs",
    "build": "npm run validate:catalog && node scripts/enrich-data.mjs && node scripts/render-readme.mjs"
  }

The pieces map onto the repository layout. `data/` holds the catalog entries, `templates/` holds the rendering templates, `generated/` holds the produced output, and the static site lives in `index.html` with `sitemap.xml`, `robots.txt` and a `CNAME` file for the custom domain. The full `build` task validates, then enriches, then renders the README, which is why the README is described as generated rather than hand written. There is also an `AGENTS.md` at the top level, so the repository is itself written with an agent oriented workflow in mind, and a `CHANGELOG.md` that records the dates on which entries were added to the list. Since the npm package is private, the scripts are run from a clone rather than pulled from a registry.

Inclusion rules that quietly shape what you see

The scope notes in the README are the part worth reading carefully, because a directory is only as useful as its admission rules. Entries must be open source or source-available, must relate to SAP, and forks are excluded automatically from the rendered tables. That last rule is a curation decision rather than a technical one, and it means a fork of an official server will never surface, no matter how much traffic it carries.

The metadata treatment is uneven, and the project is upfront about it. Entries on GitHub get auto-fetched metadata, which is where the star counts, license and last change date in the tables come from. Entries hosted elsewhere are listed without that data, so their rows are thinner. The README also states a generation date, and in the version described here it was last generated on 2026-10-20.

For a reader, the practical consequence is that a missing license field is a statement about the metadata pipeline rather than a verdict on the project, and a row with dashes in the last change column tells you nothing about activity. If a project matters to you, the catalog is a starting point for discovery, not the last word on it.

Eight community categories that mirror how SAP work splits

The navigation in the README is a taxonomy, and it is the most transferable part of this project. Official SAP entries sit at the top, split into MCP servers on one side and AI skills with Claude plugins on the other. The community MCP servers are then grouped into eight buckets: ABAP and ADT, SAP Docs and Knowledge, OData, Gateway and Graph, SAP Integration for CPI and PI, Data, Analytics and HANA, SAP GUI Automation, Operations, Monitoring and Lifecycle, and Business Apps, Security and Governance.

That last pair of buckets is the reason the list is more than a keyword index. A developer automating a GUI has a completely different risk profile from one wiring an OData service, and a governance reviewer scanning for what touches the business layer reads a different section than a Fiori developer. Below the community servers, the list continues with community SAP AI skills and Claude plugins, then a final group of libraries, SDKs and adjacent tools.

The same structure carries into the web UI at the project homepage, which the README describes as offering search, filters, sorting, package type colors, repository activity signals and mobile friendly browsing. Since the README is generated, a reader working in a terminal and a reader on a phone are looking at the same underlying data, reached by different routes.

Three official entries are documentation links, not repositories

The official SAP server table is where the catalog's honesty shows. Most rows point at a GitHub repository under an SAP organization: the SAP Fiori MCP Server for Fiori app generation and modification workflows, the CAP MCP Server for AI assisted CAP development with CDS aware context, the UI5 MCP Server for OpenUI5 and SAPUI5 work, the SAP MDK MCP Server for mobile workflows, and the UI5 Web Components MCP Server for component API, guidelines and documentation. Those five rows carry an Apache-2.0 license and a last change date.

The remaining three rows point somewhere else entirely. The ADT MCP Server entry resolves to an SAP Help Portal page about enabling ADT capabilities in ABAP Development Tools for VS Code. The MCP Server for SAP BTP Administration resolves to a Help Portal page for account administration through MCP servers, and the SAP LeanIX MCP Server entry resolves to a Help Portal page describing a hosted server that exposes enterprise architecture data such as inventory, automations, calculations and custom reports.

All three are recorded as NO LICENSE FOUND, and that is the single most important practical detail in the table. A hosted service and a documentation page are not open source code, so a team that treats the catalog as a list of adoptable components will hit a wall exactly where the SAP branding is most prominent.

The Packages column separates skill packs from Claude plugins

The skills and plugins table carries a column the server tables do not have. It is called Packages, and it records what each repository actually ships: a skill pack, a Claude Code plugin, or both. The distinction matters because the two are installed and consumed in different ways, and a row that only says Skill cannot be dropped into a Claude Code setup.

The entries show the range. The UI5 Web Components Agent Skills repository ships a Skill covering accessibility topics such as ARIA, keyboard handling and screen readers, plus styling through CSS shadow parts, custom states and variables. The SAP AI Skills Library is described as an SAP maintained library of skills for digital assistants that can be discovered, searched, filtered and installed through a skills CLI. The UI5 Plugins for Coding Agents repository ships a Claude Plugin for project creation, UI5 error fixing and framework guidance. CAP Skills from capire ships both, a Skill and a Claude Plugin, for building and maintaining SAP Cloud Application Programming Model applications.

Two more entries stretch the range. SAP Automation Pilot Agent Skills targets generating, reviewing, debugging and managing Automation Pilot commands, executors, schedules and MCP servers through the Automation Pilot content and executions APIs. SAP LeanIX AI Plugins combines a Skill and a Claude Plugin, and works through the LeanIX MCP server to build and debug enterprise architecture automations and calculations. Most of these rows show a last change date inside the recent window, while the SAP Joule A2A Agent Toolkit row shows 2026-04-21, which tells you the entry has not been refreshed as often as the rest.

A GitHub token speeds up enrichment, and scraping covers for it

Enrichment is where the catalog reaches out to the network, and the mechanism is disclosed in `.env.example`. A token is optional. When one is present, it is used for GitHub API enrichment, and the file recommends a classic personal access token with at least public repository read access. The example value in the file is a placeholder, `GH_TOKEN=ghp_your_token_here`.

GH_TOKEN=ghp_your_token_here

If no token is set, the script falls back to HTML scraping. That fallback is the part to think about before running the enrichment step yourself. Scraping a public page is slower, more fragile against layout changes, and it invites the question of what an unthrottled scraping run against the API does to a personal account's rate limit. The catalog itself is the product, and the project is generated with a stated last generation date, so the usual path is to read the published output rather than to regenerate it.

The license situation is split in two ways worth keeping straight. The catalog repository is MIT licensed, which covers the list, the data files and the scripts. The projects it points at carry their own terms, and the table records them, mostly Apache-2.0 for the official SAP repositories. Mixed licensing is normal in a directory like this, and the license column is the only place the two get compared, so it is worth reading row by row rather than assuming one rule applies to everything.

Editorial conclusion

Adopt sap-ai-mcp-servers if your job is finding the right SAP MCP server or agent skill for a task and you want one place to see which repositories exist. Skip it if you need a running server, a pinned dependency or a supported integration, since nothing here is installable on its own. Before you trust a single row, open the linked repository and check its license yourself, because the three official entries that resolve to SAP Help Portal pages are recorded as NO LICENSE FOUND, and the enrichment step leaves non-GitHub hosts without stars, license or last change.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. marianfoo/sap-ai-mcp-servers on GitHub
4. Project website
5. README