Integrationsarchitektur: So verbinden Sie LLM mit Enterprise-Software

Die zentrale Herausforderung bei der Integration eines LLM in bestehende Enterprise-Systeme ist: Wie bringe ich die KI-Fähigkeiten in bestehende Workflows, ohne die bewährte Systemlandschaft zu destabilisieren? Die Antwort: ein dedizierter API-Gateway als Vermittlungsschicht.

Warum ein API-Gateway? Nicht direkt verbinden!

Die direkte Verbindung von SAP zum LLM-Server ist technisch möglich, aber aus mehreren Gründen nicht empfehlenswert:

• Entkopplung: Änderungen am LLM (Modellwechsel, Skalierung) haben keine Auswirkung auf SAP
• Sicherheit: Data Classification, PII-Masking und Rate Limiting zentral an einer Stelle
• Audit-Trail: Alle LLM-Anfragen werden protokolliert — kritisch für DSGVO Art. 30
• Multi-System: Derselbe Gateway bedient SAP, DATEV, CRM und Custom-Apps
• Resilience: Circuit Breaker, Retry-Logik und Fallback-Strategien

API-Gateway: Die Schaltzentrale

Der API-Gateway ist die zentrale Komponente Ihrer LLM-Integrationsarchitektur. Er übernimmt Authentifizierung, Routing, Datenaufbereitung und Monitoring.

Empfohlene API-Gateways

Custom API-Gateway mit FastAPI

Für die meisten SAP/DATEV-Integrationen empfehlen wir einen Custom-Gateway mit FastAPI — er kombiniert Gateway-Funktionalität mit Datenaufbereitung:

# api_gateway.py — LLM API Gateway für SAP/DATEV
from fastapi import FastAPI, HTTPException, Depends, Header
from pydantic import BaseModel
import httpx
import logging
import time

app = FastAPI(title="LLM API Gateway")
logger = logging.getLogger("llm_gateway")

OLLAMA_URL = "http://localhost:11434"
ALLOWED_MODELS = ["example-assistant", "buchungs-assistent"]

class LLMRequest(BaseModel):
    system: str
    prompt: str
    model: str = "example-assistant"
    source_system: str  # "SAP", "DATEV", "CRM"
    user_id: str
    context: dict = {}

class LLMResponse(BaseModel):
    answer: str
    model: str
    tokens_used: int
    processing_time_ms: float

# API-Key Authentifizierung
async def verify_api_key(authorization: str = Header()):
    if not authorization.startswith("Bearer "):
        raise HTTPException(401, "Invalid auth header")
    # API-Key gegen Datenbank prüfen
    return authorization.split(" ")[1]

# PII-Masking
def mask_pii(text: str) -> str:
    """Maskiert personenbezogene Daten vor der LLM-Anfrage"""
    import re
    # E-Mail-Adressen maskieren
    text = re.sub(r'\b[\w.-]+@[\w.-]+\.\w+\b', '[EMAIL]', text)
    # Telefonnummern maskieren
    text = re.sub(r'\b\d{3,5}[-/\s]?\d{4,8}\b', '[TELEFON]', text)
    # IBAN maskieren
    text = re.sub(r'\b[A-Z]{2}\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{0,4}\b', '[IBAN]', text)
    return text

@app.post("/api/v1/generate", response_model=LLMResponse)
async def generate(req: LLMRequest, api_key: str = Depends(verify_api_key)):
    # Validierung
    if req.model not in ALLOWED_MODELS:
        raise HTTPException(400, f"Modell nicht erlaubt: {req.model}")

    # PII-Masking
    safe_prompt = mask_pii(req.prompt)

    # Audit-Log (DSGVO Art. 30)
    logger.info(f"LLM-Request | user={req.user_id} | source={req.source_system} "
                f"| model={req.model} | prompt_len={len(safe_prompt)}")

    start = time.time()

    # LLM-Anfrage
    async with httpx.AsyncClient(timeout=120) as client:
        response = await client.post(f"{OLLAMA_URL}/api/generate", json={
            "model": req.model,
            "system": req.system,
            "prompt": safe_prompt,
            "stream": False,
        })

    elapsed = (time.time() - start) * 1000
    result = response.json()

    return LLMResponse(
        answer=result["response"],
        model=req.model,
        tokens_used=result.get("eval_count", 0),
        processing_time_ms=round(elapsed, 1),
    )

