Build an AI Inventory Management System: Predict Demand, Prevent Stockouts

Inventory management is a solved problem — until it isn’t. Traditional systems track what you have. Smart systems predict what you’ll need. The difference between the two is the difference between scrambling to reorder when you’re already out of stock and having the right product in the right quantity at the right time.

AI-powered inventory management uses historical sales data, seasonal patterns, and external signals to forecast demand and optimize reorder decisions. This tutorial builds a complete system with demand forecasting, automatic reorder suggestions, and a management dashboard.

What We’re Building

An inventory management system that:

1. Tracks current stock levels across multiple products and locations
2. Forecasts demand using Prophet + AI analysis
3. Calculates optimal reorder points and quantities
4. Generates automated purchase order suggestions
5. Provides alerts for low stock, overstock, and demand anomalies
6. Displays everything in an interactive dashboard

Tech Stack

• Python 3.11+
• Facebook Prophet for time-series forecasting
• Claude API for demand analysis and anomaly explanation
• SQLite for inventory data
• Streamlit for the dashboard
• Pandas for data manipulation

Step 1: Database Schema

import sqlite3

def init_db():
    conn = sqlite3.connect("inventory.db")
    conn.execute("""
        CREATE TABLE IF NOT EXISTS products (
            id INTEGER PRIMARY KEY,
            sku TEXT UNIQUE,
            name TEXT,
            category TEXT,
            unit_cost REAL,
            selling_price REAL,
            lead_time_days INTEGER DEFAULT 7,
            min_stock INTEGER DEFAULT 10,
            max_stock INTEGER DEFAULT 1000
        )
    """)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS stock_levels (
            id INTEGER PRIMARY KEY,
            product_id INTEGER,
            quantity INTEGER,
            location TEXT DEFAULT 'main',
            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY(product_id) REFERENCES products(id)
        )
    """)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS sales_history (
            id INTEGER PRIMARY KEY,
            product_id INTEGER,
            quantity_sold INTEGER,
            sale_date DATE,
            revenue REAL,
            FOREIGN KEY(product_id) REFERENCES products(id)
        )
    """)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS reorder_suggestions (
            id INTEGER PRIMARY KEY,
            product_id INTEGER,
            suggested_quantity INTEGER,
            reason TEXT,
            urgency TEXT,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
            status TEXT DEFAULT 'pending',
            FOREIGN KEY(product_id) REFERENCES products(id)
        )
    """)
    conn.commit()
    return conn

Step 2: Demand Forecasting With Prophet

from prophet import Prophet
import pandas as pd

def forecast_demand(product_id: int, days_ahead: int = 30) -> pd.DataFrame:
    conn = sqlite3.connect("inventory.db")
    df = pd.read_sql("""
        SELECT sale_date as ds, SUM(quantity_sold) as y
        FROM sales_history
        WHERE product_id = ?
        GROUP BY sale_date
        ORDER BY sale_date
    """, conn, params=(product_id,))

    if len(df) < 30:
        return None  # Not enough data

    model = Prophet(
        yearly_seasonality=True,
        weekly_seasonality=True,
        daily_seasonality=False,
        changepoint_prior_scale=0.05
    )
    model.fit(df)

    future = model.make_future_dataframe(periods=days_ahead)
    forecast = model.predict(future)

    return forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail(days_ahead)

Step 3: AI-Powered Reorder Optimization

from anthropic import Anthropic
import json

client = Anthropic()

def calculate_reorder(product_id: int) -> dict:
    conn = sqlite3.connect("inventory.db")

    # Get product info
    product = conn.execute(
        "SELECT * FROM products WHERE id = ?", (product_id,)
    ).fetchone()

    # Get current stock
    stock = conn.execute(
        "SELECT SUM(quantity) FROM stock_levels WHERE product_id = ?",
        (product_id,)
    ).fetchone()[0] or 0

    # Get forecast
    forecast = forecast_demand(product_id)

    # Get recent sales trend
    recent = conn.execute("""
        SELECT sale_date, SUM(quantity_sold) as daily_sales
        FROM sales_history
        WHERE product_id = ? AND sale_date > date('now', '-30 days')
        GROUP BY sale_date
    """, (product_id,)).fetchall()

    # AI analysis
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=512,
        system="""You are an inventory optimization AI. Given product data,
current stock, forecast, and recent sales, recommend reorder quantity and timing.
Return JSON: {"reorder_quantity": int, "urgency": "critical|high|medium|low|none",
"days_until_stockout": int, "reason": "explanation"}""",
        messages=[{"role": "user", "content": f"""
Product: {product[2]} (SKU: {product[1]})
Current stock: {stock} units
Lead time: {product[6]} days
Min stock level: {product[7]}
Recent daily sales avg: {sum(r[1] for r in recent)/max(len(recent),1):.1f} units
Forecast next 7 days: {forecast[['ds','yhat']].head(7).to_string() if forecast is not None else 'No forecast available'}
"""}]
    )

    text = response.content[0].text
    if "```json" in text:
        text = text.split("```json")[1].split("```")[0]
    return json.loads(text.strip())

Step 4: Automated Monitoring

def run_daily_check():
    conn = sqlite3.connect("inventory.db")
    products = conn.execute("SELECT id, name FROM products").fetchall()

    alerts = []
    for product_id, name in products:
        result = calculate_reorder(product_id)

        if result["urgency"] in ("critical", "high"):
            conn.execute("""
                INSERT INTO reorder_suggestions
                (product_id, suggested_quantity, reason, urgency)
                VALUES (?, ?, ?, ?)
            """, (product_id, result["reorder_quantity"],
                  result["reason"], result["urgency"]))
            alerts.append(f"{name}: {result['reason']}")

    conn.commit()

    if alerts:
        send_inventory_alert("\n".join(alerts))

Step 5: Dashboard

Build a Streamlit dashboard with:

• Stock level overview for all products (color-coded by urgency)
• Demand forecast charts per product
• Pending reorder suggestions with one-click approval
• Sales trends and seasonality visualization
• Inventory turnover metrics

Step 6: Advanced Features

Multi-Location Support

Track stock across warehouses, stores, and fulfillment centers. AI optimizes inter-location transfers to balance stock levels.

Supplier Lead Time Learning

Track actual vs. expected lead times per supplier. Adjust reorder points based on real performance data.

Promotion Planning

Feed upcoming promotions into the forecast model. AI adjusts demand predictions based on historical promotion impact.

Dead Stock Detection

AI identifies products with declining sales velocity and recommends markdown pricing or discontinuation.

Step 7: Production Deployment

For production use:

• Replace SQLite with PostgreSQL for concurrent access
• Add authentication and role-based access control
• Integrate with your ERP/POS system for automatic sales data ingestion
• Set up daily scheduled runs for forecast updates and reorder checks
• Configure email/Slack alerts for critical stock situations

The Bottom Line

AI inventory management prevents two costly scenarios: stockouts (lost sales) and overstock (tied-up capital). The system in this tutorial combines statistical forecasting with AI reasoning to make reorder decisions that account for trends, seasonality, and business context.

Build time: 6-8 hours. Ongoing cost: $20-40/month for AI API calls. ROI: reducing stockouts by even 10% and overstock by 15% easily saves thousands monthly for businesses with significant inventory.