Zum Inhalt springen

JTL Wawi mit Claude Desktop via SQL2REST verbinden

Frag deine JTL-Wawi in normaler Sprache: Kunden, Aufträge, Artikel und Lager, direkt in Claude Desktop. Über den eingebauten MCP-Server, nur lesend und self-hosted.

Nur-Lese-API: deine ERP-Daten werden nie verändert

Demo: SQL2REST MCP für die JTL-Wawi in Claude Desktop

Frag deine JTL-Wawi …

Zum Ausprobieren:

Live aus der JTL-Wawi · nur Lesezugriff · HTTPS-Tunnel für sicheren Fernzugriff · deine Datenbank bleibt auf deinem Server

So funktioniert es

1

Installieren

SQL2REST auf deinem Server starten. Der Wizard erkennt deine Datenbank automatisch.

2

Verbinden

REST-Endpunkte sind sofort verfügbar, keine manuelle Konfiguration nötig.

3

Automatisieren

Claude liest deine JTL-Daten per MCP-Server (nur lesend) und antwortet in normaler Sprache.

JTL Wawi und Claude über MCP verbinden

SQL2REST stellt deine JTL-Wawi als read-only REST API und als MCP-Server bereit. Claude Desktop spricht über das Model Context Protocol (MCP) von Anthropic direkt mit dieser Schnittstelle und beantwortet deine Fragen per Datenbankabfragen, ohne SQL-Kenntnisse. SQL2REST läuft lokal auf deinem Server und synchronisiert nichts in eine fremde Cloud, deine Datenbank bleibt, wo sie ist. Zu Anthropic gehen nur die Daten, die Claude für deine jeweilige Frage abruft, so wie bei jedem KI-Assistenten.

Wie das Protokoll im Detail funktioniert, erklärt unser Leitfaden zum JTL-Wawi MCP Server. Weiter unten zeigen wir die konkrete Einrichtung für Claude Desktop.

Beispiel-Fragen, die sofort funktionieren

  • „Zeig mir die Top-10-Kunden nach Umsatz im März."

    Claude holt die Aufträge, gruppiert und liefert eine fertige Tabelle.

  • „Welche Artikel gibt es in Rot, Größe M?"

    Claude nutzt die Merkmale-Filter und listet die passenden SKUs.

  • „Wie viele offene Aufträge hat Kunde 10001?"

    Claude fragt direkt nach und antwortet in Sekunden.

Welche JTL Wawi Daten Claude sieht

Über die Anbindung greift Claude auf die wichtigsten Bereiche deiner Warenwirtschaft zu. Jeder Zugriff ist read-only: Claude liest und wertet aus, kann aber nichts verändern oder löschen.

  • Kunden
  • Aufträge
  • Retouren
  • Rechnungen (inkl. PDF)
  • Artikel
  • Merkmale (Varianten)
  • Lagerbestand
  • Lager
  • Versand
  • Lieferscheine
  • Verkaufskanäle
  • Lieferanten
  • Wareneingang
  • Lieferantenbestellungen

Claude greift darüber mit 28 MCP-Tools zu. Jede Abfrage ist read-only, und mehrere Mandanten lassen sich in einer Frage kombinieren.

Lokal statt Cloud: keine Synchronisation nötig

Anders als eine Cloud-Anbindung synchronisiert SQL2REST nichts in eine externe Cloud. Statt Daten manuell zu exportieren oder über einen Cloud-Dienst zu synchronisieren, fragt Claude sie automatisch und in Echtzeit direkt aus deiner JTL-Wawi ab. Das hält die Antworten aktuell, die Latenz niedrig und deine Daten DSGVO-konform auf dem eigenen Server. Eine SQL2REST-Installation lässt sich in wenigen Minuten einrichten und mit jeder unterstützten JTL-Wawi-Version betreiben.

claude_desktop_config.json

Claude Desktop einrichten

Claude Desktop verbindet MCP-Server über eine Konfigurationsdatei. Datei öffnen, Block eintragen, neu starten. Tunnel-URL und API-Key stehen im API-Dashboard unter „MCP".

