Exploring AI Capabilities Across SAP BTP

Modern software development is complex, and developers often grapple with a variety of issues that reduce their efficiency:

• Information Overload & Context Switching:

  • Problem: Developers constantly navigate vast amounts of information – documentation (internal and external), legacy code, APIs, frameworks, bug reports, and team communications. Switching between tasks or trying to recall specific syntax/APIs for different technologies is mentally taxing and time-consuming.
  • Impact: Increased cognitive load, reduced focus, errors due to incomplete information, and slower task completion.

• Repetitive & Boilerplate Tasks

  • Problem: Many development activities are repetitive, such as setting up new projects, writing basic CRUD operations, generating getters/setters, creating unit test stubs, or writing routine documentation.
  • Impact: Tedious work, prone to human error, drains motivation, and diverts time from higher-value, creative problem-solving.

• Debugging & Troubleshooting

  • Problem: Identifying the root cause of bugs, understanding obscure error messages, or pinpointing performance bottlenecks can be incredibly time-consuming and frustrating, especially in large, complex codebases or distributed systems.
  • Impact: Significant delays in project timelines, increased stress, and can lead to temporary "patch" fixes rather than robust solutions.

• Knowledge Gaps & Onboarding

  • Problem: New team members or developers moving to a new project face a steep learning curve to understand existing codebases, architectural patterns, internal libraries, and tribal knowledge. Even experienced developers frequently encounter unfamiliar technologies or complex domains.
  • Impact: Slow onboarding, reduced initial productivity, reliance on "go-to" experts, and potential for inconsistent solutions.

• Code Quality & Maintenance

  • Problem Ensuring consistent code style, adherence to best practices, identifying potential security vulnerabilities, or refactoring technical debt are crucial but often overlooked due to time pressures.
  • Impact Accumulation of technical debt, harder-to-maintain code, increased risk of bugs and security breaches, and slower future development.

• Communication & Collaboration Friction

  • Problem: Misunderstandings in requirements, slow code review cycles, difficulties in sharing knowledge, or getting timely feedback from colleagues can slow down development.
  • Impact: Delays, re-work, and potential for mismatched expectations between team members or stakeholders.

As discussed previously Generative AI assistants (like GitHub Copilot, ChatGPT, Google Bard, and specialized coding AIs) leverage large language models (LLMs) trained on vast datasets of code and text to understand context, generate new content, and assist developers in numerous ways:

• Reducing Information Overload & Context Switching

  • How AI Helps
    • Intelligent Code Completion: Autocompletes not just syntax but entire lines or blocks of code based on context, reducing the need to memorize APIs or search documentation.
    • Contextual Information Retrieval: Can answer questions about specific functions, classes, or patterns within the codebase or provide quick summaries of external documentation, eliminating the need to manually search and sift through information.
    • Code Explanation: Explains complex or unfamiliar code snippets in natural language, making it easier to understand legacy systems or new projects without deep dives into documentation.

• Automating Repetitive & Boilerplate Tasks

  • How AI Helps:
    • Code Generation from Natural Language: Developers can describe desired functionality in plain English (e.g., "create a function to validate an email address," "generate a REST API endpoint for users"), and the AI generates the corresponding code.
    • Test Case Generation: Can suggest and generate unit tests for existing functions, significantly speeding up the testing phase.
    • Scaffolding & Boilerplate: Quickly generates file structures, class definitions, and standard configurations for new projects or components.
    • Documentation Generation: Automatically drafts documentation for functions, classes, or modules based on the code's logic and comments.

• Assisting with Debugging & Troubleshooting

  • How AI Helps
    • Error Explanation & Resolution: Explains cryptic error messages, suggests common causes, and proposes potential fixes.
    • Debugging Suggestions: Can analyze code and suggest areas where a bug might be lurking or propose alternative debugging strategies.
    • Log Analysis: Helps parse and summarize large log files, identifying anomalies or critical events more quickly.

• Bridging Knowledge Gaps & Accelerating Onboarding

  • How AI Helps
    • Codebase Exploration: Acts as a smart assistant for navigating new codebases, answering questions like "Where is X defined?" or "How does this module interact with that one?"
    • Learning & Tutorial Generation: Provides explanations of new technologies, frameworks, or design patterns, often with code examples tailored to the developer's context.
    • Best Practice Adherence: Suggests idiomatic ways to write code in a specific language or framework.

