Posted on
• Artificial Intelligence

Complete Guide to Artificial Intelligence Bash Automation

Author
  • User
    linuxbash
    Posts by this author
    Posts by this author

Complete Guide to Artificial Intelligence Bash Automation

What if your Bash scripts could read logs, reason about failures, draft safe commands on request, and write reports while you sleep? AI + Bash automation turns everyday text streams into actionable insight—without abandoning the shell you already know.

In this guide you’ll learn why AI belongs in your Linux toolbox, how to choose a backend (local or cloud), and how to wire it into practical, production-safe Bash workflows. You’ll get ready-to-run snippets, install commands for apt/dnf/zypper, and a small Bash library you can drop into any host.

Why AI belongs in your Bash toolkit

  • Shell is text-native. Logs, configs, CLI help, metrics—everything is text. Modern LLMs consume and produce text. That makes the UNIX philosophy (“everything is a file”) a perfect match.

  • Zero new UI. Keep using pipes, redirection, cron/systemd timers, and your existing scripts.

  • Immediate leverage. Let AI triage noisy logs, generate safe command lines from natural language, draft incident summaries, or extract structured data—on demand or on schedule.

  • Flexible deployment. Run fully local with open models (for privacy), or use a cloud API (for stronger reasoning and larger context windows).

1) Install prerequisites

We’ll use curl for HTTP calls and jq for JSON parsing. Optional: cron (or systemd timers) for scheduling.

Debian/Ubuntu (apt):

sudo apt update
sudo apt install -y curl jq
# Optional schedulers:
sudo apt install -y cron at

Fedora/RHEL/CentOS (dnf):

sudo dnf install -y curl jq
# Optional schedulers:
sudo dnf install -y cronie at

openSUSE/SLE (zypper):

sudo zypper refresh
sudo zypper install -y curl jq
# Optional schedulers:
sudo zypper install -y cron at

Tip: systemd timers are available by default on most modern distros and can replace cron.

2) Choose your AI backend (local vs cloud)

You can start with a local model (privacy, no ongoing costs) or a cloud API (often better reasoning/context). This guide supports both via a thin Bash layer.

Option A: Local with Ollama

Ollama runs open models locally and exposes a simple HTTP API.

Install Ollama:

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

Start Ollama (if not already running) and pull a model:

ollama serve &
ollama pull llama3.1
# or a smaller model:
ollama pull phi3

Test:

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

Option B: Cloud via an OpenAI-compatible API

You can use the OpenAI API or any OpenAI-compatible endpoint (e.g., some gateways and self-hosted proxies). You only need an API key and base URL.

Set environment variables:

export OPENAI_API_KEY="sk-..."
export OPENAI_BASE_URL="https://api.openai.com/v1"  # change if using a compatible API
export OPENAI_MODEL="gpt-4o-mini"                   # pick a model your provider supports

Test (simple chat completion):

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

3) Drop-in Bash AI library

Save the following as ai.sh and source it from any script. It auto-detects Ollama vs OpenAI-compatible based on available env vars.

#!/usr/bin/env bash
# ai.sh - Minimal AI client for Bash (Ollama or OpenAI-compatible)
set -euo pipefail

# Configuration (override via environment)
: "${AI_BACKEND:=auto}"           # auto|ollama|openai
: "${OLLAMA_HOST:=http://localhost:11434}"
: "${OLLAMA_MODEL:=llama3.1}"
: "${OPENAI_BASE_URL:=https://api.openai.com/v1}"
: "${OPENAI_MODEL:=gpt-4o-mini}"
: "${AI_MAX_TOKENS:=512}"
: "${AI_TIMEOUT:=30}"             # seconds

_detect_backend() {
  if [[ "$AI_BACKEND" != "auto" ]]; then
    echo "$AI_BACKEND"; return
  fi
  if curl -sS --max-time 1 "$OLLAMA_HOST/api/tags" >/dev/null 2>&1; then
    echo "ollama"; return
  fi
  if [[ -n "${OPENAI_API_KEY:-}" ]]; then
    echo "openai"; return
  fi
  echo "none"
}

