SAP Community - SAP AI Services

Roadblocks to AI Adoption

2025-12-01T13:28:01.063000+01:00

Introduction

In an era defined by rapid technological advancement, businesses face both significant challenges and valuable opportunities as they pursue digital transformation and integrate AI-driven solutions. As organisations work to maintain a competitive edge, AI’s impact on business strategy, customer experience, and operational efficiency has become increasingly pivotal.

As part of my recent doctoral studies in Digitalisation, specialising in Technology Adoption and AI Integration at IAE Nice, Graduate School of Management, Université Côte d’Azur, I explored this evolving landscape in depth through research focused on SAP customers. I am Happy to share the key findings through a series of insightful and practical articles, each offering guidance for both SAP customer leadership and SAP executives navigating the complexities of AI adoption and technology transformation.

Maximising AI Potential: A Blueprint for Business Success
Roadblocks to AI Adoption (THIS ARTICLE)
Is SAP Business Data Cloud the Answer to Your AI Ambitions?

Photo by adventtron Unsplash

With advancements in technology continually reshaping the business landscape, artificial intelligence (AI) stands out as a transformative force across industries. However, despite its potential, many organizations stumble on the road to successful AI adoption. Understanding these barriers is critical for any business hoping to leverage AI effectively.

Organizational Readiness and Resistance to Change

One of the foremost challenges in AI adoption is the readiness of an organization to integrate new technology. According to recent studies conducted by the author within SAP, involving 29 SAP customers and their SAP counterparts, many businesses lack the necessary infrastructure, skilled personnel, and strategic vision to implement AI successfully. Additionally, the cultural resistance within organizations can be a significant hurdle. Employees often fear job displacement due to automation or feel overwhelmed by the pace of technological change, thereby resisting new implementations. A customer from the Oil & Gas industry in EMEA South as part of an interview with the author stated that " The transformation is happening in three areas: people, processes, and technology. One significant challenge is that people often resist change, which is something we frequently notice when adopting new technologies. Sometimes, these technology is introduced without a proper change management. As a result, the leadership faces langes in later stages to manage the change and convince the end users to accept the AI automation and overcome their initial hesitations and fear."

Cost and Complexity Considerations

The cost involved in deploying AI solutions is another significant barrier. Setting up AI systems requires substantial initial investment in technology and training, which can be a deterrent especially for SME enterprises. Moreover, the complexity of AI technology itself poses a challenge. Companies must ensure they have the expertise to not just implement but also maintain and scale AI solutions, which often necessitates costly ongoing training and development. A customer in the Chemicals sector from EMEA South reports to the author of this article that "Yeah, it's an easy question because in the end if there's a SAP competitor upcoming next year with a cheaper alternative, then we will think about going for the SAP’s competition." According to a CSM from EMEA South team share his experience saying with the author "A customer that I managed a couple of years ago has moved away from us and they moved to a SAP’s competitor due to the cost of our solutions"

Data Privacy and Security Concerns

Data is the lifeblood of AI. However, the increasing stringency of data protection regulations such as GDPR in Europe presents a compliance maze for companies to navigate. Ensuring data privacy and securing AI interactions becomes a critical concern that companies must address, adding another layer of complexity to AI adoption. A Higher Education industry customer based in EMEA North shares that with the author "Data Privacy and security is absolutely a concern even today, thought it really depends very much on the industry."

Lack of Clear ROI

The uncertainty about the return on investment (ROI) from AI projects also serves as a barrier. AI initiatives can be experimental in nature, making it difficult to predict outcomes precisely. This uncertainty can make stakeholders hesitant to commit the required resources, slowing down or even halting AI adoption processes.

Vendor Selection and Integration Challenges

Choosing the right technology provider and ensuring the integration of AI with existing systems is another challenge for our customers. Businesses often struggle with choosing between SAP and multiple other options, each promising superior capabilities. Making the wrong choice can lead to integration issues, wasted resources, and failed projects. MEA North’s Oil & Gas industry customer expresses in an interview with the Author that "It also plays a very important role in the industry where I'm working right now, where we have to leaverage technology and AI to lead the market and to deliver the requirement of our demanding customers worldwide."

Moving Forward: Recommendations for Overcoming AI Adoption Barriers

1. At SAP, we understand the importance of cultivating a culture receptive to innovation. We must work with your business to develop comprehensive change management strategies. Our support will help alleviate resistance and ensure a smooth integration of AI into our customer’s existing processes, fostering continuous learning and adaptability.

2. At SAP, we recommend allocating resources for essential infrastructure upgrades such as RISE with SAP. Our team should assist in building AI competency through employee training programs which our leadership is already heavely investing. Additionally, we can help establish partnerships with universities and tech institutes, ensuring a steady flow of skilled talent to support your AI initiatives.

3. At SAP, we prioritise data security. Its necessary for us to help strengthen our customer’s cybersecurity measures and ensure compliance with data protection laws. By safeguarding customer operations, we will build trust among stakeholders, thereby smoothing the path for successful AI integration.

4. To demonstrate the value of AI projects, we ought to work with customers to establish clear metrics for evaluating their performance. This will help secure ongoing support from stakeholders by showcasing tangible results and a positive return on investment.

5. We believe in transparency and performance. By implementing a robust assessment process from our solutions, including pilot projects and performance benchmarks, we will ensure that our collaboration best matches our customers's needs. Our commitment is to be our customer’s trusted partner, guiding customers through successful AI adoption and implementation is the key.

Conclusion

In summary, while artificial intelligence promises transformative benefits for businesses, the journey to successful AI adoption is fraught with challenges. These roadblocks range from organisational readiness and resistance to change, cost and complexity considerations, data privacy and security concerns, uncertainty about ROI, to vendor selection and integration issues. To overcome these hurdles, businesses must approach AI adoption strategically and holistically.

At SAP, we understand these challenges and are committed to helping our customers navigate them effectively. In the light of above information, I do recommend to focusing on cultural receptivity, infrastructure upgrades, data security, clear ROI metrics, and transparent in our sales strategies, and strive to be a trusted partner in our customers' AI adoption journey. Through comprehensive change management, skill development, robust cybersecurity measures, and performance benchmarking, SAP can aim to smooth the path to successful AI integration. By addressing these barriers head-on and fostering a collaborative approach, businesses can unlock the full potential of AI and drive meaningful growth and innovation.

If you'd like to explore further, my full research article with reproach is available here. Please don't hesitate to contact me if you wish to discuss the research findings 🙂

Find me on Linked-in: https://www.linkedin.com/in/mi4po/

Bridging Data Quality Gaps in SAP SuccessFactors TIH with CSVValidationApp and Vibe Coding

2025-12-03T16:06:10.964000+01:00

Introduction

Data quality challenges in SAP SuccessFactors Talent Intelligence Hub (TIH) often go unnoticed until they impact user experience. When thousands of attributes are imported without proper validation, issues like HTML tags, broken formatting, and unescaped characters can disrupt Growth Portfolios and compromise analytics/employee experience. This blog introduces CSVValidationApp, a solution designed to bridge this gap using functional expertise and modern development practices like Vibe Coding—and opens the door for community collaboration on similar innovations.

Why This Matters

SAP Talent Intelligence Hub is a strategic enabler for skills-based workforce planning. It helps organizations create dynamic career paths, leverage AI-driven skill recommendations, and empower employees through Growth Portfolios. These capabilities unlock smarter talent decisions and a more agile workforce.

To fully realize these benefits, data integrity during imports is critical. According to SAP Help Portal, importing entities like attributes, tags, and behaviors into TIH requires strict adherence to structure and format. Common issues include:

Incorrect headers or missing mandatory fields in CSV files
Improper encoding (non-UTF-8) causing character display errors
Unescaped quotes or HTML tags in descriptions, which can truncate or break content
Large file sizes impacting performance (recommended limit: 25,000 records per file)
Incorrect date formats for proficiencyAssignedDate when updating Growth Portfolio attributes

These challenges can lead to incomplete or inaccurate data in the Attributes Library and Growth Portfolio, affecting AI-driven recommendations and user experience. Adding a validation step before import ensures clean, consistent data—reducing manual troubleshooting and enabling HR teams to focus on strategic initiatives.

My Perspective and Approach

Having worked extensively across implementations, integrations, and functional solution design in SuccessFactors, I’ve seen how small data issues can create big challenges downstream. This experience shaped my approach: build a tool that doesn’t just validate data but actively improves it before it enters TIH.

I chose Vibe Coding as the development approach because it accelerates delivery through real-time collaboration, instant previews, and iterative design—all within SAP Business Application Studio. This allowed me to focus on business logic and user experience rather than boilerplate coding, ensuring the solution was delivered quickly without compromising quality.

How CSVValidationApp Fits into the TIH Workflow

CSVValidationApp acts as a data quality gatekeeper in the integration process. In the following example workflow after data is exported from Integration Center, the file passes through CSVValidationApp for cleansing and validation. Once clean, the data is transformed and mapped to TIH-compatible attributes before being imported back into the system.