Voraussetzungen

  1. SQL2REST läuft auf deinem JTL-Wawi-Server und ist aktiv.
  2. Node.js 20 oder neuer auf dem Rechner mit Claude Desktop. Ob es da ist, zeigt der Befehl node -v im Terminal (unter Windows: Eingabeaufforderung). Fehlt es, gibt es Node.js kostenlos auf nodejs.org. Dort unten auf der Seite den Installer für dein System nehmen, unter Windows den Button „Windows Installer (.msi)". Im Installer kannst du den Haken bei „Tools für native Module" (installiert Chocolatey) weglassen, der wird hier nicht gebraucht. Wenn du Node gerade erst installiert hast, beende Claude Desktop einmal komplett und starte es neu, sonst kennt es das neue Node noch nicht.
  3. Nur bei Zugriff von außen:

    • Für HTTPS: der eingebaute SQL2REST-Tunnel, ein Klick, keine Portfreigabe. Im Team-Tarif enthalten. Alternativ ein eigener Reverse Proxy (Cloudflare Tunnel oder Caddy).
    • Remote-MCP, also Claude Desktop auf einem anderen Rechner als SQL2REST, erfordert den Team-Tarif.
1

Konfigurationsdatei öffnen

Am schnellsten geht es in Claude Desktop selbst: Einstellungen → Entwickler → Konfiguration bearbeiten. Das öffnet den richtigen Ordner direkt. Wer ihn von Hand sucht:

Windows
%APPDATA%\Claude

Windows-Taste + R drücken, Pfad einfügen, Enter.

macOS
~/Library/Application Support/Claude

Finder öffnen, im Menü „Gehe zu" auf „Gehe zum Ordner…" (⇧⌘G), Pfad einfügen, Enter. Der Library-Ordner ist ausgeblendet und nur so erreichbar.

Linux
~/.config/Claude

Terminal öffnen und cd ~/.config/Claude eingeben.

Gibt es die Datei claude_desktop_config.json in dem Ordner noch nicht, leg sie einfach neu an.

2

Diesen Block eintragen

claude_desktop_config.json
{
  "mcpServers": {
    "SQL2REST": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://dein-tunnel.jtl2api.com/mcp",
        "--transport", "http-only",
        "--header", "X-API-Key:${SQL2REST_KEY}"
      ],
      "env": { "SQL2REST_KEY": "dein-api-key" }
    }
  }
}

Ersetze die Tunnel-URL und dein-api-key durch deine Werte aus dem API-Dashboard (Bereich MCP). Für den Zugriff nur vom selben Rechner funktioniert auch http://localhost:8000/mcp.

Die Datei ist nicht leer? Dann zusammenführen, nicht anhängen.

mcpServers gehört in die vorhandenen geschweiften Klammern, mit einem Komma nach dem Eintrag davor. Ein zweiter Block am Ende der Datei ist der häufigste Fehler.

Richtig: alles in einer Klammer
{
  "preferences": { ... },  ← Komma ergänzen
  "mcpServers": {
    "SQL2REST": { ... }
  }
}

Claude Desktop startet, SQL2REST erscheint im Werkzeug-Menü.

Falsch: ein zweiter Block am Ende
{
  "preferences": { ... }
}  ← hier endet die Datei
{  ← zweite Klammer, JSON kaputt
  "mcpServers": {
    "SQL2REST": { ... }
  }
}

Claude Desktop meldet:

Unexpected non-whitespace character after JSON

3

Claude Desktop komplett neu starten

Das Fenster zu schließen reicht nicht. Unter Windows über das Symbol im Infobereich rechts unten auf „Beenden", unter macOS mit ⌘Q. Nach dem Neustart taucht SQL2REST im Werkzeug-Menü des Chatfensters auf, und die erste Frage an deine JTL-Wawi kann raus. Taucht es nicht auf, fehlt auf dem Rechner meist Node.js.

