SAP-Daten mit einer RAG Pipeline durchsuchbar machen — Praxisanleitung

TL;DR

Eine RAG Pipeline mit SAP-Anbindung macht Materialstammdaten, Bestellanforderungen und Lieferantendaten per natürlicher Sprache durchsuchbar. Über PyRFC lesen Sie SAP-Daten via BAPI aus, indexieren sie in einer Vektordatenbank und verbinden alles mit LangChain. Ergebnis: Antworten in Sekunden statt 15 Minuten manuellem SAP-GUI-Lookup. Diese Anleitung zeigt den kompletten Weg mit Python-Code.

Warum SAP-Daten im Mittelstand ein Suchproblem haben

73% der deutschen Mittelständler nutzen SAP — von Business One bis S/4HANA. Das Wissen steckt dort drin: Materialstammdaten, Bestellanforderungen (BANF), Lieferantenbewertungen, Preisstaffeln. Aber wer schon einmal versucht hat, in der SAP GUI über Transaktion MM03 eine bestimmte Materialgruppe mit bestimmten Eigenschaften zu finden, kennt das Problem.

Ein Einkäufer bei einem Automobilzulieferer in Schwaben erzählte uns kürzlich: "Ich brauche pro Anfrage 12-15 Minuten, weil ich in drei verschiedenen Transaktionen suchen muss." Bei 40 Anfragen am Tag sind das über 8 Stunden — ein ganzer Arbeitstag nur für Suchen.

Die klassische Lösung wäre ein SAP-Report oder eine ABAP-Entwicklung. Kostet schnell €30.000-50.000 und dauert Monate. Eine RAG Pipeline mit SAP-Anbindung erreicht dasselbe in 2-3 Wochen, flexibler und mit natürlicher Sprachsuche.

So funktioniert die Architektur

Die RAG Pipeline mit SAP-Integration besteht aus drei Schichten:

Datenschicht: PyRFC verbindet sich über den SAP RFC-Connector mit Ihrem SAP-System und ruft BAPIs auf — standardisierte Schnittstellen, die SAP selbst bereitstellt. Kein SAP GUI Scripting nötig, keine fragile Screen-Automatisierung.

Indexierung: Die extrahierten Daten werden in Chunks aufgeteilt, mit einem Embedding-Modell vektorisiert und in ChromaDB oder Qdrant gespeichert. Für Materialstammdaten hat sich eine Chunk-Größe von 500 Tokens mit 50 Token Overlap bewährt.

Abfrage: LangChain orchestriert den Retrieval-Prozess. Eine Benutzeranfrage wird vektorisiert, die relevantesten Chunks werden abgerufen und als Kontext an das LLM übergeben. Das LLM generiert eine präzise Antwort auf Basis der SAP-Daten.

SAP-Daten mit PyRFC extrahieren

Bevor Sie Code schreiben: Sie brauchen den SAP NetWeaver RFC SDK von SAP (SAP-Kundennummer erforderlich) und einen RFC-Benutzer mit Leserechten auf die relevanten BAPIs.

# sap_extractor.py — SAP-Materialstammdaten via BAPI auslesen
from pyrfc import Connection
import json
from datetime import datetime

# SAP-Verbindung konfigurieren
sap_config = {
    "ashost": "sap-prod.ihr-unternehmen.de",
    "sysnr": "00",
    "client": "100",
    "user": "RFC_RAG_USER",
    "passwd": "***",  # In Produktion: aus Vault laden
    "lang": "DE"
}

def materialstamm_laden(conn, matnr_von="", matnr_bis="ZZZZZZZZ"):
    """Materialstammdaten über BAPI_MATERIAL_GETLIST abrufen"""
    result = conn.call(
        "BAPI_MATERIAL_GETLIST",
        MATNRSELECTION=[{
            "SIGN": "I",
            "OPTION": "BT",
            "MATNR_LOW": matnr_von,
            "MATNR_HIGH": matnr_bis
        }],
        MATERIALSHORTDESCSEL=[{
            "SIGN": "I",
            "OPTION": "CP",
            "DESCR_LOW": "*"
        }]
    )
    return result.get("MATNRLIST", [])