• Enhancing Code Quality & Maintenance

  • How AI Helps
    • Code Review Assistance: Can flag potential bugs, suggest performance improvements, identify security vulnerabilities, or recommend refactoring opportunities during code review.
    • Refactoring Suggestions: Proposes ways to improve code readability, maintainability, and efficiency.
    • Style & Consistency: Helps ensure code adheres to team or project-specific coding standards.

• Improving Communication & Collaboration

  • How AI Helps
    • Pull Request Summarization: Automatically generates concise summaries of changes in a pull request, making reviews faster.
    • Comment & Commit Message Generation: Suggests descriptive comments and commit messages based on code changes.
    • Knowledge Base Q&A: Facilitates asking questions about internal systems, design decisions, or team conventions.

It's important to remember that Generative AI assistants are not meant to replace developers but to augment their capabilities, acting as intelligent co-pilots. By automating the mundane, providing instant access to knowledge, and offering intelligent suggestions, these tools can significantly free up developer time for creative problem-solving and complex tasks.

As with many things the promise and the reality can be very far apart. So it is with GenAI assistants. Many solutions suffer from the following deficiencies:

• Limited GenAI development tool options scattered across multiple platforms, leading to unmet development needs and fragmented workflows.
• Context switching between environments disrupts productivity, increases coding errors, and compromises code quality.
• Inaccurate and generic GenAI recommendations demand excessive context setting and prompting, resulting in slow, error-prone development.
• Siloed GenAI tools lack integration

Joule for Developers generally speaking is a collection of AI-powered capabilities integrated into various SAP development tools designed to enhance developer productivity and streamline the creation of applications and automations within the SAP ecosystem. More specifically Joule for developers is the collective name for the design-time AI capabilities across SAP Build, including ABAP, that help improve developer productivity and proficiency. These comprise of new and existing AI capabilities that are enabled by Joule within SAP Build Code, SAP Build Apps, SAP Build Process Automation and ABAP in SAP BTP and S/4HANA Public Cloud Edition. These Joule capabilities for developers help them build faster, code smarter, and automate better.

Joule for Developers addresses each of the deficiencies noted previously and fulfills the promise of GenAI assistants. The benefits of developers and organizations utilizing it are:

• Increased productivity: Joule for Developers automates repetitive tasks and streamlines development workflows, allowing developers to focus on higher-value activities.
• Faster development cycles: By assisting with code generation, testing, and automation, Joule for Developers helps accelerate the delivery of applications and solutions.
• Enhanced code quality: Joule's AI-powered suggestions and code optimization features can lead to better quality and more maintainable code.
• Improved efficiency and faster time to market: Businesses can benefit from quicker development timelines and more reliable deployment of custom applications and automations.
• Reduced costs: Increased developer productivity and efficiency can potentially lead to lower development costs.

Now that we have an idea of what Joule for Developers is let's walk through a sample scenario showing its features:

Meet Helga, Heinrich and Takashi all of whom are seasoned developers. Their company, Food Supply Enterprises supplies online and mobile applications for operators of food trucks so they can execute orders to keep their trucks stocked with fresh food. The three of them are tasked with building and maintaining custom apps and extensions for SAP Cloud ERP. Helga typically uses SAP Build Apps for her development work and Heinrich and Takashi will use SAP Build Code for CAP based development and ADT for ABAP development respectively.

Food Supply has been successful with growth in the past year almost doubling. While this is undoubtedly a good thing nevertheless Helga, Heinrich and Takashi have been kept busy with not only maintaining current applications but creating new ones to service a diverse set of clients.

The three of them ask the CIO to invest in SAP Business AI to make their development lives a bit easier. The CIO obliges and a few months later asks for some feedback. Helga replies first. She mentions that compared to before Joule for Developers, SAP Build Apps AI capabilities allow her to:

• (1) Generate pages to handle data entities and also to
• (2) Generate sample data automatically

Heinrich (who uses SAP Build Code for his CAP development) mentions that there are numerous benefits of using Joule for Developers, SAP Build Code AI capabilities. The three he finds most useful are:

• (1) CAP application generation along with
• (2) CAP unit test generation and
• (3) SAP Fiori Elements generation

which collectively allow him to prototype stakeholders requirements in some cases within the same day received.

Takashi also echoes the compliments of his fellow developers and mentions that his ABAP programming productivity has sped up due to Joule for Developers, ABAP AI capabilities. What he finds most useful are:

• (1) Predictive code completion along with
• (2) A CDS code explainer

