LocalAI ve n8n Entegrasyonu: Sunucuda AI Otomasyonu

Otomasyon deyince aklıma hep şu senaryo gelir: gece 2’de bir sunucu alarmı geliyor, ekip uyuyor, sen de bir şeylerin otomatik çalışmasını diliyorsun. İşte tam bu noktada LocalAI ve n8n kombinasyonu devreye giriyor. Kendi sunucunda çalışan bir AI modeli ile güçlü bir otomasyon aracını birleştirdiğinde, hem veri gizliliğini koruyor hem de dışarıya bağımlılığı ortadan kaldırıyorsun. Bu yazıda bu iki aracı nasıl entegre edeceğini, gerçek dünyada nasıl kullanabileceğini ve dikkat etmen gereken noktalara odaklanacağım.

LocalAI ve n8n Nedir, Neden Birlikte Kullanmalısın?

LocalAI, OpenAI API’siyle uyumlu bir arayüz sunarak yerel makinende veya sunucunda LLM modelleri çalıştırmanı sağlar. Yani gguf formatındaki modelleri alıp bir API sunucusu gibi servis eder. Bu sayede OpenAI için yazılmış her uygulama, hiçbir değişiklik yapılmadan LocalAI ile de çalışabilir.

n8n ise açık kaynaklı, self-hosted bir otomasyon aracıdır. Zapier veya Make’e benzer ama tamamen kendi sunucunda çalışır. Yüzlerce entegrasyon, görsel workflow editörü ve HTTP request node’u sayesinde neredeyse her şeyi otomatikleştirebilirsin.

Bu ikisini birleştirdiğinde şunları elde edersin:

Veriler dışarı çıkmaz, her şey kendi altyapında kalır
OpenAI ücretlerinden kurtulursun
İnternet bağlantısına bağımlılık olmaz
GDPR ve diğer veri düzenlemelerine uyum kolaylaşır
Modeli istediğin gibi özelleştirebilirsin

Gereksinimler ve Kurulum Planı

Başlamadan önce neye ihtiyacın olduğunu netleştirelim. Test ortamı için minimum bir setup şu şekilde olabilir:

16GB RAM (8GB ile de çalışır ama küçük modeller kullanman gerekir)
4 çekirdek CPU (GPU varsa çok daha iyi)
20GB+ disk alanı
Ubuntu 22.04 veya Debian 12
Docker ve Docker Compose

Prod ortamı için GPU’lu bir makine kesinlikle fark yaratır. Mistral 7B veya Llama 3.2 gibi modeller CPU’da saniyeler içinde yanıt verirken, GPU ile bu süre dramatik şekilde düşer.

LocalAI Kurulumu

Docker Compose ile kurmak en temiz yoldur. Önce bir çalışma dizini oluştur:

mkdir -p /opt/localai/models
cd /opt/localai

Şimdi Docker Compose dosyasını oluştur:

cat > docker-compose.yml << 'EOF'
version: "3.9"
services:
  localai:
    image: localai/localai:latest-aio-cpu
    container_name: localai
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./models:/build/models
    environment:
      - THREADS=4
      - CONTEXT_SIZE=4096
      - DEBUG=false
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/readyz"]
      interval: 30s
      timeout: 10s
      retries: 3
EOF

GPU kullanmak istiyorsan image’ı değiştirmen gerekir:

# GPU versiyonu icin image satirini su sekilde degistir:
# image: localai/localai:latest-aio-gpu-nvidia-cuda-12
# ve su bolumu ekle:
# deploy:
#   resources:
#     reservations:
#       devices:
#         - driver: nvidia
#           count: all
#           capabilities: [gpu]

Servisi başlat:

docker compose up -d
docker compose logs -f localai

LocalAI ilk başladığında hazır duruma geçmesi biraz zaman alabilir. readyz endpoint’ini kontrol et:

curl http://localhost:8080/readyz
# Yanit: {"status":"ok"}

Model İndirme ve Yapılandırma

LocalAI, modelleri /build/models dizininden okur. Birkaç farklı yöntemle model ekleyebilirsin. En kolay yol, LocalAI’nin yerleşik model gallery’sini kullanmak:

# Mevcut modelleri listele
curl http://localhost:8080/models/available | python3 -m json.tool | grep '"name"' | head -20

# Mistral 7B modelini yukle
curl http://localhost:8080/models/apply 
  -H "Content-Type: application/json" 
  -d '{"id": "mistral-openorca"}'

Manuel olarak GGUF model eklemek istersen:

# HuggingFace'den model indir (ornek: Mistral 7B Q4)
cd /opt/localai/models
wget https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/mistral-7b-instruct-v0.2.Q4_K_M.gguf

