AI + ERP from the Linux shell: practical integrations you can ship this week

If you’ve ever stared at your ERP’s export button and thought, “There’s gold in here, if only I could make sense of it,” you’re not alone. ERPs centralize orders, invoices, inventory, and support notes—but surfacing patterns, forecasts, and classifications is still mostly manual. Artificial Intelligence closes that gap. And the best part: you don’t need to wait for a monolithic ERP upgrade. A few well-placed Bash scripts and API calls can graft AI capabilities onto your existing ERP today.

This post walks you through why AI+ERP is worth doing, what to watch for, and a hands-on path to deliver value quickly using standard Linux tools. You’ll get runnable Bash snippets, package installation commands, and a small, production-friendly pipeline you can extend.

Why AI + ERP is a real (and urgent) opportunity

• It automates repetitive, judgment-heavy tasks. Things like invoice categorization, PO routing, and ticket triage rely on reading text and applying policy. AI models excel here.

• It improves forecasting in the messy middle. Historical demand, seasonality, and sparse signals often live in your ERP. AI can forecast or highlight anomalies without months of BI work.

• It’s incremental. You can wrap AI around one workflow (e.g., “auto-categorize new invoices”) without changing your ERP core.

• Linux is the perfect glue. Cron/systemd for scheduling, curl/jq for APIs, and standard logging make small, reliable AI jobs straightforward.

What we’ll build (at a glance)

We’ll create a simple, safe pipeline: 1) Extract open invoices from your ERP via API. 2) Classify each invoice into categories using an AI endpoint. 3) Write the category back to the ERP. 4) Schedule and monitor the job with systemd timers.

Swap “invoices” for “tickets” or “orders” and you’ll reuse 90% of this.

Prerequisites: install the basics

We’ll use curl and jq for HTTP and JSON. Optional: Python is handy if you later add local models or more complex transforms.

• Debian/Ubuntu (apt):

sudo apt update
sudo apt install -y curl jq python3 python3-pip sqlite3

• Fedora/RHEL/CentOS (dnf):

sudo dnf install -y curl jq python3 python3-pip sqlite

• openSUSE (zypper):

sudo zypper refresh
sudo zypper install -y curl jq python3 python3-pip sqlite3

Note: We’ll demonstrate a remote AI inference API to keep things lightweight. If you prefer on-prem inference, you can swap the AI call for a local service without changing the shell structure.

Actionable step 1: choose a small, high-ROI use case

Pick one of these patterns that matches your data and pain:

• Invoice or PO categorization: Map descriptions to categories like hardware, software, services, office-supplies.

• Ticket triage: Assign priority or route to a team based on summary text.

• Vendor anomaly flags: Highlight invoices that deviate materially from prior purchases.

• Demand hints: Generate a weekly note that pairs simple stats (moving averages) with a short AI rationale for planners.

Document:

• Where the source data comes from (API path or table).

• The decision you want (e.g., category).

• Where the result should be written back (field/endpoint).

Actionable step 2: set environment and secrets

Store your ERP and AI tokens in a root-readable file. Example /etc/erp-ai.env:

ERP_BASE_URL="https://erp.example.com"
ERP_TOKEN="paste-erp-api-token-here"
HF_TOKEN="paste-huggingface-token-here"   # or your chosen AI provider token

Secure it:

sudo sh -c 'printf "%s\n" \
  ERP_BASE_URL="https://erp.example.com" \
  ERP_TOKEN="REDACTED" \
  HF_TOKEN="REDACTED" > /etc/erp-ai.env'
sudo chmod 600 /etc/erp-ai.env

Tip: For production, use your secret manager of choice. Environment files are okay for small internal jobs, but treat them like credentials.

Actionable step 3: extract records from your ERP

Most ERPs expose REST/JSON or OData. Replace the path with your system’s endpoint.

Create /usr/local/bin/erp_extract.sh:

#!/usr/bin/env bash
set -euo pipefail