• Augmented Analytics as a Core Principle
  • Goal: To democratize advanced analytics, making it accessible to business users and reducing the reliance on specialized data scientists for common tasks.
  • Mechanism: AI algorithms work behind the scenes to automate complex analytical processes.

• Smart Discovery
  • How AI Is Embedded: Users select a dataset or a specific measure, and Smart Discovery automatically analyzes the data using ML algorithms. It uncovers hidden patterns, identifies key influencers for a selected measure, detects outliers, and segments data.
  • Output: It generates a story (dashboard) with charts and textual explanations (using Natural Language Generation - NLG) summarizing its findings, highlighting what's important and why.
  • Benefit: Quickly uncovers actionable insights that might otherwise take hours or days of manual analysis.

• Smart Insights
  • How AI Is Embedded: When a user clicks on a data point, chart, or selects a particular dimension in a visualization, Smart Insights provides contextual, AI-generated explanations.
  • Output: It uses NLP/NLG to explain the factors contributing to the selected data (e.g., "Sales increased by 15% in Q3, primarily driven by a surge in demand from the North region and the introduction of Product X").
  • Benefit: Provides instant clarity and deeper understanding of data trends or anomalies directly within the visualization.

• Smart Predict
  • How AI Is Embedded: This is a dedicated environment within SAC that allows business users to create their own predictive models without writing any code. It leverages various ML algorithms.
  • Mechanism
    • Automated Model Selection & Training: Users define their target variable, and Smart Predict automatically selects the most appropriate algorithm(s), trains the models, and evaluates their performance.
    • Data Preparation & Feature EngineeringIt assists with data preparation steps crucial for predictive modeling.
    • Deployment: The trained models can then be applied to new data to generate predictions.
  • Benefit: Empowers business users to forecast future outcomes (e.g., sales, customer churn, stock levels) and understand what drives them.

• Predictive Planning
  • How AI Is EmbeddedIntegrates Smart Predict's time series forecasting capabilities directly into planning models.
  • Mechanism: Planners can generate baseline forecasts for budget and planning cycles directly within their planning models, based on historical data. They can then adjust these AI-generated forecasts with their business judgment.
  • Benefit: Automates parts of the planning process, providing data-driven starting points for budgets and forecasts, improving accuracy and efficiency.

