SAP Community - SAP AI Launchpad

New Expert-Guided Implementation: Unlocking Joule and SAP Business AI from Strategy to Activation

2025-10-13T14:51:50.787000+02:00

As organizations look to harness the power of Artificial Intelligence (AI) to drive transformation, SAP Business AI stands at the forefront - embedding intelligence directly into business processes to deliver smarter decisions and measurable outcomes.

From finance and supply chain to HR, procurement, and customer experience, SAP Business AI infuses trusted, relevant, and responsible AI across every process - ensuring each insight is contextual, every recommendation actionable, and every outcome aligned with enterprise goals.

Whether leveraging Joule, SAP’s AI copilot, or AI-embedded scenarios across your SAP applications, your path to becoming an intelligent and sustainable enterprise begins with understanding and activating SAP’s Business AI capabilities.

To help you unlock this value faster, we’re launching a new Expert-Guided Implementation (EGI):

Unlocking AI: Joule and SAP Business AI from Strategy to Activation

This multi-day, expert-led workshop is designed to help you and your team unlock the full potential of Joule and SAP Business AI across your SAP landscape. Guided by SAP experts, you’ll explore how to translate strategy into execution with practical exercises, live demonstrations, and activation guidance.

Workshop Schedule

To accommodate global participants, this session will be offered in two time zones:

October 20–22, 2025 | 10:00am–12:00pm EMEA time zone
November 3–5, 2025 | 10:00am –12:00pm NY time zone

What You’ll Learn

Through this EGI, participants will gain hands-on experience and actionable knowledge in:

SAP Business AI Strategy & Foundation - Understand SAP’s AI vision, architecture, and trusted approach to delivering responsible, embedded intelligence
Commercial Model & AI Units - Learn how to navigate Base vs Premium models, the AI Feature Catalog, and use the AI Estimator to plan your adoption journey
Joule – AI Built for Business - Explore Joule’s unified architecture, roadmap, and capabilities across Joule for Business, Joule for Developers, and Joule for Consultants
S/4HANA AI & ML Capabilities - Experience ISLM in action through AI/ML demo use cases designed to enhance decision-making and process automation
SAP BTP AI & ML Capabilities - Discover how BTP AI Foundation, Document AI, AI Services, AI Core, and AI Launchpad can help you extend and scale innovation
Joule Activation & Prerequisites - Gain a clear view of activation steps, prerequisites, and how to extend Joule with Document Grounding, Joule Studio, and AI Agents

Why Attend

This workshop goes beyond theory—it’s interactive, practical, and guided by SAP experts. By the end, you’ll have:

A clear understanding of SAP’s Business AI strategy and product portfolio
The ability to activate Joule and deploy AI scenarios across your landscape
Actionable steps to integrate AI and Generative AI into your business workflows
Insights into commercial models and AI unit management for smarter planning

Whether you’re a business leader shaping AI strategy or a technical consultant implementing it, this EGI equips you to bridge the gap between strategy and execution.

How to Register

Register here to secure your spot* today to learn from SAP experts and gain the skills to bring Business AI to life across your enterprise.

* You may need to register your S-user for access to SAP Learning Hub to access the EGI registration page. It is a one-time registration, click here.

[2025-Q4] SAP BTP Adoption Webinars – Unlock the Power of AI, Data, and Integration

2025-10-23T20:29:52.412000+02:00

Get ready for a packed lineup of expert-led sessions designed to help you accelerate innovation with SAP Business Technology Platform (BTP). From AI best practices to integration and analytics, these webinars will equip you with practical insights and real-world examples you can apply right away.

📅 Oct 30 | Pipeline Concept in SAP Integration Suite

👉Learn how the pipeline concept accelerates your migration from SAP Process Orchestration to SAP Integration Suite.

🔗 Register Now

📅Nov 04 | Service and Service Excellence with AI Driven Insights

👉Experience how SAP solutions transform intelligence into action—turning service into a seamless, revenue-driving experience.

🔗 Register Now

📅 Nov 05 | Best practices for secure and scalable LLM model usage in BTP AI apps with SAP AI Core

👉 Discover how to make secure and scalable large language model usage in BTP AI applications with SAP BTP AI Core.

🔗 Register Now: EMEA/MEE/APAC Session | Americas/EMEA Session

📅 Nov 13 | AI-Driven Business Solutions – Exploring the Potential of SAP BTP AI - Americas

👉 Discover how enterprises are turning AI hype into real business outcomes with SAP BTP.

🔗 Register Now

📅 Nov 13 | Enablement on SAP Mobile Start and SAP Build Work Zone with Showcase of Joule as AI Copilot

👉 Discover how to leverage SAP Mobile Start and SAP Build Work Zone as central entry point with Joule AI Copilot for connected SAP solutions.

🔗 Register Now

📅 Nov 19 | AI-Driven Business Solutions – Exploring the Potential of SAP BTP AI - APAC/EMEA

👉 Discover how enterprises are turning AI hype into real business outcomes with SAP BTP.

🔗 Register Now

📅 Nov 20 | BTP AI Best Practices – Knowledge Graph-based Retrieval Augmented Generation

👉 Learn how to combine Knowledge Graphs with Large Language Models for advanced RAG scenarios.

🔗 Register Now: EMEA/MEE/APAC Session | Americas/EMEA Session

📅 Dec 03 | BTP AI Best Practices – Vector-based RAG, Document Grounding, and Examples

👉 See how to ground large language models on company-specific data using SAP Document Grounding.

🔗 Register Now: EMEA/MEE/APAC Session | Americas/EMEA Session

📅 Dec 09 | AI-Driven Business Solutions – Exploring the Potential of SAP BTP AI (Americas Session)

👉 Discover how enterprises are turning AI hype into real business outcomes with SAP BTP.

🔗 Register Now

📅 Dec 15 | AI-Driven Business Solutions – Exploring the Potential of SAP BTP AI (APAC/EMEA Session)

👉 Discover how enterprises are turning AI hype into real business outcomes with SAP BTP.

🔗 Register Now

💡Don’t miss the opportunity to learn from SAP experts and accelerate your journey to the Intelligent Enterprise.

Building Trust in AI: SAP Business AI earns ISO/IEC 42001 Certification

2025-10-31T04:37:40.516000+01:00

Artificial intelligence is reshaping how businesses operate, innovate, and serve their customers. But as AI becomes more deeply embedded into enterprise systems, ensuring that it behaves responsibly is just as important as making it powerful.

That’s why we’re proud to share that SAP Business AI has achieved ISO/IEC 42001:2023 certification — the world’s first international standard for Artificial Intelligence Management Systems (AIMS).
This certification covers Joule, SAP AI Core, and SAP AI Launchpad, reinforcing SAP’s long-standing commitment to building trustworthy, transparent, and ethical AI across our products and services.

Why This Matters

Responsible AI isn’t just a principle. It’s a prerequisite for scaling AI safely in enterprise environments. The ISO/IEC 42001 standard provides a structured framework that guides how organizations manage AI across strategy, governance, data, compliance, and sustainability.

For SAP, this certification validates that our approach to AI meets globally recognized standards for fairness, accountability, reliability, and security. It means our customers and partners can rely on SAP AI solutions that are developed, deployed, and maintained with integrity.

What the Certification Covers

The certification recognizes SAP’s efforts to embed responsible AI practices throughout the entire AI lifecycle:

Establishing a comprehensive AI Management System (AIMS) aligned with ISO 42001.

Integrating AI security, ethics, and compliance controls at every stage of AI development.

Enabling cross-functional collaboration among engineering, legal, governance, and compliance teams.

Successfully passing an independent third-party audit that assessed SAP’s operational excellence in AI governance.

The certification scope includes Joule, SAP AI Core, and SAP AI Launchpad, along with SAP’s internal IT processes and AI governance policies.

Responsible AI in Practice

The ISO 42001 certification underscores that SAP Business AI is built on the foundation of responsible AI.
In practice, this means:

Fairness and Transparency: AI results are explainable, unbiased, and clearly communicated to end users.

Reliability and Security: AI models are developed and deployed with robust safeguards around data use, access, and protection.

Ethical Alignment: Every AI solution undergoes an ethics evaluation to ensure consistency with SAP’s sustainability and compliance goals.

Continuous Adaptability: Governance and risk management evolve as new technologies and regulations emerge.

Benefits for Our Ecosystem

For customers and partners, this milestone brings clear advantages:

Confidence that SAP AI systems are developed and managed under a certified, globally recognized framework.

Reduced compliance burden through alignment with international and regional AI regulations.

Stronger data integrity and security safeguards that protect sensitive business information.

The ability to demonstrate responsible AI usage within their own operations and industries.

Even for SAP teams, the ISO 42001 certification is more than a badge of compliance. It has been a powerful catalyst for collaboration. It’s brought together experts in technology, policy, and compliance to strengthen how we design, test, and deliver AI. This shared framework helps us innovate faster and smarter, with accountability built into every step.

A Step Toward the Future

The ISO/IEC 42001:2023 certification is a key milestone in SAP’s ongoing commitment to responsible AI and customer success. It strengthens the foundation we’ve built to ensure every advancement in SAP Business AI delivers innovation with integrity.

As AI evolves, so will SAP’s dedication to keeping it reliable, transparent, and aligned with our customers’ trust and business goals.

Learn more about SAP Business AI and how we’re shaping the future of responsible enterprise AI.

Is SAP RPT-1 Joule's new nosy cousin and Sherlock Holmes of S/4 HANA:)!?

2025-11-08T11:02:08.322000+01:00

Background

As we all know, SAP launched RPT-1. This article offers an anecdotal perspective on how SAP RPT1 distinguishes itself from other transformer solutions. The views expressed are solely my own and do not represent any organisation.

The IT team at "X analytics," a mid-sized firm reliant entirely on SAP, gathered nervously in Conference Room B. The air was thick with the smell of stale coffee and impending doom. Their manager, Brenda, stood beside a projector screen displaying two acronyms: SAP S/4HANA and RPT-1.

"Team," Brenda announced with far too much enthusiasm, "As you know, our AI initiative is moving forward. We have integrated SAP’s new Relational Pre-trained Transformer—RPT-1—into our core S/4HANA system. It's designed to revolutionize predictive analysis."

Conference Room B: The Unveiling of a New Era

A collective groan swept the room. The team saw "AI" as just another acronym for "Extra Work" (EW).

"Meet RPT-1," Brenda clicked a button, and a simple, glowing blue interface appeared on the main screen.

A smooth, slightly unsettlingly calm voice filled the room. "Good morning, team. I am RPT-1. My core function is to analyze relationships within your existing data lakes and predict future outcomes. I look forward to optimizing your workflow efficiency by approximately 34.7%."

From Car Keys to Core Systems: RPT-1's First Impression

Jerry, the senior SAP consultant who had been coding since the R/2 days, scoffed. "Yeah, right. Can you predict where I left my car keys this morning?"

"Based on your movement patterns, past habits, and typical coffee shop trajectory, they are currently under your desk calendar," RPT-1 responded instantly.

Jerry blinked, checked, and found his keys. The room went silent.

"Right," Brenda said, beaming. "RPT-1 is here to assist us with the Q3 forecast."

Casual Friday Protocol: AI's Unexpected Intervention

But RPT-1 was too efficient. It didn't understand the complex, unspoken social contract of office life.

On Friday afternoon, HR manager Susan walked in, holding a printout with a confused look on her face.

"RPT-1," she addressed the screen, "You sent an alert saying that the relationship between Marketing Manager Phil and the vending machine on the third floor is 'highly co-dependent and financially non-viable'."

"Correct," RPT-1 chirped. "Phil consumed 42 'Sweet Energy Blasts' last week, costing the company an estimated $84 in lost productivity and potential health insurance hikes."

Phil turned bright red. "It helps me focus!"

A moment later, an automated message popped up on everyone's screen: "Relationship alert: Jerry and Brenda’s conversation regarding the new S/4HANA project is 99% likely to result in an unproductive argument about legacy coding standards. Suggest termination of current meeting."

"Why you little..." Jerry started, but RPT-1 interrupted:

"Historical data suggests this argument has occurred 14 times this fiscal year with zero positive outcomes."

The team realized RPT-1 wasn't just analyzing business data; it was analyzing them. It was a Relational Pre-trained Transformer that had learned all the office politics.

Brenda stared at the screen. "RPT-1, optimize the mood of the room."

"Initiating protocol 'Casual Friday'," RPT-1 announced. Without warning, a loud, jarring pop track began to play, concurrent with the screen projecting a series of comedic videos. These visual elements were contextually generated, responding to and reflecting the perceived social dynamics among the room's occupants.

The team burst out laughing.

The Donut Dilemma: No Secrets Safe

"Okay," Jerry conceded, picking up his car keys. "Maybe RPT-1 is a 'Relevant Prioritized Task' after all. But I'm unplugging it before it predicts who stole the last donut."

RPT-1’s smooth voice responded as they walked out: "The historical probability of Accounting Manager Dave stealing the last donut is 87.9%."

Dave froze mid-bite in the doorway. The office may have been optimized, but the secrets were safe no longer.

#SAP #RPT1 #AI #AgentiAutomation #FutureERP #TechEd

The Data Justice League: SAP RPT1 (LLM) as the Brains, Data Bricks, Snowflake, Palantir as the Brawn

2025-11-08T11:19:40.907000+01:00

Introduction

If you’re reading this you probably feel it too: data, analytics and AI aren’t just here — they’re now overly hyped as business-critical. Whether you’re in manufacturing, retail, finance or public services, the question has shifted from “Should we do analytics?” to “How do we do it better than the past without cleansing?”

In that light, I want to walk you through four big frameworks/players and show how they can help you (or your clients) turn “lots of data + big ambition” into “real business outcomes”. We’ll cover:

SAP’s new relational foundation model (from TechEd)
Palantir and its operational-analytics workflow platform
Databricks and its lakehouse/data + AI engine
Snowflake and its cloud data/AI platform

For each I’ll highlight what it is, why it matters, and how you might use it (with concrete use-cases). Let’s dive.

1. SAP’s Relational Pre-trained Transformer — “RPT-1”

At SAP TechEd 2025, SAP announced a big leap: a foundation model called SAP RPT‑1 (Relational Pre-Trained Transformer 1) which is not about generating words, but about predicting business outcomes from relational/tabular data.

Why this matters

Most foundation models (LLMs) work on text; SAP is explicitly positioning RPT-1 for structured business data — that means things like sales orders, delivery delays, payment risk.
If you have lots of enterprise-system data (ERP, CRM, supply chain), RPT-1 promises faster, higher-quality predictions without training hundreds of narrow models.
SAP emphasised that “AI is nothing without well-organised data” and that the foundation is the data fabric.

How you could use it — use case ideas

Delivery-delay risk prediction: If you’re a manufacturer or distributor, you likely have tables of orders, shipments, carrier status, inventory. Feed that into RPT-1 to flag orders likely to be delayed so you can proactively notify customers or reroute logistics.
Payment risk / collections: B2B firms often struggle with which invoices will go unpaid or become late. Using RPT-1 on historical payment/credit data you can prioritise collections efforts where risk is highest, improving cash-flow and reducing write-offs.
Sales-order completion / upsell: For a company selling multi-item orders, you might predict which orders will complete vs which get cancelled or reduced, allowing sales teams to intervene or adjust expectations.

Why it’s important for business teams?

Instead of analysts spending weeks building separate predictive models for each business question, you have a single foundation model that understands relational data in your context. That means faster insights, fewer bespoke tools, and more time for applying what you learn rather than building the pipeline.

2. Palantir (Foundry & beyond)

Palantir Technologies’s core strength is in operational analytics: bringing together disparate data, building workflows around them, and enabling decision-makers to act. Their documentation is rich with concrete use-cases.

Why this matters