This workflow ensures that what enters TIH is not just valid but optimized for rendering and usability. The result? A clean, enriched skills library that supports AI-driven recommendations and future enhancements.

What Makes CSVValidationApp Powerful

CSVValidationApp performs comprehensive checks tailored for SuccessFactors Integration Center requirements. It detects encoding issues, validates structure, identifies problematic characters, and removes HTML tags and entities. Beyond validation, it offers auto-correction, generating clean content with proper quoting and escaping. A preview feature and detailed statistics give administrators confidence before import.

By automating these steps, CSVValidationApp transforms a tedious, error-prone process into a seamless experience—empowering HR teams to focus on strategic tasks rather than data cleanup.

Looking Ahead: Unlocking the Full Potential of TIH

SAP Talent Intelligence Hub is continuously evolving to help organizations stay ahead in a skills-based economy. Upcoming innovations include AI-driven skill inference, integration with external taxonomies, expanded APIs, and advanced analytics for workforce agility. These capabilities will empower HR teams to make smarter decisions and deliver personalized employee experiences.

Clean, validated data is the foundation for these advancements. By ensuring data integrity from the start, organizations can confidently leverage AI recommendations, predictive insights, and future integrations without disruption.

CSVValidationApp supports this vision by acting as a proactive data quality gatekeeper. Future enhancements will include AI-powered attribute correction suggestions, direct SAP API integration for one-click imports, and support for additional modules like Learning and Recruiting—making the process even more seamless and intelligent.

Getting Started

CSVValidationApp is built as an SAP Fiori application using SAP Business Application Studio. To run it locally, simply clone the ***REMOVED BY MODERATION***, install dependencies, and start the app.

Here is an example screen shot from the application. The Attribute text file I validate below had many data rows with competency description such as:
"1000009","de_DE","BUSINESS & TRANSFORMATION..","Sie planen Ihre Vorhaben, definieren herausfordernde Ziele und entscheiden mutig.Herausforderungen im &bdquo;VUCA“-Umfeld (Volatilität – Unsicherheit – Komplexität – Ambiguität) begegnen Sie aktiv und entwickeln eine klare Vision für Ihren Verantwortungsbereich.<a href= xyzurl target=_blank>Kriterien und Verhaltensanker</a> anzeigen.","COMPETENCY"

This description gets corrected to:

"1000009","de_DE","BUSINESS & TRANSFORMATION..","Sie planen Ihre Vorhaben, definieren herausfordernde Ziele und entscheiden mutig. Bei der Umsetzung agieren Sie lösungsorientiert, bewerten Ergebnisse und Prozesse und nehmen notwendige Anpassungen vor. Herausforderungen im „VUCA\"-Umfeld (Volatilität - Unsicherheit - Komplexität - Ambiguität) begegnen Sie aktiv und entwickeln eine klare Vision für Ihren Verantwortungsbereich. ","COMPETENCY"

Final Thoughts & Community Ask

Data quality may seem like a technical detail, but in reality, it’s a strategic enabler. By combining functional expertise with modern development practices, CSVValidationApp delivers a solution that not only solves today’s challenges but positions organizations for tomorrow’s opportunities.

I’d love to hear from the SAP Community:

Have you built similar tools using Vibe Coding or other rapid development approaches?
What other gaps do you see in data validation for SuccessFactors integrations, and how can we bridge them together?

Share your thoughts, examples, and ideas in the comments. Let’s collaborate to make data quality a strength, not a challenge.

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

Contribution Margin Forecast with SAP Business Data Cloud

2025-12-10T12:07:09.187000+01:00

MANAGEMENT SUMMARY

This blog demonstrates how SAP Business Data Cloud (BDC) can be used to implement a contribution margin forecast, which serves companies as a substantial controlling tool to steer financial results in the short- and medium-term. Combining SAC Planning with Datasphere (“Seamless Planning”) allows for (near) real-time usage of actual data from SAP BW to extrapolate the variable cost component of the contribution margin, while SAC Planning is used to forecast the revenue component and report on the resulting KPIs. The combination of the actual and planning data happens without the need for redundant data replication. Furthermore, this blog will briefly touch on how BDC can be leveraged to enhance this use case through a comprehensive path for BW modernization, the re-use of SAP-managed data products, and the application of advanced machine learning methods for forecasting.

RECAP

Before continue reading it is recommended to familiarize with the following preceding blog posts to properly understand the fundamentals:

The Value of SAP Business Data Cloud (BDC) in The Context of Business Steering puts this blog post into perspective of a comprehensive blog series that aims to demonstrate the business value add of SAP BDC.
Real-time steering with LIVE planning uncovers the "Seamless Planning" paradigm (which is the key enabler for below-described use case) and illustrates a practical end-to-end use case that leverages External Live Versions, our latest innovation in context of Seamless Planning.

MOTIVATION AND USE CASE

The motivation of this blog is to demonstrate a tangible implementation example for how BDC can be leveraged to enable effective and efficient business steering. The demonstrated use case is a contribution margin forecast which estimates future revenues and variable costs, calculating expected contribution margins over time. The contribution margin is particularly relevant for financial steering because fixed costs are, by definition, largely unchangeable in the short- and medium-term. Therefore, if a company aspires to impact financial results, management’s primary focus and opportunity for action resides in maximizing the contribution margin. In essence, the contribution margin is calculated by subtracting variable costs from revenues, with the remainder – that is, the contribution margin – available to cover fixed costs. The levers that management can actively influence on a regular basis are:

Picture 1: Calculation schema for Contribution Margin

Such a contribution margin forecast can be implemented in an innovative fashion leveraging the Seamless Planning capability within BDC as explained in the following paragraph.

IMPLEMENTATION

Considering the above-described contribution margin levers, we are using the following BDC components for the corresponding implementation.

A SAC Story on top of a SAC Planning model is used to enter sales volume forecast and pricing assumptions (1). Upon publishing (2) the forecasted values (volumes, prices) are directly persisted within Datasphere (“Seamless Planning”).

Picture 2: SAC frontend for revenue forecastDatasphere is used to acquire and model total actual variable costs and sales volumes based on SAP BW in our example (3) (or any other compatible and relevant source system). Note that actual sales volumes are acquired to allow the calculation of volume-weighted actual variable costs per unit in a later step. A union view (4) within Datasphere combines the forecasted sales volumes and prices (as provided via the SAC Planning frontend) with the actual sales volumes and variable costs (as acquired from SAP BW).

Picture 3: Data lineage within Datasphere

In an Analytic Model (5) on top of the union view the relevant KPIs consisting of both forecast and actual data are calculated:

Forecasted revenues: Restricted measures filter on forecasted volumes and prices originating from the SAC planning model. A calculated measure multiplies these two measures to derive the forecasted revenue [forecasted revenues = forecasted sales volumes * price assumption].

Extrapolated variable costs: Restricted measures filter on actual volumes and total manufacturing costs originating from SAP BW. These measures are cumulated over the actual time horizon as selected per prompt (6). A calculated measure divides cumulated costs by cumulated volumes to derive the volume-weighted average costs per unit [weighted-average costs per unit = cumulated actual costs/cumulated actual sales volumes]. Note that this measure is kept constant over the time dimension to allow applicability to any forecast months (see below).

Expected contribution margin: A calculated measure extrapolates the actual variable costs by multiplying the volume-weighted actuals costs per unit (see above) with the forecasted sales volumes [extrapolated variable costs = weighted-average actuals costs per unit * forecasted sales volumes]. A calculated measure subtracts extrapolated variable costs from forecasted revenues to finally derive the contribution margin [contribution margin forecast = forecasted revenues - extrapolated variable costs].

Picture 4: Analytic Model within Datasphere A SAC Story on top the Analytic Model is used to steer the prompt for the weighted-average actual variable costs (6) and display the results -- that is, the weighted-average variable costs (left chart) and the derived contribution margin (right table) (7).

Picture 5: SAC frontend for analysis The following diagram summarizes the architecture and data flow at a glance.

Picture 6: Seamless Planning architecture

It is now worthwhile looking at the unique highlights of the above-described setup. First, Seamless Planning within BDC combines "best of both worlds": SAC planning and reporting capabilities with Datasphere ETL and modeling capabilities. Second, SAC planning model entries are directly exposed within Datasphere upon publishing without the need for redundant data replication. Third, it would be generally feasible to access the actual variable costs virtually (as opposed to replicated), thus combining planning with actual data in real-time. However, note that regular snapshots (near real-time) of the actual data can be required for high-performant dashboards. Forth, the prompt to dynamically steer the time range for the weighted-average actual variable costs allows end users to sort of “smoothen” the data over time (when choosing a longer range) versus emphasizing more recent months to reflect latest changes in cost structures etc. Lastly, given the completely automated retrieval of the variable costs part of the calculation, end users only need to manually update the expected sales volumes and price assumptions. This allows for a fast forecast process with a high frequency (e.g., monthly rolling forecast) which is highly relevant in today’s dynamic market environment.

POSSIBLE ENHANCEMENTS

