Welcome to @sap/mdk-mcp-server

What is MCP server for Mobile Development Kit (MDK)?

This open-source server provides AI agents with comprehensive MDK knowledge and tools. By combining best practice guidelines, project-aware context information, templates for creating new projects, and access to the MDK CLI tools, the MDK MCP server transforms AI agents into MDK development experts.

What is Mobile Development Kit?

The mobile development kit is a powerful framework that enables developers to build cross-platform mobile applications using a metadata-driven approach. It is part of SAP Business Technology Platform and integrates tightly with SAP Mobile Services. Some of SAP’s larger and complex mobile apps are built using MDK. An example is SAP Service and Asset Manager.

Table of Contents

• Setup
• Available Tools
• Ingesting GitHub Knowledge (Advanced)
• Offline OData Querying (Advanced)
• Support, Feedback, Contributing
• Telemetry
• Security / Disclosure
• Code of Conduct
• Licensing
• Acknowledgments

Setup

Installation Steps

1. Install node.js 24.11.1.

2. To install the MDK MCP server, you have two options:

   a. Use npm to install it from the public npmjs registry at @sap/mdk-mcp-server.

   npm install -g @sap/mdk-mcp-server
   

   b. Clone the open-source code repository at https://github.com/SAP/mdk-mcp-server, and use npm to install.

   git clone https://github.com/SAP/mdk-mcp-server.git 
   cd mdk-mcp-server 
   npm i
   npm run build
   npm i -g @sap/mdk-mcp-server@. 
   

3. Configure your MCP client (AI agent) to connect to the server. Note that configuration will vary depending on the AI agent used.

   Cline in VS Code: Example using the Cline extension.

   • With Cline open, look below the prompt box and click Manage MCP Servers.
   • In the dialog, click Settings. The MCP Servers page opens.
   • Click Configure MCP Servers. This will open the cline_mcp_settings.json file in your editor.
   • In the JSON settings file, add a configuration block for MDK MCP server within the mcpServers section, and save the file. The supported schema versions include 26.6 (default), 26.3, 25.9, 25.6, 24.11, and 24.7.

   {
     "mcpServers": {
       "mdk-mcp": {
         "type": "stdio",
         "command": "mdk-mcp",
         "args": ["--schema-version", "26.6"]
       }
     }
   }
   

   Note:
   If the MCP server is not listed with its available tools in the Cline extension immediately, restart VS Code.

   Claude Code discovers MCP servers from its configuration.

   1. Open (or create) your Claude Code configuration file:

   ~/.claude.json
   

   2. Add the following MCP server configuration:

   {
     "mcp": {
       "mdk-mcp": {
         "type": "local",
         "command": [
           "mdk-mcp",
           "--schema-version",
           "26.6"
         ],
         "enabled": true
       }
     }
   }
   

   Note: If ~/.claude.json already exists, merge the mdk-mcp entry into the existing mcp section rather than replacing the entire file.

   3. Reload the VS Code window (or restart VS Code).

   Verify the installation

   Open the Claude Code panel in VS Code and run:

   /mcp
   

   You should see mdk-mcp listed as an available MCP server.

   An example using OpenCode:

   {
     "mcp": {
       "mdk-mcp": {
         "type": "local",
         "command": ["mdk-mcp", "--schema-version", "26.6"],
         "enabled": true
       }
     }
   }
   

   Edit the file ~/.cursor/mcp.json:

   {
     "mcpServers": {
       "mdk-mcp": {
         "command": "mdk-mcp",
         "args": ["--schema-version", "26.6"]
       }
     }
   }
   

   1. Find your Node.js installation path by running the terminal command:

      which node
      

      This might output something like /usr/local/bin/node or /opt/homebrew/bin/node.

   2. Edit ~/Library/Application Support/Claude/claude_desktop_config.json and update the command field to use the absolute path:

      {
        "mcpServers": {
          "mdk-mcp": {
            "command": "/usr/local/bin/node",
            "args": ["/usr/local/lib/node_modules/@sap/mdk-mcp-server/build/index.js", "--schema-version", "26.6"]
          }
        }
      }
      

   3. Restart Claude Desktop.

   Note: Adjust the paths based on your actual Node.js and MDK MCP server installation locations.

   Once configured, your AI agent will have access to the MDK MCP server. Depending on your IDE settings, you may need to approve initial tool calls.

