Building On-Premises AI Analytics for Industrial Automation with Ollama

Antti Haaraniemi — Sun, 15 Mar 2026 16:47:50 +0000

TL;DR: We built local LLM-powered analytics for industrial OPC UA data using Ollama, ASP.NET Core, and TimescaleDB — enabling anomaly detection, forecasting, and cost optimization without sending sensitive process data to the cloud.

The Problem: Cloud AI Doesn't Work for Industry

When you're running a power plant, district heating network, or manufacturing facility, your process data is:

Sensitive — production metrics, energy consumption, equipment performance
High-volume — 2000+ measurement points per second, 172 million rows per day
Network-constrained — industrial networks are often air-gapped or firewalled
Compliance-critical — GDPR, sector-specific regulations, trade secrets

Cloud-based AI analytics mean:

Uploading gigabytes of time-series data daily
Monthly subscription fees that scale with data volume
Latency (query → cloud → response takes seconds, not milliseconds)
Vendor lock-in and data residency concerns

What if you could run GPT-class AI models locally, on the same server as your time-series database?

That's what we built with DataPortia — an industrial data acquisition system with on-premises AI analytics powered by Ollama.

Tech Stack

Data Collection: OPC UA .NET Standard SDK (1.5.376)
Backend: ASP.NET Core 9.0
Database: PostgreSQL 18 + TimescaleDB (hypertables, continuous aggregates, compression)
AI: Ollama (local LLM server) with models: Qwen3, DeepSeek-R1, Gemma3, Llama 3
Data Access: Npgsql (binary COPY for batch inserts), EF Core 9, Dapper
Frontend: Vanilla JavaScript + ECharts 5.6 for visualizations

Five Types of AI Analysis (Without Cloud)

We implemented 5 analysis types that industrial automation engineers actually need:

1. Anomaly Detection (Z-score + severity classification)

"Which measurement points are behaving abnormally?"

Computes statistics: min, max, avg, median, stddev
Identifies outliers using Z-score
Classifies severity: Critical (Z>3), Warning (Z>2), Minor (Z>1)

2. Forecasting (Trend + periodicity analysis)

"Will this equipment fail? Is energy consumption rising?"

Linear regression on time-series data
Detects seasonal patterns
Predicts future values based on historical trends

3. Cost Optimization (Energy waste identification)

"Where can we save energy costs?"

Compares baseline vs. actual consumption
Identifies idle equipment, inefficient cycles
Calculates kWh waste and monetary impact

4. Report Generation (Structured 6-section analysis)

"Summarize this week's production data"

Key metrics summary
Trend analysis
Problem identification
Root cause analysis
Recommendations
Action items

5. Natural Language Queries (Chat interface)

"Why did boiler temperature spike at 14:35 yesterday?"

Multi-turn conversations with context history
Combines time-series data with facility descriptions
Markdown-formatted responses with charts

Implementation Deep Dive

1. Service Architecture (ASP.NET Core DI)

// Program.cs — Dependency Injection
builder.Services.AddSingleton<OllamaHealthCheckService>();
builder.Services.AddSingleton<PromptBuilder>();
builder.Services.AddScoped<AiAnalysisService>();

builder.Services.Configure<AiAnalysisOptions>(
    builder.Configuration.GetSection("AiAnalysis")
);

// config.ini
[AiAnalysis]
OllamaUrl = http://localhost:11434
DefaultModel = qwen3:4b
MaxTokens = 8192
TimeoutSeconds = 600
MaxConcurrentRequests = 3

Key services:

OllamaHealthCheckService (Singleton, IHostedService) — 60-second health check, caches model list
PromptBuilder (Singleton) — Builds system prompts with data context (quadlingual: fi/en/sv/de)
AiAnalysisService (Scoped) — Orchestrates data fetch → statistics → Ollama API → result persistence

2. Data Pipeline: TimescaleDB → Statistics → Prompt

// AiAnalysisService.cs
public async Task<AiAnalysisResult> RunAnalysisAsync(
    AnalysisRequest request, 
    CancellationToken ct)
{
    // 1. Fetch time-series data via DataRetrievalService
    var (rawData, aggregated) = await _dataRetrievalService
        .GetDataWithAggregation(
            request.StartTime, 
            request.EndTime, 
            request.MinuteGroup, 
            tagsJson
        );

    // 2. Compute statistics (min/max/avg/median/stddev/outliers/trend)
    var statistics = ComputeStatistics(rawData, aggregated);

    // 3. Query measurement point units from SelectedData table
    var tagUnits = await GetTagUnits(request.Tags);

    // 4. Build system prompt with data context
    var systemPrompt = _promptBuilder.BuildSystemPrompt(
        request.AnalysisType,
        aggregated,
        sampleData: rawData.Take(100), // Prevent token overflow
        request.StartTime,
        request.EndTime,
        request.Language,
        facilityContext: facilityDescriptions,
        tagUnits: tagUnits
    );

    // 5. Call Ollama /api/chat
    var aiResponse = await CallOllamaAsync(
        systemPrompt, 
        request.UserPrompt, 
        ct
    );

    // 6. Save session to database for history
    await SaveSessionAsync(request, aiResponse, statistics);

    return new AiAnalysisResult { Success = true, ... };
}