SAP-Integration im Detail

SAP bietet mehrere Integrationspunkte für externe Services. Die Wahl hängt von Ihrer SAP-Landschaft und dem Ziel-Use-Case ab.

Option 1: SAP BTP (Business Technology Platform)

SAP BTP ist die empfohlene Integrationsplattform für SAP S/4HANA Cloud. Sie stellen eine Custom Extension bereit, die Ihr lokales LLM über den API-Gateway anspricht:

// SAP BTP CAP Service — LLM Proxy
// srv/llm-service.js (SAP Cloud Application Programming Model)

const cds = require("@sap/cds");

module.exports = class LLMService extends cds.ApplicationService {
  async init() {
    this.on("analyzePurchaseOrder", async (req) => {
      const { orderId, question } = req.data;

      // Bestelldaten aus SAP laden
      const order = await SELECT.from("PurchaseOrders")
        .where({ ID: orderId });

      // LLM über API-Gateway anfragen
      const response = await fetch("https://llm-gateway.intern.example.de/api/v1/generate", {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${process.env.LLM_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          model: "example-assistant",
          source_system: "SAP",
          user_id: req.user.id,
          system: "Analysieren Sie die folgende Bestellung und beantworten Sie die Frage.",
          prompt: `Bestellung: ${JSON.stringify(order)}\n\nFrage: ${question}`,
        }),
      });

      return response.json();
    });
    
    await super.init();
  }
}

Option 2: ABAP HTTP-Client (On-Premise SAP)

Für SAP S/4HANA On-Premise oder ECC können Sie direkt aus ABAP heraus den LLM-Gateway ansprechen:

* ABAP: LLM-Aufruf über HTTP-Client
DATA: lo_http_client TYPE REF TO if_http_client,
      lv_response    TYPE string.

* HTTP-Client erstellen
cl_http_client=>create_by_url(
  EXPORTING url = 'https://llm-gateway.intern.example.de/api/v1/generate'
  IMPORTING client = lo_http_client ).

* Request konfigurieren
lo_http_client->request->set_method( if_http_request=>co_request_method_post ).
lo_http_client->request->set_header_field(
  name = 'Authorization' value = 'Bearer API_KEY_HERE' ).
lo_http_client->request->set_header_field(
  name = 'Content-Type' value = 'application/json' ).

* JSON-Body setzen
lo_http_client->request->set_cdata(
  '{"model":"example-assistant",'
  '"source_system":"SAP",'
  '"user_id":"SAP_USER",'
  '"system":"Fassen Sie den folgenden Beleg zusammen.",'
  '"prompt":"' && lv_beleg_text && '"}' ).

* Request senden
lo_http_client->send( ).
lo_http_client->receive( ).

* Antwort lesen
lv_response = lo_http_client->response->get_cdata( ).

Option 3: SAP Integration Suite (iPaaS)

Die SAP Integration Suite bietet vorgefertigte Adapter und Flow-basierte Integration. Erstellen Sie einen Integration Flow, der bei bestimmten SAP-Events (z.B. neue Bestellung, Reklamation) automatisch eine LLM-Anfrage auslöst:

• Trigger: SAP Event Mesh (z.B. Bestellungseingang)
• Transformation: Content Modifier bereitet die Daten auf
• LLM-Aufruf: HTTP Receiver zum API-Gateway
• Rückschreibung: OData-Adapter schreibt LLM-Ergebnis in SAP zurück

DATEV-Integration

DATEV ist das Rückgrat der deutschen Steuerberatung und Buchhaltung. Die Integration eines LLM mit DATEV eröffnet wertvolle Automatisierungsmöglichkeiten — unter strikter Beachtung der beruflichen Schweigepflicht (§ 203 StGB).

DATEV-Schnittstellen

Beispiel: Automatische Buchungsvorschläge

# DATEV-Integration: Automatische Buchungsvorschläge
import requests

# 1. Beleg aus DATEV Connect Online abrufen
datev_api = "https://datev-connect.intern.example.de/api/v1"
beleg = requests.get(
    f"{datev_api}/belege/{beleg_id}",
    headers={"Authorization": f"Bearer {datev_token}"},
).json()