4. Create a Rule File: To ensure your AI coding assistant uses the MCP servers appropriately for your project, define rules and guidelines in a file named AGENTS.md. In the Cline extension for VS Code, click the Manage Cline Rules & Workflows icon below the prompt box, click + to create a new rule file (e.g., AGENTS.md) and add the example rules shown below:

   - Do not generate `.service.metadata` file.
   - Do not generate `.xml` file in the `Services` folder.
   - Do not change `.project.json` file.
   

5. Verify your LLM Provider and AI model.

   When you add Cline to VS Code, it serves as the default API provider. You can choose a different LLM provider, such as SAP AI Core. To add an SAP AI Core API provider in the Cline extension for VS Code, follow these steps:

   • With Cline open, look below the prompt box and click Select Model / API Providers.
   • Choose your API provider (such as SAP AI Core) and enter your details. See the instructions here for a detailed setup.
   • Select your preferred AI model.

6. Integration with SAP Mobile Services: To create a new MDK application, the MCP server uses the Cloud Foundry CLI and a .service.metadata file containing:

   • The mobile application defined in the SAP Mobile Services instance.
     • Mobile Services API Endpoint
     • Mobile Services App ID
   • Mobile Destinations including OData service metadata.

   We include a tool to help with creating or updating this file as part of our VS Code extension: Mobile development kit extension for VS Code. This is how you can use this tool to create or update the .service.metadata file:

   1. Install the Mobile development kit extension for VS Code version 1.32.0 or later.
   2. Install the Cloud Foundry CLI.
   3. Log in to your SAP BTP Cloud Foundry environment. For more details you can refer to this help documentation.

   cf login -a <your target endpoint> --sso
   

   4. Create an empty folder on your machine and open it in VS Code.
   5. Open the Command Palette in VS Code and select MDK: Open Mobile App Editor.
   6. Create a new or select an existing mobile app.
   7. Select a destination.
   8. Click Add App to Project.

7. Your environment is now ready for the MDK development with MCP server. You can now enter a prompt to:

   • Generate a new MDK project displaying OData entities information.
   • Enhance an existing project by adding additional UI controls on a given page.
   • Validate your current MDK project schema.
   • Migrate old MDK projects to latest schema.
   • Deploy your MDK project.
   • Generate onboarding QR code.
   • Explain specific properties.
   • Find information about control properties or any aspect of the documentation.

Available Tools

[!NOTE] Tools are meant to be used by AI models and do not constitute a stable API.

This release of the MDK MCP server includes the following tools, which can be accessed by your AI agent:

Ingesting GitHub Knowledge (Advanced)

The MDK MCP server can ingest additional knowledge from GitHub repositories to enhance the search-samples operation. This allows the AI agent to search through MDK tutorial samples and code examples.

What Gets Ingested

By default, the server ingests knowledge from:

• MDK Tutorial Samples: https://github.com/SAP-samples/cloud-mdk-tutorial-samples
• MDK Sample and Showecase Apps: https://github.com/SAP-samples/cloud-mdk-samples

When to Run Ingestion

You typically only need to run ingestion in these scenarios:

• First-time setup (if you want to use search-samples operation)
• Updating knowledge base (when new samples are added to GitHub repositories)
• After cloning the repository (ingested data is not included in the repo)

Note: The ingestion process is optional. The server will work without it, but the search-samples operation will not return results until ingestion is completed.

How to Ingest

Basic ingestion (uses cached data if available):

npm run ingest

Fresh ingestion (ignores cache, re-downloads everything):

npm run ingest:fresh

With GitHub token (recommended for better rate limits):

export GITHUB_TOKEN="your_github_token_here"
npm run ingest

Custom options:

npm run build
node build/ingest-github-knowledge.js --no-cache --github-token "your_token" --chunk-size 800

Command Line Options

GitHub Token Setup

To avoid GitHub API rate limits, create a personal access token:

1. Go to https://github.com/settings/tokens
2. Click Generate new token (classic)
3. Select scopes: public_repo (read access to public repositories)
4. Copy the token and set it as an environment variable:

   export GITHUB_TOKEN="ghp_your_token_here"
   

Ingestion Output