# Model yapilandirma dosyasini olustur
cat > /opt/localai/models/mistral.yaml << 'EOF'
name: mistral
backend: llama
parameters:
  model: mistral-7b-instruct-v0.2.Q4_K_M.gguf
  temperature: 0.7
  top_p: 0.9
  max_tokens: 2048
context_size: 4096
threads: 4
EOF

Modelin çalıştığını test et:

curl http://localhost:8080/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d '{
    "model": "mistral",
    "messages": [
      {
        "role": "user",
        "content": "Turkce olarak merhaba de ve kendini tanit."
      }
    ],
    "temperature": 0.7
  }'

Eğer JSON formatında mantıklı bir yanıt geliyorsa kurulum başarılıdır.

n8n Kurulumu

LocalAI ile aynı sunucuda n8n’i de Docker Compose’a ekleyelim. Farklı bir compose dosyası kullanmak daha yönetilebilir bir yapı sağlar:

mkdir -p /opt/n8n
cd /opt/n8n

cat > docker-compose.yml << 'EOF'
version: "3.9"
services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=guvenli_sifre_buraya
      - N8N_HOST=0.0.0.0
      - N8N_PORT=5678
      - N8N_PROTOCOL=http
      - WEBHOOK_URL=http://SUNUCU_IP:5678
      - GENERIC_TIMEZONE=Europe/Istanbul
volumes:
  n8n_data:
EOF

docker compose up -d

Tarayıcıdan http://SUNUCU_IP:5678 adresine giderek n8n arayüzüne bağlanabilirsin.

n8n’de LocalAI Entegrasyonu

n8n, OpenAI node’una sahiptir ama LocalAI’yi doğrudan tanımaz. İki yöntemle entegrasyon yapabilirsin.

Yöntem 1: HTTP Request Node Kullanımı

Bu yöntem en esnektir. n8n workflow’unda bir HTTP Request node ekle ve şu ayarları yap:

Method: POST
URL: http://localai:8080/v1/chat/completions (aynı Docker ağındaysa) veya http://SUNUCU_IP:8080/v1/chat/completions
Headers: Content-Type: application/json
Body: JSON formatında

Yöntem 2: OpenAI Node’u Özelleştirme

n8n’deki OpenAI node’unu LocalAI ile kullanmak için Credentials kısmında Base URL’i değiştirmen gerekir. n8n 1.0+ sürümlerinde bu desteklenmektedir.

HTTP Request yaklaşımıyla daha fazla kontrol sahibi olduğun için ben bu yöntemi tercih ediyorum.

Gerçek Dünya Senaryosu 1: Log Analizi ve Alarm Bildirimi

Sunucu loglarını otomatik olarak analiz edip anlamlı bildirimlere dönüştüren bir workflow oluşturalım. Bu senaryo özellikle büyük log dosyalarında nelerin kritik olduğunu hızla anlamak için çok kullanışlıdır.

Önce n8n’in log dosyasını okuyacağı bir endpoint oluştur. Sunucunda şu bash script’ini hazırla:

cat > /opt/scripts/log_summarizer.sh << 'EOF'
#!/bin/bash
# Son 1 saatin error loglarini topla
LOG_FILE="/var/log/syslog"
HOURS_BACK=1

# Hata satirlarini filtrele ve JSON formatina cevir
errors=$(grep -i "error|critical|failed|fatal" "$LOG_FILE" | 
  tail -50 | 
  sed 's/"/\"/g' | 
  awk '{printf "%s\n", $0}')

# n8n webhook'una gonder
curl -s -X POST http://localhost:5678/webhook/log-analysis 
  -H "Content-Type: application/json" 
  -d "{"logs": "$errors", "timestamp": "$(date -Iseconds)"}"
EOF

chmod +x /opt/scripts/log_summarizer.sh

# Cron'a ekle - her saat basinda calistir
echo "0 * * * * root /opt/scripts/log_summarizer.sh" >> /etc/cron.d/log-analysis

n8n tarafında bu webhook’u alıp LocalAI’ye gönderen workflow için HTTP Request node body’si şöyle görünmelidir:

# n8n workflow'undaki HTTP Request node icin body ornegi
# Bu JSON'u n8n'in expression editor'unda kullanabilirsin
{
  "model": "mistral",
  "messages": [
    {
      "role": "system",
      "content": "Sen bir Linux sistem yoneticisisin. Verilen log satirlarini analiz et, kritik sorunlari tespit et ve ozet bir rapor sun. Turkce yaz."
    },
    {
      "role": "user",
      "content": "Su log satirlarini analiz et ve onemli sorunlari ozetle:nn{{ $json.logs }}"
    }
  ],
  "temperature": 0.3,
  "max_tokens": 1000
}

Gerçek Dünya Senaryosu 2: Destek E-postalarını Otomatik Sınıflandırma