def material_details_laden(conn, matnr):
    """Detaildaten eines Materials über BAPI_MATERIAL_GET_DETAIL"""
    result = conn.call(
        "BAPI_MATERIAL_GET_DETAIL",
        MATERIAL=matnr
    )
    return result.get("MATERIAL_GENERAL_DATA", {})

# Verbindung aufbauen und Daten extrahieren
with Connection(**sap_config) as conn:
    materialien = materialstamm_laden(conn)
    print(f"{len(materialien)} Materialien gefunden")

    # Details für jedes Material laden
    dokumente = []
    for mat in materialien[:500]:  # Batch-Größe begrenzen
        details = material_details_laden(conn, mat["MATERIAL"])
        dokumente.append({
            "matnr": mat["MATERIAL"],
            "beschreibung": mat.get("MATL_DESC", ""),
            "details": details,
            "zeitstempel": datetime.now().isoformat()
        })

    # Als JSON für die Pipeline speichern
    with open("sap_materialstamm.json", "w", encoding="utf-8") as f:
        json.dump(dokumente, f, ensure_ascii=False, indent=2)

Wichtig: Begrenzen Sie den initialen Datenexport. Starten Sie mit einer Materialgruppe oder einem Werk — nicht mit dem gesamten Materialstamm. Ein mittelständischer Maschinenbauer hat typischerweise 15.000-80.000 Materialstammsätze. Alle auf einmal zu laden, bringt weder den RFC-User noch die Vektordatenbank in eine gute Ausgangslage.

Die RAG Pipeline mit LangChain aufbauen

Unsere Empfehlung: Starten Sie mit Materialstammdaten. Die sind strukturiert, ändern sich selten und der Nutzen ist sofort sichtbar. Bestellanforderungen und Lieferantendaten kommen in Phase 2.

# rag_sap_pipeline.py — RAG Pipeline für SAP-Daten mit LangChain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import AzureOpenAIEmbeddings, AzureChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
import json
import os

# Azure OpenAI konfigurieren (DSGVO: Region westeurope)
embeddings = AzureOpenAIEmbeddings(
    azure_deployment="text-embedding-3-large",
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_KEY"),
    api_version="2024-06-01"
)

llm = AzureChatOpenAI(
    azure_deployment="gpt-4o",
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_KEY"),
    api_version="2024-06-01",
    temperature=0.1  # Niedrig für faktische Antworten
)

# SAP-Daten laden und in Textformat bringen
with open("sap_materialstamm.json", "r", encoding="utf-8") as f:
    materialien = json.load(f)

# Materialien in durchsuchbare Texte umwandeln
texte = []
for mat in materialien:
    text = (
        f"Material {mat['matnr']}: {mat['beschreibung']}\n"
        f"Materialgruppe: {mat['details'].get('MATL_GROUP', 'k.A.')}\n"
        f"Basismengeneinheit: {mat['details'].get('BASE_UOM', 'k.A.')}\n"
        f"Bruttogewicht: {mat['details'].get('GROSS_WT', 'k.A.')} "
        f"{mat['details'].get('UNIT_OF_WT', '')}\n"
        f"Werk: {mat['details'].get('PLANT', 'k.A.')}"
    )
    texte.append(text)

# Texte in Chunks aufteilen
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", ". "]
)
chunks = splitter.create_documents(texte)

# In ChromaDB indexieren
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_sap_db"
)
print(f"{len(chunks)} Chunks indexiert")

# RAG-Chain mit SAP-spezifischem Prompt
sap_prompt = PromptTemplate(
    template="""Du bist ein SAP-Experte für den deutschen Mittelstand.
Beantworte die Frage NUR auf Basis der folgenden SAP-Daten.
Wenn die Daten keine Antwort hergeben, sage das ehrlich.

SAP-Daten:
{context}

Frage: {question}

Antwort auf Deutsch:""",
    input_variables=["context", "question"]
)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
    chain_type_kwargs={"prompt": sap_prompt}
)

