Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
secondsky avatar

Sap Cap Capire

secondsky/sap-skills

  • 666 installs
  • 399 repo stars
  • Updated August 4, 2026
  • secondsky/sap-skills

sap-cap-capire is a Claude Code skill that guides SAP Cloud Application Programming Model development with CDS models, OData services, and CAPire patterns for developers who extend SAP BTP cloud applications.

About

sap-cap-capire is a Claude Code skill from secondsky/sap-skills for building production-ready SAP BTP cloud applications with the Cloud Application Programming Model. It covers CAP CDS domain models, OData service exposure, and Node.js or Java service handlers aligned with CAPire reference patterns. Developers reach for sap-cap-capire when extending S/4HANA or SAP BTP solutions that need typed entities, event handlers, and enterprise-grade API contracts instead of ad hoc REST endpoints. The skill targets teams shipping OData-backed microservices and side-by-side extensions on SAP's managed cloud stack.

  • CDS domain modeling
  • OData service exposure
  • Node.js and Java CAP runtimes
  • BTP Cloud Foundry deployment
  • CAPire reference patterns

Sap Cap Capire by the numbers

  • 666 all-time installs (skills.sh)
  • +52 installs in the week ending Aug 5, 2026 (Skillselion tracking)
  • Ranked #554 of 4,347 Backend & APIs skills by installs in the Skillselion catalog
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/secondsky/sap-skills --skill sap-cap-capire

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs666
repo stars★ 399
Last updatedAugust 4, 2026
Repositorysecondsky/sap-skills ↗

How do you build SAP CAP OData services on BTP?

Build SAP BTP cloud apps with CAP CDS models, OData services, Node/Java handlers, and CAPire patterns for production-ready enterprise extensions.

Who is it for?

Enterprise developers extending SAP S/4HANA or SAP BTP with CAP-based OData services who need CDS modeling and CAPire-aligned handler patterns.

Skip if: Greenfield non-SAP web apps, frontend-only React work, or teams without SAP BTP tenant access and CAP toolchain familiarity.

When should I use this skill?

A developer is scaffolding or extending a SAP CAP project with CDS models, OData endpoints, or CAPire service handlers on SAP BTP.

What you get

CAP CDS models, OData service definitions, and production-oriented Node.js or Java handler implementations for SAP BTP extensions.

  • CDS models
  • OData service definitions
  • CAP handler code

Files

SKILL.mdMarkdownGitHub ↗

SAP CAP-Capire Development Skill

Related Skills

  • sap-fiori-tools: Use for UI layer development, Fiori Elements integration, and frontend application generation
  • sapui5: Use for custom UI development, advanced UI patterns, and freestyle application building
  • sap-btp-cloud-platform: Use for deployment options, Cloud Foundry/Kyma configuration, and BTP service integration
  • sap-hana-cli: Use for database management, schema inspection, and HDI container administration
  • sap-abap: Use for ABAP system integration, external service consumption, and SAP extensions
  • sap-btp-best-practices: Use for production deployment patterns and architectural guidance
  • sap-ai-core: Use when adding AI capabilities to CAP applications or integrating with SAP AI services
  • sap-cloud-sdk-ai: Use for SDK-level AI integration (chat completion, streaming, tool calling) in CAP event handlers
  • sap-cloud-sdk-ai-python: Use for Python-based AI integration with CAP Java or standalone BTP services
  • sap-api-style: Use when documenting CAP OData services or following API documentation standards
  • sap-dependency-security: Use for secure dependency, lockfile, supply-chain, and exact MCP server pin controls in CAP service repos

When to Use This Skill

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.

Common Issues

IssueFirst check
cds watch or cds serve failsVerify @sap/cds-dk, Node.js version, and project package.json scripts.
Entity/service not foundUse CAP MCP search_model when available, then inspect db/ and srv/ CDS files.
HANA deployment failsCheck HDI service binding, mta.yaml, and the HANA deployment references.
Authorization behaves unexpectedlyReview @requires, @restrict, XSUAA/IAS bindings, and user role mappings.

Table of Contents

Quick Start

Project Initialization

# 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

Basic Entity Example

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;
}

Basic Service

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;
}