3. Ollama API Integration (SSE Streaming)

We use Server-Sent Events (SSE) for real-time streaming responses to the frontend:

// AiController.cs
[HttpPost("analyze/stream")]
public async IAsyncEnumerable<string> AnalyzeStream(
    [FromBody] AnalysisRequest request,
    [EnumeratorCancellation] CancellationToken ct)
{
    // Send progress event
    yield return JsonSerializer.Serialize(new {
        type = "status",
        message = "Fetching data..."
    });

    // ... (data fetch + statistics)

    // Stream Ollama response
    await foreach (var chunk in _aiService.StreamAnalysisAsync(
        request, ct))
    {
        yield return JsonSerializer.Serialize(new {
            type = "chunk",
            content = chunk
        });
    }

    // Send completion event with sessionId
    yield return JsonSerializer.Serialize(new {
        type = "done",
        sessionId = session.Id,
        statistics = statistics
    });
}

Ollama HTTP client:

private async IAsyncEnumerable<string> CallOllamaStreamingAsync(
    string systemPrompt,
    string userMessage,
    CancellationToken ct)
{
    var client = _httpClientFactory.CreateClient("Ollama");
    var payload = new {
        model = ActiveModel,
        messages = new[] {
            new { role = "system", content = systemPrompt },
            new { role = "user", content = userMessage }
        },
        stream = true,
        options = new {
            temperature = 0.3,
            num_predict = IsThinkingModel(ActiveModel) 
                ? _options.MaxTokens * 2 
                : _options.MaxTokens,
            repeat_penalty = IsQwenModel(ActiveModel) ? 1.05 : 1.2,
            repeat_last_n = IsQwenModel(ActiveModel) ? 256 : 128
        }
    };

    var response = await client.PostAsJsonAsync(
        "/api/chat", payload, ct
    );

    await using var stream = await response.Content
        .ReadAsStreamAsync(ct);
    using var reader = new StreamReader(stream);

    while (!reader.EndOfStream)
    {
        var line = await reader.ReadLineAsync(ct);
        if (string.IsNullOrWhiteSpace(line)) continue;

        var chunk = JsonSerializer.Deserialize<OllamaStreamChunk>(line);
        if (chunk?.Message?.Content != null)
        {
            yield return chunk.Message.Content;
        }
    }
}

4. Prompt Engineering for Industrial Data

The PromptBuilder creates context-aware prompts with:

Facility descriptions (equipment type, capacity, process flow)
Measurement point statistics (with units!)
Trend directions (increasing ↑ / stable — / decreasing ↓)
Sample data points (up to 100 to prevent token overflow)
Analysis type instructions (anomaly/forecast/cost/report/chat)

Example system prompt (abbreviated):

You are an industrial data analyst expert specializing in process
automation, energy systems, and manufacturing optimization...

FACILITY CONTEXT:

Power Plant "Main Boiler #1" (District Heating, 50 MW, 3 boilers)
Tags: boiler_temp, steam_pressure, fuel_flow
MEASUREMENT POINT STATISTICS (2025-03-10 00:00 to 2025-03-15 23:59):

SAMPLE DATA (100 points):
2025-03-15 23:45 | boiler_temp=188.2°C | steam_pressure=9.1bar | ...

TASK — ANOMALY DETECTION:
Analyze the measurement points above:

Identify anomalies using Z-score analysis
Classify severity: Critical (Z>3), Warning (Z>2), Minor (Z>1)
Explain potential root causes
Recommend corrective actions

Respond in English with markdown formatting.

5. Thinking Models (Qwen3, DeepSeek-R1, QwQ)

Some LLMs output reasoning in <think>...</think> blocks. We auto-detect and strip them:

private bool IsThinkingModel(string model)
{
    return model.Contains("qwen3", StringComparison.OrdinalIgnoreCase) ||
           model.Contains("deepseek-r1", StringComparison.OrdinalIgnoreCase) ||
           model.Contains("qwq", StringComparison.OrdinalIgnoreCase);
}

// Append /no_think to model name for Ollama API
var modelName = IsThinkingModel(ActiveModel) 
    ? $"{ActiveModel}/no_think" 
    : ActiveModel;

// Strip <think> blocks from response
var cleanContent = Regex.Replace(
    aiResponse, 
    @"<think>.*?</think>", 
    "", 
    RegexOptions.Singleline
);

Challenges and Solutions

Challenge 1: Token Limits

Problem: TimescaleDB can return millions of rows — LLMs have ~8K-32K token limits.

Solution:

Compute statistics server-side (min/max/avg/stddev/outliers)
Send only 100 sample data points to LLM
Use continuous aggregates (minute/hourly/daily) instead of raw data

