sap-wm-mcp 0.1.0

package/index.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import 'dotenv/config';
+
+import { getBinStatus } from './tools/binStatus.js';
+import { getStockForMaterial } from './tools/stockByMaterial.js';
+import { findEmptyBins } from './tools/emptyBins.js';
+import { getBinUtilization } from './tools/binUtilization.js';
+import { createTransferOrder } from './tools/createTransferOrder.js';
+import { confirmTransferOrder } from './tools/confirmTransferOrder.js';
+import { confirmTransferOrderSU } from './tools/confirmTransferOrderSU.js';
+
+const server = new McpServer({ name: 'sap-wm-mcp', version: '0.1.0' });
+
+// Tool 1 — get_bin_status
+server.tool(
+  'get_bin_status',
+  'Query classic WM storage bins from S/4HANA by warehouse, storage type, or specific bin — returns empty/blocked status and capacity',
+  {
+    warehouse: z.string().describe('Warehouse number e.g. 102'),
+    storageType: z.string().optional().describe('Storage type e.g. 001'),
+    bin: z.string().optional().describe('Specific bin number e.g. 01-01-01'),
+    top: z.number().optional().default(20).describe('Max records to return')
+  },
+  async (params) => {
+    try {
+      const result = await getBinStatus(params);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// Tool 2 — get_stock_for_material
+server.tool(
+  'get_stock_for_material',
+  'Get physical warehouse stock for a material in classic WM — shows which bins hold the material and how much',
+  {
+    warehouse: z.string().describe('Warehouse number e.g. 102'),
+    material: z.string().optional().describe('Material number e.g. TG0001'),
+    storageType: z.string().optional().describe('Filter by storage type'),
+    top: z.number().optional().default(20).describe('Max records to return')
+  },
+  async (params) => {
+    try {
+      const result = await getStockForMaterial(params);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// Tool 3 — find_empty_bins
+server.tool(
+  'find_empty_bins',
+  'Find all empty storage bins in a classic WM warehouse, optionally filtered by storage type',
+  {
+    warehouse: z.string().describe('Warehouse number e.g. 102'),
+    storageType: z.string().optional().describe('Storage type to filter e.g. 001'),
+    top: z.number().optional().default(50).describe('Max records to return')
+  },
+  async (params) => {
+    try {
+      const result = await findEmptyBins(params);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// Tool 4 — get_bin_utilization
+server.tool(
+  'get_bin_utilization',
+  'Get warehouse bin utilization stats for classic WM — occupied vs empty vs blocked, grouped by storage type',
+  {
+    warehouse: z.string().describe('Warehouse number e.g. 102'),
+    storageType: z.string().optional().describe('Filter by storage type'),
+    top: z.number().optional().default(100).describe('Max bins to analyze')
+  },
+  async (params) => {
+    try {
+      const result = await getBinUtilization(params);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// Tool 5 — create_transfer_order
+server.tool(
+  'create_transfer_order',
+  'Create a classic WM Transfer Order in S/4HANA — moves stock from source bin to destination bin via L_TO_CREATE_SINGLE',
+  {
+    warehouse:      z.string().describe('Warehouse number e.g. 102'),
+    movementType:   z.string().describe('WM movement type e.g. 999'),
+    material:       z.string().describe('Material number e.g. TG0001'),
+    plant:          z.string().describe('Plant e.g. 1710'),
+    quantity:       z.number().describe('Quantity to move'),
+    unitOfMeasure:  z.string().describe('Unit of measure e.g. ST, KG'),
+    sourceType:         z.string().optional().default('').describe('Source storage type e.g. 001'),
+    sourceBin:          z.string().optional().default('').describe('Source bin e.g. 01-02-01'),
+    sourceStorageUnit:  z.string().optional().default('').describe('Source storage unit (LENUM) — required for SU-managed types e.g. 00000000001000000017'),
+    destType:           z.string().describe('Destination storage type e.g. 001'),
+    destBin:            z.string().describe('Destination bin e.g. 01-06-03'),
+    destStorageUnit:    z.string().optional().default('').describe('Destination storage unit (LENUM) — for SU-managed types, same as source SU when moving full SU')
+  },
+  async (params) => {
+    try {
+      const result = await createTransferOrder(params);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// Tool 6 — confirm_transfer_order
+server.tool(
+  'confirm_transfer_order',
+  'Confirm a classic WM Transfer Order in S/4HANA — marks the TO as executed via L_TO_CONFIRM',
+  {
+    warehouse:           z.string().describe('Warehouse number e.g. 102'),
+    transferOrderNumber: z.string().describe('Transfer order number e.g. 0000000123')
+  },
+  async (params) => {
+    try {
+      const result = await confirmTransferOrder(params);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+// Tool 7 — confirm_transfer_order_su
+server.tool(
+  'confirm_transfer_order_su',
+  'Confirm all open transfer orders on a classic WM storage unit — uses L_TO_CONFIRM_SU to confirm by SU number instead of individual TO number',
+  {
+    warehouse:   z.string().describe('Warehouse number e.g. 102'),
+    storageUnit: z.string().describe('Storage unit number (LENUM) e.g. 000000001234567890')
+  },
+  async (params) => {
+    try {
+      const result = await confirmTransferOrderSU(params);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+console.error('SAP WM MCP Server running (stdio)...');

package/lib/s4hClient.js

@@ -0,0 +1,68 @@
+import fetch from 'node-fetch';
+import https from 'https';
+import 'dotenv/config';
+
+const agent = new https.Agent({ rejectUnauthorized: false });
+const BASE_URL = process.env.SAP_URL;
+const AUTH = Buffer.from(`${process.env.SAP_USER}:${process.env.SAP_PASSWORD}`).toString('base64');
+const CLIENT = process.env.SAP_CLIENT;
+
+export async function s4hGet(path) {
+  const url = `${BASE_URL}${path}`;
+  const response = await fetch(url, {
+    headers: {
+      'Authorization': `Basic ${AUTH}`,
+      'Accept': 'application/json',
+      'sap-client': CLIENT
+    },
+    agent
+  });
+  if (!response.ok) {
+    throw new Error(`S4H OData error ${response.status}: ${await response.text()}`);
+  }
+  return response.json();
+}
+
+export async function s4hPost(path, body) {
+  const BASE_PATH = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001/`;
+
+  // Fetch CSRF token
+  const tokenRes = await fetch(`${BASE_URL}${BASE_PATH}`, {
+    method: 'GET',
+    headers: {
+      'Authorization': `Basic ${AUTH}`,
+      'x-csrf-token': 'fetch',
+      'sap-client': CLIENT
+    },
+    agent
+  });
+  const csrfToken = tokenRes.headers.get('x-csrf-token');
+  if (!csrfToken) throw new Error('CSRF token fetch failed — no token in response headers');
+
+  // Forward session cookie so the token remains valid for this POST
+  const cookies = tokenRes.headers.raw?.()['set-cookie'] ?? tokenRes.headers.get('set-cookie');
+  const cookieHeader = Array.isArray(cookies)
+    ? cookies.map(c => c.split(';')[0]).join('; ')
+    : (cookies ?? '').split(',').map(c => c.trim().split(';')[0]).join('; ');
+
+  const url = `${BASE_URL}${path}`;
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Basic ${AUTH}`,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'x-csrf-token': csrfToken,
+      'sap-client': CLIENT,
+      ...(cookieHeader ? { 'Cookie': cookieHeader } : {})
+    },
+    body: JSON.stringify(body),
+    agent
+  });
+  if (!response.ok) {
+    throw new Error(`S4H OData POST error ${response.status}: ${await response.text()}`);
+  }
+  // 204 No Content is valid for some actions
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "sap-wm-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for SAP Classic Warehouse Management — connects AI agents to S/4HANA WM via a custom RAP OData V4 service. For systems where EWM is not active.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "sap-wm-mcp": "index.js"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "tools/"
+  ],
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "sap",
+    "wm",
+    "warehouse-management",
+    "mcp",
+    "model-context-protocol",
+    "s4hana",
+    "warehouse",
+    "odata",
+    "rap",
+    "claude",
+    "ai-agents"
+  ],
+  "author": "Noman Mohamed Hanif <noman@relacon.de> (https://github.com/CodeOfHANA)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CodeOfHANA/sap-wm-mcp.git"
+  },
+  "homepage": "https://github.com/CodeOfHANA/sap-wm-mcp#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "dotenv": "^16.6.1",
+    "node-fetch": "^3.3.2",
+    "zod": "^3.25.76"
+  }
+}

package/tools/binStatus.js

@@ -0,0 +1,35 @@
+import { s4hGet } from '../lib/s4hClient.js';
+
+const BASE = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001/WMStorageBin`;
+
+export async function getBinStatus({ warehouse, storageType, bin, top = 20 }) {
+  const filters = [`WarehouseNumber eq '${warehouse}'`];
+  if (storageType) filters.push(`StorageType eq '${storageType}'`);
+  if (bin) filters.push(`StorageBin eq '${bin}'`);
+
+  const path = `${BASE}?$filter=${encodeURIComponent(filters.join(' and '))}&$top=${top}`;
+  const data = await s4hGet(path);
+
+  return {
+    count: data.value.length,
+    warehouse,
+    bins: data.value.map(b => ({
+      bin: b.StorageBin,
+      storageType: b.StorageType,
+      storageSection: b.StorageSection,
+      binType: b.StorageBinType,
+      empty: b.IsEmpty,
+      full: b.IsFull,
+      blockedPutaway: b.PutawayBlock,
+      blockedRemoval: b.RemovalBlock,
+      quants: b.NumberOfQuants,
+      maxWeight: b.MaximumWeight,
+      occupiedWeight: b.OccupiedWeight,
+      weightUnit: b.WeightUnit,
+      totalCapacity: b.TotalCapacity,
+      remainingCapacity: b.RemainingCapacity,
+      lastMovement: b.LastMovementDate,
+      dynamic: b.IsDynamicBin
+    }))
+  };
+}

package/tools/binUtilization.js

@@ -0,0 +1,48 @@
+import { s4hGet } from '../lib/s4hClient.js';
+
+const BASE = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001/WMStorageBin`;
+
+export async function getBinUtilization({ warehouse, storageType, top = 100 }) {
+  const filters = [`WarehouseNumber eq '${warehouse}'`];
+  if (storageType) filters.push(`StorageType eq '${storageType}'`);
+
+  const path = `${BASE}?$filter=${encodeURIComponent(filters.join(' and '))}&$top=${top}`;
+  const data = await s4hGet(path);
+
+  const bins = data.value;
+  const total = bins.length;
+  const empty = bins.filter(b => b.IsEmpty).length;
+  const full = bins.filter(b => b.IsFull).length;
+  const occupied = total - empty;
+  const blockedPutaway = bins.filter(b => b.PutawayBlock).length;
+  const blockedRemoval = bins.filter(b => b.RemovalBlock).length;
+
+  // Group by storage type
+  const byType = {};
+  for (const b of bins) {
+    const t = b.StorageType;
+    if (!byType[t]) byType[t] = { total: 0, empty: 0, occupied: 0 };
+    byType[t].total++;
+    if (b.IsEmpty) byType[t].empty++;
+    else byType[t].occupied++;
+  }
+
+  return {
+    warehouse,
+    storageType: storageType ?? 'all',
+    summary: {
+      totalBins: total,
+      emptyBins: empty,
+      occupiedBins: occupied,
+      fullBins: full,
+      blockedForPutaway: blockedPutaway,
+      blockedForRemoval: blockedRemoval,
+      utilizationPct: total > 0 ? Math.round((occupied / total) * 100) : 0
+    },
+    byStorageType: Object.entries(byType).map(([type, stats]) => ({
+      storageType: type,
+      ...stats,
+      utilizationPct: stats.total > 0 ? Math.round((stats.occupied / stats.total) * 100) : 0
+    }))
+  };
+}

package/tools/confirmTransferOrder.js

@@ -0,0 +1,18 @@
+import { s4hPost } from '../lib/s4hClient.js';
+
+const BASE = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001`;
+const NS   = `com.sap.gateway.srvd.zsd_wmmcpservice.v0001`;
+
+export async function confirmTransferOrder({ warehouse, transferOrderNumber }) {
+  // Instance action — key goes in the URL path, not the body
+  const path = `${BASE}/WMTransferOrder(WarehouseNumber='${encodeURIComponent(warehouse)}',TransferOrderNumber='${encodeURIComponent(transferOrderNumber)}')/${NS}.ConfirmTransferOrder`;
+
+  const data = await s4hPost(path, {});
+
+  return {
+    success: true,
+    warehouse,
+    transferOrderNumber,
+    raw: data
+  };
+}

package/tools/confirmTransferOrderSU.js

@@ -0,0 +1,23 @@
+import { s4hPost } from '../lib/s4hClient.js';
+
+const BASE = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001`;
+const NS   = `com.sap.gateway.srvd.zsd_wmmcpservice.v0001`;
+
+export async function confirmTransferOrderSU({ warehouse, storageUnit }) {
+  // Static action — called on the entity set (collection-bound)
+  const path = `${BASE}/WMTransferOrder/${NS}.ConfirmTransferOrderSU`;
+
+  const body = {
+    StorageUnit: storageUnit
+  };
+
+  const data = await s4hPost(path, body);
+
+  return {
+    success: true,
+    warehouse,
+    storageUnit,
+    transferOrderNumber: data?.value?.[0]?.TransferOrderNumber ?? data?.TransferOrderNumber ?? null,
+    raw: data
+  };
+}

package/tools/createTransferOrder.js

@@ -0,0 +1,46 @@
+import { s4hPost, s4hGet } from '../lib/s4hClient.js';
+
+const BASE = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001`;
+const NS   = `com.sap.gateway.srvd.zsd_wmmcpservice.v0001`;
+
+export async function createTransferOrder({
+  warehouse, movementType, material, plant,
+  quantity, unitOfMeasure,
+  sourceType = '', sourceBin = '', sourceStorageUnit = '',
+  destType, destBin, destStorageUnit = ''
+}) {
+  const path = `${BASE}/WMTransferOrder/${NS}.CreateTransferOrder`;
+
+  const body = {
+    WarehouseNumber:   warehouse,
+    MovementType:      movementType,
+    Material:          material,
+    Plant:             plant,
+    Quantity:          quantity,
+    UnitOfMeasure:     unitOfMeasure,
+    SourceStorageType: sourceType,
+    SourceBin:         sourceBin,
+    SourceStorageUnit: sourceStorageUnit,
+    DestStorageType:   destType,
+    DestBin:           destBin,
+    DestStorageUnit:   destStorageUnit
+  };
+
+  const data = await s4hPost(path, body);
+
+  // RAP static action result does not carry entity fields back — query the latest TO
+  let transferOrderNumber = data?.value?.[0]?.TransferOrderNumber ?? data?.TransferOrderNumber ?? null;
+  if (!transferOrderNumber) {
+    const latest = await s4hGet(
+      `${BASE}/WMTransferOrder?$orderby=TransferOrderNumber%20desc&$top=1`
+    );
+    transferOrderNumber = latest?.value?.[0]?.TransferOrderNumber ?? null;
+  }
+
+  return {
+    success: true,
+    warehouse,
+    transferOrderNumber,
+    raw: data
+  };
+}

package/tools/emptyBins.js

@@ -0,0 +1,30 @@
+import { s4hGet } from '../lib/s4hClient.js';
+
+const BASE = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001/WMStorageBin`;
+
+export async function findEmptyBins({ warehouse, storageType, top = 50 }) {
+  const filters = [
+    `WarehouseNumber eq '${warehouse}'`,
+    `IsEmpty eq true`
+  ];
+  if (storageType) filters.push(`StorageType eq '${storageType}'`);
+
+  const path = `${BASE}?$filter=${encodeURIComponent(filters.join(' and '))}&$top=${top}`;
+  const data = await s4hGet(path);
+
+  return {
+    count: data.value.length,
+    warehouse,
+    storageType: storageType ?? 'all',
+    emptyBins: data.value.map(b => ({
+      bin: b.StorageBin,
+      storageType: b.StorageType,
+      storageSection: b.StorageSection,
+      binType: b.StorageBinType,
+      blockedPutaway: b.PutawayBlock,
+      blockedRemoval: b.RemovalBlock,
+      remainingCapacity: b.RemainingCapacity,
+      lastMovement: b.LastMovementDate
+    }))
+  };
+}

package/tools/stockByMaterial.js

@@ -0,0 +1,33 @@
+import { s4hGet } from '../lib/s4hClient.js';
+
+const BASE = `/sap/opu/odata4/iwbep/all/srvd/sap/zsd_wmmcpservice/0001/WMWarehouseStock`;
+
+export async function getStockForMaterial({ warehouse, material, storageType, top = 20 }) {
+  const filters = [`WarehouseNumber eq '${warehouse}'`];
+  if (material) filters.push(`Material eq '${material}'`);
+  if (storageType) filters.push(`StorageType eq '${storageType}'`);
+
+  const path = `${BASE}?$filter=${encodeURIComponent(filters.join(' and '))}&$top=${top}`;
+  const data = await s4hGet(path);
+
+  return {
+    count: data.value.length,
+    warehouse,
+    material: material ?? 'all',
+    stock: data.value.map(q => ({
+      bin: q.StorageBin,
+      storageType: q.StorageType,
+      quantNumber: q.QuantNumber,
+      material: q.Material,
+      plant: q.Plant,
+      batch: q.Batch,
+      totalStock: q.TotalStock,
+      availableStock: q.AvailableStock,
+      pickQuantity: q.PickQuantity,
+      transferQuantity: q.TransferQuantity,
+      uom: q.UnitOfMeasure,
+      stockCategory: q.StockCategory,
+      lastMovement: q.LastMovementDate
+    }))
+  };
+}