Ollama & OpenClaw mit LLM für Coding auf Debian 13/Ubuntu 24.04

Einleitung

Ollama ist ein Open-Source-Framework zum lokalen Ausführen von Large Language Models (LLMs) auf Ihrem System. OpenClaw ist eine moderne Code-Editor-Alternative, die speziell für die Integration mit KI-Assistenten entwickelt wurde. Zusammen bilden sie eine mächtige Entwicklungsumgebung, die es ermöglicht, KI-gestützte Code-Generierung und -Analyse direkt auf dem lokalen System durchzuführen, ohne externe APIs oder Cloud-Dienste zu benötigen.

Diese Kombination ist besonders wertvoll für Entwickler, die sensiblen Code bearbeiten, Offline-Entwicklung betreiben oder einfach die volle Kontrolle über ihre KI-Assistenten behalten möchten. Mit Ollama können Sie verschiedene LLMs wie CodeLlama, Mistral oder andere spezialisierte Coding-Modelle lokal ausführen.

Systemvoraussetzungen

Benötigte Ports

Vorbereitung

System aktualisieren

sudo apt update && sudo apt upgrade -y

Abhängigkeiten installieren

# Basis-Pakete installieren
sudo apt install -y curl wget git build-essential software-properties-common

# Python und Node.js (für OpenClaw)
sudo apt install -y python3 python3-pip nodejs npm

# Optional: NVIDIA Container Toolkit für GPU-Support
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt update
sudo apt install -y nvidia-container-toolkit

Installation

Schritt 1: Ollama installieren

# Ollama herunterladen und installieren
curl -fsSL https://ollama.ai/install.sh | sh

# Systemd-Service erstellen (falls nicht automatisch erstellt)
sudo systemctl daemon-reload

Schritt 2: Ollama-Service konfigurieren

# Service-Datei erstellen/bearbeiten
sudo tee /etc/systemd/system/ollama.service << EOF
[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/local/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_MODELS=/var/lib/ollama/models"

[Install]
WantedBy=default.target
EOF

Schritt 3: Ollama-Benutzer erstellen

# Benutzer und Gruppe für Ollama erstellen
sudo useradd -r -s /bin/false -m -d /var/lib/ollama ollama
sudo mkdir -p /var/lib/ollama/models
sudo chown -R ollama:ollama /var/lib/ollama

Schritt 4: LLM-Modelle herunterladen

# Service starten
sudo systemctl enable ollama
sudo systemctl start ollama

# Warten bis Service läuft
sleep 10

# Code-spezifische Modelle installieren
ollama pull codellama:13b-instruct
ollama pull codellama:7b-code
ollama pull mistral:7b-instruct

# Überprüfen der installierten Modelle
ollama list

Schritt 5: OpenClaw installieren

# OpenClaw Repository klonen
cd /opt
sudo git clone https://github.com/zed-industries/zed.git openclaw
sudo chown -R $USER:$USER /opt/openclaw

# In das Verzeichnis wechseln
cd /opt/openclaw

# Rust installieren (benötigt für OpenClaw Build)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source ~/.cargo/env

# OpenClaw kompilieren
cargo build --release

# Binary verfügbar machen
sudo ln -sf /opt/openclaw/target/release/zed /usr/local/bin/openclaw

Konfiguration

Ollama-Konfiguration erweitern

# Erweiterte Ollama-Konfiguration
sudo mkdir -p /etc/ollama
sudo tee /etc/ollama/config.yaml << EOF
server:
  host: "0.0.0.0"
  port: 11434
  timeout: 300

models:
  cache_size: "4GB"
  concurrency: 4
  
gpu:
  enabled: true
  memory_fraction: 0.8
  
logging:
  level: "info"
  file: "/var/log/ollama/ollama.log"
EOF

# Log-Verzeichnis erstellen
sudo mkdir -p /var/log/ollama
sudo chown ollama:ollama /var/log/ollama

OpenClaw für Ollama konfigurieren

# Konfigurationsverzeichnis erstellen
mkdir -p ~/.config/openclaw

# OpenClaw-Konfiguration für Ollama
tee ~/.config/openclaw/settings.json << EOF
{
  "ai": {
    "provider": "ollama",
    "ollama": {
      "api_url": "http://localhost:11434",
      "model": "codellama:13b-instruct",
      "temperature": 0.1,
      "max_tokens": 2048
    }
  },
  "code_actions": {
    "auto_complete": true,
    "code_explanation": true,
    "code_review": true,
    "refactoring": true
  },
  "ui": {
    "theme": "dark",
    "font_size": 14,
    "show_ai_panel": true
  },
  "editor": {
    "tab_size": 4,
    "word_wrap": true,
    "show_line_numbers": true
  }
}
EOF

Firewall-Regeln setzen

# UFW Firewall konfigurieren
sudo ufw allow 11434/tcp comment "Ollama API"

# Optional: Nur lokalen Zugriff erlauben
sudo ufw allow from 127.0.0.1 to any port 11434

# Firewall-Status prüfen
sudo ufw status numbered

Dienst starten und beim Systemstart aktivieren

# Ollama-Service neu laden und starten
sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl start ollama

# Service-Status überprüfen
sudo systemctl status ollama

# Logs überprüfen
journalctl -u ollama -f

Installation verifizieren

Ollama-API testen

# API-Status prüfen
curl http://localhost:11434/api/tags

# Test-Request senden
curl -X POST http://localhost:11434/api/generate -d '{
  "model": "codellama:7b-code",
  "prompt": "def fibonacci(n):",
  "stream": false
}'