In the above-described implementation setup actual data is being acquired from an SAP BW system via standard data acquisition means in Datasphere (remote tables, real-time replication, etc.). However, for SAP BW systems (both BW/4 and on HANA) BDC opens up the path for comprehensive BW modernization through means of the Data Product Generator (please see this blog for further details).

Furthermore, the use case could be enriched with SAP-managed data products derived from an S/4 PCE system as part of a BDC formation. For instance, if the contribution margin forecast should be integrated into a broader plan/actual reporting solution, the relevant actuals could be built upon SAP-managed data products serving as significant accelerators given that the complete data orchestration is handled by SAP. You could directly start modeling within Datasphere and combine the forecast data with the actual data based on the SAP-managed data products. A detailed blog discussing how you can leverage data products in the context of planning will follow.

Finally, for more advanced forecasting techniques you could leverage SAP Databricks as part of the BDC formation. Imagine that instead of the manually provided sales volume forecast as in the above example you would generate such a forecast by means of statistical methods such as time series forecasting.

Picture 7: Enhancement options with BDC

SUMMARY AND CALL TO ACTION

A contribution margin forecast allows companies to proactively steer financial results and can therefore be considered a crucial controlling instrument. SAP BDC enables an innovative implementation approach with clear benefits such as rapid, high-frequency forecasts through automated calculation of variable costs and replication-free, (near) real time combination of actual and planning data. Besides that, SAP BDC opens up the path for comprehensive BW modernization, thus allowing you to follow parallel streams: Implementation of innovative use cases while modernizing your SAP BW. Sounds like a plan to you? Please reach out to your SAP representative and register for your SAP BDC Discovery Workshop!

MCP Server for SAP ECC & S/4HANA: Unlimited ABAP Add-On for Display, Create and Update Tools

2025-12-18T15:53:02.178000+01:00

Introduction

It’s time to simplify integration processes between Agentic SDKs and SAP ECC & S/4HANA systems. We’d like to introduce an ABAP add-on that brings an MCP Server directly into your SAP ERP system and supports SAP ABAP releases down to 7.01.

Sounds attractive? Then let’s take a look at the architecture.

Architecture

The architecture is simple. We kept in mind that you may want to avoid middleware (such as SAP BTP applications or similar solutions) while retaining full control over:

Tool descriptions
These are essential for AI orchestration–friendly tool definitions. Standard SAP descriptions of services, tables, or other ABAP objects are not sufficient to build scalable Business AI solutions.
Data provisioning
We provide a simple mechanism that allows you to nominate Tables, Views, and CDS Views to provision data to an Agentic SDK.
Create / Update / Delete tool onboarding
We offer an easy mechanism to develop ABAP classes for create, update, and delete actions. Each tool requires only one method for the action and one method for metadata description.

This is how you can integrate it into any Agentic SDK:

Pic. 1. MCP Server at the SAP backend system level

What Does “Unlimited Display Tools” Mean?

There is an ABAP view where you can onboard Tables, Views, and CDS Views for data provisioning. Each object is automatically converted into a tool by the MCP Server.

Pic. 2. Nomination of Tables, Views, and CDS Views for data provisioning via MCP Server

How Do You Develop Tools for Create / Update / Delete Actions?

We provide an ABAP interface that helps you create an ABAP class for each tool.

Pic. 3. MCP Server tool creation for Create / Update / Delete actions

Really Any Agentic SDK?

Yes, absolutely. Here is an example of MCP Server consumption in ChatGPT.

The MCP Server can be connected either directly via an SICF node or through the SAP Cloud Connector.

Pic. 4. MCP Server SICF node

In ChatGPT, you can connect the SAP MCP Server in developer mode:

Pic. 5. Connecting MCP Server in ChatGPT

Once connected, you have direct access to SAP backend data from ChatGPT:

Pic. 6. Leave request creation from ChatGPT via Skybuffer AI MCP Server

Pic. 7. Purchase order data display from ChatGPT via Skybuffer AI MCP Server

Can Skybuffer AI MCP Server Work with SAP Joule?

Yes, absolutely. You can connect the MCP Server directly to an SAP Joule tool in SAP Joule Studio.

Conclusion

You now have a powerful, scalable MCP Server operating directly at the ABAP layer. You can provide high-quality tool descriptions, fully control display tool provisioning, and easily onboard create, update, and delete tools without the need to build OData services on top of them.

The solution works with any Agentic SDK and is ready for enterprise deployment as an ABAP add-on.

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.

Why Vectorized Master Data is Critical for AI on SAP ECC and S/4HANA

2026-01-12T17:51:02.066000+01:00

Why Most AI Agents Fail with SAP Data

AI Agents are rapidly becoming part of enterprise landscapes, and SAP ECC and S/4HANA are obvious targets for automation. However, what we see in the market today is concerning.

Most agentic solutions attempt to consume SAP data through custom coding. This approach creates three major problems:

High development and maintenance costs
Multiple, inefficient calls to the SAP backend
Mass data extraction, where AI Agents pull entire tables just to find a few relevant records

In many of the solutions we reviewed, including agentic SDKs integrations such as Joule, n8n, ChatGPT, and Claude, AI Agents frequently fail, time out, or request all records from SAP ERP systems with minimal filtering. This is inefficient, risky, and completely unnecessary.

At Skybuffer AI, we believe there is a better way.

The Foundation: Preparing SAP Data for AI Consumption

Data preparation is the key to successful AI-driven automation. While topics like data silos and data quality are well known, they cannot be fully solved overnight. Instead of fighting this reality, Skybuffer AI introduces a simple and reliable data layer that AI Agents can consume efficiently.

Skybuffer AI uses SAP master data vectorization to enable fast, accurate access to SAP ECC and S/4HANA data from agentic workflows. Any SAP master data table, including views and CDS views, can be vectorized and materialized using Retrieval-Augmented Generation (RAG).

Key capabilities include:

Support for full and delta loads
Near real-time synchronization with SAP
A scalable, AI-ready representation of SAP master data

Pic. 1 Skybuffer AI – SAP Data Vectorization Configuration

Performance at Enterprise Scale

A common concern is performance. Vectorizing SAP master data row by row would indeed be slow, if done sequentially.

Skybuffer AI solves this with parallel embedding execution, allowing vectorization at enterprise scale. On servers with 8 GPUs, Skybuffer AI can process up to 1 million records in 30 minutes. That is scalable in case even faster vectorization solution is needed.

More importantly, once initial vectorization is complete, a self-healing delta mechanism ensures that only new or changed records are processed. This keeps the data current without impacting performance.

Business Value: Why This Approach Matters

The benefits are immediate and measurable:

No coding for intelligent master data search
No multiple calls to SAP backend systems
No full-table reads triggered by AI Agents
Faster, more reliable AI-driven processes

Consider a real-world scenario:
A vendor invoice arrives by email.

Pic. 2 Real Consumption-Based Invoice Example

The AI Agent reads the email and attachment, extracts the vendor name exactly as written on the invoice, and needs the corresponding SAP vendor number. Instead of querying SAP repeatedly or scanning entire tables, the Agent performs one single RAG search against vectorized SAP master data.

Within milliseconds, the correct vendor record is returned. It is accurate, up to date, and ready for posting in SAP.

Pic. 3 Skybuffer AI – Fast and Reliable SAP Data Search Using Data Vectorization

No coding. No overload. No hallucinations.

Applicable Across Many SAP Use Cases

The same approach works seamlessly across multiple scenarios, including:

Finding SAP users or business objects by name, email address, or other attributes
Creating Sales Orders in SAP from customer Purchase Orders
Resolving customer and material master data automatically
Creating Bills of Materials and routings from Excel files managed by R&D teams
Posting Service Entry Sheets
Rapidly enabling new use cases by simply nominating tables for vectorization

If the data exists in SAP, it can be prepared for AI consumption.

Built-In Authorization and Security

Security is not an afterthought.

Skybuffer AI applies the same concept used in AI assistants for Teams, Copilot, and Joule, so vectorized data accessed by users with an additional safeguard. Once the AI Agent selects relevant records via RAG, Skybuffer AI retrieves those records directly from SAP using SSO within the active conversation session, before providing data to the user.

This ensures:

Users only see data they are authorized to access in SAP
Vectorized data never bypasses SAP authorization rules
Enterprise-grade compliance and governance

Seamless Integration with Existing AI Agents

Already running AI Agents and just need access to SAP data?

Skybuffer AI provides an MCP Server, allowing your existing agentic solutions to consume vectorized SAP data without replacing your current platform. This makes Skybuffer AI an enabler, not a disruptor.

Pic. 4 Skybuffer AI – MCP Server for Integration with Agentic SDK

Flexible Deployment: Cloud or On-Premise

Skybuffer AI is built on SAP HANA and can be deployed:

On-premise within your own infrastructure
In your SAP BTP tenant

A modern SAP UI5 user interface ensures an intuitive and productive user experience for both IT and business users.

Conclusion

SAP ECC and S/4HANA master data vectorization is the missing link between SAP and AI Agents.

With Skybuffer AI, enterprises can:

Eliminate coding
Avoid hallucinations
Reduce SAP backend load
Enable fast, secure, and reliable AI-driven processes

This is how SAP data becomes truly AI-ready.