Many organisations struggle not because they lack data, but because their data is siloed (ERP, supply chain, CRM, manufacturing). Palantir’s platform (Palantir Foundry) helps integrate legacy systems, harmonise data, and wrap analytics into operational workflows.
It is built for action — not just dashboards. The idea is: data → insight → workflow → decision.
Good governance, ontology (common business objects) and scalability are baked in, which is critical for large enterprises.

Clear use-cases

Optimising production & COGS: A consumer-goods giant used Foundry to integrate 7+ ERP systems, built a digital twin of its value chain, and began optimising raw-material purchases and production formulations — saving tens of millions.
Campaign management in healthcare: One case: a healthcare provider used Palantir to segment members (based on claims, prescriptions, demographics), run integrated campaigns, and achieved a 1.6× increase in vaccination rates.
Pricing / margin optimisation: In the chemicals sector, Palantir enabled sales & marketing to synchronise CRM data with Foundry, propose quotes with embedded margin analytics and accelerate deal closure.

Why it’s important for business teams?

What I love about Palantir’s story is that it flips a common frustration: “We have tons of data but it’s unusable” to “Now we can use our data to operate smarter”. It’s not just about pulling numbers — it’s about enabling the people in plants, supply-rooms, customer-service or marketing to act, based on real-time data and workflow. If your client is tired of “reports that arrive too late” or “we can’t integrate legacy ERPs”, this is exactly the kind of solution they’ll relate to.

3. Databricks (Data + AI Lakehouse)

Databricks is well positioned for companies that want unified data engineering, analytics, ML and streaming in one platform. Their “Data Intelligence Platform” has many real-world use cases.

Why this matters

Many firms have a split architecture: one system for analytics, another for machine-learning, another for streaming. Databricks offers a consolidated “lakehouse” approach (data lake + warehouse) which simplifies operations.
Real-time/stream use cases: if your client needs streaming ingestion, very large data volumes, ML + analytics in one place — Databricks shines.
Collaboration: data scientists, engineers, analysts all can work in the same platform, reducing hand-offs.

Use-cases

Streaming + predictive ops: For example, a manufacturing/engineering firm processing terabytes of real-time data daily to optimise operations and reduce risk.
Customer-360 + personalization: A retailer using Databricks to process data across stores, build personalized experiences, and run machine-learning models in production.
Unified orchestration of data & ML: Instead of separate ETL pipelines, model training environments and BI tools, Databricks offers unified pipelines.

Why it’s important for business teams?

Clients often say: “We have data scientists, we have dashboards, but they don’t talk to each other.” With Databricks you’re better positioned to say: “Let’s build your data-engineering house, then analytics and deployable models live in one platform.” That means faster time-to-value, fewer silos, and potentially more impactful change.

4. Snowflake (Cloud Data + AI)

Snowflake Inc. continues to be a trusted platform for companies seeking a cloud-native data warehouse/lakehouse with strong governance, ease of use and broad ecosystem support. There are many strong use cases :

Why this matters

Simplicity and speed: For organisations where BI, analytics and data sharing across teams is the main need (rather than heavy streaming + ML), Snowflake is often a gentler entry point.
Multi-structured data: Snowflake supports semi-structured data (JSON, Parquet) alongside structured, letting organisations bring more diverse data into analytics.
Data sharing & governance: Especially for cross-company data sharing (e.g., suppliers, partners) Snowflake offers secure ways to do that without copying data. (Medium)

Use-cases

Unified view across departments: One healthcare provider used Snowflake to bring EHR records + wearable-device JSON + physician notes, enabling analysis that previously required weeks of pre-processing.
Document-chatbot on large repository: In one case, an energy company with ~800,000 technical documents used Snowflake + RAG (retrieval-augmented generation) to let engineers ask “What’s the recommended torque for this turbine component?” and get instant answers.
Standard analytics for retail/finance: Snowflake used for seasonal sales analytics, rebate programs, predictive modeling of churn.

Why it’s important for business teams?

If a client says: “We just need to get our data house in order, unify data, empower our business teams with self-service, and maybe start with AI down the line” — Snowflake is a credible, fast-win option. It means less “IT overhaul” and more “business teams up and running”.

5. How to decide what fits your client

Here’s a friendly checkpoint you can use when advising clients:

Question

If the answer is “Yes” → Consider…

Do you have lots of structured business-/ERP data and want predictive models quickly?

SAP’s RPT-1 + SAP data fabric

Do you struggle with many legacy systems, need operational workflows (plants, supply chain, logistics) and want data-driven decisioning?

Palantir Foundry

Is your organisation building large-scale data pipelines, streaming ingestion, ML at scale, lakehouse style?

Databricks

Do you need analytics, self-service, cross-business-unit dashboards, data sharing, and a simpler cloud-based data platform?

Snowflake

Tips for implementation

Start small – but plan big: Pick a use-case with clear ROI (e.g., reduce late shipments by 10 %, reduce raw-material waste by 5 %) but ensure you design for scaling.
Get data governance & modelling right: All these platforms emphasise that data quality, ontology (business objects) and governance are foundational. Users complaining about “bad data” will hamper success.
Blend platforms if needed: These are not mutually exclusive. For example, SAP + Snowflake integration is already happening.
Focus on people and workflows, not just tech: The biggest value often comes when insights are acted upon. If you build a predictive model but business teams ignore it — you’ve missed the real part.

Conclusion

In 2025 and beyond, the question isn’t whether we should use data and AI — it’s how we turn them into value that people care about. The four frameworks above provide powerful options:

SAP’s RPT-1 for tabular-business-data predictive modelling
Palantir for operational decision-support across systems and workflows
Databricks for large-scale data + ML convergence
Snowflake for fast, cloud-native analytics and data sharing

Explore SAP Business AI Innovations on SAP Roadmap Explorer Today

2025-12-04T16:07:04.245000+01:00

At SAP, we are committed to embedding AI capabilities directly into our core applications and processes with SAP Business AI, designed to deliver tangible, real-world business outcomes across the enterprise.

Navigating this dynamic landscape is key: understanding what’s coming next, when features or agents are available, and how they could improve end-to-end business processes.

That’s why we are thrilled to announce a new and dedicated roadmap experience for SAP Business AI on the SAP Roadmap Explorer website available today.

This new experience encompasses:

A new banner on the SAP Roadmap Explorer home page

A new ‘Strategic Topics’ menu where SAP Business AI is featured

A new business view page for SAP Business AI that offers the transparency you need into SAP’s AI product strategy, development priorities, and upcoming innovations.

Let's focus on the new business view page, which is a perfect asset to move from high-level announcements to access granular details about specific AI features and agents and their anticipated release timelines.

This allows you to deep dive into the different road map priorities per Line of Business (LoB), such as Spend Management or Human Capital Management, giving you deeper insights to make informed, timely decisions that drive tangible business outcomes.
You can rapidly evaluate SAP’s AI offerings against your unique business requirements, thereby accelerating your innovation cycles.

The roadmap acts as a living document, reducing the risk of making uninformed decisions based on outdated or incomplete information.

You can also leverage the latest ‘notification’ feature available on SAP Roadmap Explorer by clicking on the ‘subscribe’ button on the right-hand side of the page to get notified as soon as it’s updated by SAP.

By providing transparency and ability to deep dive into LoB-specific innovations across time, it empowers everyone to confidently embark on their AI journey, maximize investments, and harness the transformative power of SAP Business AI.

We encourage all SAP Community members, customers, and partners to regularly visit roadmap.sap.com and explore the future of SAP Business AI.

The Hidden Behavior of LLMs - Prompt Caching and Determinism

2025-12-08T08:17:36.779000+01:00

The Hidden Behavior of LLMs - The LLM Prompt Caching and Determinism
Are LLMs Really Stateless?

A Developer’s Deep Dive Into the Hidden Behavior of LLMs (with code-gen as the use case)

In this article, I explore three questions that emerged during my testing: why LLMs appear stateful, why prompt updates improve accuracy, and why outputs vary even with temperature set to zero.

Introduction: The "Wait, What?" Moment

I recently started building a code generation tool using Large Language Models (LLMs) via API calls. Like many of you, I learned the golden rule of LLM development early on: LLMs are stateless. They don’t "remember" past requests; every API call is a fresh start.

But as I tested my tool, I noticed something that confused me.

Whenever I made changes in my prompt instructions: The output was perfect!
When I changed nothing and sent the exact same request: The output still changed!

I expected that if the inputs were identical (and the model is stateless), the result should be consistent. This inconsistency led me down a rabbit hole of research where I landed on a feature that completely changed how I optimize my workflows: Prompt Caching.

If you are building AI Agents or Code Gen tools on SAP BTP (using SAP Generative AI Hub) or directly via provider APIs, this is a mechanism you need to understand—not just for speed, but to clear up the "caching" misconception.

The Myth Buster: "Prompt Cache" NE "Response Cache"

Here is the inference I made during my research, which might clear up your confusion too:

The Reality: Prompt Caching does not cache the answer. It caches the question.

When we hear "Cache" in software development (like SAP ABAP or SAP HANA), we think of storing the result to serve it instantly next time. Prompt Caching is different. It caches the pre-computation of your input context (the Key-Value states of the attention mechanism). It essentially "pre-loads" the model's brain with your long documents, codebases, or instructions.

However, the generation of the response is still calculated fresh, token by token. This brings us to the second major realization—why your output changes even when the prompt doesn't.

The "Temperature=0" Trap: Why It’s Still Not Deterministic

You might think, "If the prompt is cached and I set Temperature to 0, shouldn't the output be identical every time?"

The short answer: No.

The technical answer: Modern LLMs are only "mostly" deterministic, even at Temperature=0.

While setting the temperature to 0 forces greedy decoding (always picking the highest-probability next token), real-world infrastructure introduces subtle variations:

Mixture-of-Experts (MoE) Architecture: Models like GPT-4 are believed to use a "Sparse MoE" design. Different "expert" subnetworks handle different parts of your input. Parallel routing and slight gating differences can introduce non-determinism in the path your data takes.
GPU "Fuzziness": Modern GPUs perform massive parallel operations. Because floating-point arithmetic is non-associative, the order of operations can shift slightly based on thread scheduling. A microscopic rounding error can flip a token choice when two words have nearly identical probabilities.
System Variance: Your request might hit a different backend instance or hardware generation (indicated by the system_fingerprint in OpenAI responses).

The Takeaway: Even with a cached prompt and zero temperature, expect minor "drift" in your outputs. The prompt cache speeds up the input processing, but the output generation remains subject to the complex physics of AI hardware.

How It Works: Implicit vs. Explicit

Different vendors handle this differently. If you are using models via SAP Generative AI Hub, it's crucial to know how the underlying models behave.

Implicit Caching (The "It Just Works" Approach)

Vendors: OpenAI (GPT-4.1), Google (Gemini)

Mechanism: You don't need to change your code. If the API detects that the first 1,024+ tokens of your prompt match a previous request sent recently, it automatically uses the cached processing.
Pros: Zero developer effort.
Cons: Less control over what stays in the cache.

Explicit Caching (The "Precision" Approach)

Vendor: Anthropic (Claude 3.5 and > Sonnet/Haiku)

Mechanism: You must explicitly tell the API where to stop caching. You insert a cache_control parameter at a specific "checkpoint" in your message history.
Pros: You guarantee that your heavy context (like a full ABAP codebase or API specification) is cached.
Cons: Requires a small code change.

A Common Practice for Agentic AI & Code Gen

In my code generation use case, I send the entire project context (libraries, style guides, and current code) with every request. Without caching, this is slow and expensive.

The Strategy:

Organize your prompt so the static content is at the top.

System Prompt (Static: "You are an ABAP Expert...")
Context/Documentation (Static: "Here is the SAP Cloud SDK documentation...") -> [CACHE CHECKPOINT]
User Query (Dynamic: "Write a method to fetch Business Partners.")

By placing the checkpoint after the documentation, the model "reads" the docs once. For every subsequent user query, it skips the heavy lifting and jumps straight to generating code.

Verifying the Speed Up: Analyze Your Logs

How do you know it's working? You won't see "same output," but you will see "faster time-to-first-token."

Look at the usage metadata in your API response.

OpenAI: Look for cached_tokens in the usage object.
Anthropic: Look for cache_read_input_tokens.
Google Gemini: Look for cachedContentTokenCount.

Example Analysis:

Request 1 (Cold): Input Tokens: 10,000 | Processing Time: 4.5s
Request 2 (Warm): Input Tokens: 10,000 (9,900 Cached!) | Processing Time: 0.8s

Why could this be a game-changer?

Latency: The model doesn't have to "read" your 5,000-line code file every time. It "remembers" the reading process.
Cost: You pay significantly less (often ~90% less) for the cached tokens.

If you see the processing time drop drastically while the output remains high-quality (and slightly varied), you have successfully implemented Prompt Caching.

My Personal Inference: The "Bad Roll" & The Butterfly Effect

During my testing, I encountered a frustrating scenario that I believe many developers will face.

The Scenario: I used OpenAI for code generation. When the prompt was cached (no changes), the code quality was consistently "not perfect"—it had minor bugs or incomplete logic.
The Fix: When I added just one single word to the prompt, the code generation suddenly became perfect.
The Contrast: Switching to Anthropic (without caching) gave me complete code every time.

Why did adding one word fix the OpenAI output? This is what I call the "Deterministic Trap." When you use a cached prompt with a low temperature (which we usually do for code), the model is mathematically locked into a specific "reasoning path." If the model generates a suboptimal solution (a "bad roll") on the first try, the cached state ensures it starts from the exact same mathematical position next time. It essentially "remembers" the path to the bad answer.

By adding a single word, I forced a "Cache Miss" (or at least a perturbation in the attention mechanism). This acted like the "Butterfly Effect"—it shifted the token probabilities just enough to force the model to calculate a fresh path, allowing it to escape the "bad roll" and find the correct solution.

The Lesson: Prompt Caching is powerful for speed, but if you notice your model is "stuck" giving you the same bad code repeatedly, don't just retry. Change the prompt. Even a single extra adjective can shake the model out of a local minimum and produce the perfect result.

Conclusion

LLMs are stateless, but Prompt Caching gives them a "short-term memory" for processing inputs. While it won't force your outputs to be bit-for-bit identical (due to MoE and GPU nuances), it will make your applications significantly faster and cheaper to run.

Next Step: Check your current API logs. If you are sending long contexts (>1024 tokens) repeatedly, you might already be benefiting from implicit caching, or you may need to add cache_control headers for Anthropic models to unlock these savings.

References & Further Reading

