@shahid.la/cds-db-nlquery-mcp executes SELECT queries only; its documented interface does not create or update application records.
@shahid.la/cds-db-nlquery-mcp
MCP server that answers plain-English questions against the entities in db/schema.cds — it discovers the schema, generates CQN-backed SQL with real joins, and returns rows.
Bring your own model: Anthropic, OpenAI, or any OpenAI-compatible endpoint. It reads the db layer rather than a service, so there is no per-query configuration and no hand-written SQL — which is also the caution, since it reaches past whatever a service would have restricted.
Facts
Where it sits
Who is behind it
In the atlas: maintains 1, contributes to 1@shahidlamaintainer
Before choosing this
Conditions
PolicySAP API Policy 4.2026a§ 1.1, 1.2, 2.2.2from Serve your application over MCPAn MCP server exposes an SAP API, or uses SAP APIs to supply tools, resources or data to an agent.
- § 1.1 Published APIs. Published APIs are made available for the documented purposes identified by SAP, including integration, extensions and data exchange.
- § 1.2 Non-Published APIs. Customer and third-party applications must not access non-published APIs except where documentation permits it or SAP otherwise authorizes it.
- § 2.2.2 AI call sequences and data extraction. Outside SAP-endorsed architectures, data services or expressly identified pathways, the policy prohibits specified agentic API use and systematic or large-scale extraction.
MCP does not replace the API's documented-use boundary. Check that every endpoint is published for the intended use and whether the policy's AI-call or extraction provisions apply to the design.
SAP API Policy 4.2026a →LicenceSAP Developer License Agreement 3.2 CAP§ 1, 3from Serve your application over MCPA covered CAP plugin or application exposes SAP product data or covered customer-application functionality through MCP.
- § 1 License. Productive customer applications are limited to SAP BTP or another SAP-licensed platform, and mass extraction to a non-SAP product is restricted except where solely required for SAP interoperability.
- § 3 Artificial Intelligence Training. The agreement prohibits use of the covered materials and customer applications for training artificial-intelligence models or systems.
The CAP developer agreement can apply alongside the API Policy. Ordinary agent inference is not automatically AI training; section 3 becomes relevant when covered materials or applications are used to train, develop or refine a model or system.
SAP Developer License Agreement 3.2 CAP →LicenceSAP Developer License Agreement 3.2 CAP§ 3from LLM integrationCovered SAP materials or a covered CAP customer application are used as training data or to develop or refine an AI model or system.
- § 3 Artificial Intelligence Training. The agreement prohibits use of the covered materials and customer applications for training artificial-intelligence models or systems.
Calling a model for inference is not automatically AI training. Section 3 matters when the covered material or application participates in training, model development, refinement or the text-and-data-mining uses it names.
SAP Developer License Agreement 3.2 CAP →What it declares
Every artifact
- Type
- MCP server
- Origin
- Independently maintained
- Runtime
- Node.js
As an MCP server
- Declared for
- >=7
- Read-only
- yesstates it is
- Language
- JavaScript
For serve your application over MCP
- Exposure source
- CDS database schema
- Exposed operations
- Query records
- Execution path
- Direct database queries
- Exposure control
- Entity allowlistOutput filteringCAP service authorization bypassed
Tasks this contributes to
Change application records from an agentCreate or update application records through an MCP client.
Query application data from an agentRetrieve selected application records through MCP without changing those records.
A CAP project with @sap/cds >= 7 and a configured CDS database, plus an LLM provider API key. For production, configure the dedicated read-only database user described in the README.
Connections
Calling a language model with tenant and credential handling solved
Exposing application data and operations to agents over MCP
CAP Node.js runtime
Download
Install
npm add @shahid.la/cds-db-nlquery-mcpDerived from the package name. No recipe recorded; the README has the configuration.
Learn more
- Natural Language Queries for SAP CAP via MCP: The LLM Translates, CDS ExecutesNatural Language Queries for SAP CAP via MCP: The LLM Translates, CDS ExecutesThe division of labour is the argument, and it is in the subtitle: the model turns English into a CDS query and CDS runs it, so nothing generates SQL and nothing hallucinates a join. Schema annotations do the resolving. Long, with the package, the repository and the MCP registry entry all linked.Shahid, published 2026-06-25Shahid, SAP Community
Architecture
Download
Legend and provenance
README
quoted from shahidla/cds-db-nlquery-mcp under MIT, read@shahid.la/cds-db-nlquery-mcp
MCP server for natural language queries against CDS db-layer entities (db/schema.cds).
Ask questions about your database in plain English. The server discovers your schema automatically, generates real SQL JOINs using CDS, and returns rows. No hardcoded queries, no SQL, no schema configuration. Bring your own LLM: Anthropic or OpenAI, or any OpenAI-compatible endpoint (Azure OpenAI, Groq, Ollama, local models, etc.).
Targets the
db/layer, not OData services. If your entities are exposed as OData services, use an MCP package that targets the service layer instead.
Read-only. This package only executes SELECT queries. No INSERT, UPDATE, or DELETE.
Prerequisites
- A CAP project with
@sap/cds >= 7 - A configured CDS database (HANA Cloud, SQLite, PostgreSQL)
- An MCP client (Claude Code, Claude Desktop, or any MCP-compatible host)
- An API key for an LLM provider (see LLM provider below), used to translate your question into a query, not to answer it
Quick start
1. Install in your CAP project
npm install @shahid.la/cds-db-nlquery-mcp
2. Create .mcp.json in your CAP project root (same folder as package.json)
{
"mcpServers": {
"cds-db-nlquery": {
"command": "npx",
"args": ["-y", "@shahid.la/cds-db-nlquery-mcp"],
"cwd": "/absolute/path/to/your/cap/project",
"env": {
"ANTHROPIC_API_KEY": "sk-ant-..."
}
}
}
}
Set cwd to the absolute path of your CAP project root, where db/schema.cds lives. See LLM provider for using OpenAI, Gemini, or another provider instead.
npx -y re-resolves the package on every server start (from npm's cache once
downloaded, not a fresh network fetch each time, but still an extra resolution
step). If you've run npm install @shahid.la/cds-db-nlquery-mcp already, you
can point "command" at the installed binary directly instead,
node_modules/.bin/cds-db-nlquery-mcp, for a slightly more predictable startup,
especially in production.
3. Open your project in Claude Code and ask a question
Which customers have a DTI ratio above 5?
Show me all open payments overdue by more than 30 days, include the borrower name.
List all loans in the MINING sector with the customer's current DTI ratio.
Example response: the server tells the client to render rows as a vertical field/value list, not a markdown table (real output, verified against a live deployment):
Found 3 customers with DTI above 5:
PARTNER : 30100003
DTI_RATIO : 7.20
BU_SORT1 : Domestic Customer AU 3
PARTNER : 30100001
DTI_RATIO : 5.80
BU_SORT1 : Domestic Customer AU 1
PARTNER : 30100002
DTI_RATIO : 5.40
BU_SORT1 : Domestic Customer AU 2
How it works
When you ask a question:
- Your MCP client (e.g. Claude Code) calls the
natural_language_querytool with your question. - The MCP server has already loaded your CDS schema at startup: entity names, columns, and associations. It sends this schema plus your question to the LLM provider you configured (Anthropic, OpenAI, or any OpenAI-compatible endpoint), which translates it into a structured query descriptor.
- The server executes a single CDS query. CDS association paths (
customer.BU_SORT1) generate real SQL JOINs, executed by your database, not by JavaScript. Scales to production data volumes. - Results come back to your MCP client, which formats and presents the answer.
The LLM call in step 2 is a small, cheap planning step (translating your question into JSON). It does not need a large or expensive model. A fast/cheap tier model is recommended.
Configuration
All configuration is via environment variables in the .mcp.json env block.
{
"mcpServers": {
"cds-db-nlquery": {
"command": "npx",
"args": ["-y", "@shahid.la/cds-db-nlquery-mcp"],
"cwd": "/path/to/your/cap/project",
"env": {
"ANTHROPIC_API_KEY": "sk-ant-...",
"MCP_ALLOWED_ENTITIES": "Customers,Orders,Products",
"MCP_BLOCKED_COLUMNS": "PASSWORD,EMBEDDING,SSN",
"MCP_MAX_ROWS": "100",
"MCP_MODEL_PATH": "db"
}
}
}
}
| Variable | Default | Description |
|---|---|---|
MCP_ALLOWED_ENTITIES | (all entities) | Comma-separated list of entity short names, the name after the last dot in the FQN (e.g. Customers, not my.app.Customers). Leave unset during development; always set for production. |
MCP_BLOCKED_COLUMNS | (none) | Comma-separated column names to exclude from all results. Stripped before the query runs. Useful for columns like EMBEDDING, PASSWORD, SSN. |
MCP_MAX_ROWS | 500 | Maximum rows per query. Enforced as a SQL LIMIT, not a post-fetch filter. |
MCP_MODEL_PATH | db | Path to your CDS model folder or file, relative to cwd. Change if your schema is at model/, srv/, etc. |
MCP_DB_USER / MCP_DB_PASSWORD | (consumer app's own DB user) | Connect with a different HANA user than your app's runtime user. Host/port/schema are reused, only credentials are overridden. See Security → Production for why this matters. |
LLM provider
A small LLM call translates your question into a query descriptor. Bring your own provider, set ONE of the following in the env block:
Anthropic (Claude):
"env": {
"ANTHROPIC_API_KEY": "sk-ant-...",
"ANTHROPIC_MODEL": "claude-haiku-4-5-20251001"
}
OpenAI, or any OpenAI-compatible provider:
"env": {
"OPENAI_API_KEY": "sk-...",
"OPENAI_MODEL": "gpt-4o-mini"
}
OPENAI_MODEL accepts any model name. Use whatever your provider expects. Set OPENAI_BASE_URL to point at a different OpenAI-compatible endpoint:
| Provider | OPENAI_BASE_URL | Example OPENAI_MODEL |
|---|---|---|
| OpenAI | (omit, uses default) | gpt-4o-mini |
| Google Gemini | https://generativelanguage.googleapis.com/v1beta/openai/ | gemini-2.0-flash |
| Groq | https://api.groq.com/openai/v1 | llama-3.1-8b-instant |
| Mistral | https://api.mistral.ai/v1 | mistral-small-latest |
| DeepSeek | https://api.deepseek.com | deepseek-chat |
| xAI (Grok) | https://api.x.ai/v1 | grok-2-latest |
| Azure OpenAI | your Azure endpoint | your deployment name |
| Ollama (local) | http://localhost:11434/v1 | llama3.1 (API key can be any non-empty string) |
| Variable | Description |
|---|---|
LLM_PROVIDER | "anthropic" or "openai". Auto-detected from whichever API key is set, only needed if both are set and you want to force one. |
ANTHROPIC_API_KEY / ANTHROPIC_MODEL | Anthropic native API |
OPENAI_API_KEY / OPENAI_MODEL / OPENAI_BASE_URL | OpenAI or any OpenAI-compatible endpoint |
This is a planning-only call (question to JSON descriptor). A fast/cheap tier model is sufficient and recommended.
Security
Development
The server uses your project's existing database connection, whatever CDS has configured in default-env.json or your service binding. No extra setup needed.
Production
Important: this package queries the database directly via cds.run(). It does not go through the CAP service layer, so CAP @requires and @restrict annotations are not enforced. Access control is entirely your responsibility at the database and configuration level.
Step 1: Create a dedicated read-only database user
-- Run as DBADMIN in SAP HANA Cloud Central
CREATE USER MCP_READER PASSWORD 'your-password';
GRANT SELECT ON SCHEMA YOUR_HDI_SCHEMA TO MCP_READER;
-- Revoke tables you do not want queryable
REVOKE SELECT ON "YOUR_HDI_SCHEMA"."your.AuditLog" FROM MCP_READER;
REVOKE SELECT ON "YOUR_HDI_SCHEMA"."your.RegulatoryDocuments" FROM MCP_READER;
This user can only read. No write access. HANA itself enforces it, independently of this package.
Step 2: Point the server at it with MCP_DB_USER/MCP_DB_PASSWORD
The server connects with these credentials instead of inheriting your app's own database connection. Host, port, and schema are reused automatically, only the user/password are overridden:
"env": {
"MCP_DB_USER": "MCP_READER",
"MCP_DB_PASSWORD": "your-password"
}
If you keep these in a separate gitignored file instead of directly in .mcp.json,
that's fine too. The server just reads process.env, same as any other variable here.
Step 3: Set MCP_ALLOWED_ENTITIES
"env": {
"MCP_ALLOWED_ENTITIES": "Customers,Orders,Products"
}
This is enforced on the entity you query directly and on any entity reached via
an association join in select/where. For example, if Customers isn't in the allowlist,
a query against Orders can't read Customers data through a customer.NAME join
path either. The database user restricts access at the HANA level;
MCP_ALLOWED_ENTITIES adds a second layer at the application level. Use both.
Joins
The server reads CDS associations from your schema. When the LLM references customer.BU_SORT1 in a query, CDS generates a real SQL JOIN, executed by the database.
Multiple associations in one query work:
"Show loans in the MINING sector with borrower name and current DTI"
Generates a single SQL statement joining Loans → BusinessPartners → BCA_DTI in one database round-trip.
One constraint: do not select the same column name from two different entities in the same query (e.g. LOAN_ID from both the main entity and a joined entity). The database rejects duplicate column names. Claude is instructed to avoid this, but worth being aware of.
Comparing two columns to each other
Most filters compare a column to a fixed value (DTI_RATIO > 5). For questions like "which loans have collateral worth less than the loan amount", the comparison is between two columns instead. Use valCol in place of val:
{ "col": "collateral.VALUE", "op": "<", "valCol": "AMOUNT" }
Either side can be an association path. This is handled by the same join mechanism as everything else. No separate query, no JavaScript-side comparison.
Filtering by a coded value's human meaning
If a column has a @Common.Text value-help association (see Coded values), filter via the text field directly rather than guessing the underlying code:
{ "col": "status.TEXT", "op": "like", "val": "Active" }
like is case-insensitive (enforced via UPPER() on both sides, not relying on database collation), so the exact case of the value doesn't need to match.
Column and entity labels
The LLM only sees what's in your CDS model: column names, types, and any labels you've annotated. Plain code comments (// customer name) are invisible to it. Without a label, an ambiguous column name can cause the LLM to guess wrong, regardless of how capable the model is.
@title: reused automatically, zero extra work
If your schema already has SAP's standard @title annotation (common in projects with a Fiori UI or OData service), the server picks it up automatically. You don't need to do anything:
entity Customers {
key PARTNER : String(10);
@title: 'Customer Name'
BU_SORT1 : String(40);
}
@NLP.label: for disambiguation @title isn't meant for
Use this when you need to tell the LLM something a UI-facing label shouldn't say, e.g. "don't use this column for X." This was a real bug we hit: a BU_TYPE code column (1=person, 2=organisation) was being picked by the LLM whenever a question asked for a customer's "name," because nothing told it otherwise. The fix:
entity Customers {
key PARTNER : String(10);
@NLP.label: 'Partner type code: 1=person, 2=organisation. NOT a name, never use for name lookups'
BU_TYPE : String(2);
@NLP.label: 'Customer / business partner full name, use this whenever a question asks for a name'
BU_SORT1 : String(40);
}
After adding these two labels, even the cheapest tier model (claude-haiku-4-5) picked the right column every time. Fix ambiguity at the schema level, not by tweaking prompts per-bug. It's permanent and works regardless of which LLM provider or model you use.
Precedence: @NLP.label is checked first, falls back to @title, falls back to the raw column/entity name if neither is set.
Other @NLP annotations
entity Customers @(NLP.label: 'Active borrowers, loan customers with income and sector data') {
dti : Association to BCA_DTI on dti.PARTNER = PARTNER
@NLP.joinType: 'LEFT';
}
| Annotation | Where | Effect |
|---|---|---|
@NLP.label | Entity or column | Description shown to the LLM. Falls back to @title, then the name. |
@NLP.joinType | Association | Override join type: 'LEFT' or 'INNER'. Auto-detected from cardinality if not set. |
@NLP.alias | Association | Override the association name used in queries |
All optional. The package works without any of them. But for any column whose name alone could be misread (codes, abbreviations, anything that looks like one thing but means another), a label is the difference between the LLM guessing and the LLM knowing.
Coded values: what does STATUS = 'C' mean?
Labels solve "what does this column mean." A separate problem: what does a coded
value in that column mean? STATUS = 'C'. Closed? Cancelled? Confirmed?
There are two ways to tell the LLM, and which one to use depends on whether the value list can change without a code deploy.
@Common.Text: for business-configurable codes (the common case)
Most status/type codes are business data. Someone in operations might introduce a
new value next quarter, and that should never require touching the schema file. The
SAP-standard mechanism for this is @Common.Text, pointing through an association to
a small lookup/check table, the same pattern Fiori elements uses for value-help
dropdowns:
entity LoanStatusCodes {
key CODE : String(1);
TEXT : String(20);
}
entity Loans {
@Common.Text: status.TEXT
STATUS : String(1);
status : Association to LoanStatusCodes on status.CODE = STATUS;
}
Seed it with {CODE: 'A', TEXT: 'Active'}, {CODE: 'C', TEXT: 'Closed'}. Adding a
new status later is an INSERT into LoanStatusCodes, no schema change, no
redeploy. The server detects @Common.Text, tells the LLM a readable value is
available via the association path, and the LLM includes it in select using the
normal join mechanism. No extra code on our side, it's the same association-path
JOIN used everywhere else in this package.
CDS enum: only for sets that are genuinely fixed forever
STATUS : String(1) enum { active = 'A'; closed = 'C'; };
This is compile-time: adding a value means editing schema.cds and redeploying.
Appropriate only for values that are tied to actual program logic anyway (so a code
change would be required regardless), not for business classifications. We initially
used enum for our own demo's status fields and walked it back to @Common.Text for
exactly this reason. It's documented here as a contrast, not a recommendation.
Rule of thumb: reach for @Common.Text by default. Use enum only when you're sure
the list can never grow without code changing anyway.
When a column has @Common.Text, query results get the raw code back as normal.
Presentation (showing "Closed" instead of "C") is up to whichever LLM renders the
final answer, using the readable value it fetched via the join.
Startup log
When the server starts, check the output panel in Claude Code:
[cds-db-nlquery-mcp] Schema loaded — 12 entities
[cds-db-nlquery-mcp] WARNING: MCP_ALLOWED_ENTITIES not set — all entities are queryable. Set in .mcp.json for production.
[cds-db-nlquery-mcp] WARNING: MCP_DB_USER not set — using the project's default DB connection (likely the main app's full-access user). Set MCP_DB_USER/MCP_DB_PASSWORD to a restricted read-only user for production use.
[cds-db-nlquery-mcp] LLM provider: anthropic
[cds-db-nlquery-mcp] Ready (stdio)
0 entities at startup? Check that cwd in .mcp.json points to your CAP project root and that MCP_MODEL_PATH matches your schema folder name.
WARNING: No LLM provider configured? Set ANTHROPIC_API_KEY or OPENAI_API_KEY in the .mcp.json env block, see LLM provider.
WARNING: MCP_DB_USER not set? Expected during development, the server is using the same database connection as your CAP app. Before production use, see Security → Production for creating a dedicated read-only user.
Testing this against your own deployment
npm install gives you src/, the MCP server, and nothing else. That's the
entire published package. The GitHub repository also has an
examples/capability-demo/ folder with a real CDS schema, seed data, ~35
example queries with verified expected results, and four scripts to actually
exercise them against your own database (not just read about it): one runs the
example queries directly against the internal functions, one lets you ask your
own question end-to-end through a real LLM, one runs every example question's
natural-language text through a real LLM and checks the result, and one spawns
src/mcp-server.js itself as a real child process and drives it through the
actual MCP stdio protocol, the same way Claude Code or Claude Desktop would,
rather than calling internal functions directly. None of this ships with
npm install. Clone the repo if you want it. See that folder's own README for details.
How releases are tested
npm test (126 unit tests) runs against a mocked database. Fast, but it can't
catch backend-specific behavior (a real HANA deployment has rejected things the
mocks happily accepted, more than once). Before tagging a release, npm run test:deployment is run against a real CAP project connected to live HANA
Cloud. It requires real credentials and a deployed examples/capability-demo/
schema, so it isn't part of npm test or CI, but it is a required manual step,
not an optional one. examples/capability-demo/smoke-test-server.js is also
run. It spawns src/mcp-server.js itself and drives it over the real MCP
stdio protocol with a real LLM call, not just the internal functions directly.
RELEASE_VERIFICATION.md is the actual, append-only record of this: real output from a real run against live BTP HANA, captured and committed before each release, not just claimed.
License
MIT
History
Others providing
- abap-ai/mcpabap-ai/mcpAn MCP server SDK written in ABAP to run natively on the ABAP stack, so an ABAP system can expose its own prompts, resources and tools to an agent from inside itself.independent, abapMCP server SDK written in ABAPfrom ABAP
- abap-ai/mcp2abap-ai/mcp2A stateless rewrite of the ABAP MCP server SDK: one ABAP server contract answering both the 2026-07-28 protocol draft and the legacy 2025 versions, with no sessions and no SSE.independent, abapStateless ABAP MCP server SDK for the 2026-07-28 protocol draftfrom ABAP
- abap-agent-runtimeabap-agent-runtimeAn ABAP-native MCP endpoint inside the SAP system: an agent reads the screen of an opted-in abap2UI5 app as structured data, fills its fields and fires its events as the logged-on SAP user.community org, abapABAP-native MCP endpoint that drives opted-in abap2UI5 appsfrom ABAP
- API ManagementAPI ManagementAPI proxies in front of backend services, with security and traffic management policies attached to them, and Developer Hub where consumers subscribe.sap official, btpAPI proxies with security and traffic policies and Developer Hubfrom BTP/BAIP
- com.sap.cds:cds-adapter-mcpcom.sap.cds:cds-adapter-mcpThe MCP protocol adapter for CAP Java, serving an @mcp-annotated Application Service as an MCP server with three generated tools, describe, query and call, and data changes only through unbound actions.sap official, capMCP adapter turning a CAP Java service into an MCP serverfrom CAP
- @cap-js/mcp@cap-js/mcpA CAP plugin that serves an @mcp-annotated service over MCP with three generated tools, describe, query and call_action, and writes its endpoint into the local agent's configuration in development.sap official, capExposes CAP services as MCP servers for AI agentsfrom CAP
- @gavdi/cap-mcp@gavdi/cap-mcpGenerates an MCP server from the CDS model — annotated entities become resources and annotated actions become tools, so an agent reaches the service without a second server being written.independent, capGenerates an MCP server from annotated CDS entities and actionsfrom CAP
- btp-cf-mcpbtp-cf-mcpAn MCP server over an SAP BTP account and its Cloud Foundry runtime that acts as the person who logged in, so their own global-account and space roles decide what an agent can see.independent, btpMCP server for SAP BTP and Cloud Foundry acting as the logged-in userfrom BTP/BAIP
- MarkWuRY168/SAP_MCPMarkWuRY168/SAP_MCPPublishes SAP system functions as MCP tools from configuration tables held inside the SAP system, so adding a tool is a configuration change rather than a code change.independent, abapMCP server publishing SAP functions as tools from config tablesfrom ABAP
- @neoimpulse/cap-js-mcp@neoimpulse/cap-js-mcpAn MCP server inside a CAP application, with default tools that read the running model and query entities, plus configurable application tools, prompts and resources.independent, capMCP server inside a CAP application with model and query toolsfrom CAP
- @odatano/core-mcp@odatano/core-mcpMCP server exposing ODATANO — the Cardano-to-OData bridge built on CAP — to an agent, so the chain is reachable as tools rather than as a REST client.independent, capMCP server exposing the ODATANO Cardano-to-OData bridge as toolsfrom CAP
- @odatano/nightgate-mcp@odatano/nightgate-mcpMCP server exposing NIGHTGATE, the Midnight blockchain attestation layer, as agent tools — the companion to the CAP indexer plugin of the same name.independent, capMCP server exposing the NIGHTGATE Midnight attestation layerfrom CAP
- Skybuffer AI MCP serverSkybuffer AI MCP serverAn ABAP add-on that serves SAP business data, transactions and development context as MCP tools from an ICF node inside SAP ECC and S/4HANA, each call running as the signed-in user under PFCG authorization checks.independent, abapABAP add-on serving business data and transactions as MCP toolsfrom ABAP
- cap-mcp-plugincap-mcp-pluginGenerates an MCP server from a CDS model: annotated entities become MCP resources, functions and actions become tools, and services can expose reusable prompt templates. A fork of @gavdi/cap-mcp that adds an OAuth proxy, IAS client registration and draft-lifecycle tools.independent, capMCP server generated from a CDS model, forked from @gavdi/cap-mcpfrom CAP
- llm_clientllm_clientAn ABAP client that gives chat-completion LLM APIs one interface for chat messages, structured output and tool calls across ten providers, from OpenAI and Anthropic to OLLAMA and AWS Bedrock.independent, abapABAP client with one interface to chat-completion LLM APIsfrom ABAP
- abap-agent-runtimeabap-agent-runtimeAn ABAP-native MCP endpoint inside the SAP system: an agent reads the screen of an opted-in abap2UI5 app as structured data, fills its fields and fires its events as the logged-on SAP user.community org, abapABAP-native MCP endpoint that drives opted-in abap2UI5 appsfrom ABAP
- abap_btocs_ollamaabap_btocs_ollamaAn ABAP plugin, built on the B-Tocs ABAP SDK, that calls models served by Ollama through an SM59 RFC destination, implementing four of its API endpoints: generate, tags, show and embeddings.independent, abapB-Tocs ABAP SDK plugin connecting to Ollama modelsfrom ABAP
- SAP AI CoreSAP AI CoreSAP's AI service on BTP: the runtime for AI assets, and through the Generative AI Hub inside it the access to foundation models, the orchestration service with its templating, masking, filtering and grounding modules, the Prompt Registry and Document Grounding.sap official, btpAI runtime on BTP with the Generative AI Hubfrom BTP/BAIP
- cap-java/cds-aicap-java/cds-aiBridges CAP Java to SAP AI Core and adds AI-powered field recommendations to Fiori draft UIs, as two alpha Maven modules with mock fallbacks for local development.sap official, capBridge from CAP Java to SAP AI Core, with Fiori field recommendationsfrom CAP
- @cap-js/ai@cap-js/aiOut-of-the-box value-help recommendations powered by SAP RPT-1, SAP AI Core as a standard CAP service, and an experimental local embedding model behind SQLite's vector functions.sap official, capValue-help recommendations and SAP AI Core as a CAP servicefrom CAP
- cap-llm-plugincap-llm-pluginGenerative AI in a CAP application with the sensitive fields anonymised through SAP HANA before the prompt leaves, so the model never sees the confidential half.independent, capGenerative AI in CAP with fields anonymised through SAP HANAfrom CAP
- @geertjanklaps/cds-toon-ai-protocol-adapter@geertjanklaps/cds-toon-ai-protocol-adapterA protocol adapter that serves CAP data as TOON — Token-Oriented Object Notation — instead of JSON, so a payload bound for a language model costs fewer tokens to send.independent, capProtocol adapter serving CAP data as TOON instead of JSONfrom CAP
- cap-decisionscap-decisionsAdds a decisions service to a CAP Node.js application that answers typed questions about one text or JSON state through an HTTP decision endpoint.independent, capCAP service for typed decisions about one text or JSON statefrom CAP
- abap-sdk-nwas-xabap-sdk-nwas-xAn ABAP client library for IBM's watsonx.ai and watsonx.ai Runtime APIs, installed into an SAP NetWeaver AS ABAP system through abapGit, generating and refreshing the IAM token from an API key.independent, abapABAP client library for IBM watsonx.ai APIsfrom ABAP
- @jerome-benoit/sap-ai-provider@jerome-benoit/sap-ai-providerA provider for the Vercel AI SDK that speaks to SAP AI Core through its orchestration or foundation models API, so an application written against that SDK runs on SAP's models without being rewritten.independent, capVercel AI SDK provider for SAP AI Corefrom CAP
- ui5-cap-ai-featuresui5-cap-ai-featuresBoth halves of an AI text feature in one package: a CDS plugin serving an AIService over SAP AI Core's Orchestration Service, and the be.wl.ai UI5 control library that calls exactly that service.independent, capCDS plugin and UI5 controls for AI text features via SAP AI Corefrom CAP
- Microsoft AI SDK for SAPMicrosoft AI SDK for SAPMicrosoft's ABAP library for calling Azure OpenAI and OpenAI from an SAP application server, wrapping completions, embeddings, fine-tuning and the other operations in ABAP data types, installed with abapGit.partner, abapABAP library for calling Azure OpenAI and OpenAIfrom ABAP
- zllmzllmAn ABAP framework for chaining and orchestrating calls to large language models in pure ABAP, with templated prompts, routing by complexity, response caching and token estimation.independent, abapABAP framework for chaining and orchestrating LLM callsfrom ABAP
- ABAP AI SDKABAP AI SDKSAP's reuse library for calling a large language model from ABAP code, powered by Intelligent Scenario Lifecycle Management and reaching the models in the Generative AI Hub; delivered with SAP BTP ABAP environment, SAP S/4HANA Cloud Public and Private Edition and SAP S/4HANA.sap official, abapSAP reuse library for calling large language models from ABAPfrom ABAP
- @sap-ai-sdk/ai-api@sap-ai-sdk/ai-apiThe AI Core API surface of SAP's AI SDK, covering deployments, configurations and the rest of the control plane, as opposed to calling a model.sap official, capAI Core control plane API surface of SAP's AI SDKfrom CAP
- @sap-ai-sdk/core@sap-ai-sdk/coreThe shared internals that the packages of SAP's AI SDK build on, which its own readme says are not meant to be depended on directly.sap official, capShared internals of SAP's AI SDKfrom CAP
- @sap-ai-sdk/foundation-models@sap-ai-sdk/foundation-modelsThe package of SAP's AI SDK that calls foundation models through SAP AI Core and the Generative AI Hub, and the one an application actually reaches for.sap official, capClient for foundation models via SAP AI Core and Generative AI Hubfrom CAP
- @sap-ai-sdk/orchestration@sap-ai-sdk/orchestrationThe Orchestration Service client of SAP's AI SDK, which applies templating, grounding, filtering and masking around a model call rather than in the application.sap official, capOrchestration Service client for templating, grounding and maskingfrom CAP
- @sap-ai-sdk/prompt-registry@sap-ai-sdk/prompt-registryA package for keeping prompts in SAP's prompt registry rather than in the codebase, so changing a prompt is not a deployment.sap official, capClient for prompts kept in SAP's prompt registryfrom CAP
- @saptarishi/cds-plugin-llm@saptarishi/cds-plugin-llmA CAP service kind that puts eleven model providers behind one chat, stream, embed and batch interface, so which backend a service calls is a profile in package.json rather than a change to the handler.independent, capCAP service kind putting eleven model providers behind one APIfrom CAP
- @ui5/webcomponents@ui5/webcomponentsSAP's UI elements as standard custom elements, ui5-button among them, implementing SAP Fiori design and usable from plain HTML, React, Angular or Vue.sap official, ui5SAP's UI elements as standard custom elementsfrom UI5
- abap-sdk-nwasabap-sdk-nwasAn ABAP client library for IBM Watson's Discovery, Language Translator, Natural Language Understanding, Speech to Text, Text to Speech and Assistant services, installed through abapGit.independent, abapAn ABAP client library for IBM Watson's Discovery, Language Translator, Natural Language Understanding, Speech to Text, Text to Speech and Assistant services, installed through abapGit.from ABAP
Details
Sources
Sources are graph entities: the same page may back several entries, and an unreachable source flags every row that rests on it.
Compatibility and provenance
History in the atlas
- ADR-0120: the facet is typed, and the sentence is read by its words; the quote it rests on is unchanged.
- CDS database-layer schema (db/ by default); service-layer/OData exposure is outside this interface; SELECT only; no INSERT, UPDATE or DELETE; Configured LLM plans a query descriptor; CDS executes a database query and SQL joins, rather than invoking application-service operations; Direct database access bypasses CAP @requires/@restrict; MCP_ALLOWED_ENTITIES restricts direct/joined entities, MCP_BLOCKED_COLUMNS excludes result columns; unset allowlist permits all entities
- Queries CDS database-layer entities from a CAP [Node.js](external:nodejs) project through an LLM-planned SELECT query, including database-executed association joins. It targets the database layer rather than OData/application services, and executes no INSERT, UPDATE or DELETE. The entity allowlist covers direct queries and joined entities; its default allows all entities. CAP service-level @requires/@restrict are not enforced; database permissions and configuration control access.
- CDS database schema
- Direct database queries
- Entity allowlist; Output filtering; CAP service authorization bypassed
- @sap/cds >= 7 runtime prerequisite
- this package queries the database directly via `cds.run()`
- Queries CDS database-layer entities from a CAP [Node.js](external:nodejs) project through an LLM-planned SELECT query, including database-executed association joins. It targets the database layer with a default model path of db/ and executes no INSERT, UPDATE or DELETE. MCP_ALLOWED_ENTITIES restricts direct queries and joined entities; its default allows all entities. MCP_BLOCKED_COLUMNS excludes result columns before execution. CAP service-level @requires/@restrict are not enforced; database permissions and configuration control access.
- First seen.
For your agent
- Ref
artifact:shahid-la-cds-db-nlquery-mcp- JSON
- /artifacts/shahid-la-cds-db-nlquery-mcp.json
- MCP
- Connecting an agent