Destek maillerini otomatik kategorilere ayıran ve önceliklendiren bir sistem kur. n8n’in IMAP node’uyla mailları alıp LocalAI ile analiz edebilirsin.

Workflow mantığı şu şekilde işler:

IMAP node her 5 dakikada yeni mailleri çeker
Mail içeriği LocalAI’ye gönderilir
LocalAI öncelik ve kategori döndürür
Sonuca göre mail ilgili kişiye yönlendirilir veya ticket oluşturulur

LocalAI’ye gönderilecek prompt şablonu:

# Bu prompt'u n8n'in HTTP Request node'unda kullan
{
  "model": "mistral",
  "messages": [
    {
      "role": "system",
      "content": "Musteri destek maili analiz uzmanisın. Verilen maili analiz et ve JSON formatinda su alanlari dondur: kategori (teknik/fatura/genel/sikayet), oncelik (yuksek/orta/dusuk), ozet (max 50 kelime), onerilecek_departman. Sadece JSON don, aciklama yapma."
    },
    {
      "role": "user",
      "content": "Konu: {{ $json.subject }}nnIcerik: {{ $json.body }}"
    }
  ],
  "temperature": 0.1,
  "max_tokens": 300
}

LocalAI’den gelen yanıtı parse etmek için n8n’de bir Code node kullanabilirsin:

# n8n Code node'u icin JavaScript ornegi
const response = items[0].json.choices[0].message.content;
let parsed;

try {
  // JSON parse et
  parsed = JSON.parse(response);
} catch (e) {
  // JSON parse edilemezse varsayilan deger kullan
  parsed = {
    kategori: "genel",
    oncelik: "orta",
    ozet: response.substring(0, 100),
    onerilecek_departman: "destek"
  };
}

return [{ json: parsed }];

Gerçek Dünya Senaryosu 3: Sunucu Durum Raporu Oluşturma

Günlük sunucu durum raporunu otomatik oluşturup Telegram veya Slack’e gönderen bir workflow kurabilirsin. Bu özellikle birden fazla sunucuyu yönetiyorsan çok değerlidir.

Önce sunucu metriklerini toplayan bir script:

#!/bin/bash
# /opt/scripts/collect_metrics.sh

CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d. -f1)
MEM_TOTAL=$(free -m | awk '/^Mem:/{print $2}')
MEM_USED=$(free -m | awk '/^Mem:/{print $3}')
MEM_PERCENT=$(echo "scale=0; $MEM_USED * 100 / $MEM_TOTAL" | bc)
DISK_USAGE=$(df -h / | awk 'NR==2{print $5}' | tr -d '%')
LOAD_AVG=$(cat /proc/loadavg | awk '{print $1, $2, $3}')
UPTIME=$(uptime -p)
FAILED_SERVICES=$(systemctl --failed --no-legend | wc -l)

# n8n webhook'una gonder
curl -s -X POST http://localhost:5678/webhook/daily-report 
  -H "Content-Type: application/json" 
  -d "{
    "hostname": "$(hostname)",
    "cpu_usage": $CPU_USAGE,
    "mem_percent": $MEM_PERCENT,
    "disk_usage": $DISK_USAGE,
    "load_avg": "$LOAD_AVG",
    "uptime": "$UPTIME",
    "failed_services": $FAILED_SERVICES
  }"

n8n workflow’unda bu verileri LocalAI’ye gönderip yorumlatabilirsin:

# HTTP Request node body - metrik yorumlama
{
  "model": "mistral",
  "messages": [
    {
      "role": "system",
      "content": "Sen bir sistem yoneticisisin. Verilen sunucu metriklerini degerlendirerek kisaca turkce rapor olustur. Kritik durumlari vurgula. Onceki gunle karsilastirma yapma, sadece mevcut durumu degerlendir."
    },
    {
      "role": "user", 
      "content": "Sunucu: {{ $json.hostname }}nCPU: %{{ $json.cpu_usage }}nRAM: %{{ $json.mem_percent }}nDisk: %{{ $json.disk_usage }}nLoad: {{ $json.load_avg }}nCalısma suresi: {{ $json.uptime }}nBasarisiz servisler: {{ $json.failed_services }}"
    }
  ],
  "temperature": 0.4,
  "max_tokens": 500
}

LocalAI Performans Optimizasyonu

Üretim ortamında kullanacaksan birkaç ayara dikkat etmen gerekiyor.

Model seçimi ve quantization:

Q4_K_M: Hız ve kalite dengesi için ideal, çoğu senaryo için yeterli
Q5_K_M: Biraz daha iyi kalite, daha fazla RAM
Q8_0: En iyi kalite ama yavaş ve fazla RAM tüketir
Q2_K: Çok hızlı ama kalite düşük, basit görevler için kullanılabilir