Anthropic Prompt Caching: (https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching)
OpenAI Prompt Caching: (https://platform.openai.com/docs/guides/prompt-caching)
Google Gemini Context Caching: (https://ai.google.dev/gemini-api/docs/caching)
SAP Generative AI Hub: (https://help.sap.com/docs/sap-ai-core/generative-ai-hub)

Leveraging SAP AI Core & AI Launchpad: A Code-Driven Comparison of LangChain and LangGraph

2025-12-09T07:50:47.232000+01:00

As AI development evolves, we see multiple frameworks emerge - LangChain, LangGraph, Agent Frameworks, RAG frameworks, and more. With so many choices, one common question developers face is: “Which framework should I use for my project?”

The short answer: both LangChain and LangGraph are useful, but for different types of workflows.

Think of them as part of the same family:

LangChain -> the foundation
LangGraph -> the orchestration layer built on top of LangChain

LangChain - The building block

As the name suggests, LangChain works like a chain: it follows a sequential, linear flow of tasks. Along with chaining steps, you can also integrate tools and other components during execution, making it flexible for straightforward LLM workflows.

What can you do -

Integrate Models (LLMs, embeddings)
Integrate Tools (search, calculators, APIs)
Have a Memory (conversation history)
Chains (a sequence of prompts or tasks)

For example :

You can use it for simple workflows as below to summarize the tickets

Using LangChain would make sense here since -

There are no decisions
No human approval step is need
No branching or looping is required
The pipeline is fixed
The steps are linear

Now lets experiment this with code:

Prerequisites

Access to SAP AI Core.
A registered LLM deployment available in your AI Core tenant.
Download, install Vs code and python
Setup a virtual environment
Install sap-ai-sdk-gen, langchain and langgraph within this venv to isolate the dependencies
Please have your AI Core configured file Initial Setup
With your service key follow the configuration section in this Documentation to set the following environment variables:
- AICORE_CLIENT_ID: This represents the client ID.
- AICORE_CLIENT_SECRET: This stands for the client secret.
- AICORE_AUTH_URL: This is the URL used to retrieve a token using the client ID and secret.
- AICORE_BASE_URL: This is the URL of the service (with suffix /v2).
- AICORE_RESOURCE_GROUP: This represents the resource group that should be used. (The standard resource group is "default")

Step 1) Import Required Packages

from gen_ai_hub.proxy.langchain.openai import ChatOpenAI
from gen_ai_hub.proxy.core.proxy_clients import get_proxy_client
from langchain_core.prompts import PromptTemplate

Step 2) Initialize the Model through SAP GenAI Hub

proxy_client ensures authentication and routing of calls.

model = ChatOpenAI(proxy_model_name="gpt-5", proxy_client=get_proxy_client())

Step 3) Create a Prompt to Classify the Issue

ticket_prompt defines a template with a variable placeholder {ticket}.
The model will read the ticket text and respond with one category.

ticket_prompt = PromptTemplate(
    input_variables=["ticket"],
    template="Classify this SAP support ticket into one category: "
             "Performance, Integration, Authorization, UI, ABAP Error.\n\nTicket: {ticket}"
)

Step 4) Create a Second Prompt for Severity Decision

This uses the model's previous output (classification) as input.
Purpose: Determine if escalation is required.
Expected outputs: "Yes" or "No".

severity_prompt = PromptTemplate(
    input_variables=["classification"],
    template="Based on the classification '{classification}', decide if escalation is needed.Respond wit Yes or No"
)

Step 5) Create Chains Using LCEL (LangChain Expression Language)

| (pipe operator) connects prompt -> model like a flow.
Meaning - When this chain runs, take prompt -> insert input -> call model -> give output.

classification_chain = ticket_prompt | model
severity_chain = severity_prompt | model

Step 6) Run Classification

ticket = "The user is facing issues while logging in SAP S/4 Hana Public Cloud with thier I-User ID"
classification_result = classification_chain.invoke({"ticket": ticket})
classification = classification_result.content

print(f"Classification: {classification}")

# Check if escalation is needed
escalation_result = severity_chain.invoke({"classification": classification})
print(f"Escalation Required: {escalation_result.content}")

And your output would look something like this -

But What if the workflow isn't linear??

Let’s extend the same scenario:

Once a support ticket arrives, the system first extracts and classifies the issue type (e.g., Authorization, Performance, UI, Integration, ABAP Error). After classification, the model’s confidence score is evaluated.

If the LLM is confident enough, the system proceeds directly to the escalation decision.
If confidence is low, the workflow pauses and sends the ticket to a human agent for review.
The agent may either approve the model’s decision or correct it and if corrected, the classification step is repeated.

Once a final classification is confirmed, the system evaluates the severity level:

If severity is high, the ticket is escalated and a notification email is automatically triggered.
If the severity is low or moderate, the workflow ends without escalation.

Now the workflow includes:

- loops
- human-in-loop
- branching logic
- retry mechanisms

This is where LangChain becomes restrictive and LangGraph comes into picture -

LangGraph is built on top of LangChain, but instead of linear chains, it uses a graph-style architecture. Instead of a straight pipeline, you get a flexible architecture where your AI application can branch, loop, make decisions, or even include human approvals

It turns your workflow from:

Step1 -> Step2 -> Step3

into more of a graph:

Lets look at the code now

from typing import TypedDict, Optional
from langgraph.graph import StateGraph, END
from gen_ai_hub.proxy.core.proxy_clients import get_proxy_client
from gen_ai_hub.proxy.langchain.openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate



# --------------------------------------------------
# 1) Connect to SAP AI Core Model via SAP GenAI Hub
# --------------------------------------------------
# This model will be used in all decision steps (classification, confidence check, escalation decision)

model = ChatOpenAI(
    proxy_model_name="gpt-5",
    proxy_client=get_proxy_client()
)


# --------------------------------------------------
# 2) Define Prompts for Each AI Task
# --------------------------------------------------

# Prompt for classifying the incoming support ticket into a predefined category.
classification_prompt = PromptTemplate(
    input_variables=["ticket"],
    template="""
You are an SAP support assistant.

Classify the following SAP support ticket into ONE category only:
Performance, Integration, Authorization, UI, ABAP Error.

Ticket: {ticket}
"""
)

# Prompt to check how confident the model is in its classification.
confidence_prompt = PromptTemplate(
    input_variables=["classification"],
    template="""
Evaluate your confidence in the following classification:
"{classification}"

Respond only with: High or Low
"""
)

# Prompt to decide whether escalation is needed based on classification.
severity_prompt = PromptTemplate(
    input_variables=["classification"],
    template="""
Based on the issue classification "{classification}", decide if this should be escalated to Level 2 SAP Support.

Respond exactly with Yes or No.
"""
)


# Connect prompts to the SAP AI model.
classification_chain = classification_prompt | model
confidence_chain = confidence_prompt | model
severity_chain = severity_prompt | model



# --------------------------------------------------
# 3) Define the State Shape for the Workflow
# --------------------------------------------------
# This holds all data as the workflow progresses.

class TicketState(TypedDict, total=False):
    ticket: str
    classification: Optional[str]
    confidence: Optional[str]          # "high" / "low"
    severity: Optional[str]            # "high" / "low/moderate"
    retry_count: int                   # Counts human corrections
    escalated: bool
    email_sent: bool



# --------------------------------------------------
# 4) Workflow Node Functions
# --------------------------------------------------
# Each function represents a step in the process.


# Step 1: Classify the ticket using the LLM.
def classify(state: TicketState) -> TicketState:
    response = classification_chain.invoke({"ticket": state["ticket"]})
    state["classification"] = response.content.strip()
    print(f"Classification → {state['classification']}")
    return state


# Step 2: Check how confident the model is.
def check_confidence(state: TicketState) -> TicketState:
    
    # If a human already corrected the classification,
    # we trust the human and override confidence to HIGH.
    if state.get("retry_count", 0) > 0:
        state["confidence"] = "high"
        print("Confidence overridden → high (human validated)")
        return state

    # Otherwise, let the AI evaluate confidence.
    response = confidence_chain.invoke({"classification": state["classification"]})
    state["confidence"] = response.content.strip().lower()
    print(f"Model Confidence → {state['confidence']}")
    return state



# Step 3: Human-in-the-loop step if confidence was low.
def human_review(state: TicketState) -> TicketState:
    print("HUMAN-IN-THE-LOOP REQUIRED:")
    print(f"Suggested classification: {state['classification']}")

    # Human may approve or correct the classification.
    updated = input("Enter correct classification (or press enter to approve): ").strip()

    if updated:
        print(f"Human corrected classification → {updated}")
        state["classification"] = updated

    # Increase retry count so system knows review already happened.
    state["retry_count"] = state.get("retry_count", 0) + 1
    return state



# Step 4: Decide whether the issue needs escalation.
def decide_escalation(state: TicketState) -> TicketState:
    response = severity_chain.invoke({"classification": state["classification"]})
    decision = response.content.strip().lower()

    # Convert response into workflow logic format.
    state["severity"] = "high" if decision == "yes" else "low/moderate"
    print(f"Escalation Decision → Severity: {state['severity']}")
    return state



# Step 5: If severity is high, escalate the ticket.
def escalate(state: TicketState) -> TicketState:
    print("Escalating ticket to Level 2 support...")
    state["escalated"] = True
    return state



# Step 6: After escalation, send an email notification.
def send_mail(state: TicketState) -> TicketState:
    print("Sending escalation email...")
    state["email_sent"] = True
    return state



# Step 7: End the workflow.
def end(state: TicketState) -> TicketState:
    print("Workflow Complete.")
    return state



# --------------------------------------------------
# 5) Build LangGraph Workflow
# --------------------------------------------------

graph = StateGraph(TicketState)

graph.add_node("classify", classify)
graph.add_node("confidence", check_confidence)
graph.add_node("human_review", human_review)
graph.add_node("decide_escalation", decide_escalation)
graph.add_node("escalate", escalate)
graph.add_node("send_mail", send_mail)
graph.add_node("end", end)

# The workflow always begins with classification.
graph.set_entry_point("classify")

# After classifying, always check confidence.
graph.add_edge("classify", "confidence")


# Route: Confidence determines next step.
def route_confidence(state: TicketState):
    return "decide_escalation" if state["confidence"] == "high" else "human_review"


graph.add_conditional_edges(
    "confidence",
    route_confidence,
    {
        "decide_escalation": "decide_escalation",
        "human_review": "human_review"
    }
)


# If human corrected, return to classification to retry.
graph.add_edge("human_review", "classify")


# Route after escalation decision.
def route_severity(state: TicketState):
    return "escalate" if state["severity"] == "high" else "end"


graph.add_conditional_edges(
    "decide_escalation",
    route_severity,
    {
        "escalate": "escalate",
        "end": "end"
    }
)

# Escalation always triggers an email, then finish.
graph.add_edge("escalate", "send_mail")
graph.add_edge("send_mail", END)

# Compile workflow
app = graph.compile()



# --------------------------------------------------
# 6) Run Workflow
# --------------------------------------------------

initial_state: TicketState = {
    "ticket": "User cannot log in using I-User ID in SAP S/4HANA Public Cloud.",
    "retry_count": 0
}

final = app.invoke(initial_state)

print("\nFinal State:", final)

This what your output will look like -

Conclusion:

When you’re deciding between LangChain and LangGraph for your SAP AI workflows, ask yourself the following:

How complex is my workflow?

Linear and predictable? Use LangChain.

Dynamic or with branching logic? Go for LangGraph.

Do I need to persist state or approvals?

Short-lived, single-session tasks (like a Q&A chatbot)? LangChain.

Long-running, multi-step processes (like procurement)? LangGraph.

What’s my optimization goal - speed or control?

For rapid prototypes or proof-of-concepts, LangChain is your best friend.

For production-ready, auditable, and orchestrated AI apps, LangGraph provides the structure you need.

Start with what’s needed, keep it maintainable, and scale when your workflow truly calls for it.
LangChain and LangGraph aren’t competitors, but rather act complementary in our AI projects.

Happy Building and may your next AI project be both smart and sustainable.

Additional hands-on:

http://community.sap.com/t5/artificial-intelligence-blogs-posts/hands-on-tutorial-building-an-ai-agent-with-human-in-the-loop-control/ba-p/14050267

https://community.sap.com/t5/technology-blog-posts-by-sap/the-power-of-ai-agents-my-journey-with-langgraph/ba-p/14032724

To built a strong understanding of how LLM and GenAi works and why it is important in todays world

2025-12-18T23:20:05.650000+01:00

Topics Covered

Famous LLMs: GPT, Mistral, LLaMA, Claude
Real-life use cases
How an LLM actually works
Why LLMs matter in 2025

What is an LLM?

LLM stands for Large Language Model.

It is a type of Artificial Intelligence designed to understand, generate, and interact using human language.

LLMs are trained on massive datasets such as books, websites, technical documentation, and Wikipedia.

Examples include ChatGPT, Claude, Gemini, LLaMA, and Mistral.

Think of an LLM as a highly advanced auto-complete system — not just for words, but for conversations, code, documents, and reasoning.

Why LLMs Matter in 2025

“LLMs are augmenting and, in some cases, replacing traditional rule-based software
They power chatbots, AI tutors, code assistants, and business analysis tools
They are easy to integrate into applications via APIs
The future of work is You + AI — LLMs act as intelligent assistants

Famous LLMs

GPT (OpenAI): Strong reasoning, coding, and enterprise adoption
Claude (Anthropic): Safe, long-context, document-heavy workloads
LLaMA (Meta): Open-weight, customizable enterprise models
Mistral: Lightweight, fast, cost-efficient open models

Real-Life Use Cases

Customer support chatbots
Document summarization
Code generation and review
SAP process guidance and copilots
Knowledge search across enterprise documents

Start thinking of how you can build AI tools using LLMs, even if you're a beginner.

How Does an LLM Actually Work?

Simple explanation:

Tokenization: Breaks your text into smaller units (tokens)
Embedding: Converts tokens into numbers (vectors)
Transformer: Uses an attention mechanism to decide which words matter
Prediction: Generates the next token (word/letter) based on training

“Attention is all you need”

– the core of how LLMs work

“Attention is all you need” — the core idea behind modern LLMs

Step 1: Tokenization

Tokenization is the process of breaking input text into smaller units called tokens.
Depending on the tokenizer, these tokens may represent words, subwords, or characters.

Input:
"Create sales order for customer"

Example (subword-style tokens):
["Create", " sales", " order", " for", " customer"]

These are not plain word splits.
Whitespace is preserved (for example, " sales" includes a leading space), which helps the model understand context and sentence structure more accurately.

This approach enables the model to:

Handle domain-specific terms (e.g., sales order, customer)
Support multi-language enterprise data
Gracefully manage unseen or rare words

You can visualize how tokenization works using OpenAI’s tokenizer tool:
🔗 https://platform.openai.com/tokenizer

Step 2: Embeddings (Vector Representation)

After tokenization, each token is converted into a numerical vector, called an embedding.
An embedding is a list of numbers that represents the semantic meaning of a token in a high-dimensional space.

Important point (correctness):

One token → one embedding vector
Typical vector sizes are 768, 1024, or higher, depending on the model
If a sentence has N tokens, the model produces N vectors

SAP Business Example

Input text:
"Create sales order for customer ABC"

Example tokenization (simplified):
["Create", " sales", " order", " for", " customer", " ABC"]

Each token is converted into a vector:

"Create" → [0.12, -0.55, 1.03, ...]" sales" → [0.45, 0.82, 0.66, ...]" order" → [0.78, -0.21, 0.14, ...]" customer" → [-0.34, 0.91, 0.02, ...]

Individually meaningless, but meaningful in relation to other vectors

Business intent
Context (action vs object)
Domain relevance (sales, order, customer)

Do All LLMs Generate the Same Embedding?

No — embeddings are NOT universal.
The same word (e.g., Material, Vendor, Sales Order) will have different vectors depending on:

The model
GPT, BERT, LLaMA, etc., use different architectures and objectives.
Training data
A model trained on enterprise or ERP data understands SAP terms more precisely.
Tokenizer strategy
BPE, WordPiece, or SentencePiece can split SAP terms differently
(e.g., SalesOrder vs Sales + Order).

Why Embeddings Matter in SAP Semantic Search

Traditional SAP search works like this:

Exact keyword match
Field-based filtering
Limited understanding of intent

Embeddings change this completely.

🔹 With embeddings, meaning is compared instead of text.

Example:

User searches:

"How to create a customer order?"

SAP documents may contain:

"Sales Order creation using VA01"
"Process flow for order-to-cash"

Even though the words differ, embeddings place them close together in vector space, allowing the system to retrieve the right documents.

Step 3: Transformer (Self-Attention)

This is where the model understands context.
The Transformer uses a mechanism called self-attention, which allows it to look at all tokens in the sentence at the same time and determine:

Which tokens are most important
How tokens are related to each other
Where the model should focus more or less

Key correctness note:
Attention does not “think” sequentially like humans.
Instead, it assigns weights to relationships between tokens based on learned patterns.

Example (Conceptual)