How Is Agentic AI in SAP Transforming Core Business Processes Today?

2026-01-16T15:12:49.528000+01:00

From Deterministic Automation to Agentic Process Execution

Traditional SAP automation operates via predetermined workflows that trigger events under specified circumstances only. Any change from this path necessitated manual actions. The introduction of an intelligent agent into the SAP environment allows for a very different method of operating, in which the agent has the ability to "think", analyze, and resolve problems autonomously.

SAP uses reasoning models and live business context to create AI Agents for SAP. An example of this is an AI agent that monitors the fulfillment of orders. Instead of just flagging an order as delinquent if it is delayed, the AI agent draws on its knowledge of upstream supply constraints and determines whether to re-route inventory or to negotiate new delivery windows with its supplier based on the contractual penalty associated with violating their contract. The logic for making these decisions is not hard-coded; it is inferred from the context surrounding the order.

Additionally, SAP AI supports a feedback-driven execution process whereby each decision made by the AI agent provides a learning opportunity for the next execution cycle. For example, if an agent executes a corrective action that incurs additional costs but does not improve service level performance, it will adjust future decision-making accordingly. This results in a cyclic execution loop as opposed to single-event automation.

Some of the key execution traits include:

Goal-oriented reasoning rather than task completion
Context-aware evaluation across SAP modules
Continuous recalibration based on outcomes

SAP AI Teams designs these agents with explicit governance controls that guide every action. Clearly defined business rules determine what an agent can decide and when escalation is required. Comprehensive audit trails then record the rationale behind each decision, which helps create traceability and accountability. As a result, agent autonomy functions within clearly controlled boundaries rather than operating in isolation.

Agentic Intelligence Across Finance and Controlling Functions

Finance processes within SAP are tightly governed. Yet they remain vulnerable to volume pressure, reconciliation delays, and data inconsistencies. Agentic AI in SAP introduces agents capable of interpreting transactional meaning instead of matching static fields.

For instance, agents that reconcile would review the intent of the posting as well as timing differences and relationships between companies to recommend changes rather than create exception lists. The transition from matching manually to validating decisions allows for faster closes and maintains accuracy.

Moreover, Agentic AI for SAP goes beyond finance by being used in controlling and forecasting. For example, agents that look at a Cost Center’s variance compared to plan provide warnings of potential future variances by correlating delayed purchasing, bottlenecking within operation, and price variability. Instead of standalone variance reports, the Finance team provides a context-specific recommendation with the ability to trace back to source information and assumptions.

Finally, Agentic AI for SAP provides a new definition of compliance monitoring; whereas previously, compliance would check after the posting, agents will check prior to posting, validating whether the transactions align with company policy as well as prior risk history. Predictive controls reduce the need for downstream corrections and/or auditing findings.

Typical finance use cases include:

Autonomous account reconciliation proposals
Predictive compliance validation
Contextual variance interpretation

SAP AI teams emphasize explainability in these scenarios. Each agent’s decision includes rationale, data references, and confidence levels. This maintains trust in regulated environments.

Supply Chain and Operations Under Agentic Control

All supply chains produce large amounts of 'signals', the variation in forecasts, supplier delays, and constraints on logistics result in a chain reaction. These types of 'volatility' are not well-suited to static planning models. An agentic AI is now available as part of SAP. It will allow automated agents to evaluate or negotiate the trade-offs between plans and adjust accordingly.

In demand planning, the AI agent will evaluate forecasts based on both recent and historical consumption and market signals. Instead of sending static alerts, AI agents in the SAP demand planning module will update the planning parameters. This allows for fewer manual overrides that affect the accuracy of the plan.

Operationally, agents monitor execution milestones. When deviations occur, they evaluate options across procurement, production, and distribution. Actions may include expediting materials, reallocating stock, or revising commitments. These decisions consider cost, service impact, and contractual obligations simultaneously.

Additionally, AI for SAP supports cross-functional coordination. Agents share context across modules rather than operating in isolation. This helps reduce fragmented responses and improves execution coherence.

Organizational Readiness and Governance Models

The implementation of agentic AI encompasses an organization’s readiness to use the agentic tool successfully. An organization’s level of readiness is determined by the organization’s ability to ensure data integrity, clarity of its business processes, and the level of governance that has been established.

First, data quality must support reasoning. Agents depend on consistent master data and reliable event streams. Skewed data leads to skewed decisions. Enterprises investing in agentic AI services often begin with semantic data alignment and process instrumentation.

Second, with evolving governance models, organizations set limits and thresholds that allow action authorization without the need for direct action approval for every action. AI agents within those limits and thresholds operate autonomously, with escalation of the process when risk increases or when agents are doubtful in their decision-making. This helps reduce the "approval fatigue" associated with governance models but still allows for oversight.

Security models are evolving as well, whereby agents receive scoped authority and scoped access controls, not only to see the data a user sees but also to take the action the user can take. The decisions that AI agents make in SAP are recorded alongside the decisions made by the human agents, creating one single audit trail for both human and AI agents.

Core governance principles include:

Explicit decision boundaries
Continuous monitoring of agent behavior
Transparent reasoning documentation

SAP AI Teams play a critical role here. They bridge business intent and technical design, ensuring agents act responsibly and predictably.

Final Thought

Agentic AI in SAP signals a structural shift in enterprise execution. SAP systems move beyond recording outcomes toward autonomous action. AI agents in SAP reason across modules, adjust to change, and act within defined constraints. Moreover, AI for SAP reshapes organizational roles and allows SAP teams to operate as agents of change rather than manual intervention.

To develop these agents, SAP teams will need to implement strict guidelines and oversight within their designs. Once agentic systems have been properly developed, they will provide a dependable means of digital operations for organizations to pursue. As more organizations adopt agentic AI into their SAP teams, the companies that invested time and effort into developing mature SAP AI teams and Agentic AI will be the companies establishing the standard for how intelligent enterprise execution will take place in the future.

Inside the GCID AI Hackathon: A Global Contest where AI Initiatives came to life.

2026-01-20T18:06:17.313000+01:00

A journey that came to life on stage

The hackathon took place on December 10 during a hybrid event in Sofia hosted by Matheus Souza, Head of AI Incubation, in Sofia. Where a global audience came together both in person and online. And more than 170 participants tuned in as the 11 finalist teams presented their work during the qualifying round and later to the finals.

Each team stepped on stage with a short, high-impact pitch supported by a live demo. In just 7 minutes, they told the story behind their solutions, showing how AI can address concrete technical and business challenges when creativity, and clear communication come together. From this round, three teams stood out and advanced to the final.

The final round opened with motivating messages from Ozren Kopajtic, Global Cloud Infrastructure and Delivery Head, Kiril Krantev representing the GCID T&I Cloud Operations, and Ricardo Silva GCID Business Delivery Excellence Head. Then the atmosphere was further energized by an inspiring message from Thomas Saueressig, and the executive jury: Radoslav Nikolov, Niraj Singh, Boris Maeck, Henning Heitkötter, and Ricardo Silva. Who encouraged teams to continue pushing their ideas.

Awarding outstanding ideas and execution

Throughout the hackathon, one message became clear: AI has the potential to reshape how we operate, decide, and scale across the organization. The event came an end with Radoslav, Ricardo and Matheus, announcing and celebrating the teams whose solutions stood out for their originality, technical strength, and real-world applicability:

First place:" AI-Powered AWX Analyser & Hammer Helper" by Barath Ramachandran, Suresh Kumar Sekar, and team
Second place: "Smart Data Center" by Geghard Bedrosian, Philipp Matthes, and team
Third place: "AI for Smarter Observability Hygiene" by Mario Romero, Duc Nguyen, and team

What’s next for the hackathon journey

Rather than an ending, this first edition marked the beginning of something bigger. Announced at the end of the event, the hosting city for this year's edition of the GCID AI Hackathon will take is Budapest. There the community is set to continue growing and creating even more space for experimentation and innovation.

The excitement is already building for what the next edition will bring, and we can't wait for it to begin. See you there?

Why Bringing SAP to Agentic SDK via Regular MCP Server Is Not Good Enough

2026-01-23T00:38:39.594000+01:00

Advocating Technology

Let me name things properly – we have lots of noise around AI. Companies are trying to jump into the technology because they think that Business AI is simple, that it is just a kind of ChatGPT that gets access to business data. Sounds simple, doesn’t it?

I strongly disagree! Bringing SAP data to an Agentic SDK, like Claude or SAP Joule, does not mean delivering Business AI. It is far away from even an understanding of business needs. I know, you start hating me 😊. And the only reason for the internal opinion in your head is that you are most probably one of the MCP bridge providers that think that wrapping APIs (I will not write “discover OData via MCP Server,” because the whole SAP community will hate me :D), or wrapping SAP tables/views, or wrapping SAP function modules is the way to bring SAP data to Business AI.

