# Sap Integration Suite Advanced > > - **Type:** Skill - **Install:** `agentstack add skill-efeumutaslan-sap-skills-sap-integration-suite-advanced` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [efeumutaslan](https://agentstack.voostack.com/s/efeumutaslan) - **Installs:** 0 - **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [efeumutaslan](https://github.com/efeumutaslan) - **Source:** https://github.com/efeumutaslan/SAP-SKILLS/tree/main/skills/sap-integration-suite-advanced ## Install ```sh agentstack add skill-efeumutaslan-sap-skills-sap-integration-suite-advanced ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Advanced SAP Integration Suite — Groovy, API Mgmt & Edge ## Related Skills - `sap-event-mesh` — Event-driven integration patterns - `sap-s4hana-extensibility` — S/4HANA API consumption via Integration Suite - `sap-security-authorization` — OAuth/SAML policies in API Management - `sap-devops-cicd` — Integration content transport and CI/CD ## Quick Start **Advanced capabilities:** | Capability | Use Case | Key Feature | |-----------|----------|-------------| | **Cloud Integration** | A2A, B2B, cloud-to-on-prem | iFlows, Groovy, mapping | | **API Management** | API facade, rate limiting, analytics | Policies, Developer Portal | | **Integration Advisor** | B2B message mapping | MAG (Message Application Group) | | **Trading Partner Management** | EDI/B2B partner onboarding | AS2, EDIFACT, X12 | | **Edge Integration Cell** | On-premise/private cloud runtime | Kubernetes-based, hybrid | | **Open Connectors** | 170+ SaaS connectors | Pre-built adapters | ## Core Concepts ### iFlow Processing Pipeline ``` Sender ──► Sender Adapter ──► Integration Flow ──► Receiver Adapter ──► Receiver │ ┌───────────────┼───────────────┐ ▼ ▼ ▼ Content Message Router / Modifier Mapping Splitter │ │ │ ▼ ▼ ▼ Groovy XSLT / Aggregator Script Graphical ``` ### API Management Policy Types | Category | Policy | Purpose | |----------|--------|---------| | **Traffic** | Spike Arrest | Prevent traffic spikes | | **Traffic** | Quota | Limit calls per time period | | **Traffic** | Concurrent Rate Limit | Max simultaneous connections | | **Security** | OAuth v2.0 | Token validation | | **Security** | SAML Assertion | SAML token validation | | **Security** | Verify API Key | Simple API key auth | | **Mediation** | JSON to XML | Format conversion | | **Mediation** | Assign Message | Set headers/variables | | **Extension** | JavaScript | Custom policy logic | ### Edge Integration Cell Architecture ``` ┌─────────────────────────────────────────┐ │ Customer Data Center / Private Cloud │ │ ┌───────────────────────────────────┐ │ │ │ Edge Integration Cell │ │ │ │ ┌─────────┐ ┌──────────────┐ │ │ │ │ │ Runtime │ │ Edge Event │ │ │ │ │ │ (iFlows) │ │ Broker │ │ │ │ │ └────┬─────┘ └──────┬───────┘ │ │ │ │ │ │ │ │ │ │ ┌────┴───────────────┴────┐ │ │ │ │ │ Kubernetes (K3s/K8s) │ │ │ │ │ └─────────────────────────┘ │ │ │ └───────────────┬───────────────────┘ │ │ │ HTTPS (outbound only) │ └──────────────────┼──────────────────────┘ ▼ SAP Integration Suite (Cloud Control Plane) ``` ## Common Patterns ### Pattern 1: Groovy Script — JSON Transformation ```groovy import com.sap.gateway.ip.core.customdev.util.Message import groovy.json.JsonSlurper import groovy.json.JsonOutput def Message processData(Message message) { def body = message.getBody(String) def json = new JsonSlurper().parseText(body) // Transform structure def result = json.orders.collect { order -> [ orderNumber: order.id, customerName: order.customer?.name ?: 'Unknown', totalAmount: order.items?.sum { it.price * it.quantity } ?: 0, currency: order.currency ?: 'EUR', lineItems: order.items?.collect { item -> [ materialId: item.productId, description: item.description?.take(40), quantity: item.quantity, unitPrice: item.price ] } ?: [] ] } message.setBody(JsonOutput.toJson([salesOrders: result])) message.setHeader('Content-Type', 'application/json') message.setProperty('OrderCount', result.size()) return message } ``` ### Pattern 2: Groovy Script — Error Handling & Logging ```groovy import com.sap.gateway.ip.core.customdev.util.Message import org.apache.camel.Exchange def Message processData(Message message) { def log = messageLogFactory.getMessageLog(message) def props = message.getProperties() try { def body = message.getBody(String) // Validate input if (!body || body.trim().isEmpty()) { throw new IllegalArgumentException("Empty message body") } // Log for monitoring (appears in Message Processing Log) log?.addAttachmentAsString('InputPayload', body, 'application/json') // Process... def result = transform(body) log?.setStringProperty('ProcessingStatus', 'SUCCESS') log?.setStringProperty('RecordCount', result.size().toString()) message.setBody(result) } catch (Exception e) { // Set error details for exception subprocess message.setProperty('ErrorMessage', e.message) message.setProperty('ErrorClass', e.class.simpleName) message.setProperty('ErrorTimestamp', new Date().format("yyyy-MM-dd'T'HH:mm:ss'Z'")) log?.setStringProperty('ProcessingStatus', 'ERROR') log?.setStringProperty('ErrorDetail', e.message) // Re-throw to trigger error handling throw e } return message } ``` ### Pattern 3: Groovy Script — Dynamic Routing ```groovy import com.sap.gateway.ip.core.customdev.util.Message def Message processData(Message message) { def body = new groovy.json.JsonSlurper().parseText(message.getBody(String)) // Determine route based on payload def routeTarget = switch(body.documentType) { case 'INVOICE' -> 'InvoiceEndpoint' case 'CREDIT_MEMO' -> 'CreditMemoEndpoint' case 'PO' -> 'PurchaseOrderEndpoint' default -> 'DefaultEndpoint' } // Set routing header for Router step message.setHeader('RouteTarget', routeTarget) // Set dynamic endpoint URL def endpoints = [ 'InvoiceEndpoint': 'https://erp.example.com/api/invoices', 'CreditMemoEndpoint': 'https://erp.example.com/api/credit-memos', 'PurchaseOrderEndpoint': 'https://erp.example.com/api/purchase-orders', 'DefaultEndpoint': 'https://erp.example.com/api/documents' ] message.setProperty('DynamicEndpointURL', endpoints[routeTarget]) return message } ``` ### Pattern 4: API Management — Rate Limiting Policy ```xml Spike Arrest - 30ps 30ps Monthly Quota 1 month 2026-01-01 00:00:00 true Verify OAuth Token VerifyAccessToken request.header.Authorization read write Cache GET responses 300 request.verb != "GET" ``` ### Pattern 5: XSLT Mapping — IDoc to JSON ```xslt {"orders":[ 1">, {"orderNumber":" ","orderDate":" ","items":[ 1">, {"lineItem":" ","material":" ","quantity": } ]} ]} ``` ### Pattern 6: B2B Integration — AS2 with TPM ``` Trading Partner Setup: ┌──────────────┐ AS2/HTTPS ┌──────────────────┐ │ Partner A │───────────────►│ Integration Suite │ │ (Supplier) │ EDIFACT msg │ ┌──────────────┐ │ │ │◄───────────────│ │ TPM Config │ │ └──────────────┘ AS2 MDN │ │ - Partner ID │ │ │ │ - AS2 ID │ │ │ │ - Certificate│ │ │ │ - Agreement │ │ │ └──────┬───────┘ │ │ ▼ │ │ ┌──────────────┐ │ │ │ iFlow │ │ │ │ (EDI→XML→ │ │ │ │ IDoc/OData) │ │ │ └──────┬───────┘ │ └─────────┼─────────┘ ▼ SAP S/4HANA ``` **TPM Configuration checklist:** 1. Create Trading Partner profile (AS2 ID, certificates) 2. Define Agreement (message type: ORDERS, INVOIC, DESADV) 3. Configure B2B adapter in iFlow (AS2 sender/receiver) 4. Map EDI segments to SAP IDoc/API structure 5. Set up MDN (Message Disposition Notification) for acknowledgment 6. Test with partner's test environment before go-live ## Error Catalog | Error | Context | Root Cause | Fix | |-------|---------|------------|-----| | Groovy: `NullPointerException` | Script step | Accessing null property | Add null-safe operator `?.` and default values | | Groovy: `ClassNotFoundException` | Custom library | JAR not uploaded to tenant | Upload via Integration Content → Resources | | `HTTP 429` | API Management | Rate limit/quota exceeded | Adjust policy; contact API provider | | `MPL: FAILED` | Message Processing Log | iFlow step error | Check MPL attachments and trace for root cause | | `Certificate expired` | Receiver adapter | SSL/TLS cert expiration | Rotate certificate in Security Material | | AS2: `MDN negative` | B2B | Partner rejected message | Check EDI validation; verify message structure | | `Mapping error` | Message Mapping | Source/target mismatch | Compare source XML structure with mapping definition | | Edge: `Pod CrashLoopBackOff` | Edge Integration Cell | Memory/config issue | Check pod logs; increase resource limits | | `Credential not found` | Adapter auth | Missing Security Material | Deploy OAuth/Basic auth credentials to tenant | | `Queue full` | JMS adapter | Consumer too slow | Scale consumer iFlow; increase queue depth | ## Performance Tips 1. **Groovy: Reuse parsers** — Compile JsonSlurper once, reuse across messages; avoid `new` in hot paths 2. **Streaming for large payloads** — Use Groovy `XMLStreamReader` instead of DOM for >10 MB XML 3. **Content Modifier over Script** — Use Content Modifier for simple header/property changes; Groovy adds overhead 4. **JMS queues for decoupling** — Use JMS between sender and receiver iFlows for retry and buffering 5. **API caching** — Enable ResponseCache policy for read-heavy APIs; 5-min cache reduces backend calls 80%+ 6. **Parallel processing** — Use Splitter (parallel) + Aggregator for batch processing 7. **Edge Cell for latency** — Deploy latency-sensitive iFlows to Edge; keep cloud for management only 8. **Minimize trace logging** — Trace-level logging in production impacts throughput; use only for debugging ## Gotchas - **Groovy sandbox**: Integration Suite Groovy runs in a restricted sandbox — no file I/O, no network calls (use adapters) - **Groovy version**: Integration Suite uses Groovy 2.4.x (not 4.x); avoid newer syntax - **iFlow versioning**: Each deploy creates a new version; rollback by redeploying older version - **Edge Cell updates**: Edge runtime must be kept within 2 versions of cloud; auto-update recommended - **API proxy vs. iFlow**: API Management proxies are for facade/security; iFlows for transformation/routing - **JMS queue limits**: Default 30 queues per tenant; each 9.3 GB max; request increase via support ticket - **B2B certificates**: Partner certificates expire; set calendar reminders for rotation ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [efeumutaslan](https://github.com/efeumutaslan) - **Source:** [efeumutaslan/SAP-SKILLS](https://github.com/efeumutaslan/SAP-SKILLS) - **License:** MIT Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** yes - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-efeumutaslan-sap-skills-sap-integration-suite-advanced - Seller: https://agentstack.voostack.com/s/efeumutaslan - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.