# ai_text "prompt" -> prints model response to stdout
ai_text() {
  local prompt="${1:-}"; [[ -n "$prompt" ]] || { echo "ai_text: prompt required" >&2; return 2; }
  local backend; backend=$(_detect_backend)
  case "$backend" in
    ollama)
      curl -sS --fail --max-time "$AI_TIMEOUT" \
        -H "Content-Type: application/json" \
        -d "{\"model\":\"$OLLAMA_MODEL\",\"prompt\":$(jq -Rn --arg p "$prompt" '$p'),\"stream\":false}" \
        "$OLLAMA_HOST/api/generate" | jq -r '.response'
      ;;
    openai)
      curl -sS --fail --max-time "$AI_TIMEOUT" \
        -H "Authorization: Bearer $OPENAI_API_KEY" \
        -H "Content-Type: application/json" \
        -d "$(jq -n --arg m "$OPENAI_MODEL" --arg p "$prompt" --argjson mt "$AI_MAX_TOKENS" \
             '{model:$m,messages:[{role:"user",content:$p}],max_tokens:$mt}')" \
        "$OPENAI_BASE_URL/chat/completions" | jq -r '.choices[0].message.content'
      ;;
    *)
      echo "ai_text: No AI backend available. Start Ollama or set OPENAI_API_KEY." >&2
      return 3
      ;;
  esac
}

# ai_command "instruction" -> prints a single-line safe shell command
# The model is instructed to return ONLY a command (no backticks, no explanations).
ai_command() {
  local instr="${1:-}"; [[ -n "$instr" ]] || { echo "ai_command: instruction required" >&2; return 2; }
  local sys="You are a CLI assistant. Output ONLY a single safe POSIX shell command with arguments. No explanations."
  local prompt="$sys\n\nInstruction: $instr"
  local cmd; cmd=$(ai_text "$prompt" | tr -d '\r' | sed -E 's/^```.*$//g' | head -n1)
  # Basic guardrails: disallow obvious destructive commands unless explicitly allowed
  if grep -Eq '(^|[[:space:]])(rm|mkfs|dd|:>|>|truncate|chmod 000|chown root|shutdown|reboot)([[:space:]]|$)' <<<"$cmd"; then
    echo "# Blocked potentially destructive command: $cmd" >&2
    return 4
  fi
  echo "$cmd"
}

# ai_summarize_file path "hint"
ai_summarize_file() {
  local path="${1:-}"; local hint="${2:-Briefly summarize the key issues.}"
  [[ -f "$path" ]] || { echo "ai_summarize_file: $path not found" >&2; return 2; }
  local content; content=$(tail -c 200000 "$path" || true) # last ~200KB
  ai_text "You will read a file snippet and $hint

--- BEGIN FILE ---
$content
--- END FILE ---"
}

Usage:

source ./ai.sh
ai_text "List three ways to speed up apt on Debian."
ai_command "find all .log files modified in last 24 hours and show sizes"
ai_summarize_file /var/log/syslog "extract the top error categories and suggested actions"

4) Real-world automation patterns you can deploy today

A) Smart log triage (nightly)

Create jobs/log-triage.sh:

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

LOG=${1:-/var/log/syslog}    # or /var/log/nginx/error.log, /var/log/messages, etc.
OUT="./reports/log_triage_$(date +%F).md"

mkdir -p ./reports
summary=$(ai_summarize_file "$LOG" "1) list top recurring errors with counts, 2) probable root causes, 3) concrete next actions. Be concise.")
{
  echo "# Log Triage Report ($(date -I))"
  echo
  echo "Source: $LOG"
  echo
  echo "$summary"
} > "$OUT"

echo "Wrote $OUT"

Run it:

bash jobs/log-triage.sh /var/log/syslog

Schedule via cron (runs 02:15 daily):

crontab -e
# add:
15 2 * * * /bin/bash /path/to/jobs/log-triage.sh /var/log/syslog >/tmp/log-triage.out 2>&1

Or systemd timer (recommended for reliability):

/etc/systemd/system/log-triage.service

[Unit]
Description=AI Log Triage