How many posts do we see now on LinkedIn where people are happy like kids seeing data from an agentic SDK, e.g. Claude Desktop, returned by OData that is called via an MCP Server and shown as a table. Wow-wow! A list of Purchase Orders! As a table! Based on my utterance! C’mon people, we are not in 2017 when we, together with the SAP Conversational AI team, were happy to see such kinds of cases. Yes, 9 years ago it was innovation, not now. Why not post on LinkedIn that the same OData service draws an even nicer table in a standard SAP Fiori app showing a list of Purchase Orders with… OMG… DRILL DOWN!!! 😊

Why am I writing this? Just to emphasize that Business AI is an excellent technology that is now far beyond strange posts where people see SAP data in another UI than GUI or Fiori. Real Business AI returns investment, works autonomously, and understands data. For example, an AI agent that gets emails from customers with purchase orders from their systems confirming the deals we’ve made with them. That AI agent posts those emails to SAP, creating Sales Orders, for sure not using OData. Why not? Because there are two EntitySet calls you need to do to create a Sales Order via OData, and you need to be able to simulate a batch call; otherwise, you will get lots of Sales Order headers in your SAP productive system when the OData call for Sales Order Items has failed.

Pic.1 Example from LinkedIn Article – Creating Sales Order via OData without Batch Mode

However, even creating a Sales Order from my example is not the biggest challenge for that AI agent.

The Biggest Challenge

SAP data and the “bridges” we build to connect AI agents with SAP via “regular” MCP servers, this is the biggest challenge we create for AI agents. Sometimes it seems that after allocating a really good business case, we are doing everything possible to push the AI agent to fail 😊.

SAP data preparation is the boring, but extremely essential, step here. We should think about what we feed to the AI agent when asking it to read an email and post a Sales Order in the SAP system. We need to give the AI agent a chance to query master data that is so essential for that AI automation scenario and allocate master data in a robust and reliable way, independent of how the customer names our services and products in their systems.

SAP Master Data Vectorization

Let’s see a simple example we have created using the ChatGPT UI showing how different AI agents will act if you prepare and only then bridge SAP data properly. We will use two MCP servers for this:

Regular MCP Server for SAP Data (any MCP server, we do not like to point fingers at someone’s solution; we’d like to advocate AI automation only)
Skybuffer AI MCP Server for SAP Data (here we have a data preparation layer where we vectorize SAP master data first)

Pic.2 SAP Master Data Vectorization as a Data Preparation Step

See the Difference

Now let’s simulate a request from an AI agent that is working autonomously and has responsibility to create Sales Orders in an SAP production system with the maximum level of automation.

Here is a simple example of a regular MCP Server failure, just because the customer captured data in their system a bit differently from our SAP productive system:

Pic.3 Regular MCP Server for SAP Data – Failing on the Simple Case of Small Wording Differences

And now let’s see how easily and robustly an AI agent gets information from the same SAP system, but via an MCP Server that reads prepared SAP master data for AI automation:

Pic.4 Skybuffer AI MCP Server – Easy and Robust Access to SAP Master Data

Now you see that 99% of all examples or success stories from LinkedIn about how fast we can create MCP servers to bridge SAP data and how reusable OData services are, are solutions that are far away from productive implementation (unless you are OK with getting a 50% automation rate 😊).

Conclusion

Indeed, MCP servers that consume OData, tables/views, etc. make sense for some steps in AI automation. However, we need to be very careful, and we should not mix hype with productive implementations. A good MCP server bridges prepared SAP data that an AI agent can consume to provide a maximal rate of automation that will reach 100% in a short time of productive usage. Saving on implementation ruins the impression of Business AI and reduces trust in it. Let’s not harm our overall revenue and investment return, and think twice whether the bridge we build for an AI agent suits the goal.

Imagine connecting the Skybuffer AI MCP Server to SAP Joule, making it able to understand user input by similarities. How powerful would your SAP Joule implementation be, and how smoothly would SAP Joule understand requests? Skybuffer AI runs on SAP BTP, providing a hidden but necessary layer for SAP Joule that can properly bridge your SAP on-premise data.

Closing Statement

Good luck with AI automation implementations, and do not hesitate to ask questions, collaborate, and bring technology to customers in a way they benefit from it, not just seeing the hype in it.

How AI Automation Eliminates Master Data Duplicates in SAP

2026-01-30T15:58:32.901000+01:00

The Business Case

Whether running SAP ECC or S/4HANA, most organizations struggle with duplicate master data for materials, vendors, and customers. This isn't just a "clutter" problem, poor material master data leads to users creating Purchase Requisitions with text items, bypassing procurement controls and ruining spend analytics.

Let’s explore how AI automation and data vectorization can clean up the core and prevent duplicates before they happen.

The Engine: What is Data Vectorization?

At Skybuffer, we are constantly exploring the benefits of SAP data vectorization. Simply put, vectorization converts data into numerical arrays (vectors) using embedding functions.

Unlike standard SAP keyword searches, vectors are language-independent and allow algorithms to perform similarity searches. While standard tables see rows and columns, a vectorized model sees the relationship between data points.

How Does It Help?

When data is vectorized, we can execute hybrid searches that are indifferent to word order or exact spelling.

Example: Imagine searching for a global customer like "Skybuffer." You might have different accounts for Poland and Norway. If a user tries to create a new record, they can simply ask:

"Do we have a Customer master record for Skybuffer in Poland?"

By querying vectorized KNA1 table data, the AI identifies the record even if the naming convention differs slightly.

Pic.1 Hybrid Search based on Vectorized KNA1 Table Data

Real-World Integration Points

Hybrid search is most powerful when embedded directly into the SAP business process:

Preventative Checks: During the "Save" action in SAP, a custom check against vectorized data can alert the user to a potential duplicate.
External Access: Quick searches via Microsoft Teams or SAP Fiori to find existing masters on the go.
Smart Procurement: Identifying an existing Material Master during the ordering process, preventing the user from resorting to a "text item."

Pic.2 Quick Searches of SAP Master Data based on Vectorized Data

Conclusion

Generative AI is a powerhouse when used wisely. Many companies struggle to find the right use cases, often just mirroring existing SAP processes in a chat window. That isn’t true AI automation.

Our approach is different: we focus on the gaps in standard automation. By using AI to simplify data discovery, we reduce development effort and provide an intelligent, frictionless experience for SAP users.

Closing Statement

Keep automating. Remember: smart customization is a competitive advantage, not a deviation from the standard. Build with AI in mind to slash support costs and maximize your ROI via the Skybuffer AI platform.

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! 🚀

Stop Building from Scratch: Autonomous AI Agents for SAP Sales Order Processing

2026-02-07T18:50:48.664000+01:00

Why this article?

It is great that we are living in the era of AI technologies where humans are still needed to design and automate 😀. But let’s be honest: give it a few more years and no company will ask "Which AI platform should we choose?" That decision will be made by central AI services based on strict country and corporate regulations. The only thing that will matter is security and reliability.

So, why am I writing this? Because I see so many people struggling with custom, built-from-scratch AI automation solutions at the enterprise level. These projects start quickly, but they get stuck just as fast.

You know, it is like cookies 😀. You can make one in a sandbox; however, to scale that to a corporate production level is a totally different problem.

If you are still wondering why this article matters: I want to highlight that while humans are still designing automation, speed is everything. Deploying autonomous AI agents on a solid, reliable platform is a massive competitive advantage. Those playing around with internal IT projects or relying on System Integrators (SI) to build from zero are being left behind.

Let me explain why using one simple example: Customer Purchase Orders.

The Business Case: The Reality of POs

A company wins a deal (congratulations!), and the Customer sends a Purchase Order (PO).

In an ideal world, this happens via EDI. If you have EDI, you are lucky and you can stop reading. But in the real world, customers send PDFs, scanned images with handwriting, Excel files with macros, or even a screenshot of their laptop screen.

This shouldn't be an issue. Innovative platforms must handle data extraction from unstructured sources out of the box.

“Training? Fine-tuning??”

I know some of you just thought that 😊. Yes, training OCR models used to be mandatory. If you haven't faced the pain of training models, be happy, because you are young enough 😊. Today, this must work without that hassle.

The Main Challenge: Master Data Mapping

Extracting text is easy. The real challenge is my favorite one: Master Data Mapping.

How do we robustly and reliably read the customer’s product description and map it to the correct Master Data Object in our SAP system? And how do we do it without heavy development?

The Solution: SAP Master Data Vectorization

We don't need custom code; we need Vectorization.

Generative AI can write SQL queries, sure. But think about it: how many SQL queries would the AI have to guess to find a material that is semantically similar but written differently? Infinite. Or maybe a few less if you are lucky and the description contains an acronym like "A4 Paper" 😊.

When AI looks for a material master in vectorized data (rather than a database table), it reads by sense, not just by keywords. This allows it to reliably find the right SAP object even if the customer's description is vague.

I know only one SAP-certified Business AI Platform that has this Vectorization feature in its standard set: Skybuffer AI.

Pic.1 SAP Master Data Vectorization Setup

Pic.2 Example of Material Master Similarities based Search

The Implementation: Autonomous Agents in Action

This is the essential part: stop playing in the sandbox. Take a platform and create a simple autonomous AI agent.

In this example, I am using Skybuffer AI because it handles the heavy lifting out of the box:

Vectorizes SAP master data for semantic search.
Reads Emails (including complex attachments and OCR).
Safety First: Uses Mailboxes as a staging area (no messy data replication).
ABAP Control: It doesn't let the AI "guess" how to create data. It passes structured JSON to an ABAP class/BAPI for safe execution.
No Code: configured entirely in SAP Fiori.

The Flow

A Skybuffer AI agent acts effectively as an automated employee. You can schedule it, give it tools, and let it run.

Pic.3 Scheduling Autonomous AI Agent

Step 1: The Input

The Agent connects to a Mailbox. It reads the email, extracts the attachment data, and places it into the Agent's memory.

Pic.4 Flow inside the Tool of Skybuffer AI Action Server

Step 2: The Brain (Generative AI)

We connect the Generative AI and give it guidelines.

Note: The vectorized SAP master data is mapped directly to this action.

Pic.5 Generative AI Action of Skybuffer AI Action Server

The AI creates a JSON structure based on our request. Crucially, we do not ask the AI to update SAP directly. We hand that JSON over to an SAP ABAP class. This ensures the transactional data is created correctly, without hallucinations.

Step 3: The Output

We update the email in the Mailbox with the status and send a confirmation back to the customer.

Everything runs either in your SAP HANA On-Premise shell (directly in your network) or on your SAP BTP tenant.

Conclusion

Autonomous AI agents are no longer "future tech", they are easy solutions available now.

By choosing a Business AI automation platform rather than building from scratch, your company gets the best of Generative AI and the SAP backend immediately.

It is strange that so many companies are still "playing" with in-house development. You wouldn't build your own Sales Order Management system from scratch instead of using SAP, right? 😊 That would be weird. Yet, companies are giving huge budgets to internal teams to build AI wrappers.

You don't need a giant team. You need a reliable solution, speed, and flexibility. Just look at Cursor, they revolutionized coding with roughly 60 employees before their massive 900M funding round 😉.

Be quick. Be autonomous.

The Combined Power of SAP Joule and AI for the RISE with SAP Methodology

2026-02-11T08:00:00.018000+01:00

Part five of the five-part series, “RISE with SAP Methodology”

AI is everywhere right now. Not just in tech headlines or innovation labs, but also in boardrooms, architecture discussions, and project plans. And if you work with SAP solutions, you’ve likely noticed that most road maps now mention it, too.

Many of us have seen “the next big thing” come and go. New tools, new buzzwords, and big promises have often delivered limited practical impact. So, the real question isn’t whether AI exists. It’s “where will AI actually make a difference?”

Organizations want technology that helps people work better, make smarter decisions faster and cut through complexity in day-to-day work with real-world pressures and consequential deadlines. AI should not be treated as a standalone innovation topic, but as a capability embedded across products, processes and user experiences.

That’s exactly the direction SAP’s new strategy is taking. At the heart of this strategy sits a simple idea: bring applications, data, and AI together in SAP Business Suite, so intelligence becomes part of how work naturally happens, as shown in Figure 1.

Figure 1: The Future of AI in SAP Business Suite

Joule vs. AI Capabilities: Understanding the Difference

When people talk about AI in SAP environments, two concepts often get mixed together: AI capabilities and the Joule solution.

While connected, each one plays vastly distinct roles:

AI capabilities form the foundation and are the engine, quietly running in the background. Powerful, but often invisible, they analyze huge volumes of data, predict risks and generate recommendations. They include technologies such as machine learning, predictive analytics and automation embedded across SAP solutions.
Joule, on the other hand, is the interaction layer between people and AI and facilitates one-on-one conversations with the user. This is the moment when intelligence becomes accessible. Instead of searching through lots of guidelines, dashboards or compiling reports, users simply ask questions, such as “What should I focus on next in our transformation project?” or “Where are we off track?”. Users can even just say “Summarize the risks”. And in return, they get answers immediately and in context. (see Figure 2 below)

Together, AI capabilities and Joule form a complementary model where AI feels natural, not abstract. The experience is remarkably similar to talking to a knowledgeable colleague who already understands the system landscape. There’s deep intelligence behind the scenes and a simple, human interaction up front.

Figure 2: Interacting with Joule as the new AI user experience

Joule: A practical entry point to AI

As shown in Figure 2 above, one of SAP´s strategic priority is to offer a new AI user experience through Joule. This AI-enabled assistant introduces a simple, practical way to bring AI into transformation work.

While delivering many AI capabilities across the SAP solution portfolio, Joule goes beyond using AI as another analytics tool or dashboard by running an interaction layer that allows customers to work with AI through a single, conversational interface.

This changes how teams engage with information during transformation projects or in day-to-day business. Instead of navigating multiple tools, reports, or status decks, users can interact with Joule in natural language—asking questions, requesting summaries, or starting conversations on how to proceed with tasks alongside the transformation project. (see Figure 3)

Behind the scenes, Joule connects to relevant data across SAP solutions and presents answers in a way that is easy to understand and easy to act on. In practice, this lowers the barrier to insight. Instead of searching for information, teams start working interactively with it.

Figure 3: Using Joule interactively during your transformation work

Strategic enablers of the transformation journey

As mentioned before, AI is embedded directly into SAP solutions and workflows to help people navigate complexity. Users can surface relevant insights, identify patterns, and reduce manual effort.

Take, for example, transforming an ERP landscape. This project can easily become complex, depending on customer requirements. The volume of information that teams must use at the same time—including process data, system insights, project status, testing results, risks, and dependencies—often spread across tools and documents. Even with a clear methodology in place, the effort required to connect these dots manually has become a challenge of its own.

RISE with SAP Methodology already provides the structure needed by providing the integrated tooling, standardized framework, and expert guidance to support the proper execution discipline. However, embedding AI in the methodology adds a new layer of intelligence at the point of action, helping teams understand what matters where risks are emerging, and which decisions requires attention (see Figure 4).

In this case, AI reduces the load that comes with large-scale change. When applied correctly, it supports people in making better and faster decisions, especially when time and attention are limited.

Meanwhile, Joule is used whenever clarity is needed (see Figure 4). This opens up a new way of working with guidance, insights, and execution support throughout the transformation journey when using RISE with SAP Methodology, serving as an active companion.

Figure 4: Joule and AI as an integral part of RISE with SAP Methodology

Giving an end-to-end perspective alongside the transformation, Joule allows project teams to handle time-consuming and complex tasks faster and with greater ease. This includes searching for information and guidelines that can help them start and review extensive assessments and analyses.

As planning and design activities progress, Joule enables teams to stay oriented. It supports prioritization, highlights dependencies, and helps validate assumptions before decisions become difficult to reverse. AI does not replace workshops or experience, but it strengthens them with data-driven insight.

During execution, when the build and testing phases accelerate, Joule supports transparency and focus. AI capabilities detect patterns in defects, progress, and quality signals, while Joule summarizes what matters most. So instead of consolidating information manually, teams can react early.

Joule supports readiness discussions as go-live approaches. By correlating information across testing, migration, and operational checks, AI helps teams assess whether they are truly ready based on evidence, not gut feeling.

After go-live, AI continues to support continuous improvement. Usage patterns, incidents, and performance signals are analyzed in the background. Joule helps connect teams to those insights to understand where to improve next and how operational issues relate back to earlier transformation decisions.

Practical value over automation

The strength of AI in SAP transformations does not lie in automation alone.
It lies in reducing all the cognitive load that happens during the transformation project.

By combining all elements of the RISE with SAP Methodology:

a clear path (with the Standardized Framework)
Integrated tooling (with the Integrated toolchain)
End-to-end Execution support (with the Expert Guidance) and
AI-driven assistance through Joule and specific AI capabilities

customers are well equipped to move through their transformation with focus, confidence and consistency.

AI does not replace people or experience.
It supports both – at the right moment, in the right context.

To learn more about RISE with SAP Methodology, read our in-depth overview.

--------------------------------------------------------------------------------------------------------------------------------------------------

RISE with SAP Methodology - Blog-series

Discover the 5-part blog series:

Blog 1/5 (December 3rd, 2025)
RISE with SAP Methodology: A practical Guide to Modernizing with Confidence
Blog 2/5 (December 10th, 2025)
Deep Dive: Inside the framework of RISE with SAP Methodology
Blog 3/5 (January 14th, 2026)
The Integrated Toolchain in a Nutshell
Blog 4/5 (January 28th, 2026)
Expert Guidance: Your Guided Transformation Accelerator
Blog 5/5 (February 11th, 2026)
The Combined Power of SAP Joule and AI for the RISE with SAP Methodology

--------------------------------------------------------------------------------------------------------------------------------------------------

#clouderpprivate #s4hanacloud #sap #risewithsap #transformation #risewithsapmethodology

Shadow AI対策：SAP AI Core で実現する安全なAI活用環境

2026-02-13T06:12:30.136000+01:00

1. 仕組み：SAPが仲介し、認証情報を隠蔽する