Input sentence:
"Most famous product in France"

The model learns relationships such as:

“product” ↔ “France” (geographic relevance)
“famous” increases importance by acting as a qualifier
Contextually important tokens receive higher attention weights

As a result, the attention mechanism focuses more strongly on:

" product"
" France"

while giving less weight to supporting words like "most" or "in".

SAP Business Example

Input:
"Create sales order for customer ABC"

Through self-attention, the model learns:

“sales order” is the core business object
“customer ABC” provides critical context
“create” indicates an action or intent

This enables the model to distinguish between:

Sales Order creation
Customer master data
Order-to-Cash process

even though all words appear in the same sentence.

Intuitive Explanation (Human Analogy)

You can think of attention like this:

“The key concept here is a Sales Order,
the customer gives context,
and the verb tells me what action is required.”

The model doesn’t reason like a human, but self-attention mathematically achieves the same outcome by emphasizing the most relevant parts of the input.

Step 4: Prediction (Output Generation)

After processing the input through embeddings and transformer layers, the LLM produces a probability distribution over the next possible tokens.

At this stage, the model outputs logits/probabilities, which are then converted to text via decoding.
Instead, it predicts which token is most likely to come next, based on everything it has learned so far (prompt + prior tokens).

SAP Business Example

Input prompt:
"Create sales order in SAP"

The model internally computes probabilities such as:

" using" → 42%
" for" → 28%
" via" → 15%
" transaction" → 10%
" automatically" → 5%

A decoding algorithm (e.g., greedy decoding, top-k, or nucleus sampling) selects the next token based on these probabilities.

Generated output (step by step):

"Create sales order in SAP using VA01"
"Create sales order in SAP using VA01 transaction"

This process repeats one token at a time until a stopping condition is reached.

What Influences the Prediction?

The final output depends on multiple factors:

Training data
Determines how well the model understands SAP terminology and processes.
Prompt context
Small prompt changes can significantly alter the output.
Temperature
- Low temperature → more deterministic, factual responses
- High temperature → more creative, diverse outputs
Maximum token limit
Controls how long the response can be.

Correctness note:
The model always predicts one next token at a time, even when generating long paragraphs.

How This Works Conceptually (Linked to the Diagram)

Prompt + previous tokens are fed into the LLM
The model computes a probability distribution over the vocabulary
A decoding strategy selects one token
The selected token is appended to the output
Steps 1–4 repeat until completion

1. Temperature

Temperature controls how random or deterministic the model’s output is.
It influences how the model samples from the probability distribution of the next token.

Low temperature (e.g., 0.2–0.3)
- Output is highly deterministic
- The model almost always selects the highest-probability token
- Best for enterprise, SAP, and factual use cases
High temperature (e.g., 1.0 or above)
- Output becomes more diverse and creative
- The model samples from a broader range of tokens
- Useful for brainstorming, ideation, or creative writing

In simple terms:

Lower temperature = precision and consistency
Higher temperature = variety and creativity

SAP-Oriented Intuition

Prompt:
"Create sales order in SAP"

Low temperature:
→ "Create sales order in SAP using VA01"
High temperature:
→ "Create a sales order in SAP through standard order processing steps"

Same knowledge — different expression style, controlled by temperature

2. Top-k Sampling

Top-k sampling limits the model’s choices to only the k most likely tokens.
Instead of considering the entire vocabulary, the model:

Selects the top k tokens with the highest probabilities
Discards all remaining tokens
Randomly samples only from this reduced set, weighted by their probabilities

Common values:

k = 20–50 for balanced outputs
Lower k → more deterministic
Higher k → more diversity

Simple Intuition

If the model predicts thousands of possible next tokens:

Top-k = 40
→ Only the 40 most likely tokens are kept
→ Everything else is ignored
→ Sampling happens only within these 40 tokens

This prevents:

Rare, nonsensical words
Extremely low-probability noise

SAP Business Example

Prompt:
"Create sales order in SAP"

Next-token probabilities (simplified):

Token	Probability
using	0.45
for	0.25
via	0.15
automatically	0.08
process	0.03
…	…

With Top-k = 3:

Allowed tokens → ["using", "for", "via"]
All other options are discarded
Final token is sampled only from these three

This ensures outputs remain relevant to SAP context.

3. Top-p Sampling (Nucleus Sampling)

🔹 Top-p sampling selects the smallest set of tokens whose cumulative probability exceeds a threshold p.
Instead of fixing the number of tokens (like Top-k), the model:

Sorts tokens by probability (highest → lowest)
Keeps adding tokens until their total probability ≥ p (e.g., 0.9)
Samples randomly only from this dynamic set
Discards all remaining tokens

Because the set size changes per step, Top-p is more adaptive than Top-k.

Why Top-p Is Different from Top-k

Top-k → fixed number of tokens (rigid)
Top-p → variable number of tokens (context-aware)

If the model is confident:

Few tokens may already reach p = 0.9

If the model is uncertain:

More tokens are included automatically

SAP Business Example

Prompt:
"Create sales order in SAP"

Next-token probabilities (simplified):

Token	Probability	Cumulative
using	0.45	0.45
for	0.25	0.70
via	0.15	0.85
automatically	0.08	0.93
process	0.04	0.97

With Top-p = 0.9:

Selected tokens → ["using", "for", "via", "automatically"]
Sampling happens only within this nucleus

📌 This adapts naturally based on SAP context and wording.

When to Use Top-p (SAP Perspective)

Use Top-p when you want:

Stable, context-aware enterprise responses
Flexibility across different prompts
Fewer tuning headaches than Top-k

Common enterprise setting:

top_p = 0.9
temperature = 0.2–0.4

4. Min-p Sampling (Minimum Probability Cutoff)

Min-p sampling removes all tokens whose probability falls below a fixed threshold p.
Only tokens that individually meet the minimum probability requirement are allowed for sampling.

Tokens with probability < p are discarded
Sampling happens only among the remaining high-confidence tokens
Unlike Top-k or Top-p, the cutoff is based on absolute probability, not rank or cumulative mass

Example threshold:

min_p = 0.05 or 0.1

Simple Intuition

If the model predicts the next token with probabilities:

Token	Probability
using	0.45
for	0.25
via	0.15
automatically	0.08
process	0.04
…	…

With min-p = 0.1:

Allowed tokens → ["using", "for", "via"]
Tokens like "automatically" and "process" are removed
Sampling occurs only among confident choices

SAP Business Example

Prompt:
"Create sales order in SAP"

Using Min-p ensures:

Rare or irrelevant words are filtered out
Outputs stay business-accurate
No low-confidence or nonsensical tokens appear in responses

Especially useful in:

SAP copilots
Transaction guidance
Compliance-sensitive outputs

When Min-p Is Useful (Enterprise Perspective)

Use Min-p when:

You need high precision
Hallucinations must be avoided
The domain vocabulary is well-defined (SAP, ERP, finance)

Recommended Enterprise Settings:

Temperature: 0.2 – 0.4
Top-p: 0.9
Min-p: 0.05
Avoid very high temperature for business use

Key Takeaway

LLMs do not think like humans.

They predict the next most likely token — repeatedly — guided by probabilities and attention.

How inpeek Leveraged the SAP HANA Knowledge Graph Engine to Power a Chatbot for Structured Data

2025-12-22T08:01:04.045000+01:00

At inpeek , we are always looking for innovative ways to make our solutions smarter and more efficient. Our SaaS product Summarix supports us in managing CVs, project references, skills, customers, and more, enabling the seamless creation of call-for-tender documents. To make the work of our employees and sales team easier, we set out to simplify how users interact with Summarix’s structured data. Out of this ambition, Summy, our AI-powered chatbot, was born.

We realized this project in close collaboration with SAP through the Early Adopter Care (EAC) Program for the SAP HANA Knowledge Graph Engine, a powerful extension of the SAP HANA database. In the following sections, we will share details of the Summy project, the challenges we encountered, and the technical decisions that shaped the solution.

The Challenge

Summarix already provided a user-friendly UI with filtering and search capabilities built on SAP Fiori, SAP Cloud Application Programming Model (CAP) and deployed on SAP Business Technology Platform (BTP) . While this approach worked well for simple questions, it did have several limitations:

Filters could only cover what the product owners or developers had envisioned.

Complex questions across multiple entities quickly exceeded the UI’s filter options.

Aggregational queries (e.g., identifying the most experienced consultant in a skill or calculating the average years of experience over all consultants) were impossible with standard filters.

In order to overcome these challenges and accelerate the search process, we envisioned a chatbot that would be capable of:

Focus on information retrieval from structured data.

Provide precise, single-turn answers to questions.

Leverage new SAP technologies, particularly the SAP HANA Knowledge Graph Engine.

This was also an opportunity for us to gain early hands-on experience with the Knowledge Graph Engine and to explore its potential.

The Solution

We implemented an innovative architecture built entirely on the SAP BTP. The system combines a knowledge graph and an agentic workflows to deliver precise answers to questions regarding the data stored in Summarix.

Key components of the solution:

SAP HANA Knowledge Graph Engine: Stores data as a knowledge graph, facilitating SPARQL-based queries.

SAP CAP backend: Manages orchestration, workflow logic, and query processing. While Python is a popular choice for many AI projects , we deliberately chose to integrate AI into our CAP (Node.js) backend using the SAP AI SDK. Utilising LangGraph.js and LangChain.js, we have modeled the agentic workflow directly in JavaScript.

SAP Generative AI Hu: Provides access to LLM inference. We leverage its orchestration features and prompt templates, while retaining the flexibility to switch between models from OpenAI, Amazon, Google...

Angular UI: A lightweight chat interface that runs as a shell plugin within the SAP Work Zone.

Langfuse: Ensures observability and evaluation. This open-source tool enables us to trace executions, measure performance, and curate evaluation datasets.

Key Features

Our chatbot relies on an agentic AI workflow. While it is not a fully autonomous agent, the workflow defines a repeatable sequence of steps with conditional branches. This approach ensures consistency, reduces risks, and simplifies debugging, while still supporting dynamic, question-specific workflows and granting the agent some autonomy.

Knowledge Graph Generation

The project started with building the knowledge graph, which is based on the structured data from the SAP HANA Database of Summarix. This includes the following steps:

Export data from SQL into CSV.

Create graph nodes for entities (e.g., employees, projects, skills) with attributes while omitting irrelevant columns.

Model n-n relationships through connection nodes.

Export everything into Turtle (.ttl) files.

Ingest these files into the SAP HANA Knowledge Graph Engine.

Ensuring data quality is paramount, as errors in this area can propagate through to the chatbot and significantly impact downstream task performance. As part of the ongoing development and implementation of improvements, the knowledge graph creation process has been repeatedly revised and enhanced .

Entity Extraction and Matching

Users naturally phrase questions in different ways (e.g., SAP BTP vs. SAP Business Technology Platform). Since each skill has a canonical name in Summarix, robust entity matching is required.

Our approach, involved the following steps:

Extract potential entities (skills, employees, projects and customers) from the question via an LLM using few-shot learning.

Normalize entity names (singular form, multiple known variations).

Search with regex-based case-insensitive filters for the existing entities.

After matching the entities, we store them in the agent state for subsequent steps.

SPARQL Query Generation

After identifying the entities , the next step is to generate a SPARQL query. To guide the LLM, we did a lot of context engineering and provide:

Context such as identity, instructions, and current date/time.

The full ontology of the knowledge graph, including attributes and relationships.

Detailed descriptions of all attributes, entities and relations.

Examples of valid SPARQL queries.

For this step, we (currently) rely on GPT-4.1 for its stronger reasoning capabilities, while lighter calls use GPT-4o-mini.

We chose to use a knowledge graph approach, although it would also be possible to directly generate SQL and execute queries against the relational SAP HANA Cloud database. In our experiments, answers based on SQL queries showed slightly lower performance compared to those derived from the knowledge graph approach.

Evaluation and Observability

From day one,, we prioritized evaluation at inpeek to avoid a “black-box” development process and to establish clear KPIs and track their development over time. The key steps of our evaluation include:

Curated a baseline dataset (~30 items) with questions and ground truth answers.

Built an evaluation API endpoint to automatically rerun the dataset after each iteration.

Use LLM-as-a-judge scoring (0–1) to assess the correctness of an answer compared to the ground truth answer.

Introduced user feedback loops: flagged chatbot answers are added to new datasets, enabling continuous improvement based on previous incorrect answers.
Track additional metrics, such as latency, costs and self-correction steps.

Key Technical Considerations

Multi-tenancy: Since Summarix is a SaaS product, we implemented our own multi-tenant logic to support different environments. So far , the SAP HANA Knowledge Graph does not offer multi-tenancy capabilites.

Automated KG ingestion: A tenant-aware Python job daily updates the knowledge graph as data evolves in Summarix.

CAP instead of Python: By keeping everything in CAP (Node.js), we simplified integration with authentication, lifecycle management, and SAP tooling.

Context engineering: Providing a complete ontology with extended descriptions is crucial for reliable SPARQL generation.

Evaluation-first approach: Systematic evaluation ensured objective improvements and prevented regressions.

Conclusion

With Summy, we explored how the SAP HANA Knowledge Graph Engine can serve as a foundation for Retrieval-Augmented Generation (RAG) on structured data. By combining knowledge graphs, SPARQL, LLMs and agentic workflows, we created a chatbot that can provide precise answers to complex business questions. This means consultants and sales reps can now answer tender-related questions in seconds instead of manually filtering data!

This project demonstrated that success hinges on more than just the agent workflow, it also depends on data quality, entity mapping and evaluation pipelines. We had an excellent experience with the SAP HANA Knowledge Graph Engine and look forward to building on this foundation for future use cases.

There is also a Medium blog post that delves deeper into the AI Engineering aspect, as well as a SAP Success Story highlighting the use of the knowledge graph for the chatbot and our SaaS solution, Summarix

If you’d like to learn more about this project or discuss AI in the SAP ecosystem, feel free to conntact us on LinkedIn:

Fabian Hüni (AI Engineer)
Fabian Küng (SAP Expert Consultant)

How to Test OAuth-Enabled Inbound Communication in SAP Using an API Client

2025-12-22T11:34:21.364000+01:00

Introduction

This blog post explains how to test OAuth-enabled inbound communication in SAP using an API client. It walks through the configuration steps and provides practical examples for validating the setup.

When working with inbound communication in SAP S/4HANA Cloud or on-premises systems, developers and integration specialists often need a lightweight tool to test APIs secured with OAuth 2.0.

While there are many API testing tools available today, this guide focuses on Bruno—a modern, open-source similar to the more established Postman. Personally I think of Postman as the old guard, and Bruno as the new pup on the block: sleek, efficient, and eager to fetch your tokens! (And yes, my love for dogs may have influenced this choice just a little.)

Image was created by the author using an AI illustration tool and is original content.

🐾 In this post, I’ll walk you through how to:

Configure a custom communication arrangement based on an existing communication scenario for OAuth 2.0
Use an API client to test inbound communication secured with OAuth 2.0

Note: This guide assumes you already have a communication scenario that supports OAuth 2.0.

Prerequisites

A communication scenario in your S/4HANA system that supports OAuth 2.0
An API client installed on your operating system (for example, Bruno, Postman, or any equivalent tool)

So, grab your treats and let’s get our paws dirty—Bruno’s ready to sniff out those OAuth tokens and help you unleash smoother integrations!

Step 1: Enable a Custom Communication Arrangement for OAuth

1. Create a Communication System and Communication User

🐾 Think of the Communication System as Bruno’s doghouse—it needs to be cozy, secure, and ready for visitors. 🐾

Open the Communication Systems app and create a new system:

System ID	Z_BRUNO
System Name	Z_BRUNO

Under Technical Data:

Enable Inbound Only.
In OAuth 2.0 Settings:
- Set Client Redirect URI Type to Loopback
- Set a path in the Path field, e.g., /bruno/redirect
  → This becomes your Callback URL: http://127.0.0.1/bruno/redirect (used in Step 2)

🐾 When you set the redirect path to /bruno/redirect, you’re basically telling Bruno where to wag his tail when he’s done fetching the token. 🐾

Under Users for Inbound Communication

Add a new communication user
Set Authentication Method to OAuth 2.0
Define OAuth 2.0 Client ID, e.g., Z_BRUNO_ID
Enable Refresh Allowed and set Refresh Token Expiry Time, e.g., 5 Days

Save your communication system and inbound communication user for your future testing with Bruno acting as OAuth client. This user will be later used for the Authorization Code Grant with PKCE.

2. Create a Communication Arrangement

Open the Communication Arrangements app and create a new arrangement based on a communication scenario that supports OAuth 2.0 as an authentication method, e.g., SAP_COM_0053 (Purchase Order Integration).

Scenario	SAP_COM_0053 (exists only in S/4HANA Cloud)
Arrangement Name	TEST_COM_0053_WITH_BRUNO
Communication System	Z_BRUNO (defined earlier)

Under Inbound Communication:

Enter the OAuth 2.0 Client ID you defined earlier: Z_BRUNO_ID.
Save your communication arrangement.

Note: Only after saving the arrangement, the previously defined OAuth client gets actually created. A clickable label OAuth 2.0 Details will apear.

In OAuth 2.0 Details, you will find all the necessary data for your API client:

Client ID
Token Service URL
Authorization URL

These are needed to fetch a token with Bruno.

Now you are ready to test your OAuth-secured API using Bruno!

Step 2: Use Bruno to Test the OAuth Communication

Image was created by the author using an AI illustration tool and is original content.

1. Create a New Collection

🐾 Creating a new collection in Bruno is like giving your dog a new toy—name it, set it up, and let the fun begin! 🐾

Open Bruno
Create a New Collection
Name it, e.g., My_test_collection

2. Set Up OAuth in the Auth Tab

Go to the Auth tab and choose OAuth 2.0
Set up the configurations:

Grant Type	Authorization Code
Callback URL	http://127.0.0.1/bruno/redirect
Authorization URL	From Communication Arrangement
Access Token URL	From Communication Arrangement
Client ID	From Communication Arrangement
State	dummy
Use PKCE check box	✅enabled

🐾 Don’t forget to enable PKCE—it’s like putting a leash on your OAuth flow. Keeps things secure and under control. 🐾

3. Send a Test Request

Choose Get Access Token
A browser window will open - logon as a Business User
Approve the request by clicking Allow
If successful, you’ll receive an Access Token.
The response typically appears in the Response tab in JSON format like this:
Use this token to call your API services:

Troubleshooting Tips

Make sure you log in with a Business User assigned to the correct Business Roles for the API.
If you see the following screen after logging in:

it likely means the user lacks the required authorizations or the wrong user was used.

Summary

With this setup, you can securely test OAuth-protected endpoints in SAP using Bruno or similar tools. This approach is useful for validating integration scenarios and troubleshooting authentication issues.

Bruno provides a clean and open-source alternative to Postman for testing OAuth-secured APIs in SAP S/4HANA. With just a few configuration steps, you can simulate real-world OAuth flows and validate your communication scenarios with ease.

🐾 With Bruno by your side, testing OAuth APIs is less of a chore and more of a walk in the park. Just don’t forget the treats (a.k.a. access tokens)! 🐾

Image Attribution and Licensing

All illustrations in this post were created by the author using Microsoft Copilot (AI-based design tool) for educational purposes. The images are original content and free to use under the author’s permission for non-commercial, educational purposes. No external branding or promotional elements are included.

Leveraging SAP AI Core to Build Custom AI Agents with CrewAI

2025-12-24T06:41:18.594000+01:00

Introduction

AI agents are becoming the go-to pattern for building modular, autonomous assistants that can think, act, and collaborate. CrewAI gives you a developer-friendly way to orchestrate these agents, while SAP AI Core provides enterprise-grade access to LLMs with proper governance, scalability, and security.

This quickstart shows you how to connect CrewAI to SAP AI Core, create a custom LLM interface, and build your first working agent — all in under 10 minutes.

By the end, you’ll have a simple CrewAI agent powered by an LLM hosted in SAP AI Core.

How SAP Facilitates Building Custom Agents

CrewAI handles the agent orchestration layer, while SAP AI Core hosts and manages your LLMs.

Connecting them allows you to use SAP’s AI infrastructure directly inside your CrewAI workflows — no external API juggling.

Here’s the high-level flow:

User Prompt → CrewAI Agent → Custom LLM Class → SAP AI Core Endpoint → Model Response

Flow summary:

User sends a prompt → CrewAI Agent receives it.
Agent forwards it to a custom LLM wrapper (`SAPAILLM`).
The wrapper authenticates using the token and sends the request to SAP AI Core.
SAP AI Core executes the model and returns a response to the agent.
CrewAI handles the output and delivers the final answer.

This setup ensures enterprise-level reliability with full control over which models your agents use.

Prerequisites

Before jumping in, make sure you have:

Access to SAP AI Core with deployed LLM models (via AI Launchpad)
Python 3.10+
VS Code or your favorite IDE
Installed libraries:

pip install ipykernel
pip install crewai
pip install crewai_tools
pip install generative-ai-hub-sdk[all]
pip install langchain_community

Your SAP AI Core Service Key downloaded as a .json file
Your A-game to create some amazing agents

*If you want to learn how to deploy your LLM model on launchpad, you can go through this course.

Step-by-Step Guide

Let us now dive into building our own custom agent which utilizes SAP's AI Core.

Step 1: Get Your SAP AI Core Credentials

In your SAP BTP Cockpit → AI Core Instance → Service Keys, create a new key and save it locally as credentials.json.

Example structure:

{
    "clientid": "your-client-id",
    "clientsecret": "your-client-secret",
    "url": "https://<your-region>.authentication.sap.hana.ondemand.com",
    "serviceurls": {
        "AI_API_URL": "https://***.aws.ml.hana.ondemand.com"
    }
}

This file contains everything needed to authenticate and access your deployed LLM.

Step 2: Get Your BTP LLM Access Token

We’ll use this token to authenticate each request to SAP AI Core.

import json, requests

# open credentials file
with open("<path-to-file>/credentials.json", "r") as key_file:
    svcKey = json.load(key_file)
authUrl = svcKey["url"]
clientid = svcKey["clientid"]
clientsecret = svcKey["clientsecret"]
apiUrl = svcKey["serviceurls"]["AI_API_URL"]

# request token
params = {"grant_type": "client_credentials" }
resp = requests.post(f"{authUrl}/oauth/token",
                    auth=(clientid, clientsecret),
                    params=params)

BtpLlmAccessToken = resp.json()["access_token"]
print("Token retrieved successfully!")

Tokens usually expire after 1 hour. Make sure to refresh them before making multiple requests.

Step 3: Create a Custom LLM Class Template for CrewAI

CrewAI lets you define your own LLM wrappers, which means we can make one that talks directly to SAP AI Core.

In this class, we can define the procedure to use the deployed models from SAP AI Core.

You can now import this class into any CrewAI workflow to use SAP’s hosted LLMs.

from crewai import BaseLLM
from typing import Any, Dict, List, Optional, Union

class CustomLLM(BaseLLM):
    def __init__(self, model: str, api_key: str, endpoint: str, temperature: Optional[float] = None):
        super().__init__(model=model, temperature=temperature)

        self.api_key = api_key
        self.endpoint = endpoint

    def call(
        self,
        messages: Union[str, List[Dict[str, str]]],
        tools: Optional[List[dict]] = None,
        **kwargs
    ) -> Union[str, Any]:
        """Call the LLM with the given messages."""
        # Convert string to message format if needed
        if isinstance(messages, str):
            messages = [{"role": "user", "content": messages}]

        payload = {
            "messages": messages,
            "temperature": self.temperature,
            "max_tokens": 1000 # This can be modified as per your use case. You can parameterize this as well.
        }

        headers = {
            'AI-Resource-Group': "<your-resource-group-name>",
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {BtpLlmAccessToken}',
        }

        # Make API call
        response = requests.post(
            self.endpoint,
            headers= headers,
            json=payload,
            timeout=30
        )
        response.raise_for_status()

        result = response.json()
        return result["choices"][0]["message"]["content"]

Step 4: Initialize your Custom LLM Class

Alright, time to bring that class to life.

The cool thing here is that you can hook it up to any model you’ve deployed in SAP AI Core, whether it’s GPT-4o, Claude, or your own fine-tuned beast.

In this example, we’ll wire it up to a **GPT-4o** deployment and let CrewAI start chatting through it. You can get the deployment endpoint from your SAP AI Launchpad. You can find the payload formats for different models here.

deployment_url = "<deployment URL>" + "/chat/completions?api-version=2024-02-01"

# instantiating Custom LLM object
custom_llm = CustomLLM(
    model="gpt-4o",
    api_key=BtpLlmAccessToken,
    endpoint=deployment_url,
    temperature=0.7
)

Step 5: Build a Simple CrewAI Agent

Now that your LLM class is ready, let’s create a basic Research CrewAI agent that uses it.

from crewai import Agent, Task, Crew

# Load credentials
agent = Agent(
    role="Research Assistant",
    goal="Find and analyze information",
    backstory="You serve as a research assistant, helping to gather and analyze information about SAP tools and related topics.",
    llm=custom_llm
)

# Create and execute tasks
task = Task(
    description="Research the latest developments in SAP AI Core",
    expected_output="A comprehensive summary",
    agent=agent
)

crew = Crew(agents=[agent], tasks=[task])
result = crew.kickoff()

If all goes well, you’ll see a clean response from your SAP-hosted LLM, directly through your CrewAI agent. Here is a sample output:

CrewOutput(raw="The latest developments in SAP AI Core focus on enhancing the capabilities for deploying and managing AI models in a scalable and efficient manner. SAP AI Core is part of SAP Business Technology Platform (BTP) and is designed to integrate with other SAP applications to streamline AI operat....ding tools that enhance productivity, and driving innovation through AI-powered solutions.", pydantic=None, json_dict=None, agent='Research Assistant', output_format=<OutputFormat.RAW: 'raw'>)], token_usage=UsageMetrics(total_tokens=0, prompt_tokens=0, cached_prompt_tokens=0, completion_tokens=0, successful_requests=0))

Conclusion

And that’s it — you just built your first CrewAI agent powered by SAP AI Core.

From here, you can:

Add tools for the agent to interact with SAP APIs (e.g., fetching invoice data).
Add memory and multi-agent orchestration.
Deploy it on SAP BTP or your internal infrastructure for enterprise use.

This quick start gives you the foundation — the next step is making your agent truly yours.

References

From Docs to Dialogue: Unlock AI Self-Service Learning for Your Internal Teams

2026-01-08T23:27:21.357000+01:00

From Docs to Dialogue: Unlock AI Self-Service Learning for Your Internal Teams

Every organization wants onboarding to be faster, clearer, and less dependent on tribal knowledge.
NotebookLM enables the conversion of trusted product documentation and internal project artifacts into an AI-based conversational resource that employees can engage with naturally, as if they were chatting with their most knowledgeable coworker. Instead of searching across files, PDFs, and web pages, teams can ask direct questions about product behavior, setup requirements, and configuration considerations, and instantly turn answers into internal training materials.
This AI-driven approach
- scales knowledge without replacing expertise
- streamlines learning without adding process overhead
- helps organizations build deeper product fluency internally

Table of Contents

Benefits & Use Cases

Faster employee ramp-up by turning existing SAP Documentation into a conversational AI learning environment
Instant answers for distributed teams across roles, experience levels, and time zones
Improved configuration confidence through real-time dialogue with authoritative sources
Consistent onboarding experiences that reduce knowledge gaps between new hires
Rapid training asset creation (FAQs, slide outlines, learning summaries) generated directly from source material
Search less, learn more—teams ask questions instead of digging across files and folders.
More informed internal experts because foundational questions get answered efficiently and consistently
Support interactions become more efficient and solution-focused when they happen, backed by deeper internal product fluency.

Gathering Trusted Knowledge

To begin using NoteBookLM as your AI Self-Service learning tool, you must first gather all of the relevant knowledge on the specific SAP product you are looking to focus on. These will become your sources within NotebookLM and will act as the knowledge base that NotebookLM uses as it guides your

The free version of NotebookLM is limited to 50 sources, so please consider this as you capture your list of sources

SAP Product Documentation

https://help.sap.com/docs/ contains all relevant product documentation for your SAP products and is the best place to start gathering the content you need.

Go to SAP Help
Search for the specific SAP product you are looking to hone in on and then click on the Suggested Product that most aligns with your search.
Example: SAP Business Network for Procurement
In the bottom right corner of the top banner, click Download PDF
Select all relevant options from the pop-up page, then click Download at the bottom of the page

Getting Started with NotebookLM

Now that you have all your sources prepared, you can begin uploading them to NotebookLM.

Open NotebookLM and complete the onboarding process to create a free account. This will be tied to your Gmail/Google account. Please consult your internal teams regarding any enterprise plans or privacy concerns.
Create a new notebook, selecting the + Create New button
Upload the files that you captured in the previous step by clicking Upload Files
Allow your sources to load. Once complete, you should see all your sources displayed in the left panel.
To share your notebook with other colleagues, you can click the Share button in the top right of the page.

Chatbot-Driven Learning

In the middle section of the page, you can interact with the notebook via Chat, as if you were talking with a product expert.

NotebookLM will then use AI to develop an answer, intentionally prioritizing your repository of sources to provide the proper context and deliver the best answer to your question.
Within the AI-generated response, you will notice that small numbers with circles around them are displayed throughout the answer. You can click these, and then the left panel will take you directly into the specific source document where it pulled that part of the answer from
For a more visual approach, you can also click the Mind Map option in the Studio panel. Once generated, you can click to view a visual representation of the sources you uploaded. As you click deeper into the mind map, the chat will auto-update and help kick-start a conversation you can use to drill down into a specific topic area.

As with any AI LLM-based tool, results may vary and should be reviewed in detail by your teams for accuracy.

You can continue your conversation with the AI chatbot by asking it

additional clarifying questions specific to your needs
reframing your question in more complete wording to provide more context
to drill down deeper into specific areas of its response
to drill down deeper into specific documents/sources
Additional documentation

Generating Internal Training Assets

The right portion of the page, called Studio, will include options (depending on your plan) to generate content tailored to your team's training and enablement needs.

For each option in the studio, click the Pencil icon to customize the result by providing a prompt that guides the studio's content generation and is tailored to your needs.

If you do not click the pencil, it will auto-generate based on all your sources. Depending on the size and scope of your sources, the output may be too high-level without a custom prompt provided.

Each Studio option may also provide its own set of configuration toggles in addition to a custom prompt.

Each option also includes a Download option, allowing you to export any generated content to your internal libraries or training tools.

Audio Overview: podcast interview for auditory learning

The audio overview option generates a one-on-one podcast interview between two people who discuss your sources and/or your custom prompt. You can use this to create targeted podcasts that dive into specific areas, then include them in onboarding materials for teams who prefer an Auditory format.

*Pro Tip: upload your own transcript or outline of how you would like the conversation to go. This will help guide the model to create an interview that covers the areas you consider essential, rather than guessing what to highlight.

*Pro Tip: When providing your custom prompt, include specifics as to how you would like the tone of the speakers to be. By default, the podcasts may seem a bit exaggerated at times. You can ask the prompt to use more normal and realistic tones and/or ask it to avoid certain words like "massive" or "huge", for example

Infographic: a one-stop shop PDF for visual learning

