llmlite vs. Ollama: Lokale Enterprise-KI für deutsche Unternehmen

# llmlite Installation (vereinfacht)
pip install llmlite
llmlite run --model llama-7b --port 8000

# Klingt einfach, aber...

# Ollama Installation auf Ubuntu Server
curl -fsSL https://ollama.ai/install.sh | sh

# Modell herunterladen und starten
ollama pull llama2:13b
ollama serve

# REST API ist sofort verfügbar
curl http://localhost:11434/api/generate \
  -d '{
    "model": "llama2:13b",
    "prompt": "Analysiere den DSGVO-Compliance Status...",
    "stream": false
  }'

# Basis-Setup
import llmlite
model = llmlite.load_model("llama-7b")
response = model.generate("Prompt hier")

# docker-compose.yml für Production
version: '3.8'
services:
  ollama:
    image: ollama/ollama:latest
    ports:
      - '11434:11434'
    volumes:
      - ollama_data:/root/.ollama
      - ./models:/models
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_MODELS=/models
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped

volumes:
  ollama_data:

# Basis-Implementierung mit llmlite
import llmlite
from typing import Dict, Any

class SimpleDocumentAnalyzer:
    def __init__(self):
        self.model = llmlite.load_model("llama-7b")

    def analyze_document(self, text: str) -> str:
        prompt = f"Analysiere dieses Dokument: {text}"
        return self.model.generate(prompt)

# Probleme:
# - Keine Skalierung für mehrere Anfragen
# - Keine Governance-Features
# - Schwierige Integration in bestehende Systeme

import requests
import logging
from datetime import datetime
from typing import Dict, Any, Optional
import hashlib

