Artificial Intelligence Bash Projects for Enterprise Linux

If you run Linux in the enterprise, your terminal is already your command center. Now imagine that same terminal quietly triaging logs, answering runbook questions, reviewing scripts, and drafting safe SQL—all on demand. That’s the value of adding a small, auditable layer of AI to your Bash toolkit: reduced toil, faster incident response, and consistent outcomes without introducing heavyweight platforms.

This article shows why AI-in-Bash is a practical choice for Enterprise Linux and walks you through 4 real, production-ready examples—with installation steps for apt, dnf, and zypper wherever relevant.

---

Why AI + Bash is a smart fit for Enterprise Linux

• Control and auditability: Bash scripts are plain text, version-controlled, and easy to audit. Perfect for change control and regulated environments.

• Composable: AI is just an API or local HTTP endpoint. cURL + jq + your policies = repeatable, testable workflows.

• Choice of backend: Use a cloud model when appropriate; fall back to a local LLM (Ollama) for sensitive data or air-gapped sites.

• Simple ops integration: Works with cron, systemd timers, and your existing monitoring and alerting.

• Cost and performance: Use small, fast models for routine tasks; scale up only when necessary.

---

Prerequisites and installation

These projects rely on standard CLI tools. Install them per your distro:

• Tools: curl, jq, ripgrep (rg), ShellCheck, git, sqlite3

Debian/Ubuntu (apt):

sudo apt update
sudo apt install -y curl jq ripgrep shellcheck git sqlite3

RHEL/Fedora/AlmaLinux/Rocky (dnf):

• On RHEL/CentOS/Alma/Rocky, enable EPEL for ripgrep and ShellCheck:

sudo dnf install -y epel-release

• Then install tools:

sudo dnf install -y curl jq ripgrep ShellCheck git sqlite

openSUSE/SLES (zypper):

sudo zypper refresh
sudo zypper install -y curl jq ripgrep ShellCheck git sqlite3

Choose an AI backend

You can use either a cloud API (OpenAI example) or a local model (Ollama).

Option A — Cloud (OpenAI):

• Set your API key securely:

export OPENAI_API_KEY="sk-..."

• Quick test:

curl -s https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role":"user","content":"Say hello from Bash"}],
    "temperature": 0.2
  }' | jq -r '.choices[0].message.content'

Option B — Local (Ollama):

• Install Ollama (not typically in apt/dnf/zypper):

curl -fsSL https://ollama.com/install.sh | sh

• Start the service and pull a model:

sudo systemctl enable --now ollama
ollama pull llama3

• Quick test:

curl -s http://localhost:11434/api/generate \
  -d '{"model":"llama3","prompt":"Say hello from Bash","stream":false}' \
  | jq -r '.response'

Security tip: Store API keys in a root-readable file and load via /etc/profile.d or systemd EnvironmentFile with proper permissions (chmod 600).

---

Reusable AI helper for scripts

Drop this in ai_helpers.sh and source it from the examples below.

#!/usr/bin/env bash
# ai_helpers.sh
set -euo pipefail

: "${AI_BACKEND:=openai}"        # or: ollama
: "${OPENAI_MODEL:=gpt-4o-mini}" # lightweight, economical default
: "${OLLAMA_MODEL:=llama3}"

ai_chat() {
  # Usage: ai_chat "your prompt"
  local prompt="${1:-}"
  if [[ -z "$prompt" ]]; then
    echo "ai_chat: empty prompt" >&2
    return 1
  fi

  case "$AI_BACKEND" in
    openai)
      if [[ -z "${OPENAI_API_KEY:-}" ]]; then
        echo "OPENAI_API_KEY is not set" >&2
        return 1
      fi
      curl -sS https://api.openai.com/v1/chat/completions \
        -H "Authorization: Bearer ${OPENAI_API_KEY}" \
        -H "Content-Type: application/json" \
        -d "$(jq -cn --arg p "$prompt" --arg m "$OPENAI_MODEL" '{
              model: $m,
              temperature: 0.2,
              messages: [
                {role:"system",content:"You are a concise Linux/SRE assistant."},
                {role:"user",content:$p}
              ]
            }')" \
        | jq -r '.choices[0].message.content'
      ;;
    ollama)
      curl -sS http://localhost:11434/api/generate \
        -d "$(jq -cn --arg p "$prompt" --arg m "$OLLAMA_MODEL" '{
              model: $m,
              prompt: $p,
              stream: false
            }')" \
        | jq -r '.response'
      ;;
    *)
      echo "Unsupported AI_BACKEND: $AI_BACKEND" >&2
      return 1
      ;;
  esac
}