# Testabfrage
antwort = qa_chain.invoke(
    "Welche Materialien in Werk 1000 haben ein Gewicht über 50 kg?"
)
print(antwort["result"])

Synchronisation: SAP-Daten aktuell halten

Ein häufiger Fehler bei RAG-Projekten: Die Pipeline läuft einmal, die Daten veralten, niemand merkt es — bis jemand nach einem Material fragt, das seit drei Wochen gesperrt ist.

Für den SAP-Materialstamm gibt es zwei Strategien. Der Delta-Sync über die BAPI BAPI_MATERIAL_GETLIST mit Änderungsdatum-Filter ist der sauberere Weg:

# delta_sync.py — Nur geänderte SAP-Materialien synchronisieren
from pyrfc import Connection
from datetime import datetime, timedelta

def delta_sync(conn, tage_zurueck=1):
    """Nur Materialien laden, die sich in den letzten N Tagen geändert haben"""
    stichtag = (datetime.now() - timedelta(days=tage_zurueck)).strftime("%Y%m%d")

    # BAPI mit Änderungsdatum-Filter aufrufen
    result = conn.call(
        "BAPI_MATERIAL_GETLIST",
        MATNRSELECTION=[{
            "SIGN": "I", "OPTION": "CP", "MATNR_LOW": "*"
        }],
        MATERIALSHORTDESCSEL=[{
            "SIGN": "I", "OPTION": "CP", "DESCR_LOW": "*"
        }]
    )

    geaenderte = []
    for mat in result.get("MATNRLIST", []):
        # Änderungsdatum prüfen (über Detail-BAPI)
        detail = conn.call("BAPI_MATERIAL_GET_DETAIL", MATERIAL=mat["MATERIAL"])
        aenderungsdatum = detail.get("MATERIAL_GENERAL_DATA", {}).get("CHANGED_ON", "")
        if aenderungsdatum >= stichtag:
            geaenderte.append(mat)

    print(f"{len(geaenderte)} geänderte Materialien seit {stichtag}")
    return geaenderte

Planen Sie diesen Sync als täglichen Cronjob ein. In der Praxis reicht für Materialstammdaten einmal pro Nacht — die ändern sich nicht stündlich. Bei Bestellanforderungen sieht das anders aus, da brauchen Sie eventuell einen Intervall von 15 Minuten.

Kosten und Zeitrahmen realistisch einschätzen

Wir raten davon ab, eine RAG Pipeline mit SAP-Anbindung als "Schnellprojekt in einer Woche" zu verkaufen. Das funktioniert in der Praxis selten, weil allein die RFC-Berechtigungen im SAP-System 3-5 Tage Abstimmung mit der Basis kosten.

Laufende Kosten: Azure OpenAI für Embeddings und LLM ca. €150-400/Monat je nach Abfragevolumen. ChromaDB ist Open Source, Qdrant Cloud ab €50/Monat.

Das kennen Sie vermutlich: Ein SAP-Berater würde für einen ABAP-Report mit ähnlicher Funktionalität €30.000-50.000 ansetzen, ohne die natürliche Sprachsuche. Die RAG Pipeline ist damit nicht nur günstiger, sondern auch flexibler erweiterbar.

Worauf Sie achten sollten

Wer direkt loslegen will, dem empfehlen wir diese Checkliste:

1. RFC-Benutzer mit Leserechten anlegen — niemals einen Dialog-User verwenden. Ihr SAP-Basis-Team wird das einfordern, und zurecht.
2. Mit einem Datentyp starten — Materialstammdaten sind ideal, weil sie strukturiert und stabil sind. BANF-Daten kommen in Phase 2.
3. Embedding-Modell testen — text-embedding-3-large von Azure liefert für deutsche SAP-Fachbegriffe bessere Ergebnisse als text-embedding-ada-002. Der Unterschied bei Retrieval-Qualität liegt bei rund 12%.
4. Chunk-Größe für SAP-Daten anpassen — 500 Tokens pro Chunk mit 50 Token Overlap funktioniert für Materialstammdaten gut. Für Langtext-Felder (z.B. Bestelltext in der BANF) besser 800 Tokens.
5. DSGVO beachten — SAP-Daten, die auf Azure OpenAI verarbeitet werden, müssen in der EU-Region bleiben. westeurope oder swedencentral sind die richtigen Azure-Regionen.