class EnterpriseDocumentAnalyzer:
    def __init__(self, ollama_endpoint: str = "http://localhost:11434"):
        self.endpoint = ollama_endpoint
        self.setup_logging()

    def setup_logging(self):
        """DSGVO-konforme Audit-Logs"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('/var/log/ki-analysis/audit.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)

    def analyze_document(
        self,
        text: str,
        user_id: str,
        document_type: str,
        retention_days: int = 30
    ) -> Dict[str, Any]:
        """DSGVO-konforme Dokumentenanalyse"""

        # Dokumenten-Hash für Tracking (keine Inhalte geloggt)
        doc_hash = hashlib.sha256(text.encode()).hexdigest()

        # Audit-Log
        self.logger.info(f"Document analysis started - User: {user_id}, "
                        f"DocHash: {doc_hash}, Type: {document_type}")

        try:
            # Ollama API Call
            response = requests.post(
                f"{self.endpoint}/api/generate",
                json={
                    "model": "llama2:13b-german",
                    "prompt": self._create_analysis_prompt(text, document_type),
                    "stream": False,
                    "options": {
                        "temperature": 0.1,  # Konsistente Ergebnisse
                        "top_p": 0.9
                    }
                },
                timeout=120
            )

            result = response.json()

            # Erfolg loggen
            self.logger.info(f"Analysis completed - DocHash: {doc_hash}, "
                           f"Tokens: {result.get('eval_count', 0)}")

            return {
                "analysis": result['response'],
                "document_hash": doc_hash,
                "timestamp": datetime.now().isoformat(),
                "model_used": "llama2:13b-german",
                "retention_until": (datetime.now() +
                                  timedelta(days=retention_days)).isoformat(),
                "compliance_status": "processed_locally"
            }

        except Exception as e:
            self.logger.error(f"Analysis failed - DocHash: {doc_hash}, "
                            f"Error: {str(e)}")
            raise

    def _create_analysis_prompt(self, text: str, doc_type: str) -> str:
        """Deutsche Prompts für verschiedene Dokumenttypen"""

        prompts = {
            "vertrag": """
            Analysiere den folgenden deutschen Vertrag auf:
            1. Hauptvertragsparteien
            2. Wesentliche Vertragsinhalte
            3. Zahlungsbedingungen
            4. Kündigungsfristen
            5. Besondere Risiken oder Klauseln

            Gib eine strukturierte Zusammenfassung auf Deutsch zurück:
            """,
            "rechnung": """
            Analysiere die folgende deutsche Rechnung und extrahiere:
            1. Rechnungssteller (Unternehmen)
            2. Rechnungsnummer und Datum
            3. Netto-, MwSt- und Bruttobetrag
            4. Zahlungsziel
            5. Besonderheiten oder Auffälligkeiten

            Strukturierte Antwort auf Deutsch:
            """,
            "bericht": """
            Fasse den folgenden deutschen Geschäftsbericht zusammen:
            1. Kernaussagen und Hauptthemen
            2. Wichtige Kennzahlen oder Entwicklungen
            3. Risiken und Chancen
            4. Empfohlene Handlungsschritte

            Deutsche Zusammenfassung:
            """
        }

        base_prompt = prompts.get(doc_type, "Analysiere das Dokument:")
        return f"{base_prompt}\n\n{text}\n\nAnalyse:"

# Usage
analyzer = EnterpriseDocumentAnalyzer()
result = analyzer.analyze_document(
    text=document_content,
    user_id="max.mustermann@firma.de",
    document_type="vertrag",
    retention_days=90
)

#!/bin/bash
# Production Ollama Setup für deutsche Unternehmen

# System Updates
sudo apt update && sudo apt upgrade -y

# Docker Installation
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# NVIDIA Container Toolkit (für GPU Support)
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-docker.list

sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

# Ollama mit Docker Compose
mkdir -p /opt/enterprise-ki/{data,logs,config}
cd /opt/enterprise-ki

# SSL Zertifikate für HTTPS
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /opt/enterprise-ki/config/ollama.key \
  -out /opt/enterprise-ki/config/ollama.crt \
  -subj "/C=DE/ST=NRW/L=Cologne/O=Firma/CN=ki.firma.de"

version: '3.8'
services:
  ollama:
    image: ollama/ollama:latest
    container_name: enterprise-ollama
    ports:
      - '11434:11434'
    volumes:
      - ./data:/root/.ollama
      - ./logs:/var/log/ollama
      - ./config:/etc/ollama
    environment:
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_KEEP_ALIVE=24h
      - OLLAMA_MAX_LOADED_MODELS=3
    deploy:
      resources:
        limits:
          memory: 32G
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ['CMD', 'curl', '-f', 'http://localhost:11434/api/tags']
      interval: 30s
      timeout: 10s
      retries: 3

  nginx:
    image: nginx:alpine
    container_name: enterprise-nginx
    ports:
      - '443:443'
      - '80:80'
    volumes:
      - ./config/nginx.conf:/etc/nginx/nginx.conf
      - ./config/ollama.crt:/etc/ssl/certs/ollama.crt
      - ./config/ollama.key:/etc/ssl/private/ollama.key
      - ./logs/nginx:/var/log/nginx
    depends_on:
      - ollama
    restart: unless-stopped

  monitoring:
    image: prom/prometheus:latest
    container_name: enterprise-monitoring
    ports:
      - '9090:9090'
    volumes:
      - ./config/prometheus.yml:/etc/prometheus/prometheus.yml
      - ./data/prometheus:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
    restart: unless-stopped

volumes:
  ollama_data:
  prometheus_data:

# /opt/enterprise-ki/config/nginx.conf
events {
    worker_connections 1024;
}

http {
    # Security Headers für DSGVO-Compliance
    add_header X-Frame-Options DENY;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains";

    # Logging für Audit-Zwecke
    log_format audit '$remote_addr - $remote_user [$time_local] '
                    '"$request" $status $body_bytes_sent '
                    '"$http_referer" "$http_user_agent" '
                    'request_id="$request_id"';

    access_log /var/log/nginx/audit.log audit;
    error_log /var/log/nginx/error.log;

    upstream ollama_backend {
        server ollama:11434;
    }

    server {
        listen 80;
        server_name ki.firma.de;
        return 301 https://$server_name$request_uri;
    }

    server {
        listen 443 ssl http2;
        server_name ki.firma.de;

        ssl_certificate /etc/ssl/certs/ollama.crt;
        ssl_certificate_key /etc/ssl/private/ollama.key;
        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512;
        ssl_prefer_server_ciphers off;

        # Rate Limiting für DoS-Schutz
        limit_req_zone $binary_remote_addr zone=api:10m rate=30r/m;
        limit_req zone=api burst=5 nodelay;

        location /api/ {
            proxy_pass http://ollama_backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # Timeout Settings für große Modelle
            proxy_connect_timeout 300s;
            proxy_send_timeout 300s;
            proxy_read_timeout 300s;

            # Authentifizierung (hier Basic Auth, produktiv: OAuth/SAML)
            auth_basic "Enterprise KI Access";
            auth_basic_user_file /etc/nginx/.htpasswd;
        }

        location /health {
            proxy_pass http://ollama_backend/api/tags;
            access_log off;
        }
    }
}

Hardware-Setup (RTX 4090 Server):
- Anschaffung: 8.000€
- Strom (300W, 24/7): 650€/Jahr
- Wartung: 800€/Jahr
- Gesamt/Jahr: 1.450€

vs. Cloud-LLM (GPT-4):
- 100.000 Tokens/Tag: 90€/Tag
- Jährliche Kosten: 32.850€

Ersparnis lokal: 31.400€/Jahr
ROI: 3 Monate

class DSGVOCompliantKIService:
    def __init__(self):
        self.data_processor = "Firma GmbH"  # Art. 4 Nr. 8 DSGVO
        self.processing_purpose = "Automated document analysis"
        self.legal_basis = "Art. 6 Abs. 1 lit. f DSGVO (legitimate interest)"
        self.retention_period = 90  # Tage

    def process_with_consent(self, data: str, user_consent: dict) -> dict:
        """DSGVO-konforme Verarbeitung mit Einwilligung"""

        # Artikel 7 DSGVO: Bedingungen für die Einwilligung
        if not self._validate_consent(user_consent):
            raise ValueError("Invalid or withdrawn consent")

        # Verarbeitung nur lokal, keine Übermittlung an Dritte
        result = self._local_ai_processing(data)

        # Artikel 5 Abs. 1 lit. e DSGVO: Speicherbegrenzung
        self._schedule_deletion(result['id'], days=self.retention_period)

        return result

    def _validate_consent(self, consent: dict) -> bool:
        """Prüfung der Einwilligung nach Art. 7 DSGVO"""
        required_fields = ['timestamp', 'purpose', 'freely_given', 'specific']
        return all(field in consent for field in required_fields)

class ComplianceAuditLogger:
    def __init__(self, log_path: str = "/var/log/dsgvo-audit/"):
        self.log_path = Path(log_path)
        self.log_path.mkdir(exist_ok=True)

    def log_processing_activity(
        self,
        user_id: str,
        data_category: str,
        processing_purpose: str,
        legal_basis: str
    ):
        """Art. 30 DSGVO: Verzeichnis von Verarbeitungstätigkeiten"""

        audit_entry = {
            'timestamp': datetime.now().isoformat(),
            'controller': 'Firma GmbH',
            'processor': 'Local KI System',
            'data_subject_id': hashlib.sha256(user_id.encode()).hexdigest(),
            'data_category': data_category,  # Art. 4 Nr. 1 DSGVO
            'processing_purpose': processing_purpose,  # Art. 5 Abs. 1 lit. b DSGVO
            'legal_basis': legal_basis,  # Art. 6 DSGVO
            'retention_period': '90 days',
            'third_party_transfer': False,  # Art. 44 ff. DSGVO
            'data_location': 'DE - Frankfurt am Main'
        }

        # Täglich rotierendes Log
        log_file = self.log_path / f"audit-{datetime.now().strftime('%Y-%m-%d')}.json"

        with open(log_file, 'a') as f:
            json.dump(audit_entry, f, ensure_ascii=False)
            f.write('\n')

class CloudToLocalMigration:
    def __init__(self):
        self.phases = ['assessment', 'pilot', 'parallel', 'migration', 'optimization']

    def phase_1_assessment(self) -> dict:
        """Bewertung aktueller Cloud-KI-Nutzung"""
        return {
            'current_costs': self._calculate_cloud_costs(),
            'data_sensitivity': self._assess_data_classification(),
            'compliance_gaps': self._identify_compliance_issues(),
            'technical_requirements': self._define_hw_requirements()
        }

    def phase_2_pilot(self) -> dict:
        """Pilot-Implementierung mit Ollama"""
        pilot_config = {
            'duration': '4 weeks',
            'scope': 'non-critical documents only',
            'success_criteria': {
                'accuracy': '>85% vs cloud solution',
                'latency': '\<5s response time',
                'availability': '>99% uptime'
            },
            'rollback_plan': 'immediate fallback to cloud'
        }
        return pilot_config

    def phase_3_parallel_operation(self) -> dict:
        """Parallel-Betrieb für Vergleich"""
        return {
            'duration': '8 weeks',
            'traffic_split': {
                'week_1_2': {'local': 20, 'cloud': 80},
                'week_3_4': {'local': 40, 'cloud': 60},
                'week_5_6': {'local': 60, 'cloud': 40},
                'week_7_8': {'local': 80, 'cloud': 20}
            },
            'monitoring': [
                'response_quality_comparison',
                'cost_analysis',
                'user_satisfaction',
                'compliance_metrics'
            ]
        }

Investition:
- Hardware: 15.000€
- Setup/Integration: 8.000€
- Schulung: 3.000€
Total: 26.000€

Einsparungen vs. Cloud-KI:
- Jahr 1: 25.000€
- Jahr 2: 30.000€
- Jahr 3: 35.000€
Total: 90.000€

ROI: 246% über 3 Jahre
Break-Even: 10 Monate