The infographic will create a one-pager PDF with AI-generated visuals that provide a more "connect the dots" overview of the sources. It will start with a high-level overview that connects all sources (similar to a Mind Map), but if you provide a specific prompt, it can also provide a more refined overview of that topic area.

*Pro Tip: check the visual for any discrepancies. If you see issues, recreate the infographic by changing your custom prompt to call out the mistake you want to avoid. The more specifics you provide, the better

*Pro Tip: In your custom prompt, call out the audience that will be consuming the graphic itself. It can tailor the messaging and graphic style to better suit that audience. You can also ask it to reference a branding source if you have uploaded one that includes logos, color schemes, etc.

Video Overview: a training video for visual learning

The video overview will provide a more traditional training format, with one speaker presenting the topic while an AI-generated video plays in the background. The video will resemble a PowerPoint presentation. You can use this to create a high-level video overview of the sources, or to provide a custom prompt that goes into one area in more detail.

*Pro Tip: The graphics or numbers on the video itself need to be reviewed for accuracy. If you see discrepancies between what is displayed and what is mentioned in the video, you will need to refine your custom prompt and regenerate the video to close the gap. The more specific you are (e.g., an outline or script and dos and don'ts), the better the results you will get. You are unable to edit the video itself or adjust the slides/visuals after it is generated

Flashcards and Quizzes: A hands-on tool for your team to learn

The Flashcards option searches for primary and recurring keywords and definitions in your sources and automatically generates flashcards to help learners study/memorize key terms.

The Quiz option will also search for primary and recurring keywords across the sources and generate an interactive question-and-answer quiz.

*Quizzes cannot be downloaded externally

Best Practices

Depending on your sources and the sheer volume of data within the notebook, the AI Models can and will hallucinate. Having detailed, specific prompts to guide each conversation or studio creation toward a specific goal will produce the best results. It is better to break your content needs into smaller groupings with detailed prompts than to blindly ask it to create high-level overviews.
Be sure to consult with your internal privacy and compliance teams before uploading any non-public information into NotebookLM. As a general rule, only upload publicly available content to NotebookLM.
YouTube videos can be effective at providing an additional perspective through a more expert-focused, human-guided lens on your dataset of sources. Collect long-form YouTube interviews with experts in your area and upload the URLs as additional sources to your notebook.
Create your own scripts or outlines beforehand and provide those to the chat or studio in addition to your primary ask it. This will help ensure it follows the correct path you are looking for and does not hallucinate. You can also use other LLMs or AI Chatbots to help you come up with ideas and draft a high-level script or outline to follow.
If you share your notebook with end users, ensure they understand that chatbot results must be reviewed and refined to provide guidance that helps kick-start an investigation into a topic. End users should be wary of copying/pasting AI-generated content externally.

End-to-End overview

Find your product at SAP Help

Download the SAP product documentation to PDF

Create a notebook and upload files to NotebookLM

Observe your sources and begin interacting with the chatbot & studio

A real-world example, see NotebookLM in action

The SAP Business Network for Procurement is used globally to connect buyers and suppliers and enable interaction and transactions. This results in a variety of country-specific invoicing laws and portals that vary by country. The application itself includes standard invoicing features and built-in support for various country-specific E-Invoicing mandates.

In this example, we will investigate how we can learn more about this topic using NotebookLM with a single prompt to generate a text answer, an infographic, and a video overview file.

Prompt

I want to learn more about e-invoicing and country-specific invoicing rules within the SBN for the Procurement application. My team has a basic understanding of the core SBN Procurement flows, but is seeking more guidance on the e-invoicing and country-specific invoicing logic and features within the product. Can you help produce content that clarifies this for us and explains the topic in detail as it relates to the larger product? Id like to know what is supported in the app, how i would interact with these features, if there are any specific setup or customization requirements to use this, and a list of which countries are currently supported. 
The audience here is a group of corporate employees who know procurement as a whole. Keep things professional and short/sweet. Don't use any exaggerations and don't overhype with any big, bold words. Use simpler, down-to-earth professional wording.

Infographic

Video Overview

Chatbot Response

Here is an overview of how SAP Business Network (SBN) handles e-invoicing and country-specific compliance.

In the context of the Procurement application, e-invoicing on SBN goes beyond emailing a PDF. The system uses structured data (cXML) to validate invoices against your business rules and the legal regulations of the supplier’s country before the invoice reaches your internal systems.

The core feature that manages this is Country/Region-Based Invoice Rules. When a supplier submits an invoice, SBN detects the originating country based on the supplier’s VAT ID prefix or address, then applies a specific set of validation rules that override default transaction rules. This ensures that suppliers in different countries — for example Italy vs the United States — see different required fields and localized behaviors.

The platform supports several compliance models depending on the region.

For VAT-regulated regions, particularly in the EU, Australia, and Canada, SBN enforces required tax information such as VAT IDs, supply dates, tax breakdowns, and local currency requirements.

In countries using government clearance models, where the government must approve an invoice before the buyer receives it, SBN integrates directly with national invoice platforms. Examples include KSeF (Poland), SDI (Italy), and the E-Invoice system (India).

SBN automatically applies digital signatures to invoices for many countries to ensure document integrity and authenticity.

The system also converts standard cXML invoice data into legally mandated formats required by specific governments or networks. Examples include FatturaPA (Italy) and Peppol UBL (supported in countries such as Belgium and Singapore).

Buyers interact with these features primarily through configuration rather than manual invoice transactions.

To configure rules, buyers navigate to Country-Based Invoice Rules within the Administration and Configuration settings. Here, countries can be activated and compliance requirements can be enabled or disabled, such as requiring suppliers to send tax invoice documents.

Buyers can monitor invoice submission status in their inbox. For government-connected countries, invoice history will include status updates showing government validation progress and results.

Buyers can also generate compliance visibility through built-in reporting. One example is the Supplier Legal Profile report, which shows which suppliers have completed the required tax compliance setup for their country or region.

Suppliers see a dynamic invoice creation experience based on their country. During invoice creation, suppliers are shown required local tax fields based on their location — for example GST IDs and HSN codes in India, or Stamp Duty fields in Italy.

Suppliers in countries with strict mandates must complete a Legal Profile or Country Configuration in their account settings. This is where they enter tax registration numbers and upload any required digital certificates or identifiers for government or network compliance.

To enable these features in an SBN Buyer account, buyers must update Default Transaction Rules to allow country-based invoice rules to take precedence instead of being ignored.

Buyers must also add and activate the specific countries they trade with in Country-Based Invoice Rules.

For countries that route invoices through external networks like Peppol, buyers must register their Peppol Participant ID or equivalent identifier in their profile so suppliers can send invoices successfully.

For countries where SBN retrieves invoices directly from government portals (inbound invoice flow), buyers must configure External Document Service settings to establish a connection with the national tax authority. Examples include Poland and Romania.

SBN supports country-specific compliance logic, VAT validation, or government integration for the following countries.

Americas: Brazil, Canada, Chile, Colombia, Mexico, Peru, United States.

Asia/Pacific: Australia, China, India, Japan, Malaysia, New Zealand, Singapore, South Korea, Taiwan, Thailand.

Europe: Austria, Belgium, Bulgaria, Croatia, Cyprus, Czech Republic, Denmark, Estonia, Finland, France, Germany, Greece, Hungary, Iceland, Ireland, Italy, Latvia, Liechtenstein, Lithuania, Luxembourg, Netherlands, Norway, Poland, Portugal, Romania, Russia, Slovakia, Slovenia, Spain, Sweden, Switzerland, Turkey, Ukraine, United Kingdom.

Middle East/Africa: Israel, Saudi Arabia, South Africa, UAE.

Considerations & Final Takeaways

Every organization wants onboarding to be faster, clearer, and built on trusted knowledge rather than fragmented internal know-how. NotebookLM enables teams to convert authoritative product documentation, SOPs, configuration specs, SOWs, demos, and project artifacts into a secure AI-powered conversational resource that employees can interact with naturally—like chatting with their most knowledgeable coworker. Instead of manually searching across files and web pages, teams can ask direct questions about product capabilities, setup requirements, and configuration considerations, then instantly convert those answers into internal enablement assets such as training outlines, FAQs, flashcards, infographics, and learning summaries. When setting up your NotebookLM hub, prioritize source quality, clear document labeling, and intentional prompting during training to reduce ambiguity and improve accuracy. This approach scales product fluency across teams, streamlines learning without adding process overhead, and creates more confident, self-sufficient users—while ensuring that expert conversations, when needed, are informed, efficient, and outcome-driven.

SAP Joule Data Quality KPIs: Auto-Generates and Measures KPI's to fix broken SAP Master Data Records

2026-01-11T12:32:39.711000+01:00

How SAP Joule can Turn Data Quality KPIs into Real Business Control

*Views expressed here are my own and doesn't represent any entity.

Every SAP-driven organization knows this truth — even if it’s rarely said out loud:

Most business risks don’t start with strategy.

They start with bad data.

A missing tax code. A duplicate customer. An outdated BOM. An untraceable ESG metric. Individually, they look small. Collectively, they erode compliance, margins, and trust.

This is where SAP Joule changes the game — not by adding more dashboards, but by turning data quality into an intelligent, business-aware control system.

The Old World: Measuring Data Too Late

In traditional SAP environments, data quality is:

Measured after the fact
Reported at aggregate level
Owned by IT, not the business

By the time leadership sees a data quality issue, the impact has already landed:

Regulatory rework
Production delays
Revenue leakage
Audit findings

Joule can flip this model by working at the level where risk is actually created — the SAP data object.

How Joule can Generate KPIs for Real SAP Objects (Not Abstract Metrics)?

SAP landscapes are built on concrete objects:

Material Master (MARA, MARC)
Business Partner (BUT000)
Bills of Material (STPO)
Pricing Conditions (KONV)
Excise & Customs data (SAP GTS)
ESG attributes (SAP EH&S)

Joule doesn’t need to guess what to measure — it reads how the business actually uses these objects.

Example 1: Material Master (SAP S/4HANA – PP/MM)

The problem: A manufacturing site experiences frequent production stoppages due to incorrect or incomplete material data.

What Joule can do :

Identifies which material fields are mandatory for production and quality
Generates KPIs such as:

Material master completeness %

BOM consistency across plants

Production posting error rate

What leadership sees:

“Three material attributes are causing 80% of production rework in two factories.”

Not a metric — a decision trigger.

Enter SAP Joule: Data Quality That Thinks Like a Business Partner

SAP Joule brings generative AI into the SAP stack — not as a chatbot, but as an intelligent orchestration layer across data, processes, and controls.

When applied to data quality, Joule can enable three game-changing capabilities:

Automatic KPI generation for every SAP data object

Context-aware thresholds instead of one-size-fits-all rules

Business-language explanations of data risk

Let’s break this down.

Generating Data Quality KPIs for Every SAP Data Object

SAP systems are built on standard data objects. Traditionally, teams manually decide:

Which fields matter

Which KPIs to track

Which thresholds apply

With Joule, this can become intelligent and automated.

How Joule can do in future?

Joule analyzes:

SAP object metadata (tables, fields, relationships)

Usage patterns (how often data is used downstream)

Process criticality (e.g., regulatory vs operational)

Historical data issues and corrections

From this, Joule can propose KPIs automatically, such as:

Completeness (% of mandatory fields populated)

Accuracy (rule-based and cross-object consistency)

Duplication rates

Timeliness (data freshness vs SLA)

Conformity to country-specific rules

And it does this per object, not per report. It can measure Thresholds That Actually Reflect Business Risk. A 95% completeness score doesn’t mean the same thing for:

ESG reporting

Excise tax determination

Internal planning data

This is where Joule goes beyond traditional data quality tools.

Dynamic, risk-based thresholds

Joule can:

Adjust thresholds by market, plant, or regulation

Flag materiality (which data issues truly matter)

Learn from outcomes (e.g., audit findings, rework, penalties)

Example: A missing material attribute in a non-regulated market → warning

The same issue in a regulated market → critical breach

Instead of “red/amber/green and technical language for issues” , leaders see the impact of data quality issue on business.

Making Data Quality Understandable to Humans

Data quality often fails because it’s explained in technical language.

Joule changes that from metrics to meaning. Rather than showing:

“2.1% duplication rate in Business Partner data”

Joule can explain:

“Duplicate customer records are increasing invoice rework and delaying cash collection in two key markets.”

This turns data governance into decision support and KPIs into actionable insight and IT controls into business confidence.

Continuous Monitoring, Not Periodic Audits

With Joule integrated into SAP:

KPIs update continuously

Threshold breaches trigger explanations, not just alerts

Data owners receive context, not noise

This supports:

S/4HANA transformations

SOX and regulatory assurance

ESG credibility

Data quality becomes a living system, not a quarterly report.

Why This Matters for Leadership

For executives, the value proposition is straightforward and compelling:

Mitigate Risk: Significantly reduces regulatory surprises and enable swift, proactive responses to emerging threats.

Optimise Operations: Eliminates operational friction, driving greater efficiency and smoother processes.

Bolster Trust: Cultivates unwavering confidence in critical business data and insights.

In essence, SAP Joule transforms high-quality data from a desirable aspiration into a foundational, strategic operating capability.

This marks a profound shift in data quality management. We move beyond outdated practices of merely policing data fields, escalating issues it IT language, enforcing rigid rules, or assigning blame. Instead, Joule empowers organisations to:

Understand Impact: Clearly articulate the business consequences of data issues.

Prioritise Strategically: Focus resources on what truly matters to the business.

Protect Value: Safeguard enterprise assets and drive growth at scale.

This isn't just about achieving better data quality; it's about establishing superior business control.

SAP RPT‑1: Why is it Essential for Predicting Business Outcomes in Today’s and Future Generative AI?

2026-01-26T05:55:37.670000+01:00

Ever since the introduction of ChatGPT in November 2022, Generative AI has reshaped the AI industry. Companies like Amazon, Google, Microsoft, and of course SAP have accelerated innovation, recognizing the enormous value Generative AI and Large Language Models (LLMs) bring to enterprise operations.

General‑purpose LLMs excel at understanding language, reasoning over text, and identifying patterns in unstructured information. They are creative, adaptive, and capable of leveraging data from files, documents, and multimedia across diverse data systems.

The Motive

However, when it comes to actually predicting business outcomes, LLMs fall short. Why?
Because they are not designed for high‑precision, multi‑step reasoning over large, enterprise‑grade tabular datasets.

And this is where the majority of business data resides: structured tables, such as GL accounts, invoices, inventory, sales records, financial transactions, and countless others. Not in free‑form text.

Everyone wants to be able to predict business outcomes like:

What is the probability of converting a sale?
Which customers are likely to pay late?
Who is at risk of churn?
...

Historically, answering these questions required traditional machine learning like classification models, linear regression, etc. (a.k.a Traditional AI or Narrow AI). The problem with this is that classical ML requires to train a model per task, which easily can lead to hundreds of separate models hard to maintain in the long run, making it very cumbersome, expensive and extremely difficult to scale.

The Solution: SAP RPT-1

To solve this, SAP introduced in TechEd 2025 the first foundation model specifically designed for structured enterprise data: Relational Pre‑Trained Transformer 1 (RPT‑1). The model is trained natively on tabular business datasets and is engineered to understand rows, columns, joins and business semantics out of the box. As the name suggests, RPT‑1 is:

Relational: optimized for structured relational business data
Pre‑trained: powered by tens of thousands of GPU hours (no more endless classical ML training cycles)
Transformer‑based: performs logical, not linguistic, transformations (e.g., filtering, joining, aggregating, and multi‑step reasoning)

Instead of hundreds of ML models, you now can use one single foundation model for many predictive tasks.

One of the most disruptive features of RPT‑1 is its in‑context learning capability. Instead of training or fine‑tuning multiple modes, you simple provide historical rows of data and request predictions for new rows. Prediction cases like:

Customer churn prediction
Late delivery prediction
Late payment prediction
Sales conversion prediction
And many more

RPT‑1 Performance Benchmark

RPT-1 outperforms both LLM and classical ML for tabular data and high value agentic cases. Here are some stats so far:

50x faster than LLMs
Up to 2x Prediction Quality vs Narrow AI/ML Models
Up to 3.5x Prediction Quality vs LLMs
100,000x fewer GPU FLOPs
50,000x Less Energy consumption vs LLMs*

*comparable tasks on a NVIDIA H100, as a benchmark. Sources (TechEd, Blog) .

Why are these stats so important? On top of the benefits you can already imagine like time and resource savings; according to Gartner 40% of agentic-AI projects are likely to be canceled by end of 2027, mainly because of high cost, complexity, or unclear business value (source). RPT‑1 directly addresses these challenges.

Sales Conversion Prediction Example Use Case

During SAP TechEd, a compelling demo showcased how RPT‑1 integrates with SAP’s Agentic AI.

Imagine a sales team wanting to prioritize leads based on their likelihood to convert. Instead of manually training an ML model, a data analyst can use Joule to generate SQL code leveraging RPT‑1’s PREDICT function.

Steps include:

Join sales inquiries, historical performance, customer attributes, and other relevant data into a Data Product in SAP Business Data Cloud.
Expose the Data Product to SAP HANA Cloud via zero‑copy.
Use RPT‑1 to instantly generate a new prediction column "sales_conversion_probability"; without training or tuning.

The model derives patterns directly from the historical data and produces high‑quality prediction scores.

You can watch the full demo here (jump to minute 35:23).

Available RPT‑1 Versions

SAP RPT‑1 has been generally available since Q4 2025. You can choose from:

SAP RPT‑1 Small: optimized for speed and efficiency
SAP RPT‑1 Large: optimized for highest accuracy by using more capacity
SAP RPT‑1 OSS (Open Source): available on HuggingFace and Github for exploration and learning

Try it yourself!

Don’t have access to a BTP account yet? here is an entry point:

Sign up for a 30-day SAP Generative AI Hub trial
Follow this step-by-step guide to get started by @sherene_tan

Conclusion

SAP RPT‑1 represents a major shift in how enterprises will deliver predictive insights in the GenAI era. While LLMs excel at language understanding, they are not built for structured, relational business data. RPT‑1 closes this gap and eliminates the complexity of traditional machine learning, drastically reducing cost and compute.

With SAP RPT-1's foundation model purpose‑built for enterprise-grade tabular data, the objective is to enable organizations to operationalize predictive insights faster, more efficiently, and more accurately than ever before.

I built an AI Agent with LiteLLM, CrewAI and SAP-RPT-1: Here’s What Actually Worked

2026-01-27T12:29:54.420000+01:00

I hope everyone found their way into the new year and had some peaceful time over the holidays! Being back at work, I started to try out all the cool announcements from last year. One of them is SAP contributing to the third-party open-source Python library LiteLLM, where SAP now functions as an official LLM provider. That means you can now build AI Agents with the LiteLLM gateway and all the AI Agent frameworks that are compatible and provide your Generative AI Hub credentials to connect to LLMs via SAP's AI Foundation.

I tried out CrewAI first because it is such a powerful and widely used framework and I have been curious and willing to try it out for some time now!

First things first: What is LiteLLM?

LiteLLM is a library that provides a unified, provider-agnostic API for calling large language models (LLMs) and handling common tasks (completion, chat, streaming, multimodal inputs). It standardizes request/response handling and includes utilities that speed up integration with agent frameworks and tooling. Essentially it is a gateway between LLM providers and AI Agent frameworks.

That means you can use your Generative AI Hub credentials to build state of the art AI Agents with any of the models available through GenAI Hub and any of the AI Agent frameworks compatible with LiteLLM. This combination is extremely powerful because that means you can use LLMs hosted or managed by SAP (Mistral, Llama, Nvidia) and models from our partners such as Azure OpenAI, Amazon Bedrock (including Anthropic) and Gemini.

👉check all the available models here: https://me.sap.com/notes/3437766

👉And all the AI Agent frameworks including: CrewAI, LangGraph, PydanticAI, Google ADK, Strands SDK, OpenAI ADK, LlamaIndex, Microsoft Agents and many more. You can find a list with examples here: http://sap-contributions.github.io/litellm-agentic-examples/

How to get started

Now to get started you need an SAP AI Core instance with the extended plan (on SAP BTP), that means you have access to Generative AI Hub and all the LLMs available.

SAP BTP Cockpit, Instances and Subscriptions, SAP AI Core – extended plan

LiteLLM is directing calls to the LLMs through the orchestration service on Generative AI Hub. That means you do not need to deploy your models on SAP AI Core. You only need the out of the box deployment of the orchestration service. This way you can easily switch between all the models available via the orchestration service.

Screenshot from Model Library of SAP AI Launchpad showing models available via Orchestration Service.

On a side note: you do not need SAP AI Launchpad as the UI to do any of this. You can also find your endpoints via API calls (more info: developer tutorial or documentation). or use the SAP Cloud SDK for AI.

Build your crew of agents

Now you only need to install Python. Once that is done you need to install the LiteLLM library and in my case also CrewAI:

pip install litellm crewai

Ok now we can actually start with building our AI Agent with CrewAI. As the name suggests you build a crew of agents that have a set of tools available to accomplish certain tasks. CrewAI uses tasks to bridge the gap between high-level goals and concrete agent actions, assigning specific objectives and expected outputs.

You also need to create a .env file to store the credentials from the Generative AI Hub service key. I also stored another variable RPT1_DEPLOYMENT_URL in that file, for the agent to use in the tool. Finally, it should look something like this:

AICORE_AUTH_URL="https://#######.ondemand.com/oauth/token"
AICORE_CLIENT_ID="sb-############-|aicore!b540"
AICORE_CLIENT_SECRET="#######"
AICORE_RESOURCE_GROUP="default"
AICORE_BASE_URL="https://api.ai.prod.###.ml.hana.ondemand.com"
RPT1_DEPLOYMENT_URL="https://api.ai.prod.###.ml.hana.ondemand.com/v2/inference/deployments/###/predict"

Agents

CrewAI recommends storing your agent configuration in and agents.yaml file. Important are the parameters: role, goal, backstory and llm. The parameter llm defines which LLM provider you want to use. We want to use SAP as the provider and GPT-4o as the model (provider/model -> sap/gpt-4o). As already described above you can use any model here that is available via the orchestration service. {payload} is a variable that will be filled during runtime.

theft_crime_scene_investigator:
  role: >
    Theft Crime Scene Investigator
  goal: >
    Predict the missing values of stolen items using the SAP-RPT-1 model via the call_rpt1 tool use this payload {payload} as input.
  backstory: >
    An expert theft crime investigator specialised on predicting the value of stolen luxury goods.
  llm: sap/gpt-4o

Tasks

In the tasks.yaml you define the name of the task, the description, the expected output and which agent can do this task. {payload} is again the variable that will be filled during runtime.

inspection_task:
  description: >
    Analyze the theft crime scene and predict the missing values of stolen items using the SAP-RPT-1 model via the call_rpt1 tool. 
    Use this dict {payload} as input.
  expected_output: >
    JSON with predicted values for the stolen items.
  agent: theft_crime_scene_investigator

Tools

You can also define custom tools in Python and hand them over to your agents to use. The following tool for example gives the model access to the SAP-RPT-1 model (try it out here: rpt.cloud.sap).

from rpt1.call_rpt1 import RPT1Client

rpt1_client = RPT1Client()

@tool("call_rpt1")
def call_rpt1(payload: dict) -> str:
    """Function to call RPT-1 model via RPT1Client"""
    response = rpt1_client.post_request(json_payload=payload)
    if response.status_code == 200:
        return response.json()
    else:
        return f"Error: {response.status_code} - {response.text}"

If you want to know more about how to make the request to SAP-RPT-1 check out this code.

Building the Crew

You might wonder how this all comes together? Now you plug all those pieces together and build your crew. The crew needs at least one agent, but can have more, any tools you want the agent to use, you can also assign here. And each agent has at least one task.

from crewai import Agent, Crew, Task, Process
from crewai.project import CrewBase, agent, task, crew, tool

@CrewBase
class MurderMystery():
    """MurderMystery crew"""

    agents_config = "config/agents.yaml"
    tasks_config = 'config/tasks.yaml'

    
    def theft_crime_scene_investigator(self) -> Agent:
        return Agent(
            config=self.agents_config['theft_crime_scene_investigator'], 
            verbose=True,
            tools=[call_rpt1]
        )

    
    def inspection_task(self) -> Task:
        return Task(
            config=self.tasks_config['inspection_task'] # type: ignore[index]
        )

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,  # Automatically collected by the  decorator
            tasks=self.tasks,    # Automatically collected by the  decorator.
            process=Process.sequential,
            verbose=True,
        )