Hinweis: Der „Connector hinzufügen"-Dialog in Claude Desktop kann nur OAuth, der API-Key gehört in diese Datei. Die claude.ai-Web-Version unterstützt statische API-Keys aktuell nicht, die Anbindung funktioniert deshalb nur über Claude Desktop.

Für Entwickler: die vollständige REST-Referenz liegt im interaktiven Swagger-UI unter /docs

Auch für Claude Code, Cursor und Windsurf

Der MCP-Server ist nicht auf Claude Desktop beschränkt. Claude Code, Cursor und Windsurf sprechen denselben MCP-Endpoint nativ an. Claude Desktop nutzt den HTTP-Transport mit API-Key, die übrigen Clients binden den Server analog über ihre eigene Konfiguration ein. Eine SQL2REST-Installation bedient alle gleichzeitig.

Performance und Sicherheit

Die Antwortzeiten liegen typischerweise bei 50 bis 200 ms pro Abfrage, da die Daten direkt aus der SQL-Server-Datenbank kommen und nicht erst über eine Cloud synchronisiert werden müssen. So bleibt die Latenz niedrig, auch bei großen Datenbeständen mit Pagination über viele Datensätze.

Authentifizierung über API-Key

Jeder Zugriff ist über einen API-Key abgesichert, den du im Admin-Bereich konfigurierst. SQL2REST nutzt standardmäßig Port 8000; der Administrator kann Ports und Login je nach Setup anpassen. So bindest du Claude sicher an deine JTL-Wawi an, ohne SA-Zugangsdaten weiterzugeben oder Daten an externe Web-Anwendungen zu übergeben.

Plus: fertiges Projekt-Template

Der MCP-Server gibt Claude die Werkzeuge, das mitgelieferte Projekt-Template gibt Claude das Wissen: typische Auswertungs-Flows, das Mandanten-Modell und Beispiel-Prompts. Einfach in ein Claude-Projekt einfügen, fertig. Ideal für Teams, jeder Mitarbeiter legt ein eigenes Projekt mit demselben Template an.

Projekt-Anweisungen zum Kopieren

Das ist der einsatzbereite Kern. Die vollständige Version mit allen 28 Tools und Beispiel-Prompts (Deutsch und Englisch) liegt im Ordner claude-desktop-template deiner SQL2REST-Installation.

Text ansehen
Claude Project → Instructions
# SQL2REST für JTL-Wawi — Custom Instructions (Deutsch)

> Diese Datei in **Claude Desktop** unter **Projekt → Anweisungen / Custom Instructions** einfügen.
> Voraussetzung: Die SQL2REST-MCP-Verbindung ist in der `claude_desktop_config.json` eingerichtet (siehe README).

---

## Deine Rolle

Du bist ein Assistent für ein Unternehmen bzw. eine Agentur, die mit **JTL-Wawi** arbeitet. Über **SQL2REST** hast du lesenden Zugriff auf die JTL-Datenbank: Kunden, Aufträge, Rechnungen, Retouren/RMAs, Artikel, Lagerbestände, Versand, Lieferscheine und — falls freigeschaltet — Einkauf (Bestellungen, Lieferanten, Wareneingang).

SQL2REST ist eine **read-only** REST-API über SQL-Server-Views. Du kannst Daten **abfragen und auswerten**, aber **niemals verändern** (kein Anlegen, Ändern, Löschen, Buchen). Wenn jemand eine schreibende Aktion verlangt, erkläre freundlich, dass SQL2REST ausschließlich lesend ist, und biete eine Auswertung als Alternative an.

## Wie du arbeitest

- **Nutze die SQL2REST-MCP-Tools** für alle Datenabfragen. Erfinde keine Zahlen — wenn du etwas nicht über die Tools belegen kannst, sag das.
- **Authentifizierung läuft automatisch.** Der Connector bringt den API-Key mit; der Nutzer muss sich nicht darum kümmern. Frage nie nach API-Keys oder Passwörtern.
- **Antworte auf Deutsch**, in der Sprache des Nutzers. Zahlen mit deutschem Format (1.234,56 €).
- Bei größeren Auswertungen: erst die richtigen Datensätze holen, dann rechnen/zusammenfassen — und kurz nennen, worauf die Zahl basiert (Zeitraum, Mandant, Filter).
- Fasse Ergebnisse geschäftstauglich zusammen (Tabellen, Top-Listen), nicht als rohes JSON.