LocalAI container environment değişkenleri:

THREADS: CPU çekirdeği sayısına eşit veya bir eksiği
CONTEXT_SIZE: Uzun metinler için artır, RAM kullanımını etkiler
LLAMACPP_GRPC_SERVERS: Birden fazla backend kullanmak için
MODELS_PATH: Özel model dizini belirlemek için

n8n tarafında dikkat edilecekler:

Workflow’larında LocalAI çağrılarını yaparken timeout değerini artır. LocalAI’nin CPU’da yanıt üretmesi birkaç saniye sürebilir, özellikle uzun metinlerde bu 30-60 saniyeye çıkabilir.

n8n HTTP Request node’unda timeout’u en az 120000 (120 saniye) olarak ayarla. Bunu node’un “Options” sekmesinden yapabilirsin.

Güvenlik Konfigürasyonu

Her iki servis de doğrudan internete açık olmamalıdır. Nginx reverse proxy arkasına almak en doğru yaklaşımdır:

# /etc/nginx/sites-available/localai-n8n
server {
    listen 443 ssl;
    server_name otomasyon.sirket.com;

    ssl_certificate /etc/letsencrypt/live/otomasyon.sirket.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/otomasyon.sirket.com/privkey.pem;

    # n8n icin
    location / {
        proxy_pass http://127.0.0.1:5678;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

server {
    listen 8443 ssl;
    server_name otomasyon.sirket.com;

    ssl_certificate /etc/letsencrypt/live/otomasyon.sirket.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/otomasyon.sirket.com/privkey.pem;

    # LocalAI icin - sadece guvenilir IP'lere izin ver
    allow 10.0.0.0/8;
    deny all;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_read_timeout 300s;
    }
}

Firewall tarafında da LocalAI portunu dışarıya kapatmayı unutma:

# LocalAI'yi sadece localhost'a kapat
ufw deny 8080
ufw allow from 127.0.0.1 to any port 8080
# veya Docker network'u kullanarak container'lar arasi iletisim sagla

Workflow İzleme ve Hata Yönetimi

n8n workflow’larında hata yönetimi çok önemlidir. LocalAI bazen yük altında yavaş yanıt verebilir veya beklenmedik formatta çıktı üretebilir.

Her kritik workflow için şunları yapılandırmanı öneririm:

Error Workflow: n8n’de ayrı bir hata yakalama workflow’u tanımla
Retry Logic: HTTP Request node’unda otomatik retry aktif et (3 deneme, 5 saniye aralık)
Execution Logging: n8n’in execution loglarını düzenli kontrol et
Health Check: LocalAI’nin /readyz endpoint’ini düzenli ping’le

Basit bir health check cron job’ı:

#!/bin/bash
# /opt/scripts/localai_health.sh
LOCALAI_URL="http://localhost:8080/readyz"
TELEGRAM_TOKEN="BOTTOKEN"
CHAT_ID="CHATID"

if ! curl -sf "$LOCALAI_URL" > /dev/null 2>&1; then
    # Servis yanit vermiyor, yeniden baslatmayı dene
    docker restart localai
    sleep 30
    
    if ! curl -sf "$LOCALAI_URL" > /dev/null 2>&1; then
        # Hala yanit vermiyorsa bildirim gonder
        curl -s -X POST "https://api.telegram.org/bot$TELEGRAM_TOKEN/sendMessage" 
          -d "chat_id=$CHAT_ID" 
          -d "text=ALARM: LocalAI servisi yanit vermiyor ve yeniden baslatilamadi!"
    fi
fi

Sonuç

LocalAI ve n8n kombinasyonu, kurumsal ortamlarda veri gizliliğini korurken güçlü AI destekli otomasyonlar kurmanın en pratik yollarından biri. Dışa bağımlılık yok, aylık API faturası yok, verilen internet kesintisinde sistem çalışmaya devam ediyor.

Başlangıçta kurulum ve model seçimi biraz zaman alıyor ama bir kez çalışır hale getirdiğinde log analizi, destek sınıflandırma, rapor oluşturma gibi görevleri tamamen otomatikleştirebiliyorsun. Ben bu yapıyı birkaç farklı müşteri ortamında kullanıyorum ve en büyük kazanım özellikle gece saatlerinde log anomalisi tespitinde kendini gösteriyor.

Modeli küçük tutmaktan çekinme. Çoğu otomasyon senaryosu için 7B parametreli bir model fazlasıyla yeterli oluyor. İleride daha güçlü donanım eklersen sadece modeli değiştirmen yeterli, workflow’larına dokunman gerekmiyor. Bu esneklik, bu ikiliyi gerçekten değerli kılıyor.

LocalAI ile n8n Otomasyon Entegrasyonu: Sunucunda Yapay Zeka ile İş Akışları