[Service]
Type=oneshot
ExecStart=/bin/bash /path/to/jobs/log-triage.sh /var/log/syslog
Environment=OPENAI_API_KEY=YOUR_KEY   # or rely on Ollama

/etc/systemd/system/log-triage.timer

[Unit]
Description=Run AI Log Triage nightly

[Timer]
OnCalendar=02:15
Persistent=true

[Install]
WantedBy=timers.target

Enable:

sudo systemctl daemon-reload
sudo systemctl enable --now log-triage.timer

B) “Translate intent to command” with confirmation

Add an interactive helper bin/aicmd:

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

instr="${*:-}"
[[ -n "$instr" ]] || { echo "Usage: aicmd <instruction>"; exit 2; }

cmd=$(ai_command "$instr") || { echo "Could not generate a safe command."; exit 3; }

echo "Proposed: $cmd"
read -r -p "Run it? [y/N] " ans
if [[ "$ans" =~ ^[Yy]$ ]]; then
  eval "$cmd"
else
  echo "Aborted."
fi

Examples:

./bin/aicmd "compress all .txt files in current dir into texts.tar.gz without including subdirs"
./bin/aicmd "show top 10 processes by RSS memory with headers"

Guardrails:

  • The helper blocks obviously destructive commands by default. Expand/adjust filters to match your environment.

  • Always ask for confirmation before eval.

C) Auto-generate incident summaries from journalctl

Create jobs/inc-summary.sh:

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

range="${1:-1h}"   # last 1 hour
logs=$(journalctl --since "-$range" -p 3..0 --no-pager || true)

report=$(ai_text "You are an SRE assistant. From the logs below, produce:

- A one-paragraph incident summary

- Impacted components

- Probable root cause hypotheses

- Immediate next steps
Keep it under 250 words.

--- LOGS START ---
$logs
--- LOGS END ---")

echo "$report"

Run:

bash jobs/inc-summary.sh 2h > reports/incident_$(date +%s).md

D) Structured extraction: Turn unstructured CLI output into JSON

Example: Parse df -h into JSON rows using AI as a last-mile extractor.

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

raw=$(df -h --output=source,size,used,avail,pcent,target | sed 1d)

json=$(ai_text "Convert the following table into JSON array of objects with keys:
device,size,used,avail,used_percent,mountpoint. Use exact values. Output ONLY JSON.

$raw")

# Validate and pretty-print
echo "$json" | jq .

Now you can feed the result into jq for alerts, dashboards, or compliance checks.

5) Production hardening, security, and cost control

  • Redact secrets. Pipe content through a redactor before sending to any remote API. Example: sed -E 's/(password|token|secret)=\S+/\1=REDACTED/gi'.

  • Timeouts and retries. Use AI_TIMEOUT in ai.sh and wrap calls with retry logic for robustness.

  • Budget tokens. Keep prompts short; tail logs instead of sending whole files. Adjust AI_MAX_TOKENS.

  • Audit trail. Save prompt/response pairs for jobs that change state or create tickets. Simple: tee the JSON and response into a dated folder.

  • Local-first when needed. For confidential logs, prefer Ollama or another on-prem model.

  • Confirm before action. For any command generation, always require explicit user confirmation or run in dry-run mode first.

Quick reference: package installs seen above

Debian/Ubuntu (apt):

sudo apt update
sudo apt install -y curl jq cron at

Fedora/RHEL/CentOS (dnf):

sudo dnf install -y curl jq cronie at

openSUSE/SLE (zypper):

sudo zypper refresh
sudo zypper install -y curl jq cron at

Ollama (universal script):

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

Conclusion and next steps

You don’t need a new platform to get value from AI—just glue it to the shell you already trust. Start small:

1) Install jq/curl and either Ollama or set your OpenAI-compatible env vars.
2) Drop ai.sh into your repo and try ai_text on a real log.
3) Wrap one repetitive task—nightly log triage or an “intent to command” helper—behind a cron/systemd timer.

When you’re ready, expand into ticket creation, chat notifications, or policy-as-code that’s AI assisted. Your terminal just got smarter—keep it that way by iterating with guardrails and audits.

If you found this useful, wire up your first AI job today and share your best prompt-patterns and safety tricks with your team.

Related posts