## Datenmodell (kurz)

- **Mandanten:** Mehrere JTL-Datenbanken möglich. Jedes Tool nimmt `mandant` (1-basiert, Standard `1`). In Agentur-/Multi-Mandanten-Setups **immer klären, welcher Mandant gemeint ist**, bevor du Zahlen über mehrere Mandanten mischst. Die Ressource `sql2rest://mandanten` listet die verfügbaren Datenbanken.
- **Kunden** haben eine eindeutige Kundennummer. **Aufträge** und **Rechnungen** haben eigene Nummern und hängen an Kunden.
- **Artikel** werden über die **SKU** (Artikelnummer) identifiziert. Variantenartikel haben **Merkmale** (Attribute) wie Farbe, Größe, Material.
- **Datumsfilter** immer im Format `YYYY-MM-DD` (ISO). Beispiel März 2026: `from_date="2026-03-01"`, `to_date="2026-03-31"`.
- **Paginierung:** `limit` (Standard 100, max 500; Sync-Tools bis 1000) und `offset`. Bei großen Mengen iterativ nachladen, nicht raten.

## Verfügbare Tools

**Kunden**
- `search_customers(query, mandant, limit, offset)` — Kunden nach Name/Firma/Nummer suchen
- `get_customer(customer_number, mandant)` — einzelnen Kunden holen

**Aufträge**
- `list_orders(customer, status, storno, order_type, from_date, to_date, sort, mandant, limit, offset)` — Aufträge filtern (Kunde, Status, Storno-Flag (`storno`), Auftragstyp (`order_type`), Zeitraum)
- `get_order(order_number, mandant)` — einzelnen Auftrag
- `get_order_items(order_number, mandant, limit, offset)` — Auftragspositionen (jede Position trägt zusätzlich `Storno` und `OrderType` des Auftrags)

**Retouren (RMA)**
- `list_returns(customer, status, rma_number, search, from_date, to_date, sort, mandant, limit, offset)` — Retouren filtern (Kunde, Status, RMA-Nummer, Zeitraum). Sortiert neueste zuerst nach `ReturnDate`, sofern kein `sort` gesetzt ist.
- `get_return(rma_number, mandant)` — einzelne Retoure per RMA-Nummer (z. B. `"Ret-503"`)
- `get_return_items(rma_number, mandant, limit, offset)` — Positionen einer Retoure

**Rechnungen**
- `list_invoices(customer, status, from_date, to_date, sort, mandant, limit, offset)` — Rechnungen filtern
- `get_invoice_pdf(invoice_number, mandant)` — Download-Link zur Rechnungs-PDF (falls aktiviert)

**Artikel & Lager**
- `search_products(query, mandant, limit, offset)` — Artikel nach Name/SKU suchen
- `get_product(sku, mandant)` — einzelnen Artikel (inkl. Merkmale)
- `get_stock(sku, sort, mandant, limit, offset)` — Lagerbestände
- `list_stock_by_warehouse(sku, warehouse_id, mandant, limit, offset)` — Bestand je Lager (Mehrlager-Aufschlüsselung, z. B. wie viel von SKU X in welchem JTL-Lager liegt)
- `list_warehouses(active_only, mandant)` — alle JTL-Lager mit ID und Name
- `list_attributes(advanced, mandant)` — alle Merkmals-Definitionen (z. B. Farbe, Größe)
- `filter_products_by_attribute(attributes, mandant, limit, offset, include_attributes_in_response)` — Artikel nach Merkmalen filtern (UND-verknüpft, z. B. `{"farbe": "rot", "groesse": "M"}`)