: "${ERP_BASE_URL:?Missing ERP_BASE_URL}"
: "${ERP_TOKEN:?Missing ERP_TOKEN}"

# Example: fetch up to 100 open invoices
curl -sS -G "${ERP_BASE_URL}/api/invoices" \
  -H "Authorization: Bearer ${ERP_TOKEN}" \
  --data-urlencode "status=open" \
  --data-urlencode "limit=100"

Make it executable:

sudo install -m 0755 erp_extract.sh /usr/local/bin/erp_extract.sh

Test:

source /etc/erp-ai.env
/usr/local/bin/erp_extract.sh | jq .

If your ERP is DB-only, you can extract to JSON using sqlite3 or psql. Example with sqlite3:

sqlite3 -json /path/to/erp.db 'select id, vendor, description, total from invoices where status="open" limit 100;'

Actionable step 4: add an AI call via HTTP

We’ll use Hugging Face Inference API as an example for zero-shot classification with the “facebook/bart-large-mnli” model. You can substitute any HTTP AI endpoint with a compatible payload.

Create /usr/local/bin/ai_classify.sh:

#!/usr/bin/env bash
set -euo pipefail

: "${HF_TOKEN:?Missing HF_TOKEN}"

TEXT="${1:?Provide text to classify}"

# Candidate categories you want AI to choose among
CATEGORIES='["hardware","software","office-supplies","services","other"]'

# Build JSON payload safely with jq to avoid escaping issues
PAYLOAD=$(jq -n --arg text "$TEXT" --argjson labels "$CATEGORIES" \
  '{inputs:$text, parameters:{candidate_labels:$labels}}')

# Call the inference API with retries (cold starts can 503)
RESP=$(curl -sS --max-time 30 --retry 5 --retry-all-errors \
  -H "Authorization: Bearer ${HF_TOKEN}" \
  -H "Content-Type: application/json" \
  -X POST "https://api-inference.huggingface.co/models/facebook/bart-large-mnli" \
  -d "$PAYLOAD")

# Emit the top predicted label
echo "$RESP" | jq -r '.labels[0]'

Make it executable:

sudo install -m 0755 ai_classify.sh /usr/local/bin/ai_classify.sh

Quick smoke test:

source /etc/erp-ai.env
/usr/local/bin/ai_classify.sh "Purchase of 10 Lenovo T14 laptops with docking stations"
# Expect: hardware (or similar)

Actionable step 5: wire the end-to-end pipeline

Create /usr/local/bin/erp_ai_pipeline.sh:

#!/usr/bin/env bash
set -euo pipefail

: "${ERP_BASE_URL:?Missing ERP_BASE_URL}"
: "${ERP_TOKEN:?Missing ERP_TOKEN}"

EXTRACT_JSON="$(/usr/local/bin/erp_extract.sh)"

# Adjust the path to match your ERP's response, e.g. .items, .data, or root array
# Here we assume the response is { "invoices": [ {id, description, ...}, ... ] }
echo "$EXTRACT_JSON" | jq -c '.invoices[]' | while IFS= read -r row; do
  id=$(jq -r '.id' <<< "$row")
  desc=$(jq -r '.description' <<< "$row")
  vendor=$(jq -r '.vendor // ""' <<< "$row")
  total=$(jq -r '.total // ""' <<< "$row")

  text="Vendor: ${vendor}. Description: ${desc}. Amount: ${total}."
  category=$(/usr/local/bin/ai_classify.sh "$text")

  # Write back category to ERP; adjust path/field as needed
  update_payload=$(jq -n --arg category "$category" '{category: $category}')

  curl -sS -X PATCH "${ERP_BASE_URL}/api/invoices/${id}" \
    -H "Authorization: Bearer ${ERP_TOKEN}" \
    -H "Content-Type: application/json" \
    -d "$update_payload" >/dev/null

  printf "Invoice %s -> %s\n" "$id" "$category" >&2
  sleep 0.3 # gentle rate limiting
done

Make it executable:

sudo install -m 0755 erp_ai_pipeline.sh /usr/local/bin/erp_ai_pipeline.sh