個人でChatGPTを使う場合、PCから直接OpenAI社のサーバーにデータが送られます。一方、SAPの環境では、SAP AI Core や Generative AI Hub が「仲介役（プロキシ）」として動作します。アプリケーションは、SAP BTP内のプライベートなエンドポイント（外部インターネットから直接アクセスできない、SAP BTPで管理された安全な接続口）へアクセスするため、直接外部のAIサービスと通信することはありません。

さらに、SAP BTPの Connectivity Service を利用すれば、接続先URLや認証情報（Client ID/Secretなど）を一元管理できます。これにより、アプリケーションのコードの中に機密情報を書く必要がなくなり、開発者はより安全に大規模言語モデル（LLM）を利用することができます。Connectivity Serviceの詳細は次のURLを参照してください。https://help.sap.com/docs/connectivity/sap-btp-connectivity-cf/connectivity?locale=en-US

2. 技術的詳細：入力データを自動で守る「Orchestration」

SAP AI Core には「Orchestration（オーケストレーション）」という機能があります。これは、大規模言語モデル（LLM）への問い合わせに対して、送信前の入力チェックや送信後の出力フィルタリングなど、複数の処理を統合的に実行できる機能です。

Shadow AI対策として特に重要なのが以下の2点です。

個人情報のマスキング: 従業員が誤って個人情報（メールアドレスや氏名など）を入力した場合でも、Orchestration機能がAIへの送信直前に自動的に検知し、伏せ字（マスキング）に変換します。これにより、外部モデルへの個人情報流出を未然に防ぎます。
有害な入力のブロック: 差別的な発言や暴力的な内容が含まれていないかをチェックし、企業のポリシーに反する入力を遮断します。

これらの具体的な設定方法（JSONパラメータの記述例など）については、私が執筆した以下のブログ記事で詳しく解説しています。実装を検討される方は、ぜひこちらをご参照ください。

SAP AI CoreにおけるOrchestration機能とセキュリティ設定の実装ガイド

3. プロンプトのライフサイクル管理：Prompt Registry

Shadow AIのもう一つの問題は、「誰がどんなプロンプトを使っているかわからず、品質や結果が一貫しない」ことです。これを解決するのが Prompt Registry です。

これは、プロンプトを単なるテキストではなく「バージョン管理されたライブラリ」として中央で管理するサービスです。設計から実行（runtime）までのライフサイクル全体を管理できるため、アプリケーション間での一貫性と再利用性が保証されます。コンセプトについては SAP Learning: Managing Prompts with the Prompt Registry and Templates でも詳しく解説されています。

技術的には、以下の2つの方法でプロンプトを管理・利用できます。

Declarative API（Git連携）: Gitリポジトリ上のプロンプト定義（repo_name を指定）と自動的に同期し、コードの一部として管理する方法。
Imperative API（直接操作）: API経由でテンプレートの ID や、名前・シナリオ・バージョンの組み合わせを指定して取得・更新する方法。

これにより、従業員が勝手なプロンプトを使うのではなく、会社が承認し、バージョン管理された安全なプロンプト（Approved Prompts）だけを利用するよう統制を効かせることが可能になります。開発者向けの実装ガイドは SAP Cloud SDK for AI: Prompt Registry が参考になります。

4. まとめ

Shadow AIを防ぐには、ルールで縛るだけでなく、技術的な解決策が必要です。

SAP AI Core / Generative AI Hub を仲介役として利用し、Destination Service で認証情報を管理することで、安全な接続経路を確立できます。さらに、Orchestration によるデータの保護や Prompt Registry による利用管理を組み合わせることで、企業は安心してAI活用を進めることができます。

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

SAP Testing in 2026: Agentic AI and Quality Engineering for S/4HANA & BTP

2026-02-18T13:48:12.256000+01:00

Quality Engineering Transformation in S/4HANA and BTP Programs

Quality engineering integrated with S/4HANA project architecture is the new norm. It is no longer feasible for a company to simply convert to S/4HANA; they are reinventing their finance, logistics, manufacturing, and procurement processes while transitioning custom logic to BTP and running side-by-side applications. With each architectural choice comes the added complexity of testing for data integrity, service integration, authorization models, and performance characteristics.

In this context, testing begins well before a system is built. Quality engineers are involved in the solution design phase to assess migration paths, extensibility patterns, and potential integration risks. Data conversion strategies should be validated not only for their structural integrity, but also for their business relevance as they relate to S/4HANA’s simplified data model. This can be particularly challenging with historical data. During the build phase, regular configuration changes and transport movements require continuous regression testing rather than milestone-based testing.

Several structural changes define SAP quality engineering at this stage:

Testing scope is increasingly derived from business criticality rather than transaction count. Processes with financial exposure or regulatory impact receive deeper validation.
BTP extensions require testing beyond SAP GUI transactions. API behavior, event messaging, and cloud security controls must be validated under real usage conditions.
Performance and stability testing have shifted earlier in the lifecycle, particularly for hybrid scenarios where S/4HANA interacts with external platforms.

Within this framework, SAP teams are emerging as a practical response to scale. Autonomous systems analyze all configuration changes and provide valuable recommendations for which specific tests should be conducted to achieve maximum test coverage. The SAP Artificial Intelligence team partners with the Quality Engineers to ensure that the intelligence used in testing aligns with the test's business intent. This leads to testing that adapts rather than exhausts test execution, resulting in reduced execution overhead and improved reliability of the S/4HANA and BTP landscapes.

Agentic AI and the Evolution of SAP Testing Models

The adoption of agentic AI introduces a fundamentally different operating model for SAP testing. Automation systems that have been traditionally used, either defined by static logic elements and pre-written scripts or operate in just a 'set and forget' manner. The way that agentic AI is built, on the other hand, is to learn from the outcomes that occur, identify the patterns associated with those outcomes, and act on its own within a pre-defined set of constraints. Automated processes that rely on predetermined scripts to run a series of tests will not work well in SAP systems, as they are constantly changing and closely interrelated.

AI agents in SAP testing environments are capable of monitoring transport activity, configuration updates, and integration changes. When a test fails, these agents evaluate the execution context rather than simply logging an error. In this case, they can determine whether the test failure is due to data inconsistencies, authorization issues, or delays caused by upstream integrations. By reasoning the error context, agents are much more accurate at prioritizing and classifying defects, reducing the need for rework.

Common applications of agentic AI in SAP quality engineering include:

Dynamic regression planning where agents adjust test scope based on recent system changes rather than executing full regression cycles.
Intelligent failure clustering that groups related defects and identifies systemic issues instead of isolated symptoms.
Context-aware test data generation that aligns with real business scenarios, improving validation depth for complex S/4HANA processes.

These capabilities also reshape team structures. Agentic SAP teams operate with a shared responsibility model, where quality engineers define validation objectives, and AI systems handle execution level decisions. SAP AI teams provide governance, ensuring transparency and auditability of autonomous actions. Over time, these systems accumulate knowledge from prior releases, enabling predictive insights that anticipate failure patterns before they impact production.

As enterprises evolve to develop Agentic AI Services, there’s an ever-increasing demand from companies that want to create scalable solutions to incorporate into their existing SAP landscapes, while also minimizing the amount of manual work. If properly implemented, SAP testing programs may realize tangible improvements in release confidence, defect containment, and operating efficiency - all without sacrificing an enterprise’s ability to maintain control.

Conclusion

The defining characteristics of SAP testing in 2026 are depth, continuity, and intelligence. The quality engineering practices required for S/4HANA and BTP programs require an understanding of the technical architecture and business context. Active testing has moved beyond a final check to become an inherent part of the testing discipline, influencing design, observing how it is executed, and facilitating continual improvement in SAP environments.

The rise of agentic AI in SAP testing represents a natural progression in this evolution. By enabling autonomous reasoning and adaptive execution, AI agents (e.g., chatbots) within SAP ecosystems enable organizations to manage the complexity of their operations without increasing testing overhead. As SAP AI teams add these capabilities to SAP, and enterprises use agentic AI services, quality engineering becomes predictive, reactive, and aligned with overarching enterprise transformation goals. In this environment, AI used for SAP testing is no longer an experiment but an operational requirement for maintaining reliable, scalable SAP systems.

ISO 42001 Certification: The New Benchmark for AI Vendor Selection

2026-02-19T08:31:26.737000+01:00

Introduction: AI Governance Moves from "Guidelines" to "Certification"

Since the publication of ISO/IEC 42001 (AI Management System) in December 2023 [1], the landscape of AI governance has evolved steadily. Now, entering 2026, we are witnessing a phase where major certification bodies worldwide have operationalized their audit services, and leading technology vendors are increasingly acquiring this certification. AI governance, which began as a collection of local guidelines and ethical codes, is now adopting a global benchmark: "certification (proof) by a third party."

For SaaS/PaaS vendors like SAP, the questions we receive from customers have shifted. Beyond the traditional functional question of "What can this AI do?", we are now asked non-functional and governance-related questions with equal weight, such as "Is this AI safe?" and "How is the training data managed?"

In this article, from a security and compliance perspective, I will explain the practical implications of the ISO 42001 certification that SAP has acquired and how it can help reduce AI adoption risks for user companies.

1. Why ISO 42001 is the "Common Language of Trust"

