AivexaNewsSearch
AI news for builders and product teamsChecked every hour

Build a semantic layer for agentic AI on AWS with Denodo and Amazon Bedrock AgentCore

Collected Oct 20, 2026

AWS's machine learning blog published a walkthrough for building a governed semantic layer for agentic AI using the Denodo Platform on top of Amazon Bedrock AgentCore. It is the second post in a series; the first used Stardog's knowledge graph over Amazon Aurora and Amazon Redshift with a Strands agent hosted on AgentCore. This entry keeps the same customer 360 pattern but swaps the semantic layer implementation and adds a source that sits outside AWS entirely.

The concrete change: the rewards_account table now lives on an on-premises PostgreSQL cluster instead of in Aurora alongside the rest of the customer profile data. Aurora (PostgreSQL-compatible) still holds customer profile information across customer, address and credit_card tables; Amazon Redshift holds order history across order and product; the on-premises cluster holds the rewards program. The shared identifier is cid, a plain integer that is the primary key of the Aurora customer table and a non-foreign-key column in the Redshift order table and the on-premises rewards_account table. Customer.location is an integer foreign key to address.id inside Aurora only. No foreign key spans two engines and no ETL job builds one, so joins must be reconciled at query time.

The motivating question the setup answers is: which of the top 20 customers by lifetime spend have not yet enrolled in the rewards program? Answering it requires profile data from Aurora, spend from Redshift and enrollment status from the on-premises cluster. Denodo plans the federated query at execution time, deciding what to push into each source and how to combine results; no data moves between sources, and the semantic layer is declared once for every consumer.

The Denodo vocabulary matters for anyone following the steps. Denodo Virtual DataPort (VDP) is the core query engine where semantic objects live, where VQL executes and where access policies are evaluated; Design Studio is the browser-based authoring surface. A base view maps one physical table, API or file to a logical view. A derived view is a VQL query over other views, and customer_360 is one. A metric view defines a business measure once and lets other views reference it. VQL is Denodo's ANSI-aligned SQL dialect with Denodo-specific constructs, including DDL for representing data sources and syntax for metric views; in agentic use a skill supplies this syntax to the model so it writes correct Denodo queries. A Global Security Policy is a runtime rule bound to views or columns carrying a tag, and it enforces row filters and column masks per caller.

At runtime there are two flows. Inbound, a client sends the user's request through AgentCore Gateway, which validates the user's JSON Web Token against the enterprise identity provider and routes it to the AgentCore runtime hosting the Strands agent. The agent calls a foundation model on Amazon Bedrock, Anthropic Claude Sonnet 4.6 in this walkthrough, to interpret the prompt and plan the query. Outbound, Gateway proxies the agent's tool calls; the Denodo MCP Server is registered as an MCP target on Gateway, so data requests route through it. AgentCore Identity performs an On-Behalf-Of token exchange before the request reaches Denodo, turning the user's inbound token into a scoped access token representing the same user with Denodo as audience. The MCP Server passes that token as a bearer credential and sends the VQL request to VDP over JDBC. VDP validates the token independently, resolves the caller to a Denodo role, applies access policies and plans the federated query.

The modeling work proceeds in three passes. Six base views map the source tables: aurora_customer, aurora_address and aurora_credit_card over Aurora; redshift_order and redshift_product over Redshift; and postgres_rewards_account over the on-premises cluster. During creation, ssn on the customer view and card_num on the credit_card view receive a pii_sensitive tag, which is what the Global Security Policy later binds to. cid is marked as the primary key on aurora_customer and as the join field on redshift_order and postgres_rewards_account. Design Studio infers keys from source metadata when available and otherwise they are set manually. The tooling also supports natural-language authoring through Denodo Assistant, where a developer describes a view in plain English and gets a candidate VQL definition to review and refine iteratively.

The customer_360 derived view left-joins customer to address on location, then to credit_card and postgres_rewards_account on cid, and carries every column including ssn and card_num. Because it is a view rather than a materialized table, joins resolve at execution time rather than through a pipeline. The lifetime_customer_value metric view sits beside it as its own object with SOURCES, ASSOCIATIONS, DIMENSIONS and METRICS sections, defining lifetime_spend as the sum of price times quantity, order_count as a count of order ids and units_sold as a sum of quantity. Because the measure is defined once, a business-rule change such as excluding canceled orders from lifetime spend updates in one place and every consumer picks it up at the next query.

For the auto-enrollment question, the VQL selects name and state from the metric view, filters where rewards_since is null and orders by EVALUATE_METRIC(lifetime_spend) descending with a limit of 20. Even though the query references only the metric view, VDP's cost-based optimizer pushes a customer, address and credit_card join into Aurora, pushes a small rewards projection into the on-premises cluster and pushes the spend aggregation to Redshift grouped by cid. Denodo then left-joins the Aurora result with the rewards result on cid, right-outer-joins that with the Redshift aggregate, applies the null filter, evaluates the metric as an outer sum of sums and returns up to 20 rows. VDP also reconciles type mismatches, such as an identifier stored as an integer in one source and a string in another, by pushing the cast into the source that can still filter on it.

Two deployment options exist for Denodo on AWS: Agora, a fully managed cloud service, and self-managed installation on Amazon EC2 or Amazon EKS. The article also indicates the pattern extends to SaaS tools, CRM systems, mainframes and the hundreds of other sources Denodo supports by default.

This design puts joins, metric definitions and caller-specific filters inside the semantic layer rather than in the prompt or in the agent's code. In practice that is the interesting architectural claim: the model plans queries but does not own the joins, so a prompt injection cannot rewrite the access rules, and swapping the foundation model or the agent framework leaves governance intact. A likely trade-off is operational dependency on VDP as a single query choke point, plus the latency of cross-engine federation, though the pushed-down plans in this example keep intermediate result sets small. The On-Behalf-Of exchange is worth noting for anyone building similar agents, since it preserves the human caller's identity end to end instead of having the agent act as a service account.

Why it matters: Teams building agents over live enterprise data face a governance problem, since credentials and filters embedded in prompts do not survive model swaps or audits. This pattern shows a workable division of labor in which AgentCore handles hosting, inbound token validation and outbound credential exchange while Denodo enforces policy and federation. Developers should expect to think more in terms of semantic views and tag-driven policies than hand-written SQL against each warehouse, and to plan for federation latency and a central query layer in their architecture.

Read at AWS Machine Learning Blog

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Build a governed semantic layer for agentic AI on AWS with the Denodo Platform and Amazon Bedrock AgentCore. It federates Amazon Aurora, Amazon Redshift, and an on-premises PostgreSQL database into a single customer 360 view an agent queries in VQL, with identity propagation and row- and column-level access control enforced at the semantic layer.