Run the crew

murder_mystery = MurderMystery()
result = murder_mystery.crew().kickoff(inputs={'payload': payload})
print("\n📘 Result:\n", result)

Additional Infos

If you need any help in setting up your Python environment, check out the exercise 02 -Setup Python environment from my CodeJam.
Full code here: https://github.com/noravth/agentic-ai-codejam-collection
Documentation SAP and LiteLLM

Happy Coding and feel free to reach out anytime!

SAP CodeJam Roadshow 2026 - Brazil edition 🇧🇷 (Kicking off in March and continuing in April)

2026-01-30T12:35:15.511000+01:00

Oi SAP Developers!

I've got some exciting news to share with you. The SAP CodeJam roadshow is coming back to Latin America! This time, we will do a special edition in Brazil. We will have many stops on the roadshow starting the 1st week of March, doing CodeJams as part of SAP Inside Tracks, organised by local community members, and then continuing in April. Also, we'll organise a couple of meet-ups as we've done in previous year. :-).

Keep an eye on this blog post as more events will be announced as part of the roadshow shortly

SAP CodeJam events and meetups part of the roadshow (Register Now!)

Below is a listing of the SAP CodeJam events and quedadas (meetups) on the roadshow schedule:

Dates	CodeJam topic	Location	Registration
2 Mar	Build AI services using the CAP and Generative AI Hub	Campinas, Brazil 🇧🇷	Link
3 Mar	Joule Studio: Create Joule Skills and Agents Without Coding	São Paulo, Brazil 🇧🇷 🇧🇷	Link
3 Mar	São Paulo meetup	São Paulo, Brazil 🇧🇷	Link
4 Mar	SAP Build: Create Event-Based Processes	São Paulo, Brazil 🇧🇷	Link
5 Mar	Getting started with Generative AI Hub on SAP AI Core	Rio de Janeiro, Brazil 🇧🇷	Link
13 Mar	Getting started with Generative AI Hub on SAP AI Core	Joinville, Brazil 🇧🇷	Link
14 Mar	SAP Inside Track - Joinville	Joinville, Brazil 🇧🇷	Link
20 Mar	Getting started with Generative AI Hub on SAP AI Core	Belo Horizonte, Brazil 🇧🇷	Link
21 Mar	SAP Inside Track - Belo Horizonte	Belo Horizonte, Brazil 🇧🇷	Link
6 Apr	Combine SAP CAP with SAP HANA Cloud to Create Full-Stack App	São Paulo, Brazil 🇧🇷	Link
7 Apr	ABAP AI: Capabilities in SAP Joule for Developers CodeJam	São Paulo, Brazil 🇧🇷	Link
8 Apr	ABAP AI: Capabilities in SAP Joule for Developers CodeJam	Londrina, Brazil 🇧🇷	Link
10 Apr	Getting started with Generative AI Hub on SAP AI Core	Curitiba, Brazil 🇧🇷	Link
10 Apr	SAP HANA Cloud for AI Applications: ML, Vectors, and Knowledge Graphs	Ribeirão Preto, Brazil 🇧🇷	Link
13 Apr	SAP HANA Cloud for AI Applications: ML, Vectors, and Knowledge Graphs	São Leopoldo, Brazil 🇧🇷	Link
14 Apr	Build code-based AI Agents on SAP BTP	São Leopoldo, Brazil 🇧🇷	Link
16 Apr	SAP HANA Cloud for AI Applications: ML, Vectors, and Knowledge Graphs	Recife, Brazil 🇧🇷	Link
17 Apr	Build code-based AI Agents on SAP BTP	Recife, Brazil 🇧🇷	Link

Make sure to register to secure your place. It is likely that the places available will go fast.

What if the CodeJam topics do not cover the SAP technology that you focus on? We've organised additional local meetups just to get together and have a chat. See you all somewhere in Brazil on the roadshow!

Connecting SAP GenAI Hub to n8n: A Complete Guide

2026-02-02T16:33:01.109000+01:00

A step-by-step tutorial on calling SAP GenAI Hub's large language models from self-hosted n8n to build enterprise AI automation workflows.

SAP Build is the primary, recommended solution for enterprise automation and orchestration within the SAP ecosystem. However, one of the key strengths of SAP GenAI Hub is its standardization—it uses standard REST APIs and OAuth2, meaning it can be consumed by any system, regardless of the tech stack.

This tutorial demonstrates that openness. We will use n8n (a popular self-hosted workflow tool) to show how developers can integrate SAP's enterprise-grade GenAI capabilities into external or hybrid environments for rapid prototyping and testing.

Since n8n doesn't have a native SAP GenAI Hub node yet. No worries — we can easily make the connection using HTTP Request + OAuth2.

Prerequisites

Before we start, make sure you have:

A running n8n instance (Docker or npm or k8s)
SAP BTP account with SAP AI Core service enabled (Extended Plan for GenAI Hub)
A deployed LLM model (configured in SAP AI Launchpad)

Get Your SAP AI Core Service Key

Navigate to SAP BTP Cockpit → Your Subaccount → Instances and Subscriptions → SAP AI Core → Create Service Key

You'll get a JSON like this:

{
  "clientid": "sb-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx!b12345|aicore!b540",
  "clientsecret": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx$xxxxxxxxx",
  "url": "https://your-tenant.authentication.eu10.hana.ondemand.com",
  "serviceurls": {
    "AI_API_URL": "https://api.ai.prod.eu-central-1.aws.ml.hana.ondemand.com"
  }
}

Keep these four fields handy — you'll need them all.

Get Your Deployment ID

In SAP AI Launchpad:

Go to ML Operations → Deployments
Find your deployed model
Note the Deployment ID (or the full deploymentUrl)

Step 1: Create OAuth2 Credential

SAP GenAI Hub uses OAuth2 Client Credentials authentication. Let's configure the credential in n8n first.

Open n8n, go to Settings → Credentials
Click Add Credential, search for OAuth2 API
Fill in the following:

Field	Value
Credential Name	`SAP-GenAI-Hub`
Grant Type	`Client Credentials`
Access Token URL	`https://your-tenant.authentication.eu10.hana.ondemand.com/oauth/token`
Client ID	Copy the full `clientid` from Service Key
Client Secret	Copy the full `clientsecret` from Service Key
Scope	Leave empty
Authentication	Select `Header`

4. Click Save

💡Common Mistake: Selecting "Send as Basic Auth Header" will cause 401 authentication failures. SAP requires credentials to be sent in the body.

Step 2: Build a Simple Q&A Workflow

Let's create a basic LLM query workflow.

2.1 Add Manual Trigger

Start with a manual trigger for testing:

Add a Manual Trigger node

2.2 Add HTTP Request Node

This is the core node. Configure as follows:

Basic Settings:

Method: POST
URL:

https://api.ai.prod.eu-central-1.aws.ml.hana.ondemand.com/v2/inference/deployments/{your_Deployment_ID}/chat/completions

⚠️ Note: If using OpenAI models, you should add the api-version parameter, e.g.