Use it in your shell:

source ./ai_helpers.sh
AI_BACKEND=ollama ai_chat "Summarize tail -n 100 /var/log/syslog best practices."

---

Project 1: AI-augmented log triage

Problem: On-call engineers drown in noisy logs. We want a quick, consistent summary plus probable root causes and next steps.

Script: ai-summarize-logs.sh

#!/usr/bin/env bash
set -euo pipefail
source "$(dirname "$0")/ai_helpers.sh"

LOG_FILE="${1:-/var/log/messages}"
LINES="${LINES:-2000}"   # override: LINES=5000 ./ai-summarize-logs.sh /path/to/log
SERVICE_HINT="${SERVICE_HINT:-}" # optional: a service or component name

if [[ ! -r "$LOG_FILE" ]]; then
  echo "Cannot read $LOG_FILE" >&2
  exit 1
fi

# Pre-aggregate to keep token usage low
SNIP="$(tail -n "$LINES" "$LOG_FILE" \
  | sed -E 's/[0-9]{2,4}[-/: ][0-9]{2}[-/: ][0-9]{2}([ T][0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?(Z)?)?//g' \
  | sed -E 's/[0-9a-fA-F]{8,}/<HEX>/g' \
  | awk '{print tolower($0)}' \
  | sort | uniq -c | sort -nr | head -n 50)"

read -r -d '' PROMPT <<'EOF' || true
You are assisting an SRE with log triage. From the aggregated lines below
(top frequency first), produce:

- Top 5 themes (with brief explanation)

- Probable root causes

- Concrete next actions (commands with flags if applicable)

- Any safety or rollback considerations
Keep it concise, bullet-pointed, and actionable.
EOF

if [[ -n "$SERVICE_HINT" ]]; then
  PROMPT+="\nService hint: ${SERVICE_HINT}"
fi
PROMPT+="\n\nAggregated log lines (count + message):\n${SNIP}\n"

ai_chat "$PROMPT"

Run it:

AI_BACKEND=openai OPENAI_API_KEY=... ./ai-summarize-logs.sh /var/log/syslog
# or local:
AI_BACKEND=ollama ./ai-summarize-logs.sh /var/log/messages

Cron idea:

# Summarize kubelet logs hourly and mail to SREs
0 * * * * AI_BACKEND=ollama /opt/ai/ai-summarize-logs.sh /var/log/kubelet/kubelet.log | mail -s "Kubelet summary" sre@yourco

---

Project 2: Runbook Q&A from the terminal

Problem: You’ve got great runbooks, but searching and stitching steps together takes time.

Script ai-runbook.sh finds relevant snippets with ripgrep and asks the model to produce a concise, sourced answer.

#!/usr/bin/env bash
set -euo pipefail
source "$(dirname "$0")/ai_helpers.sh"

RUNBOOK_DIR="${RUNBOOK_DIR:-/srv/runbooks}" # Markdown, txt, etc.
QUERY="${*:-}"
if [[ -z "$QUERY" ]]; then
  echo "Usage: $0 \"How do I rotate TLS certs for service X?\"" >&2
  exit 1
fi

# Find top matches and collect snippets
RESULTS="$(rg --ignore-case --json --max-count=5 --no-heading --line-number --sortrank "$QUERY" "$RUNBOOK_DIR" | jq -r '
  select(.type=="match") | .data | "\(.path):\(.lines.text)"' \
  | head -n 20 )"

if [[ -z "$RESULTS" ]]; then
  echo "No runbook hits. Try broadening your query." >&2
  exit 2
fi

read -r -d '' PROMPT <<EOF || true
You are a reliability engineer assistant. Answer the user's question using the
provided runbook excerpts only. If unsure, say so. Include explicit shell
commands and name any files to edit. Cite file paths you used at the end.

Question:
$QUERY

Runbook excerpts:
$RESULTS
EOF

ai_chat "$PROMPT"

Run it:

RUNBOOK_DIR=/srv/runbooks AI_BACKEND=ollama ./ai-runbook.sh "restart procedure for payments-api"

Tip: Keep runbooks clean and up-to-date—AI can’t fix stale docs.

---

Project 3: AI-assisted ShellCheck review

Problem: ShellCheck is great for linting, but humans still need to interpret and improve. Let the model propose focused refactors, security hardening, and POSIX notes—backed by ShellCheck diagnostics.

Install ShellCheck if you haven’t yet:

• apt: sudo apt install -y shellcheck