MCP Integration

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 model
  • search_docs - Semantic search through CAP documentation for syntax, patterns, and best practices

Key Benefits:

  • Instant Model Discovery: Query your project's entities, associations, and services without reading files
  • Context-Aware Documentation: Find relevant CAP documentation based on semantic similarity, not keywords
  • Zero Configuration: No credentials or environment variables required
  • Offline-Capable: All searches are local (model) or cached (docs)

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.

CAP MCP and LSP Routing

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.

  • Use references/mcp-integration.md for MCP configuration and package pin checks.
  • Use references/mcp-use-cases.md only for workflow selection and illustrative impact examples.
  • Use .lsp.json as a Claude-compatible sidecar for CAP editor integration; other harnesses should not assume it is auto-loaded.
  • For Codex, OpenCode, editors, or other LSP-capable clients, configure the command manually as 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.
  • Without LSP integration, use the Markdown guidance, bundled references, rg, and CAP CLI checks directly.
  • Mark live deployment, HANA, XSUAA, and multitenancy verification pending unless the target project or tenant evidence is available.

Project Structure

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)

Core Concepts

CDS Built-in Types

CDS TypeSQL MappingCommon Use
UUIDNVARCHAR(36)Primary keys
String(n)NVARCHAR(n)Text fields
IntegerINTEGERWhole numbers
Decimal(p,s)DECIMAL(p,s)Monetary values
BooleanBOOLEANTrue/false
DateDATECalendar dates
TimestampTIMESTAMPDate/time

Common Aspects

using { cuid, managed, temporal } from '@sap/cds/common';
// cuid = UUID key
// managed = createdAt, createdBy, modifiedAt, modifiedBy
// temporal = validFrom, validTo

Event Handlers (Node.js)

// 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();
  }
}

Basic CQL Queries

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 } });

AI Integration

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.

Service Binding (MTA)

resources:
  - name: my-ai-core
    type: org.cloudfoundry.managed-service
    parameters:
      service: aicore
      service-plan: extended

Local Development (Hybrid Mode)

cds bind -2 <AICORE_INSTANCE> && cds-tsx watch --profile hybrid

Event Handler Pattern (Node.js/TypeScript)

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();
  }
};

Asynchronous Processing (Production Pattern)

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'
  });
}

HANA Vector Type for RAG

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.

Prompt Externalization

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;
}

Memory and Deployment

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.

Database Setup

Development (SQLite)

// package.json
{
  "cds": {
    "requires": {
      "db": {
        "[development]": { 
          "kind": "sqlite", 
          "credentials": { "url": ":memory:" } 
        },
        "[production]": { "kind": "hana" }
      }
    }
  }
}

Production (SAP HANA)

cds add hana
cds deploy --to hana

Initial Data (CSV)

  • File location: db/data/my.bookshop-Books.csv
  • Format: <namespace>-<EntityName>.csv
  • Auto-loaded on deployment

Deployment

Cloud Foundry

# 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

Multitenancy (SaaS)

cds add multitenancy

Configuration:

{
  "cds": {
    "requires": {
      "multitenancy": true
    }
  }
}

Authorization Examples

// Service-level
@requires: 'authenticated-user'
service CatalogService { ... }

// Entity-level
@restrict: [
  { grant: 'READ' },
  { grant: 'WRITE', to: 'admin' }
]
entity Books { ... }

Bundled Resources

Reference Documentation (22 files)

1. references/annotations-reference.md - Complete UI annotations reference (10K lines) 2. references/cdl-syntax.md - Complete CDL syntax reference (503 lines) 3. references/cql-queries.md - CQL query language guide 4. references/csn-cqn-cxn.md - Core Schema Notation and query APIs 5. references/data-privacy-security.md - GDPR and security implementation 6. references/databases.md - Database configuration and deployment 7. references/deployment-cf.md - Cloud Foundry deployment details 8. references/event-handlers-nodejs.md - Node.js event handler patterns 9. references/extensibility-multitenancy.md - SaaS multitenancy implementation 10. references/fiori-integration.md - Fiori Elements and UI integration 11. references/java-runtime.md - Java runtime support 12. references/localization-temporal.md - i18n and temporal data 13. references/nodejs-runtime.md - Node.js runtime reference 14. references/plugins-reference.md - CAP plugins and extensions 15. references/tools-complete.md - Complete CLI tools reference 16. references/consuming-services-deployment.md - Service consumption patterns 17. references/service-definitions.md - Service definition patterns 18. references/event-handlers-patterns.md - Event handling patterns 19. references/cql-patterns.md - CQL usage patterns 20. references/cli-complete.md - Complete CLI reference 21. references/mcp-integration.md - MCP server setup and usage guide (new) 22. references/mcp-use-cases.md - Illustrative MCP workflow scenarios (new)