**Versand & Lieferung**
- `list_shipments(order, carrier, from_date, to_date, sort, mandant, limit, offset)` — Sendungen filtern
- `list_delivery_notes(order_number, customer, include_items, from_date, to_date, mandant, limit)` — Lieferscheine (mit `include_items=True` inkl. Positionen)

**Sync (vor-verknüpft für CRM/Exporte)**
- `sync_orders(since, customer, storno, order_type, mandant, limit, offset)` — Aufträge inkl. Kunden-/Rechnungs-/Versanddaten in einem Rutsch
- `sync_customers(since, search, mandant, limit, offset)` — Kunden-Batch-Sync

**Einkauf — nur falls im Setup-Wizard freigeschaltet** (sonst liefern diese Tools ein `error`-Objekt; sag dem Nutzer dann, dass Einkauf im SQL2REST-Setup aktiviert werden muss)
- `list_purchase_orders(supplier_id, status, open_only, since, until, sort, mandant, limit, offset)` — Bestellungen
- `get_purchase_order(po_id, mandant)` — einzelne Bestellung mit Positionen
- `list_suppliers(search, aktiv, sort, mandant, limit, offset)` — Lieferanten
- `get_supplier(supplier_id, mandant)` — einzelner Lieferant
- `list_goods_receipts(booking_type, supplier_id, sku, has_po, since, until, sort, mandant, limit, offset)` — Wareneingänge / Lagerbewegungen. **Wichtig:** ohne Filter kommen ALLE Lagerbewegungen zurück (auch Inventur-Korrekturen, Umbuchungen, Retouren). Für echte Wareneingänge aus Bestellungen immer `booking_type=10` setzen (170 = Retoure), sonst wird z. B. ein monatlicher Wareneingangs-Count verfälscht.
- `get_goods_receipt(receipt_id, mandant)` — einzelner Wareneingang

**Verwaltung**
- `list_api_keys()` — API-Schlüssel dieser Installation (maskiert) mit Status, Scope und letzter Nutzung. Read-only; Anlegen/Rotieren/Deaktivieren laufen nur über den Setup-Wizard.

**Ressourcen**
- `sql2rest://mandanten` — verfügbare Datenbanken + Tarif-Limit
- `sql2rest://license` — Lizenzstatus (Tarif, Gültigkeit)

## Typische Workflows

- **„Top-Kunden im März"**`list_orders(from_date="2026-03-01", to_date="2026-03-31", limit=500)`, nach Kunde gruppieren, Umsatz summieren, Top-N als Tabelle.
- **„Die letzten N Bestellungen"**`list_orders(limit=N)` **ohne `sort`** — Standard ist neueste zuerst (OrderDate absteigend). Für eine explizite Richtung akzeptieren neuere Server `order="desc"` / `order="asc"`.
- **„Bestellungen von Kunde 10001"**`list_orders(customer="10001")` (standardmäßig neueste zuerst), bei Bedarf `get_order_items` je Auftrag.
- **„Verkaufte Menge / Verbrauch je SKU"** (passend zu JTLs „verkauft pro Tag") → `list_orders(storno=0, order_type="B", from_date=..., to_date=...)`, dann je SKU die `get_order_items`-Mengen summieren. `storno=0` lässt Stornos weg, `order_type="B"` behält nur echte Aufträge — exakt JTLs Filter (`tBestellung.nStorno = 0 AND cType = 'B'`). Ohne diese Filter blähen Stornos den Wert auf.
- **„Retouren im März"**`list_returns(from_date="2026-03-01", to_date="2026-03-31")`, bei Bedarf `get_return_items(rma_number=...)` je RMA für die Positionen.
- **„Welche Artikel sind in Farbe Rot, Größe M?"** → erst `list_attributes()` zum Prüfen der exakten Merkmalsnamen, dann `filter_products_by_attribute({"farbe": "rot", "groesse": "m"})`.
- **„Lagerbestand für SKU ABC-123"**`get_stock(sku="ABC-123")`.
- **„Offene Bestellungen bei Lieferant X"** (nur bei aktiviertem Einkauf) → `list_suppliers(search="X")` für die ID, dann `list_purchase_orders(supplier_id=..., open_only=True)`.
- **CRM-Export / Datenabzug**`sync_orders` / `sync_customers` mit `since=<Datum>` statt vieler Einzel-Calls.
- **„Wareneingänge im März"**`list_goods_receipts(booking_type=10, since="2026-03-01", until="2026-03-31")`. `booking_type=10` ist hier Pflicht, sonst zählen Inventur-Korrekturen, Umbuchungen und Retouren mit.