# 2. LLM um Buchungsvorschlag bitten
llm_response = requests.post(
    "https://llm-gateway.intern.example.de/api/v1/generate",
    headers={"Authorization": f"Bearer {llm_api_key}"},
    json={
        "model": "buchungs-assistent",
        "source_system": "DATEV",
        "user_id": "steuerberater_mueller",
        "system": """Sie sind ein erfahrener Buchhalter nach SKR03/SKR04.
Analysieren Sie den folgenden Beleg und schlagen Sie die korrekte Buchung vor.
Nennen Sie: Sollkonto, Habenkonto, Betrag, Steuerschlüssel, Buchungstext.
Bei Unsicherheit markieren Sie die Buchung als "Prüfung erforderlich".""",
        "prompt": f"""
Belegdaten:
- Datum: {beleg['datum']}
- Betrag: {beleg['betrag']} EUR
- Lieferant: {beleg['lieferant']}
- Belegtext: {beleg['text']}
- Kategorie: {beleg.get('kategorie', 'unbekannt')}

Bitte erstellen Sie einen Buchungsvorschlag nach SKR03.
""",
    },
).json()

# 3. Buchungsvorschlag in DATEV zurückschreiben
requests.post(
    f"{datev_api}/buchungsvorschlaege",
    headers={"Authorization": f"Bearer {datev_token}"},
    json={
        "beleg_id": beleg_id,
        "vorschlag": llm_response["answer"],
        "modell": llm_response["model"],
        "confidence": "mittel",  # Immer zur manuellen Prüfung markieren
        "status": "vorschlag",
    },
)

Generische ERP-Integration

Neben SAP und DATEV lassen sich auch andere ERP-Systeme integrieren — das Grundmuster ist immer gleich: API-Gateway als Vermittler, REST-API zum LLM, Audit-Logging für Compliance.

Typische ERP-Systeme im DACH-Raum

Datenfluss & Sicherheit

Die Sicherheit des Datenflusses zwischen Enterprise-Systemen und LLM ist die kritischste Designentscheidung. Implementieren Sie mehrere Sicherheitsschichten:

Data Classification Layer

Nicht alle Daten dürfen an das LLM gesendet werden. Definieren Sie klare Klassifizierungsregeln:

Netzwerk-Sicherheit

• mTLS: Gegenseitige TLS-Authentifizierung zwischen SAP, Gateway und LLM
• VLAN-Isolation: LLM-Server in eigenem Netzwerksegment
• Kein Internet: LLM-Server hat keinen Internetzugang
• Firewall-Regeln: Nur Gateway darf mit LLM kommunizieren

Praxis-Use-Cases

Use Case 1: SAP FI — Automatische Rechnungsverarbeitung

Use Case 2: DATEV — Mandantenkorrespondenz

Use Case 3: SAP SuccessFactors — HR-Assistent

Implementierungs-Roadmap

Die erfolgreiche Integration eines LLM in SAP/DATEV folgt einem bewährten Phasenmodell:

Phase 1: PoC (2–4 Wochen)

• LLM-Server aufsetzen (Ollama Enterprise Guide)
• Einfachen API-Gateway implementieren
• Einen Use Case end-to-end testen
• Qualität und Latenz messen

Phase 2: Pilot (4–8 Wochen)

• Security Hardening und PII-Masking
• SAP/DATEV-Konnektoren implementieren
• Audit-Logging und DSGVO-Dokumentation
• Pilotgruppe (5–10 Nutzer) einbinden

Phase 3: Produktion (4–8 Wochen)

• Monitoring und Alerting aufsetzen
• Fehlerbehandlung und Fallback-Strategien
• Rollout auf alle Nutzer
• Schulung und Change Management

Phase 4: Optimierung (laufend)

• Modell-Qualität kontinuierlich evaluieren
• Weitere Use Cases identifizieren und umsetzen
• Performance-Optimierung (Modellgröße, Caching)
• RAG-System für unternehmensspezifisches Wissen aufbauen

Weiterführende Ressourcen

• Ollama Enterprise Guide — LLM-Server aufsetzen
• vLLM vs. Ollama — Die richtige Engine für Ihre Integration
• RAG-Systeme — LLM mit Ihren Dokumenten verbinden
• GPU-Server Guide — Hardware für LLM-Server
• LLM für Kanzleien — § 203 StGB konforme Integration
• DSGVO & KI — Datenschutz bei der Integration