The ingestion process will:

1. Fetch content from configured GitHub repositories
2. Chunk the content into manageable pieces
3. Generate embeddings using the AI model
4. Store embeddings in a vector database
5. Enable semantic search via the search-samples operation

Example output:

Fetching from MDK Tutorial Samples...
Chunking content: 150 chunks created
Generating embeddings: 150/150 (100%)
✓ Ingestion complete!

Troubleshooting

Issue: GitHub API rate limit exceeded

• Solution: Set up a GitHub token (see above)

Issue: Ingestion takes too long

• Solution: Use --no-cache only when necessary; cached runs are much faster

Issue: Out of memory

• Solution: Reduce --chunk-size or process fewer repositories

Offline OData Querying (Advanced)

The MDK MCP server can help you query offline OData stores using the ilodata command-line tool. This is useful for debugging offline applications or inspecting data stored locally on devices during development.

Prerequisites

1. MDK SDK
2. ilodata Tool: Extract from SAPOfflineOData-xx.xx.xx-Tools.zip in the MDK SDK
3. Offline Store Files: A pair of .udb and .rq.udb files from your offline application

Setup Steps

1. Extract the ilodata tool:

   # Download MDK SDK and locate the tools zip file
   unzip SAPOfflineOData-*.zip -d ~/ilodata-tools
   

2. Prepare your offline store files:

   # Copy your offline store files to the ilodata folder
   cp /path/to/your/app/*.udb ~/ilodata-tools/
   cp /path/to/your/app/*.rq.udb ~/ilodata-tools/
   

Querying Offline Stores

Once set up, you can use natural language prompts with the MDK MCP server to query offline stores:

Example Prompts:

Basic query:

Open and query the CustomerStore offline store located at ~/ilodata-tools/CustomerStore.udb 
and retrieve the top 5 entities from the Customers entity set

Filtered query:

Query the SalesOrders offline store at ~/ilodata-tools/SalesOrders.udb 
and get all orders where CustomerID equals `ALFKI`

Specific fields:

Open the Products offline store at ~/ilodata-tools/Products.udb 
and retrieve ProductID, ProductName, and UnitPrice from the Products entity set

Count entities:

Query the Employees offline store at ~/ilodata-tools/Employees.udb 
and count the total number of records in the Employees entity set

How It Works

The AI agent will:

1. Understand your natural language query
2. Construct the appropriate ilodata command
3. Execute the command against your offline store
4. Return the results in a readable format

Support, Feedback, Contributing

This project is open to feature requests/suggestions, bug reports, and so on, via GitHub issues. Contribution and feedback are encouraged and always welcome.

Contributing

These instructions help contributors set up, test, and maintain code quality for this project. All commands should be run from your project folder in a terminal.

• Test: npm test
• Build: npm run build
• Lint: npm run lint:all

For more information about how to contribute, the project structure, as well as additional contribution information, see our Contribution Guidelines.

Telemetry

You can enable or disable the collection of analytics. By default, non-personally identifiable information is collected to help understand how you use the product and improve the MDK MCP Server. If you want to opt-out, there are two ways to disable telemetry:

Method 1: Configuration File

Create or change the file ~/.fioritools/telemetrysettings.json:

{
  "telemetrysettings": {
    "telemetrySetting": {
      "enableTelemetry": false
    }
  }
}

Set enableTelemetry to false to disable telemetry collection.

Method 2: Environment Variable

Set the environment variable SAP_UX_FIORI_TOOLS_DISABLE_TELEMETRY to true:

export SAP_UX_FIORI_TOOLS_DISABLE_TELEMETRY=true

Setting this environment variable disables the telemetry client.

Security / Disclosure

If you find a bug that may pose a security problem, please follow our instructions in our security policy on how to report it. Please do not create GitHub issues for security-related doubts or problems.

Code of Conduct

As members, contributors, and leaders, we pledge to make participation in our community a harassment-free experience for everyone. By participating in this project, you agree to abide by its Code of Conduct at all times.

Licensing

Copyright 2025 SAP SE or an SAP affiliate company. Please see our LICENSE for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available .

Acknowledgments

• @huggingface/transformers.js is used to compare the output of the WordPiece tokenizer.
• @modelcontextprotocol/sdk provides the SDK for MCP.