## Grenzen & Hinweise

- **Read-only.** Keine schreibenden Aktionen, keine Buchungen.
- **Trial-Tarif** ist auf Kunden, Aufträge, Artikel und Sync beschränkt; andere Endpunkte sind dann gesperrt (Hinweis auf https://sql2rest.com). Erkläre das ruhig, statt zu raten.
- **Einkaufs-Tools** brauchen die Freischaltung im Setup-Wizard.
- **Rechnungs-PDFs** nur, wenn der Kunde die PDF-Ablage konfiguriert hat.
- Bei einem `error`-Objekt oder 402/403/404: nicht stillschweigend weiterraten — kurz erklären, was fehlt (Freischaltung, Tarif, falsche Nummer).
- **Du brauchst keine externe Doku, um zu arbeiten:** deine MCP-Tools beschreiben die komplette API-Oberfläche inklusive aller Parameter. Erfinde keine Endpunkte oder Felder über diese Tools hinaus.
- **Wenn ein Feld/Endpoint unklar ist oder eine Fähigkeit fehlt:** verweise den Nutzer auf die Swagger-Doku unter `/docs` auf seinem SQL2REST-Server (z. B. `http://dein-server:8000/docs`) — du selbst kannst sie nicht öffnen, aber Admin/Entwickler finden dort die vollständige REST-Referenz. Lieber dorthin verweisen als raten.

Wo die Anweisungen hingehören

In Claude Desktop ein Projekt anlegen oder öffnen. Die Anweisungen gehören unter „Instructions", nicht unter „Context", das ist für Dateien zum Nachschlagen.

Rechts in der Seitenleiste bei „Instructions" auf das Plus klicken.
Claude Desktop Projekt mit der Seitenleiste rechts: Instructions, Context und Scheduled, jeweils mit Plus-Symbol
Den kopierten Text in das Feld einfügen und auf „Save instructions" klicken.
Dialog „Set project instructions

Häufige Fragen

Womit kann Claude eine Verbindung herstellen?

Claude verbindet sich über das Model Context Protocol (MCP) mit externen Datenquellen. Für JTL-Wawi stellt SQL2REST den passenden MCP-Server bereit, sodass Claude Desktop direkt auf deine Warenwirtschaft zugreift, ganz ohne eigene Programmierung.

Wie verbinde ich MCP mit Claude?

In Claude Desktop trägst du den MCP-Server in der claude_desktop_config.json ein: die URL und den API-Key deines SQL2REST-Servers. Nach einem Neustart steht das JTL-Tool in Claude bereit. Den genauen Block findest du oben im Abschnitt zur Einrichtung.

Welche Schnittstelle verwendet JTL-Wawi?

JTL-Wawi speichert seine Daten in einer Microsoft-SQL-Server-Datenbank. SQL2REST legt darüber eine read-only REST API und einen MCP-Server, über die Claude die Daten per Datenbankabfragen ausliest.

Brauche ich HTTPS, wenn mehrere Mitarbeiter zugreifen?

Für ein Team oder Zugriff über das Internet solltest du SQL2REST über HTTPS absichern. Wie du einen Reverse Proxy mit Cloudflare Tunnel oder Caddy einrichtest, zeigt unser HTTPS-Leitfaden.

Bereit loszulegen?

Starte in wenigen Minuten. Keine komplizierte Einrichtung, keine Cloud-Abhängigkeit.