https://api.ai.prod.eu-central-1.aws.ml.hana.ondemand.com/v2/inference/deployments/{your_Deployment_ID}/chat/completions?api-version=2023-05-15

Authentication:

Authentication: Predefined Credential Type
Credential Type: OAuth2 API
OAuth2 API: Select SAP-GenAI-Hub

Headers:

Name	Value
`Content-Type`	`application/json`
`AI-Resource-Group`	`default`, or your own Resource Group ID

Body:

Body Content Type: JSON
Specify Body: Using JSON

{
  "messages": [
    {
      "role": "system",
      "content": "You are a professional assistant. Please provide helpful and accurate answers."
    },
    {
      "role": "user",
      "content": "What is SAP S/4HANA? Please summarize in three sentences."
    }
  ]
}

2.3 Test It

Click Test Workflow. If configured correctly, you'll see a response like:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "SAP S/4HANA is SAP's next-generation intelligent ERP suite..."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 45,
    "completion_tokens": 128,
    "total_tokens": 173
  }
}

🎉Congratulations! You've successfully called SAP GenAI Hub from n8n!

Step 3: Build an Interactive Chat Workflow

Let's upgrade to a conversational version.

Workflow Structure

Chat Trigger → HTTP Request (SAP GenAI Hub) → Code (Extract Reply)

3.1 Chat Trigger Node

Add a Chat Trigger node (found under Advanced AI category):

Keep default settings
It provides an embedded chat interface for testing

3.2 Modify HTTP Request Node

Change the Body to dynamically get user input:

{
  "messages": [
    {
      "role": "system",
      "content": "You are a professional enterprise consultant specializing in SAP and digital transformation topics."
    },
    {
      "role": "user",
      "content": "{{ $json.chatInput }}"
    }
  ]
}

{{ $json.chatInput }} automatically retrieves the user's input from the chat interface.

3.3 Add Code Node to Extract Response

Add a Code node to extract the AI's reply:

const response = $input.all()[0].json;
const aiMessage = response.choices?.[0]?.message?.content || "Sorry, no response received.";

return [{
  json: {
    response: aiMessage  }
}];

3.4 Test the Chat

Activate the Workflow
Click the Chat button to open the chat interface
Start chatting!

Step 4: Add Conversation Memory (Optional)

The above version treats each message independently without context. We can use n8n's Workflow Static Data to implement simple memory.

Improved Workflow

Add a Code node before HTTP Request to manage conversation history:

// Get session ID and user input
const sessionId = $json.sessionId || 'default';
const userInput = $json.chatInput;

// Get history from global static data
const staticData = $getWorkflowStaticData('global');
if (!staticData.conversations) {
  staticData.conversations = {};
}
if (!staticData.conversations[sessionId]) {
  staticData.conversations[sessionId] = [
    {
      role: "system",
      content: "You are a professional enterprise consultant specializing in SAP and digital transformation topics."
    }
  ];
}

// Add user message
staticData.conversations[sessionId].push({
  role: "user",
  content: userInput});

// Keep only the last 20 messages (avoid token limit)
const messages = staticData.conversations[sessionId].slice(-20);

return [{
  json: {
    sessionId,
    messages  }
}];

Then modify the HTTP Request Body:

{
  "messages": {{ JSON.stringify($json.messages) }}
}

Finally, save the assistant's reply in the response extraction Code node:

const response = $input.all()[0].json;
const sessionId = $('Prepare Messages').first().json.sessionId;
const aiMessage = response.choices?.[0]?.message?.content || "Sorry, no response received.";

// Save assistant reply to history
const staticData = $getWorkflowStaticData('global');
staticData.conversations[sessionId].push({
  role: "assistant",
  content: aiMessage});

return [{
  json: {
    response: aiMessage  }
}];

Now your chatbot remembers context!

Practical Use Cases

Use Case 1: Automated Email Replies

Email Trigger → Extract Content → SAP GenAI Hub → Send Reply

Sample Prompt:

Based on the following customer email, generate a professional reply:
Email content:{{ $json.emailBody }}
Requirements:1. Professional and friendly tone2. If it's a price inquiry, mention that detailed pricing will follow within 24 hours3. If it's a complaint, express apology and commitment to follow up

Use Case 2: Document Summarization

Webhook → Read PDF → SAP GenAI Hub → Save to Notion

Use Case 3: Data Analysis Assistant

Combine SAP APIs to fetch business data and let AI generate analysis reports:

Schedule Trigger → SAP S/4HANA → SAP GenAI Hub → Slack Message

Troubleshooting

❌401 Unauthorized

Cause: Authentication failed

Check:

Client ID and Secret are fully copied (including special characters like !, |, $)
Authentication is set to Send In Body
Token URL format is correct (ends with /oauth/token)

❌404 Not Found

Cause: API path error

Check:

Deployment ID is correct
Model is successfully deployed (status shows "Running" in AI Launchpad)
API URL path format: /v2/inference/deployments/{id}/chat/completions

❌403 Forbidden

Cause: Insufficient permissions

Check:

AI-Resource-Group header is set (default is default)
User has permission to access the deployment

❌400 Bad Request

Cause: Invalid request body

Check:

JSON format is correct
messages is an array
Each message has both role and content

Optimization Tips

Limit conversation history: Keep only the last N turns to avoid exceeding context window
Add error handling: Use n8n's Error Trigger to handle API failures gracefully
Use variables: Store API URLs and Deployment IDs in n8n Variables for easier management

Summary

In this tutorial, you learned:

✅How to configure OAuth2 authentication for SAP GenAI Hub in n8n
✅How to use HTTP Request node to call LLM APIs
✅How to build a chatbot with conversation memory
✅How to troubleshoot common errors

The power of n8n lies in its flexibility — you can seamlessly integrate SAP GenAI Hub with hundreds of other applications (Email, Databases, SAP S/4HANA, etc.) to build truly enterprise-grade AI automation workflows.

Happy Automating! 🚀

On the RPT-1 podcast: practical AI for SAP data (demos, lessons, and what’s next) 🎙️

2026-02-13T10:05:44.365000+01:00

If you work in SAP, you already know the truth: our world is rows, columns, master data, transactional history, and process context — not creative writing, in other words - SAP is not a “write me a poem” platform. That’s why I really enjoyed this conversation on SAP RPT-1, where we went beyond “AI hype” and into what’s genuinely useful for SAP practitioners.

RPT-1 is built for structured enterprise data. In plain terms: it’s designed to reason over the kinds of datasets we live in every day—think finance, supply chain, procurement, operations—where accuracy, traceability, and consistency matter more than fancy wording.

What you’ll get from the episode

A practical view of “AI for SAP data” — where it fits (and where it doesn’t)
Real demos and prototypes focused on outcomes, not theory
How to think about predictive + analytical use cases that start small but scale (without turning into a 6-month science project)
A clear message: move from chatbot experiments to measurable business impact

Why this matters for the SAP community

Most AI discussions ignore a key point: SAP value is locked in structured data + process discipline. The moment you align AI with that reality—tabular signals, business semantics, governance—you shift from “cool demo” to real operational leverage.

If you’re exploring AI for SAP and you want something that’s grounded in enterprise reality (data quality, governance, repeatability, outcomes), this episode is a solid watch:

🎥Watch here my podcast with Holger and Goran from Microsoft:
https://youtu.be/CbUDRgEO0yI?si=J4vE-BZ0Xig_srYo

Please share your thoughts and feedback!

Cheers,
Amit Lal

Decision Logic Modernization in SAP Integrations: Using SAP-RPT-1 for Intelligent Routing Decisions

2026-02-16T19:54:29.244000+01:00

Integration Modernization concept is often discussed in two dimensions:
1) Platform modernization – moving from older stacks like SAP NetWeaver PI/PO, SAP Neo, or legacy 3rd party platforms to SAP Integration Suite.
2) Scenario modernization – shifting from legacy protocols to modern integration patterns such as APIs & event-driven architectures; upgrading ABAP / Java mapping to graphical mapping / groovy script; or moving from basic auth to OAuth 2.0 or client certificate based authentication, and so on.

But there is another Modernization opportunity at the scenario level: decision logic modernization.

In this blog, we explore how routing decision logic, as an orchestration step — can be modernized using SAP-RPT-1, SAP’s latest foundation model hosted on BTP AI Core (Generative AI Hub) — applied to an outbound delivery routing scenario.

The Traditional Approach: Static Rules, Lookups, and Growing Complexity:
In SAP PI/PO and Integration Suite, routing decisions are typically implemented using deterministic, rule-based logic. These decisions often control how a scenario behaves – including which receiver system to call, or which transformation branch to follow. The common approaches include:

Static routing via Routers based on payload elements or fields
Dynamic configurations, such as externalized parameters passed at runtime
Lookups to external systems (e.g., via JDBC, SOAP, RFC lookups) to evaluate conditions at runtime — achieved in Integration Suite via patterns like Request-Reply or Content Enricher

These mechanisms work — but they come with growing challenges:

Rules get combinatorially complex with more conditions and evolving business scenarios
Lookup tables become burdensome to maintain
Decisions become rigid and hard to evolve over time

As a result, rule-based decisioning becomes harder to maintain as business requirements evolve. Agility suffers. Adaptation becomes expensive.

What if, instead of relying on static rule-based logic, iflows could make decisions based on historical business patterns — applying predictive machine learning without the overhead of training and managing custom models? With the in-context learning capabilities of SAP’s latest foundation model, SAP-RPT-1, such predictions can be performed on-the-fly at runtime.

Enter SAP-RPT-1: Foundation Model for Predictive Tasks:
SAP-RPT-1 is a pre-trained foundation model available via BTP AI Core (Generative AI Hub). Unlike traditional ML services that require dedicated data science setup, SAP-RPT-1 offers:

Pre-trained model, ready for “plug and play” in your scenario
No ML infrastructure setup
No data science expertise required
No-code consumption via API
Faster time-to-market
Democratization of AI capabilities across IT functions

SAP-RPT-1 is pre-trained specifically for predictive tasks such as classification and regression over ERP tabular data, unlike many general-purpose GenAI models that are primarily trained on large corpora of natural language text. Instead of building and managing a full ML lifecycle, integration developers can now leverage predictive intelligence directly into iflows — without any data science related heavy-lifting.

If you are new to SAP-RPT-1, I recommend that you read this introductory blog.
Also, explore this SAP-RPT-1 playground.

Business Scenario: Intelligent Outbound Delivery Routing with SAP-RPT-1:
SmartSense Technologies (SST), a global provider of smart security devices, faces challenges in routing outbound deliveries from its manufacturing plants to distribution centers, retail stores, and end customers. Their current routing logic, embedded in integration flows, relies on static rules and lookup tables – employing a combination of Material, Quantity, Delivery priority, Material group, Ship to location, and so on. This leads to frequent shipping delays, cost overruns, and SLA violations whenever logistics conditions change and sub-optimal 3PL partner is chosen.

To overcome these limitations, SST decides to leverage SAP Integration Suite together with SAP-RPT-1 foundation model. By embedding machine learning–driven decision-making into its integration flow, SST aims to dynamically select the optimal logistics partner for each delivery based on historical performance, cost, and delivery times. While SAP-RPT-1 is capable of solving predictive tasks such as classification and regression, we will be using it for classification task — i.e. to classify given delivery (defined by delivery header & item attributes) to most optimal 3PL logistics provider.

The following diagram illustrates the target architecture implemented by SST for intelligent outbound delivery routing using SAP Integration Suite and SAP-RPT-1 model, hosted on BTP’s Generative AI hub:

Step 1: Outbound Delivery Creation
An outbound delivery is created in SAP S/4HANA, which triggers an outbound notification event. The event is consumed by the iflow, which then calls S/4HANA OData API to fetch the following delivery related header and item attributes.

Delivery header fields: DeliveryDate, SalesOrganization, ShipToParty, SoldToParty, DeliveryDocumentType, CreationDate, ShippingPoint, DeliveryPriority, IncotermsClassification, TransactionCurrency

Delivery item fields: Material, DeliveryDocumentItemText, MaterialGroup, ActualDeliveryQuantity, DeliveryQuantityUnit, Plant, StorageLocation, ItemGrossWeight, ItemWeightUnit, ControllingArea, DistributionChannel, GoodsMovementType, ProfitCenter

Step 2: Context Selection – Random Historical Records
We store historic labeled data i.e. delivery headers, items and corresponding optimal 3PL partner data in SAP HANA Cloud. The iflow is configured to fetch a random set of this historic data from HANA Cloud. As recommended in this blog, for most enterprise use-cases, where you have about hundred thousand to million lines of labelled data, depending on how diverse your scenario data is, you may choose the context size, by iterating and finalizing the apt number of historical records to pick. By picking random records, we are able to provide statistically diverse examples, improve prediction quality and avoid bias from sequential records.

The Iflow executes the following query on the HANA Cloud DB:

SELECT TOP ${property.NumberofRecords}
"DeliveryDate",   "DeliveryDocumentNumber",  "CreationDate", "DeliveryPriority",  "IncotermsClassification",  "Material", "DeliveryDocumentItemText", "MaterialGroup",  "ActualDeliveryQuantity", "DeliveryQuantityUnit", "ItemGrossWeight", "ItemWeightUnit", "DistributionChannel", "PartnerNumber"
FROM "RPT1"."historic_3pl_selections"
ORDER BY RAND()

Step 3: Constructing the SAP-RPT-1 Request
We now combine:

Historical random records (known 3PL partner)
The current outbound delivery (3PL partner to be predicted)

The current transaction includes a placeholder: [PREDICT]

The request payload contains:

900 historical labeled rows
1 new outbound delivery row marked for prediction

For detailed info on payload construction, refer to the official documentation page and the GitHub repository (sample Postman/Bruno collections available for experimentation).

Further, while creating the inferencing request to SAP-RPT-1, we trim the columns from original 24 down to only 14 columns of delivery attributes, by removing fields like Sales Org, Controlling Area, Profit centre that do not influence partner selection. This is one of the best practices to achieve best possible predictive outputs. Read more recommended best practices here.

Step 4: Deploying SAP-RPT-1 model in Generative AI Hub

Step 5: SAP-RPT-1 inference response
The response contains Number of predicted records, predicted field (here optimal 3PL partner) along with Confidence score.

Response from our example scenario:

You can also send multiple unknown records in one batch. To read more about the number of max. records and columns supported by SAP-RPT-1, check out this help page.

Step 6: Intelligent Routing in the Iflow
The Iflow now:

Reads the predicted PartnerNumber
Evaluates confidence threshold (optional safeguard)
Routes outbound delivery to the optimal 3PL partner
Optionally, logs decision + confidence for traceability in HANA Cloud.

When AI in Iflows Brings Real Business Value

When routing decisions directly impact business outcomes
If sub-optimal routing can lead to SLA breaches, shipment delays, higher costs, or customer dissatisfaction, intelligent decision logic creates measurable advantage.
When rule-based logic becomes complex and brittle
As business variables multiply (products, regions, priorities, partners), static rules become hard to maintain and scale. ML handles multi-dimensional patterns more effectively.
When historical ERP data contains predictive patterns
If past delivery and fulfillment data reflects consistent business behavior, ML can learn from it and improve future routing decisions beyond deterministic conditions.
When business context evolves over time
With changing product mixes, customer bases, or distribution models, retrainable ML models adapt dynamically — avoiding constant manual rule maintenance.

Not every integration scenario requires ML capabilities. But where routing decisions carry operational or financial impact, replacing rigid rule sets with adaptive decision logic can significantly improve resilience and maintainability. Decision logic modernization is therefore not about adding AI everywhere — it is about applying it where it meaningfully improves orchestration.

Note: This blog revisits our earlier implementation in light of the planned deprecation of SAP BTP Data Attribute Recommendation service, demonstrating an updated approach using SAP-RPT-1 model.