Since the widespread adoption of generative AI, companies have faced significant challenges in managing risks such as the "black box" nature of AI (lack of transparency in decision-making) and "hallucinations" (generation of incorrect information). While traditional security standards like ISO/IEC 27001 are essential for information security, they were not designed to fully cover the specific nuances of the AI lifecycle such as data bias, continuous learning, and ethical considerations.

This is why ISO/IEC 42001:2023 was introduced as the first international management system standard specifically for AI.

A key feature of this standard is that it does not certify the accuracy of a specific AI model at a single point in time. Instead, it validates whether an organization has established a "system to continuously identify, manage, and improve AI risks (Management System)." [2] Holding ISO 42001 certification serves as objective proof that a company has built and operates a responsible management structure for its AI systems.

2. SAP's Certification and Scope of Application

SAP announced the acquisition of ISO 42001 certification for its key AI services in 2025.

What is important here is the scope of application. This certification covers core services such as Joule (our generative AI assistant) and SAP AI Core (our AI development and execution platform). This indicates that the applications and development environments utilizing these foundations are managed under a system based on international standards.

Understanding the Difference: "Self-Attestation" vs. "Third-Party Certification"

There are two primary approaches to demonstrating conformity to AI governance: "Self-attestation" by the supplier and "Third-party certification" by an independent body. SAP has chosen the path of "Third-party certification," which involves rigorous audits by an independent organization, to ensure a higher level of objectivity.

For security and legal professionals, this distinction is significant. When adopting a service based solely on self-attestation, user companies often need to send detailed security checklists to vendors and scrutinize their responses—a process that consumes considerable time and resources. However, when a vendor holds ISO 42001 certification, the certification itself serves as objective evidence of governance, which can significantly streamline the Vendor Risk Management (VRM) process.

3. Practical Benefits for User Companies

What are the practical benefits for user companies utilizing SAP's certified environment? I see two main advantages.

1. Clarifying Roles in Supply Chain Risk Management

If a user company were to build an AI service from scratch and aim for ISO 42001 compliance, the effort would be substantial, requiring resources for AI-specific risk assessments and continuous monitoring systems.

By adopting a certified platform (PaaS/SaaS) like SAP Business AI, companies can leverage the vendor's established governance for the infrastructure layer. This concept is similar to the "Shared Responsibility Model" in cloud security.

Specifically, SAP maintains governance over the training environment and infrastructure (Security of the AI). This allows user companies to focus their resources on managing the upper layers directly linked to their specific business values and use cases, such as data quality and ethical decision-making (Security in the AI). This division of labor can help shorten the lead time for AI adoption while maintaining reliability across the supply chain.

2. Supporting Accountability to Stakeholders

In addition to shareholders and regulators, business partners are increasingly conducting strict due diligence regarding the safety and transparency of AI integrated into business operations.

In such scenarios, being able to demonstrate that "we utilize SAP's platform, which complies with the international standard ISO 42001 and is audited by a third party," provides a strong, objective basis for trust. This certification functions as valid evidence to help fulfill accountability requirements to stakeholders.

Furthermore, as legal frameworks like the EU AI Act are implemented globally, compliance is becoming a critical management issue. While ISO 42001 certification does not automatically guarantee legal compliance, it is widely recognized as a framework that supports alignment with these regulations. Leveraging a certified foundation can help streamline the complex process of proving compliance, allowing companies to direct limited resources toward creating business value rather than just defensive measures.

Conclusion: Criteria for Selecting AI in the Future

AI technology evolves daily, but the importance of the trust that underpins it remains constant. As technology advances, the value of transparency and governance only increases.

As a compliance professional, I want to emphasize that for SAP, acquiring ISO 42001 is not a final goal but a milestone. It is objective proof that we have established a robust governance structure to continuously provide an "environment where customers can integrate AI into the core of their business with confidence."

I recommend incorporating "ISO 42001 certification status" into your functional comparison table when selecting AI solutions. This addition will serve as a definitive step toward realizing long-term, stable, and trustworthy AI utilization.

References

SAP Trust Center: Certifications and Compliance

Setting up LLM Model Connection in Open WebUI using Hyperspace Proxy

2026-02-19T16:41:40.753000+01:00

Introduction

Open WebUI provides a powerful, self-hosted interface for interacting with Large Language Models (LLMs). When combined with SAP's Hyperspace Proxy, you can access multiple enterprise-grade AI models securely through a unified gateway. This guide walks you through the complete setup process, from configuring the Hyperspace Proxy to accessing various LLM models in your local Open WebUI instance.

Prerequisites

Before starting, ensure you have:

Access to SAP's internal tools and GitHub Enterprise
Administrative privileges on your local machine
Basic familiarity with terminal/command line operations
Docker installed (or ability to install it)

Part 1: Setting up Hyperspace Proxy

Step 1: Enroll in the Pilot Program

Important: Start this step at least one day before you need to use the proxy, as approval typically takes 24 hours.

~~Navigate to the Hyperspace Pilot Program enrollment page:~~
~~https://pages.github.tools.sap/hAIperspace/hai-docs/llm-proxy/pilot-program/~~
~~Follow the registration instructions provided on the page~~

State of Feb. 19. 2026: Hyperspace Proxy is available to all of SAP teams!

Step 2: Run the Hyperspace Proxy Locally

Once approved, set up the proxy on your local machine:

Follow the quick start guide at:
https://pages.github.tools.sap/hAIperspace/hai-docs/llm-proxy/quickstart/
After successful setup, you should see the proxy running in your Terminal with important connection details including:
- Local proxy URL (typically http://localhost:6655)
- Your API key
- Available endpoints

Keep this terminal window open - the proxy needs to run continuously for Open WebUI to access the models.

Part 2: Installing Open WebUI with Docker

Step 1: Install Docker

Docker will host the Open WebUI application locally.

For macOS:

Install Homebrew (if not already installed):
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Install Docker via Homebrew:
brew install --cask docker
Verify the installation:
docker info

For Windows/Linux:
Follow the official Docker installation guide for your operating system at docker.com.

Step 2: Launch Open WebUI

Follow the Open WebUI Quick Start Guide (refer to official Open WebUI documentation)
Start the Open WebUI service in Docker
Check the container status:
docker ps
Wait for the status to show "Up About..." (this typically takes a few minutes)
Once ready, access the web interface at:
http://localhost:3000

Part 3: Connecting Hyperspace Proxy to Open WebUI

Now comes the crucial step - connecting your local Open WebUI instance to the Hyperspace Proxy to access LLM models.

Basic Connection Setup

Access Admin Panel
- Open Open WebUI in your browser (http://localhost:3000)
- Navigate to the Menu Bar and select "Admin Panel"
Add New Connection
- Go to "Connections" → "Settings"
- Click the "+" button to add a new connection
Configure OpenAI-Compatible Endpoint
- URL: http://host.docker.internal:6655/openai/v1
- API Key: Enter the API key from your Hyperspace Proxy terminal output
- Click "Save"

Note: We use host.docker.internal instead of localhost because the Open WebUI container needs to access services running on your host machine.

Verify Connection
- After saving, navigate to the Chat window
- You should now see available models in the model selector dropdown

Advanced Setup: Accessing More Models via LiteLLM

To unlock access to a broader range of models including Claude, GPT, and Gemini variants:

Add LiteLLM Connection
- Return to "Admin Panel" → "Connections" → "Settings"
- Click "+" to add another connection
- URL: http://host.docker.internal:6655/litellm/v1
- API Key: Use the same API key from Hyperspace Proxy
- Click "Save"

Specify Model IDs

Unlike the basic OpenAI endpoint, LiteLLM requires explicit model ID specification. Here's the complete reference:

API Base URL Available Model IDs

`http://localhost:6655/anthropic/v1`	anthropic--claude-4.5-opus anthropic--claude-4.5-sonnet anthropic--claude-4.5-haiku
`http://localhost:6655/openai/v1`	gpt-5
`http://localhost:6655/litellm/v1`	gemini-2.5-flash gemini-2.5-pro gpt-5 gpt-5-mini anthropic--claude-4.5-sonnet anthropic--claude-4.5-opus anthropic--claude-4.5-haiku

Configure Model Access
- In the Admin Panel, you may need to enable specific models
- Enter the model IDs from the table above as needed
- Save your configuration

Troubleshooting Tips

Proxy Connection Issues

Ensure the Hyperspace Proxy terminal window is still running
Verify your API key is copied correctly without extra spaces
Check that you're using host.docker.internal not localhost in Docker

Docker Container Not Starting

Run docker logs <container-name> to check error messages
Ensure port 3000 isn't already in use by another application
Verify Docker has sufficient resources allocated

You now have a fully functional local Open WebUI instance connected to enterprise LLM models via Hyperspace Proxy! This setup provides:

Privacy: All interactions run locally on your machine
Flexibility: Access to multiple cutting-edge LLM models
Control: Full customization of your AI interface
Security: Enterprise-grade access through SAP's Hyperspace gateway

Enjoy exploring the capabilities of various LLMs through your personalized Open WebUI interface!