Test end-to-end:

source /etc/erp-ai.env
/usr/local/bin/erp_ai_pipeline.sh

If your ERP requires a POST to a separate classification endpoint or a different field name, tweak the PATCH URL and JSON body accordingly. For OData services, this may be a PATCH to .../Invoices({id}).

Productionizing: schedule, secure, observe

• Principle of least privilege:

  • Create a dedicated service user:

  sudo useradd --system --no-create-home --shell /usr/sbin/nologin erpbot || true
  sudo chown root:root /etc/erp-ai.env
  sudo chmod 600 /etc/erp-ai.env
  

  • Ensure scripts are root-owned and not writable by others.

• systemd unit: Create /etc/systemd/system/erp-ai.service:

  [Unit]
  Description=ERP AI Categorization Pipeline
  After=network-online.target
  Wants=network-online.target
  
  [Service]
  Type=oneshot
  User=erpbot
  EnvironmentFile=/etc/erp-ai.env
  ExecStart=/usr/local/bin/erp_ai_pipeline.sh
  Nice=10
  ProtectSystem=full
  ProtectHome=true
  NoNewPrivileges=true
  
  [Install]
  WantedBy=multi-user.target
  

• systemd timer (daily at 02:15): Create /etc/systemd/system/erp-ai.timer:

  [Unit]
  Description=Run ERP AI pipeline nightly
  
  [Timer]
  OnCalendar=*-*-* 02:15:00
  Persistent=true
  AccuracySec=1m
  
  [Install]
  WantedBy=timers.target
  

Enable and start:

sudo systemctl daemon-reload
sudo systemctl enable --now erp-ai.timer
sudo systemctl list-timers | grep erp-ai

• Logging:

  • Use journalctl to review runs:

  journalctl -u erp-ai.service --since today
  

  • For file logs, wrap ExecStart in a tiny logger script that tees to /var/log/erp-ai.log and rotates with logrotate.

• Back-pressure and retries:

  • We used curl’s --retry for the AI call; you can add similar flags to ERP calls.
  • If your ERP enforces strict rate limits, implement a token bucket (sleep) or batch by 20–50 records per run.

Real-world patterns you can implement next

• Ticket triage: Replace invoices with tickets. Extract subject/body; ask a classification model for priority and team. Write back priority = High|Medium|Low and routing = TeamA|TeamB.

• Anomaly hints: For each vendor/month, compute a simple z-score for amount using jq or a quick awk/Python helper. If flagged, call AI to produce a short “explain-like-I’m-five” note for the approver and post it as a comment.

• Demand notes: Roll a 4-week moving average for each SKU and ask AI for a one-sentence risk summary. Store it in a “planner_notes” field. No heavy ML required to start seeing value.

Governance and safety checklist

• Data minimization: Send only the fields AI needs. Avoid PII unless your contract and policy allow it.

• Redaction: Mask account numbers and emails before sending to third-party AI endpoints.

• Determinism vs. creativity: For classification, prefer deterministic models and strict categories. For summaries, allow more freedom.

• Human-in-the-loop: Start with “suggested category,” require approval, then automate once confidence is consistently high.

Optional: working locally (no external AI)

If you must keep everything on-prem, point ai_classify.sh to your internal model gateway (e.g., a containerized service behind Nginx) and keep the JSON contract the same. Your pipeline logic won’t change.

Wrap-up and next step

You don’t need a massive project to bring AI into your ERP. With a few shell scripts, jq, and a reliable AI endpoint, you can:

• Extract the right records,

• Enrich them with intelligent decisions,

• And write the results back into your ERP—on a schedule, with logs, and with guardrails.

Your next step:

• Ship one narrow workflow (invoice categorization is ideal).

• Measure impact (time saved, accuracy vs. manual).

• Iterate with a second workflow (ticket triage or anomaly flags).

Have a different ERP or data shape? Paste a sample of your JSON response (with sensitive fields removed), and I’ll help you adapt the extract/AI/update scripts.