OpenClaw-Integration testen

# Test-Projekt erstellen
mkdir -p ~/test-project
cd ~/test-project
echo "print('Hello World')" > test.py

# OpenClaw starten
openclaw .

Performance-Test durchführen

# Performance-Test-Script erstellen
tee ~/test_ollama_performance.py << 'EOF'
#!/usr/bin/env python3
import requests
import time
import json

def test_ollama_performance():
    url = "http://localhost:11434/api/generate"
    prompt = "Write a Python function to calculate factorial"
    
    data = {
        "model": "codellama:7b-code",
        "prompt": prompt,
        "stream": False
    }
    
    start_time = time.time()
    response = requests.post(url, json=data)
    end_time = time.time()
    
    if response.status_code == 200:
        result = response.json()
        print(f"Response time: {end_time - start_time:.2f} seconds")
        print(f"Generated code:\n{result['response']}")
    else:
        print(f"Error: {response.status_code}")

if __name__ == "__main__":
    test_ollama_performance()
EOF

# Test ausführen
python3 ~/test_ollama_performance.py

Troubleshooting

Häufige Fehler und Lösungen

Fehler: „Connection refused“ beim API-Aufruf

• Service-Status prüfen: sudo systemctl status ollama
• Port überprüfen: netstat -tlnp | grep 11434
• Firewall-Regeln prüfen: sudo ufw status
• Service neu starten: sudo systemctl restart ollama

Fehler: „Model not found“

# Verfügbare Modelle auflisten
ollama list

# Modell erneut herunterladen
ollama pull codellama:7b-code

Fehler: Langsame Performance

• RAM-Verbrauch prüfen: free -h
• GPU-Nutzung überprüfen: nvidia-smi
• Kleineres Modell verwenden: ollama pull codellama:7b-code

Fehler: OpenClaw startet nicht

# Abhängigkeiten prüfen
ldd /usr/local/bin/openclaw

# Neu kompilieren
cd /opt/openclaw
cargo clean
cargo build --release

Fehler: GPU wird nicht erkannt

# NVIDIA-Treiber prüfen
nvidia-smi

# CUDA-Version prüfen
nvcc --version

# Ollama mit GPU-Support neu starten
sudo systemctl stop ollama
CUDA_VISIBLE_DEVICES=0 ollama serve

Log-Analyse

# Ollama-Logs analysieren
sudo journalctl -u ollama --since "1 hour ago"

# System-Performance überwachen
htop
iotop

# Festplatten-Performance prüfen
iostat -x 1

Updates und Wartung

Ollama aktualisieren

# Service stoppen
sudo systemctl stop ollama

# Neuste Version herunterladen
curl -fsSL https://ollama.ai/install.sh | sh

# Service neu starten
sudo systemctl start ollama

# Modelle aktualisieren
ollama pull codellama:13b-instruct

OpenClaw aktualisieren

# Repository aktualisieren
cd /opt/openclaw
sudo git pull

# Neu kompilieren
cargo build --release

Regelmäßige Wartung

# Wartungs-Script erstellen
sudo tee /etc/cron.weekly/ollama-maintenance << 'EOF'
#!/bin/bash
# Logs rotieren
find /var/log/ollama -name "*.log" -mtime +30 -delete

# Temporäre Dateien löschen
find /tmp -name "ollama-*" -mtime +1 -delete

# Service-Status prüfen
systemctl is-active --quiet ollama || systemctl restart ollama

# Performance-Report
echo "$(date): Ollama maintenance completed" >> /var/log/ollama/maintenance.log
EOF

sudo chmod +x /etc/cron.weekly/ollama-maintenance

Fazit und nächste Schritte

Sie haben erfolgreich Ollama mit OpenClaw für lokale LLM-basierte Code-Entwicklung auf Debian 13/Ubuntu 24.04 installiert. Das System ermöglicht es Ihnen:

• KI-gestützte Code-Generierung und -Vervollständigung
• Code-Review und Refactoring-Vorschläge
• Offline-Entwicklung ohne externe APIs
• Datenschutz durch lokale Ausführung

Empfohlene nächste Schritte:

• Experimentieren Sie mit verschiedenen LLM-Modellen für spezifische Programmiersprachen
• Konfigurieren Sie OpenClaw-Plugins für Ihre bevorzugten Entwicklungs-Workflows
• Implementieren Sie Backup-Strategien für Ihre Modelle und Konfigurationen
• Überwachen Sie die Performance und optimieren Sie die Hardware-Ressourcen
• Erstellen Sie eigene Prompts und Templates für wiederkehrende Coding-Aufgaben

Die Kombination aus Ollama und OpenClaw bietet eine mächtige, lokale Alternative zu Cloud-basierten KI-Coding-Assistenten und gibt Ihnen die volle Kontrolle über Ihre Entwicklungsumgebung.