SAP Cloud Application Programming Model (CAP) development skill using Capire documentation. Use when: building CAP applications, defining CDS models, implementing services, working with SAP...
Use this skill when creating CAP projects, modeling CDS entities/services, implementing Node.js or Java event handlers, configuring HANA/SQLite/PostgreSQL persistence, deploying to BTP Cloud Foundry or Kyma, adding Fiori UIs, configuring authorization/multitenancy/messaging, or using CAP MCP/LSP tooling.
| Issue | First check |
|---|---|
cds watch or cds serve fails |
Verify @sap/cds-dk, Node.js version, and project package.json scripts. |
| Entity/service not found | Use CAP MCP search_model when available, then inspect db/ and srv/ CDS files. |
| HANA deployment fails | Check HDI service binding, mta.yaml, and the HANA deployment references. |
| Authorization behaves unexpectedly | Review @requires, @restrict, XSUAA/IAS bindings, and user role mappings. |
# Use an approved CAP toolchain:
# - project-local devDependencies
# - user-local npm prefix
# - enterprise-managed Node/CAP installation
# Ensure cds and optional cds-lsp commands are on PATH.
cds --version
# Create new project
cds init <project-name>
cds init <project-name> --add sample,hana
# Start development server with live reload
cds watch
# Add capabilities
cds add hana # SAP HANA database
cds add sqlite # SQLite for development
cds add xsuaa # Authentication
cds add mta # Cloud Foundry deployment
cds add multitenancy # SaaS multitenancy
cds add typescript # TypeScript support
using { cuid, managed } from '@sap/cds/common';
namespace my.bookshop;
entity Books : cuid, managed {
title : String(111) not null;
author : Association to Authors;
stock : Integer;
price : Decimal(9,2);
}
entity Authors : cuid, managed {
name : String(111);
books : Association to many Books on books.author = $self;
}
using { my.bookshop as my } from '../db/schema';
service CatalogService @(path: '/browse') {
@readonly entity Books as projection on my.Books;
@readonly entity Authors as projection on my.Authors;
@requires: 'authenticated-user'
action submitOrder(book: Books:ID, quantity: Integer) returns String;
}
This skill integrates with the official CAP MCP (Model Context Protocol) server, providing AI agents with live access to your project's compiled CDS model and CAP documentation.
Available MCP Tools:
search_model - Fuzzy search for CDS entities, services, actions, and relationships in your compiled CSN modelsearch_docs - Semantic search through CAP documentation for syntax, patterns, and best practicesKey Benefits:
Setup: See MCP Integration Guide for configuration with Claude Code, opencode, or GitHub Copilot. MCP package pins are governed by sap-dependency-security and validated by npm run validate:mcp-security.
Use Cases: See MCP Use Cases for illustrative local workflow examples and planning assumptions, not repository-verified ROI.
Agent Integration: The specialized agents (cap-cds-modeler, cap-service-developer, cap-project-architect, cap-performance-debugger) automatically use these MCP tools as part of their workflows.
Use MCP first for local model and docs questions, then fall back to direct file search when MCP is unavailable. Use rg -n "<entity|service|aspect|annotation|handler|cds compile|deployment>" references/*.md srv db app to locate the narrowest reference before loading long CAP guides.
references/mcp-integration.md for MCP configuration and package pin checks.references/mcp-use-cases.md only for workflow selection and illustrative impact examples..lsp.json as a Claude-compatible sidecar for CAP editor integration; other harnesses should not assume it is auto-loaded.node <sap-cap-capire-plugin-root>/lsp/cds-lsp-launcher.mjs --stdio. This still requires @sap/cds-lsp to be installed through an approved project-local devDependency, user-local npm prefix, or enterprise-managed toolchain, with cds-lsp available on PATH.rg, and CAP CLI checks directly.project/
├── app/ # UI content (Fiori, UI5)
├── srv/ # Service definitions (.cds, .js/.ts)
├── db/ # Data models and schema
│ ├── schema.cds # Entity definitions
│ └── data/ # CSV seed data
├── package.json # Dependencies and CDS config
└── .cdsrc.json # CDS configuration (optional)
| CDS Type | SQL Mapping | Common Use |
|---|---|---|
UUID |
NVARCHAR(36) | Primary keys |
String(n) |
NVARCHAR(n) | Text fields |
Integer |
INTEGER | Whole numbers |
Decimal(p,s) |
DECIMAL(p,s) | Monetary values |
Boolean |
BOOLEAN | True/false |
Date |
DATE | Calendar dates |
Timestamp |
TIMESTAMP | Date/time |
using { cuid, managed, temporal } from '@sap/cds/common';
// cuid = UUID key
// managed = createdAt, createdBy, modifiedAt, modifiedBy
// temporal = validFrom, validTo
// srv/cat-service.js
module.exports = class CatalogService extends cds.ApplicationService {
init() {
const { Books } = this.entities;
// Before handlers - validation
this.before('CREATE', Books, req => {
if (!req.data.title) req.error(400, 'Title required');
});
// On handlers - custom logic
this.on('submitOrder', async req => {
const { book, quantity } = req.data;
// Custom business logic
return { success: true };
});
return super.init();
}
}
const { Books } = cds.entities;
// SELECT with conditions
const books = await SELECT.from(Books)
.where({ stock: { '>': 0 } })
.orderBy('title');
// INSERT
await INSERT.into(Books)
.entries({ title: 'New Book', stock: 10 });
// UPDATE
await UPDATE(Books, bookId)
.set({ stock: { '-=': 1 } });
CAP applications integrate with SAP AI Core via the SAP Cloud SDK for AI. The recommended pattern uses the Orchestration Service through CAP event handlers, with all credential management handled by BTP service bindings.
resources:
- name: my-ai-core
type: org.cloudfoundry.managed-service
parameters:
service: aicore
service-plan: extended
cds bind -2 <AICORE_INSTANCE> && cds-tsx watch --profile hybrid
import { OrchestrationClient } from '@sap-ai-sdk/orchestration';
module.exports = class AnalysisService extends cds.ApplicationService {
async init() {
const { Feedback } = this.entities;
this.on('analyzeFeedback', async (req) => {
const userText = req.data.text;
const client = new OrchestrationClient({
promptTemplating: {
model: { name: 'gpt-4o' },
prompt: [
{ role: 'system', content: 'Categorize feedback as JSON: sentiment, category, urgency.' },
{ role: 'user', content: '{{?userText}}' }
]
}
});
const response = await client.chatCompletion({
placeholderValues: { userText }
});
const aiResult = response.getContent();
await INSERT.into('FeedbackResults').entries({
originalText: userText,
analysisJson: aiResult
});
return aiResult;
});
return super.init();
}
};
LLM calls can take 30-60 seconds. Never process them synchronously in production — the BTP load balancer will timeout before the LLM responds.
this.on('analyzeFeedback', async (req) => {
const id = await INSERT.into('FeedbackResults').entries({
originalText: req.data.text,
status: 'processing'
});
cds.spawn(() => processWithLLM(id, req.data.text));
return req.reply(202, { id, status: 'processing' });
});
async function processWithLLM(id, text) {
const response = await client.chatCompletion({
placeholderValues: { userText: text }
});
await UPDATE('FeedbackResults', id).set({
analysisJson: response.getContent(),
status: 'completed'
});
}
entity Documents {
key id : UUID;
content : String(5000);
embedding : Vector(1536);
}
Use this with the HANA Cloud Vector Engine and AI Core orchestration grounding to build RAG scenarios directly in your CAP data model.
Do not hardcode prompts in event handlers. Store them in JSON files or a CDS configuration entity so they can be updated without redeployment:
entity PromptTemplates {
key id : UUID;
name : String(100);
systemPrompt : LargeString;
updatedBy : String;
modifiedAt : Timestamp;
}
Node.js containers with AI SDK processing large text payloads require at least 512MB memory in the MTA descriptor. The AI SDK and JSON payload handling consume more memory than typical CAP services.
For complete SDK documentation, see sap-cloud-sdk-ai skill. For AI Core platform setup and orchestration configuration, see sap-ai-core skill.
// package.json
{
"cds": {
"requires": {
"db": {
"[development]": {
"kind": "sqlite",
"credentials": { "url": ":memory:" }
},
"[production]": { "kind": "hana" }
}
}
}
}
cds add hana
cds deploy --to hana
db/data/my.bookshop-Books.csv<namespace>-<EntityName>.csv# Add CF deployment support
cds add hana,xsuaa,mta,approuter
# Build and deploy
npm install --package-lock-only
mbt build
cf deploy mta_archives/<project>_<version>.mtar
cds add multitenancy
Configuration:
{
"cds": {
"requires": {
"multitenancy": true
}
}
}
// Service-level
@requires: 'authenticated-user'
service CatalogService { ... }
// Entity-level
@restrict: [
{ grant: 'READ' },
{ grant: 'WRITE', to: 'admin' }
]
entity Books { ... }
cds init [name] # Create project
cds add <feature> # Add capability
cds watch # Dev server with live reload
cds serve # Start server
cds compile <model> # Compile CDS to CSN/SQL/EDMX
cds deploy --to hana # Deploy to HANA
cds build # Build for deployment
cds env # Show configuration
cds repl # Interactive REPL
cds version # Show version info
cuid and managed aspects from @sap/cds/commondb/, services in srv/, UI in app/