Templates (8 files)

1. templates/bookshop-schema.cds - Complete data model example 2. templates/catalog-service.cds - Service definition template 3. templates/fiori-annotations.cds - UI annotations example 4. templates/mta.yaml - Multi-target application descriptor 5. templates/package.json - Project configuration template 6. templates/service-handler.js - Node.js handler template 7. templates/service-handler.ts - TypeScript handler template 8. templates/xs-security.json - XSUAA security configuration

Quick References

Common CLI Commands

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

Best Practices

DO ✓

  • Use cuid and managed aspects from @sap/cds/common
  • Keep domain models in db/, services in srv/, UI in app/
  • Use managed associations (let CAP handle foreign keys)
  • Design single-purpose services per use case
  • Start with SQLite, switch to HANA for production

DON'T ✗

  • Don't use SELECT * - be explicit about projections
  • Don't bypass CAP's query API with raw SQL
  • Don't create microservices prematurely
  • Don't hardcode credentials in config files
  • Don't write custom OData providers

Version Information

  • CAP Version: @sap/cds 9.7.x
  • MCP Version: @cap-js/mcp-server 0.0.5
  • LSP Version: @sap/cds-lsp 9.7.x
  • License: GPL-3.0

Related skills

open.feishu.cnLark Openapi ExplorerInstantly explore, test, and generate calls against the full Lark (Feishu) OpenAPI surface without leaving their agent workflow.493klarksuiteLark EventConsume real-time events from Lark/Feishu as structured NDJSON streams inside AI agent workflows.387k16klarksuiteLark Openapi ExplorerWhen an existing Lark/Feishu skill or CLI command cannot fulfill a specific requirement and they need to discover and invoke the exact native OpenAPI endpoint.386k16kscrapegraphaiJust ScrapeQuickly search, crawl, extract structured JSON, or monitor web pages without writing custom scraping code.245k41larksuiteLark AppsQuery the current visibility and permission scope of a Lark (Feishu) app without writing HTTP client code.235k16kmattpocockDesign An InterfaceGenerate multiple radically different interface or API designs in parallel before committing to one.188k198k

How it compares

Pick sap-cap-capire over generic backend API skills when the target platform is SAP BTP and deliverables must be CAP CDS models with OData rather than standalone REST microservices.

FAQ

What does sap-cap-capire help developers build?

sap-cap-capire helps developers build SAP BTP cloud apps using CAP CDS models, OData services, and Node or Java handlers. It applies CAPire patterns so enterprise extensions ship with typed entities and service contracts.

Which SAP runtimes does sap-cap-capire cover?

sap-cap-capire covers SAP Cloud Application Programming Model projects on SAP BTP with Node.js and Java service handlers. Developers use it when OData APIs and CDS schemas must align with CAPire production conventions.

Backend & APIsbackendintegrationsdocs
Browse by category
AI & AgentsFrontend & DesignBackend & DataDev ToolsAutomationTesting & ReviewSecurityMonitoring & CloudDocs & Planning
Design & frontend
Design systemsAnimation & motionAccessibility (a11y)CSS & TailwindUI designUXDesign to codeshadcn/uiLanding pagesBest design skills
Most searched skills
find-skillscavemanfrontend-designbrainstormingsystematic-debuggingstop-slopemil-design-engui-ux-pro-maxkarpathy-guidelinesweb-design-guidelinesreact-best-practicesgrill-meimprovemicrosoft-foundryagent-browser
Browse all listings
All agent skillsAll MCP serversAll marketplacesAll plugins

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.