Für die technische Basis einer solchen RAG-Lösung lohnt sich ein Blick in unseren Praxisleitfaden zu RAG-Chatbots mit eigenen Dokumenten. Wer den Chatbot-Teil vertiefen möchte, findet im Artikel zu Open-Source-Chatbots mit Azure AI Search eine passende Ergänzung. Und wenn SAP nur ein System von vielen in Ihrer IT-Landschaft ist, hilft der Guide zur KI-Integration in bestehende IT-Systeme bei der Gesamtarchitektur.

Häufig gestellte Fragen

Was kostet eine RAG Pipeline mit SAP-Anbindung?

Rechnen Sie mit €12.000-21.000 für die initiale Implementierung, abhängig von der Komplexität Ihrer SAP-Landschaft und der Anzahl der Datentypen. Laufende Kosten für Cloud-LLM und Vektordatenbank liegen bei €200-450 pro Monat. Der ROI zeigt sich ab dem dritten Monat durch eingesparte Suchzeiten — bei 40 Abfragen pro Tag sparen Sie rund 6 Stunden täglich.

Funktioniert die Anbindung auch mit SAP Business One oder nur mit S/4HANA?

Beide Systeme unterstützen RFC-Aufrufe und BAPIs. Bei SAP Business One nutzen Sie alternativ die DI API oder die Service Layer REST API, die in neueren Versionen verfügbar ist. S/4HANA bietet zusätzlich OData-Services, die sich besonders einfach anbinden lassen. Der Python-Code in dieser Anleitung funktioniert mit beiden Systemen.

Wie stelle ich sicher, dass keine sensiblen SAP-Daten in die Cloud gelangen?

Drei Maßnahmen: Erstens, der RFC-User bekommt ausschließlich Leserechte auf freigegebene BAPIs — keine Dialog-Berechtigungen. Zweitens, Azure OpenAI in der Region westeurope verarbeitet Daten DSGVO-konform innerhalb der EU. Drittens können Sie sensible Felder wie Einkaufspreise oder Lieferantenkonditionen vor der Indexierung filtern oder maskieren.

Welche SAP-Daten eignen sich am besten für den Einstieg?

Materialstammdaten (Transaktion MM03) sind der ideale Startpunkt: Sie sind strukturiert, ändern sich selten und der Suchbedarf ist hoch. Als zweiter Schritt eignen sich Lieferantenstammdaten und Bestellanforderungen (BANF). Von Finanzdaten raten wir im ersten Schritt ab — zu sensibel, zu viele Compliance-Anforderungen.

Wie unterscheidet sich eine RAG Pipeline von einer klassischen SAP-Suche?

Die SAP-Suche über Transaktionen wie MM03 oder ME53N erfordert exakte Feldwerte — Sie müssen die Materialnummer oder den exakten Kurztext kennen. Eine RAG Pipeline versteht natürliche Sprache: "Welche Edelstahl-Flansche haben wir für DN100?" liefert Ergebnisse, auch wenn im Materialstamm "Flansch V4A DN100 PN16" steht. Die semantische Suche überbrückt die Lücke zwischen Fachsprache und SAP-Kurztext.

Fazit und nächster Schritt

Eine RAG Pipeline mit SAP-Anbindung ist kein Forschungsprojekt mehr — die Bausteine (PyRFC, LangChain, Azure OpenAI) sind produktionsreif und im deutschen Mittelstand einsetzbar. Der Schlüssel liegt nicht in der Technologie, sondern in der richtigen Reihenfolge: erst Materialstammdaten, dann BANF, dann Lieferantendaten. Nicht alles auf einmal.

Wenn Sie den nächsten Schritt gehen wollen: Nutzen Sie unseren KI-Reifegrad-Check, um zu prüfen, ob Ihre SAP-Landschaft und IT-Organisation bereit für eine RAG-Integration sind.