Just Ask (a technology originally acquired from SAP's acquisition of AskData) is a part of SAP Analytics Cloud and enables the searching of data easily and efficiently using business terms users are familiar with. They simply ask their question using natural language in a dedicated text field, and Just Ask will instantly provide answers as simple charts and tables. The results can be further processed in different ways such as incorporating into a story, exporting to CSV or Excel files, or processed using additional tools such as the Data Analyzer tool for example. Joule complements Just Ask very nicely. Recall that in the previous lesson we mentioned that Joule encompasses four interaction patterns (Information, navigation, transaction, analytical). Through Joule Just Ask will cover NLP based off of the analytical pattern while Joule itself will cover the other three. This enables NLP to expand beyond just SAP Analytics Cloud users to business users in general. To summarize Just Ask + Joule in SAP Analytics Cloud:

• How AI Is Embedded: Users can type questions in natural language (e.g., "Show me sales by region for Q3 last year," or "What are my top 5 products by revenue?")
• Mechanism: NLP interprets the question, identifies relevant dimensions and measures, queries the underlying data model, and generates appropriate charts or tables as an answer.
• Benefit: Makes data exploration more intuitive and accessible, similar to asking a question to a human analyst.

Imagine that you have a super-smart robot friend.

This robot friend can read all the books in the world. He knows every single word, like "ball," "cat," "tree," and "run."

But here's the tricky part:

• If you say, "Robot, please give me the ball!" he might look confused. He knows the word "ball" from his books, but he doesn't know what a ball actually looks like, or feels like, or what it does! He's never seen one in the real world.

"Grounding" is when you help the robot learn what the words really mean in the real world.

Here's how that could possibly happen:

• You take a real, bouncy, round, red ball and you show it to him. You say, "THIS is a ball!" You let him touch it, and maybe you even bounce it so he sees what it does.
• Now, the robot doesn't just know the word "ball." He knows that the word "ball" means that specific, bouncy, round thing he just saw and felt! He's "grounded" the word "ball" to a real thing.

More examples:

• He knows the word "cat." But when he sees a real, fluffy, meowing kitty, he learns that "cat" means that animal. He's "grounded" the word "cat."
• He knows the word "run." But when he sees you run fast and he tries to make his wheels go fast like you, he learns what "run" means to do. He's "grounded" the word "run."

So taking this explanation to the next level if we have a business user who's asking Joule a question (i.e., "Do I have open purchase orders?"), then the LLM tasked with providing the answer must ensure its answers are grounded. In other words not only must it know what a purchase order is and where to find it, in addition it must make sure that the organizations actual purchase orders (and not some orders from a different company) are analyzed. Otherwise uses run the risk of "hallucinations" which are answers to prompts that are incorrect, nonsensical, or even completely fabricated, despite appearing plausible or realistic.

Grounding can be achieved through various techniques, including:

• Retrieval-Augmented Generation (RAG): Integrating external knowledge bases or search engines to provide context to the AI model.
• Fine-tuning on specific datasets: Training the AI model on datasets relevant to a particular domain or task to improve its understanding of that context.
• Reinforcement learning: Training the AI model through interaction with the real world or a simulated environment, allowing it to learn by trial and error.

The SAP HANA Cloud vector engine is a powerful new capability within the SAP HANA Cloud database that enables the storage, indexing, and high-performance similarity search of vector embeddings (explained in a moment). This provides the basis for RAG and thus grounding for prompts such as the open purchase order prompt discussed in the example above.

Let's did a little deeper:

At its core SAP HANA Cloud vector engine deals with vector embeddings:

• Definition: A vector embedding is a numerical representation (a list of numbers, or a vector) of a piece of data, such as text, images, audio, video, or complex transactional records.
• Semantic Meaning: These embeddings are generated by Machine Learning models (like large language models for text, or vision transformers for images) in such a way that the semantic meaning or characteristics of the original data are captured. Critically, data points that are semantically similar will have vector embeddings that are geometrically close to each other in a high-dimensional space.
• Example: "Apple" and "orange" are both fruits, sharing the basic characteristic of being edible and grown on trees therefore their embeddings will be close to one another. The same would be true for "chair" and "sofa". However the embedding for "cup" would not be close to any entry in either pair as there is no similarity between the objects.

There are several use cases where SAP HANA Cloud vector engine can help:

• Retrieval Augmented Generation: This is the most prominent use case. When an LLM needs to answer a question or generate content based on specific, up-to-date enterprise data (which it wasn't trained on), RAG steps in:
  • The user's query (e.g., "Show me sales expenses by month actual and forecast") is converted into a vector embedding.
  • The vector engine searches the enterprise knowledge base (SAP Concur expense data, company travel policies, payroll data, etc.) to find the most semantically relevant information (the "context").
  • This retrieved context is then provided to the LLM along with the original query, allowing the LLM to generate a more accurate, relevant, and factual response, reducing "hallucinations."
• Similarity Search: Also a prominent use case. The focus here is on finding terms or concepts similar to what is being prompted about. The way it works:
  • Given a query vector (e.g., "sales forecast for all hardware"), the vector engine efficiently finds other vectors in the database that are "closest" to it (i.e., "notebook", "keyboard") based on various distance metrics (e.g., Cosine Similarity, Euclidean Distance, Dot Product).
  • This allows users to retrieve information based on meaning and context, rather than just exact keyword matches.
• Information Retrieval: Build powerful internal search engines that allow employees to quickly find relevant information across vast repositories of documents, wikis, and reports.
• Content Moderation: Detect and flag inappropriate content (text, images) by comparing its embedding to known problematic embeddings.
• Recommendation Systems: Suggest products, services, or content based on similarity to items a user has interacted with or enjoyed.
• Anomaly Detection: Identify unusual patterns or outliers in data by finding vectors that are far removed from the general cluster.
• Customer Support Bots: Improve the accuracy and relevance of chatbot responses by providing them with real-time access to detailed product information or customer history via vector search.

In the use case above we see how SAP HANA Cloud vector engine is able to work with different types of data both structured and unstructured (text documents in this case). When the business user prompts the LLM (e.g., "sales forecast within the EMEA region") a similarity search is performed (i.e., "Germany, Dubai") ensuring that the answer is contextually relevant.

As covered previously Integration Advisor is a sophisticated AI-powered capability within a SAP Integration Suite designed to significantly accelerate and simplify the process of defining, modeling, and mapping data transformations between different systems, applications, or business partners particularly in "Business to Business" (B2B) scenarios. Its primary goal is to address the complexity and manual effort traditionally associated with:

• Understanding diverse data structures: Different systems use different formats (XML, JSON, EDI, flat files, databases) and varying definitions for the same concepts.
• Adhering to industry standards: Many integrations, especially B2B, require strict compliance with standards like EDIFACT, X12, OAGIS, RosettaNet, SWIFT, etc.
• Creating accurate data mappings: Manually mapping fields, segments, and elements between source and target structures is tedious, error-prone, and time-consuming.

The Integration Advisor typically leverages a combination of machine learning (ML), semantic analysis, and a vast knowledge base to provide intelligent recommendations. Here's a breakdown of how it uses AI:

• Intelligent Structural and Semantic Matching (AI/ML Driven)

  • Learning from Data: The advisor analyzes existing integrations, sample data, and user-defined mappings within the suite to learn patterns and common transformations.
  • Semantic Understanding: Unlike simple keyword matching, it tries to understand the meaning behind field names (e.g., "customer_ID", "cust_num", and "clientIdentifier" are semantically similar). It can suggest mappings even when field names differ.
  • Contextual Recommendations: Based on the source and target structures, it suggests the most probable field-to-field mappings, including complex transformations like concatenation, splitting, date formatting, currency conversions, etc.

• Crowd-Sourced and Pre-Built Content/Knowledge Base

  • Industry Message Types: It includes a comprehensive library of pre-defined standard message types (e.g., X12 810 Invoice, EDIFACT ORDERS, RosettaNet PIPs). This eliminates the need to manually define these structures.
  • Application-Specific Schemas: Connectors to popular enterprise applications (e.g., SAP ERP, Salesforce, Workday) might have their API or data model schemas pre-loaded.
  • Community Contributions (Crowd-sourcing): Some integration suites allow users to contribute and share their defined message types and mappings. The advisor can then leverage this collective intelligence, identifying frequently used or highly rated mappings. This "cloud of content" drastically reduces initial setup time.

• Automated Mapping Generation and Validation

  • Draft Mappings: Given a source and target message type, the advisor can automatically generate a "draft" mapping proposal, highlighting recommended connections and transformations.
  • Confidence Scores: Often, it provides a confidence score for its suggestions, allowing human integrators to quickly review and validate high-confidence mappings and focus on those with lower scores.
  • Validation Rules: It can also help define or suggest validation rules based on data types, constraints, and business logic, ensuring data quality at runtime.

Within the context of SAP Integration Suite, Cloud Integration an Integration Flow (iFlow) is the fundamental building block and the core design-time artifact used to define and execute integration scenarios. When created manually, iFlows are designed visually using a drag-and-drop interface in the SAP Cloud Integration Web UI, making complex integrations more intuitive to build and understand than pure code. GenAI based iFlow generation takes this one step further by significantly accelerating and simplifying iFlow creation. It leverages the power of LLMs and other generative techniques to translate natural language descriptions, existing system metadata and high-level integration requirements into executable iFlows. The LLM used has been trained on a vast dataset of integration patterns, integration components, adapter configurations, mapping rules and GroovyScript/XSLT code. The Unified Cloud Landscape (UCL) is used to register organizations specific systems (i.e., SAP S/4HANA Cloud, SFTP Servers, etc.) so specific adapter connection and configuration settings can be generated also.

With GenAI based iFlow generation instead of manually dragging and dropping components, configuring adapters, and writing complex mapping logic or Groovy scripts, a developer (or maybe even a business user) could provide a prompt such as the following:

• "Integrate sales orders from an external SFTP server (CSV format) into SAP S/4HANA Cloud via OData API 'SalesOrder_Create'. Map CSV columns 'CustomerID' to 'SoldToParty', 'OrderDate' to 'CreationDate', and 'Amount' to 'TotalNetAmount'. Handle potential duplicate orders by checking existing orders in SAP S/4HANA Cloud. On successful creation, send a confirmation email to 'sales@mycompany.com'. On error, log the details to an internal logging service."

• SFTP Sender Adapter: Configured with file path, polling interval, etc. for a specific SFTP Server
• CSV to XML Converter: To parse the incoming data
• Message Mapping: With auto-generated field mappings (CSV to an SAP S/4HANA Cloud OData structure); an XSLT or graphical mapping for a transformation might be generated
• Lookup/Conditional Logic: To check for duplicate orders in SAP S/4HANA Cloud before creation
• OData Receiver Adapter: Configured to connect to a specific SAP S/4HANA Cloud instance
• Mail Receiver Adapter: For success notifications
• Error Handling Branch: With a configurable component to call an external logging service or send an error notification
• Security Artifacts: Placeholders or suggestions for credentials, certificates, etc.