Challenge 2: Numeric Precision

Problem: Industrial sensors output double values → NaN, Infinity break JSON serialization.

Solution:

private static double SanitizeDouble(double value)
{
    if (double.IsNaN(value) || double.IsInfinity(value))
        return 0.0;
    return value;
}

// JsonSerializerOptions for statistics
var options = new JsonSerializerOptions {
    NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals
};

Challenge 3: Concurrency Control

Problem: Multiple users triggering AI analysis → Ollama server overload.

Solution:

private static SemaphoreSlim _concurrencySemaphore = 
    new SemaphoreSlim(3, 3); // Max 3 concurrent requests

public async Task<AiAnalysisResult> RunAnalysisAsync(...)
{
    await _concurrencySemaphore.WaitAsync(ct);
    try
    {
        // ... AI analysis
    }
    finally
    {
        _concurrencySemaphore.Release();
    }
}

Challenge 4: Model Availability

Problem: User selects model, downloads it via ollama pull, app needs to detect new models.

Solution: Background health check service (60s interval):

// OllamaHealthCheckService.cs
protected override async Task ExecuteAsync(CancellationToken ct)
{
    while (!ct.IsCancellationRequested)
    {
        var response = await _client.GetAsync("/api/tags", ct);
        var models = JsonSerializer.Deserialize<OllamaTagsResponse>(
            await response.Content.ReadAsStringAsync(ct)
        );

        lock (_modelsLock) {
            _cachedModels = models.Models;
        }

        _isOllamaAvailable = true;
        await Task.Delay(TimeSpan.FromSeconds(60), ct);
    }
}

Performance & Capacity

Real-world metrics from a district heating network (10 connections, 200 tags each):

Why On-Premises AI Matters for Industry

Data privacy: Process data never leaves the local network. GDPR compliance is simpler.

Zero cloud costs: No per-API-call fees. Run unlimited analyses. Model downloads are free.

Low latency: LAN query times (<50ms) vs. cloud round-trips (500ms+).

Offline operation: Industrial sites with limited internet connectivity can still use AI.

Customization: Fine-tune models on site-specific data without uploading to third parties.

Try It Yourself

DataPortia is available as a free 30-day trial:
👉 https://atorcom.fi/en/dataportia-opc-ua-reporting-software

Requirements:

Windows 10/11 or Windows Server 2016+ (Linux supported)
PostgreSQL 18 + TimescaleDB (included in installer)
Ollama installed separately: https://ollama.ai
Recommended models: ollama pull qwen3:4b or ollama pull gemma3:4b

For developers:

OPC UA simulator: Prosys OPC UA Simulation Server
Test with synthetic time-series data generation scripts (included)

What's Next?

We're exploring:

RAG (Retrieval-Augmented Generation) for equipment manuals and maintenance logs
Fine-tuning local models on 24 months of historical data (domain-specific predictions)
Edge deployment on Raspberry Pi / industrial PCs running at substations
Multi-agent workflows (one agent for anomaly detection, another for root cause analysis)

Closing Thoughts

Cloud AI is powerful, but not every use case belongs in the cloud. For industrial automation, on-premises AI with Ollama offers:

✅ Data sovereignty
✅ Cost predictability (no per-token pricing)
✅ Low latency
✅ Offline resilience

And with modern .NET performance + TimescaleDB compression + Ollama's efficient inference, you can run GPT-class analytics on modest hardware.

Have you built on-premises AI for industrial/IoT applications? Drop a comment — I'd love to hear about your architecture and challenges!

About the Author

Building industrial data acquisition software at Atorcom (Finland). Interested in ASP.NET Core, OPC UA, TimescaleDB, and local-first AI. Connect: antti.haaraniemi@atorcom.fi

This article is based on real production code from DataPortia v2.22.0. All code snippets are simplified for readability but reflect actual implementation patterns.

DEV Community: Antti Haaraniemi

Building On-Premises AI Analytics for Industrial Automation with Ollama

The Problem: Cloud AI Doesn't Work for Industry

Tech Stack

Five Types of AI Analysis (Without Cloud)

1. Anomaly Detection (Z-score + severity classification)

2. Forecasting (Trend + periodicity analysis)

3. Cost Optimization (Energy waste identification)

4. Report Generation (Structured 6-section analysis)

5. Natural Language Queries (Chat interface)

Implementation Deep Dive

1. Service Architecture (ASP.NET Core DI)

2. Data Pipeline: TimescaleDB → Statistics → Prompt

3. Ollama API Integration (SSE Streaming)

4. Prompt Engineering for Industrial Data

5. Thinking Models (Qwen3, DeepSeek-R1, QwQ)

Challenges and Solutions

Challenge 1: Token Limits

Challenge 2: Numeric Precision

Challenge 3: Concurrency Control

Challenge 4: Model Availability

Performance & Capacity

Why On-Premises AI Matters for Industry

Try It Yourself

What's Next?

Closing Thoughts