• dnf: sudo dnf install -y epel-release && sudo dnf install -y ShellCheck

• zypper: sudo zypper install -y ShellCheck

Script ai-shellcheck-review.sh:

#!/usr/bin/env bash
set -euo pipefail
source "$(dirname "$0")/ai_helpers.sh"

TARGET="${1:-}"
if [[ -z "$TARGET" || ! -f "$TARGET" ]]; then
  echo "Usage: $0 path/to/script.sh" >&2
  exit 1
fi

SC_OUT="$(shellcheck -S style -f gcc "$TARGET" || true)"
CODE="$(sed -n '1,200p' "$TARGET")" # limit size for tokens

read -r -d '' PROMPT <<EOF || true
You are reviewing a Bash script for correctness, security, and maintainability.
Given the ShellCheck diagnostics and the code, produce:

- Top risks (command injection, unsafe word-splitting, globbing)

- Concrete diffs or line-by-line fixes

- Modern best practices (set -euo pipefail, traps, quoting)

- One concise, improved version of critical functions if needed

ShellCheck diagnostics:
$SC_OUT

Script (first 200 lines):
$CODE
EOF

ai_chat "$PROMPT"

Run it:

AI_BACKEND=openai OPENAI_API_KEY=... ./ai-shellcheck-review.sh ./deploy.sh

Remember: Don’t auto-apply changes in production without code review.

---

Project 4: Natural-language to SQL (SQLite edition)

Problem: Analysts ask natural-language questions; engineers translate them to SQL. Speed this up safely by keeping a human in the loop and scoping access to a staging SQLite database.

Install SQLite:

• apt: sudo apt install -y sqlite3

• dnf: sudo dnf install -y sqlite

• zypper: sudo zypper install -y sqlite3

Script nl2sql-sqlite.sh:

#!/usr/bin/env bash
set -euo pipefail
source "$(dirname "$0")/ai_helpers.sh"

DB="${1:-./staging.db}"
shift || true
QUESTION="${*:-}"

if [[ -z "$QUESTION" ]]; then
  echo "Usage: $0 path/to.db \"Which 5 customers spent the most last month?\"" >&2
  exit 1
fi
if [[ ! -f "$DB" ]]; then
  echo "DB not found: $DB" >&2
  exit 2
fi

SCHEMA="$(sqlite3 "$DB" '.schema' | sed -E 's/\s+/ /g' | head -n 400)"

read -r -d '' PROMPT <<EOF || true
You translate questions to valid, safe SQLite SQL only.
Constraints:

- Use only tables/columns present in this schema.

- Prefer parameterless, read-only SELECT queries.

- Return a single SQL statement with no explanation.

Schema:
$SCHEMA

Question:
$QUESTION
EOF

SQL="$(ai_chat "$PROMPT" | sed -n '1p' )"

echo "Proposed SQL:"
echo "$SQL"
echo
read -r -p "Execute against $DB? [y/N] " ans
if [[ "${ans,,}" == "y" ]]; then
  echo
  sqlite3 -header -column "$DB" "$SQL"
else
  echo "Aborted."
fi

Run it:

AI_BACKEND=ollama ./nl2sql-sqlite.sh ./staging.db "Top 10 products by revenue this quarter"

For PostgreSQL or MySQL/MariaDB, adapt the schema extraction and client call, and use a non-production replica. Always review the SQL before executing.

---

Governance, security, and ops tips

• Data classification: Don’t send sensitive logs off-host; prefer local models (Ollama) for PII/prod data.

• Secrets handling: Use environment files with 600 permissions; avoid hardcoding keys in scripts.

• Rate/cost control: Batch inputs (as we did with log aggregation), choose small models for routine tasks, and enforce timeouts.

• Observability: Wrap these scripts via systemd units with journald logging; export metrics or mail summaries to your on-call list.

• Version and test: Treat prompts like code. Keep them in Git, review changes, and have a staging environment for AI-integrated workflows.

---

Conclusion and next steps

Bash remains the simplest, most auditable glue in the enterprise. By adding a thin AI layer, you can upgrade everyday workflows—without new servers, agents, or platforms.

• Pick your backend (OpenAI or Ollama).

• Install the small toolchain (curl, jq, rg, ShellCheck, sqlite3).

• Drop in the helper and try one project today—log summarization takes minutes to wire up.

• Expand gradually: runbook Q&A, script reviews, and safe NL→SQL can follow.

Want more? Package these as systemd services with timers, add alert routing, and standardize prompts across teams. Your terminal just got a lot smarter—now put it to work.