# OpenWebUI Architektur für KMU
architecture:
  frontend:
    - web-interface: React-basiertes UI
    - chat-interface: Real-time Messaging
    - admin-panel: Konfiguration und Monitoring

  backend:
    - ollama: Lokale LLM-Engine
    - vector-database: ChromaDB/Pinecone für Dokumente
    - rag-pipeline: Retrieval-Augmented Generation
    - api-gateway: REST/WebSocket APIs

  data-layer:
    - document-store: PDF, DOCX, TXT Verarbeitung
    - knowledge-base: Firmenspezifische Informationen
    - conversation-history: Chat-Verlauf
    - analytics: Nutzungsstatistiken

# Minimale Systemanforderungen
- CPU: Intel i5/AMD Ryzen 5 (4 Cores)
- RAM: 16GB (32GB empfohlen)
- Storage: 50GB freier Speicher
- OS: Ubuntu 22.04 LTS / Windows 11 / macOS 12+
- GPU: Optional (NVIDIA GTX 1060+ für bessere Performance)

# Docker Compose Setup
version: '3.8'
services:
  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: openwebui
    restart: unless-stopped
    ports:
      - "3000:8080"
    volumes:
      - ./data:/app/backend/data
      - ./uploads:/app/backend/uploads
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_SECRET_KEY=your-secret-key-here
      - DEFAULT_USER_ROLE=admin
      - ENABLE_SIGNUP=false
      - ENABLE_LOGIN_FORM=true
    depends_on:
      - ollama
      - chromadb

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ./ollama:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - ./chroma:/chroma/chroma
    environment:
      - CHROMA_SERVER_HOST=0.0.0.0
      - CHROMA_SERVER_HTTP_PORT=8000

# Installation starten
docker-compose up -d

# Status prüfen
docker-compose ps

# Logs überwachen
docker-compose logs -f openwebui

# Deutsche Modelle (empfohlen für KMU)
ollama pull llama3.2:3b-instruct-q4_K_M
ollama pull mistral:7b-instruct-v0.2-q4_K_M
ollama pull qwen2.5:7b-instruct-q4_K_M

# Spezialisierte Modelle
ollama pull codellama:7b-instruct-q4_K_M  # Für technische Dokumentation
ollama pull neural-chat:7b-v3.1-q4_K_M    # Für Kundenservice

# Modell-Konfiguration für KMU-Anwendungen
model_config:
  llama3.2:3b-instruct-q4_K_M:
    context_length: 4096
    temperature: 0.7
    top_p: 0.9
    repeat_penalty: 1.1

  mistral:7b-instruct-v0.2-q4_K_M:
    context_length: 8192
    temperature: 0.6
    top_p: 0.85
    repeat_penalty: 1.05

# document_processor.py
import os
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader, Docx2txtLoader
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma

class KMUDocumentProcessor:
    def __init__(self, model_name="llama3.2:3b-instruct-q4_K_M"):
        self.embeddings = OllamaEmbeddings(model=model_name)
        self.text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            length_function=len,
        )

    def process_documents(self, folder_path):
        documents = []

        for filename in os.listdir(folder_path):
            file_path = os.path.join(folder_path, filename)

            if filename.endswith('.pdf'):
                loader = PyPDFLoader(file_path)
                documents.extend(loader.load())
            elif filename.endswith('.docx'):
                loader = Docx2txtLoader(file_path)
                documents.extend(loader.load())
            elif filename.endswith('.txt'):
                with open(file_path, 'r', encoding='utf-8') as f:
                    text = f.read()
                    documents.append(text)

        # Dokumente aufteilen
        splits = self.text_splitter.split_documents(documents)

        # Vector Database erstellen
        vectorstore = Chroma.from_documents(
            documents=splits,
            embedding=self.embeddings,
            persist_directory="./chroma_db"
        )

        return vectorstore

# Verwendung
processor = KMUDocumentProcessor()
vectorstore = processor.process_documents("./kmu_documents")

# KMU-Datenstruktur
kmu_data:
  produktkatalog:
    - produktbeschreibungen.pdf
    - preislisten.xlsx
    - technische_spezifikationen.docx

  kundenservice:
    - faq.md
    - support_richtlinien.pdf
    - troubleshooting_guide.docx

  interne_dokumente:
    - unternehmensrichtlinien.pdf
    - prozessbeschreibungen.docx
    - schulungsmaterialien/

  externe_quellen:
    - branchenberichte.pdf
    - gesetzesänderungen.txt
    - marktanalysen.docx

# rag_pipeline.py
from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain.chains import RetrievalQA
from langchain.llms import Ollama

class KMURAGPipeline:
    def __init__(self, vectorstore, model_name="llama3.2:3b-instruct-q4_K_M"):
        self.vectorstore = vectorstore
        self.llm = Ollama(model=model_name)

        # Retriever mit Kompression
        compressor = LLMChainExtractor.from_llm(self.llm)
        self.retriever = ContextualCompressionRetriever(
            base_retriever=vectorstore.as_retriever(search_kwargs={"k": 5}),
            base_compressor=compressor
        )

        # QA Chain
        self.qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            chain_type="stuff",
            retriever=self.retriever,
            return_source_documents=True
        )

    def answer_question(self, question, company_context=""):
        # Firmenspezifischen Kontext hinzufügen
        enhanced_question = f"""
        Kontext: {company_context}

        Frage: {question}

        Bitte antworte basierend auf den verfügbaren Firmendokumenten und sei hilfreich für KMU-Kunden.
        """

        response = self.qa_chain({"query": enhanced_question})
        return response

# openwebui_config.yaml
webui:
  title: 'KMU Business Assistant'
  description: 'Ihr intelligenter Assistent für alle Unternehmensfragen'

  branding:
    logo: '/static/kmu-logo.png'
    primary_color: '#2563eb'
    secondary_color: '#1e40af'

  features:
    enable_file_upload: true
    enable_rag: true
    enable_conversation_history: true
    enable_analytics: true

  models:
    default: 'llama3.2:3b-instruct-q4_K_M'
    available:
      - 'llama3.2:3b-instruct-q4_K_M'
      - 'mistral:7b-instruct-v0.2-q4_K_M'
      - 'qwen2.5:7b-instruct-q4_K_M'

  rag:
    vector_store: 'chromadb'
    embedding_model: 'llama3.2:3b-instruct-q4_K_M'
    chunk_size: 1000
    chunk_overlap: 200
    similarity_threshold: 0.7

# kmu_system_prompt.yaml
system_prompt: |
  Du bist ein hilfreicher Business-Assistent für ein deutsches KMU-Unternehmen.

  Wichtige Richtlinien:
  1. Antworte immer höflich und professionell auf Deutsch
  2. Verwende die verfügbaren Firmendokumente für präzise Antworten
  3. Bei Unsicherheiten verweise auf den menschlichen Ansprechpartner
  4. Halte Antworten prägnant und praxisorientiert
  5. Verwende eine freundliche, aber professionelle Tonalität

  Verfügbare Informationen:
  - Produktkatalog und Preise
  - Kundenservice-Richtlinien
  - Technische Dokumentation
  - Unternehmensrichtlinien

  Bei Fragen zu:
  - Produkten: Verweise auf aktuelle Preise und Verfügbarkeit
  - Support: Biete erste Hilfe und leite bei Bedarf weiter
  - Prozessen: Erkläre interne Abläufe basierend auf Dokumentation
  - Buchungen: Sammle Informationen und leite an Sales weiter

# kundenservice_config.yaml
use_case: 'Kundenservice'
features:
  - 24/7 Verfügbarkeit
  - FAQ-Beantwortung
  - Ticket-Erstellung
  - Produktinformationen
  - Terminbuchung

implementation:
  data_sources:
    - faq_database.csv
    - produktkatalog.pdf
    - support_richtlinien.docx

  workflows:
    greeting:
      - 'Willkommen bei [Firmenname]! Wie kann ich Ihnen helfen?'
      - 'Ich kann Ihnen bei Produktfragen, Support und Buchungen helfen.'

    product_inquiry:
      - Frage nach Produktkategorie
      - Zeige relevante Produkte
      - Preis und Verfügbarkeit prüfen
      - Weiterleitung an Sales bei Interesse

    support_request:
      - Problem identifizieren
      - Erste Lösungsvorschläge
      - Ticket erstellen falls nötig
      - Kontaktdaten sammeln

# mitarbeiter_support.yaml
use_case: 'Mitarbeiter-Support'
features:
  - Prozess-Dokumentation
  - Schulungsunterstützung
  - IT-Support
  - HR-Fragen

implementation:
  data_sources:
    - prozesshandbuch.pdf
    - it_richtlinien.docx
    - hr_policies.pdf
    - schulungsmaterialien/

  access_control:
    - Authentifizierung über LDAP/Active Directory
    - Rollenbasierte Berechtigungen
    - Audit-Log für sensible Anfragen

# vertrieb_support.yaml
use_case: 'Vertriebsunterstützung'
features:
  - Produktinformationen
  - Angebotserstellung
  - Kundenhistorie
  - Marktanalysen

implementation:
  data_sources:
    - produktkatalog.pdf
    - preislisten.xlsx
    - kunden_datenbank.csv
    - marktberichte.pdf

  integrations:
    - CRM-System (Salesforce, HubSpot)
    - ERP-System (SAP, Microsoft Dynamics)
    - E-Mail-System
    - Kalender-Integration

# api_integration.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import requests
import json

app = FastAPI()

class ChatRequest(BaseModel):
    message: str
    user_id: str
    context: dict = {}

class ChatResponse(BaseModel):
    response: str
    confidence: float
    sources: list
    next_action: str

@app.post("/chat", response_model=ChatResponse)
async def chat_endpoint(request: ChatRequest):
    try:
        # OpenWebUI API aufrufen
        openwebui_response = requests.post(
            "http://localhost:3000/api/v1/chat",
            json={
                "message": request.message,
                "model": "llama3.2:3b-instruct-q4_K_M",
                "context": request.context
            }
        )

        if openwebui_response.status_code == 200:
            response_data = openwebui_response.json()

            return ChatResponse(
                response=response_data["response"],
                confidence=response_data.get("confidence", 0.8),
                sources=response_data.get("sources", []),
                next_action=determine_next_action(request.message)
            )
        else:
            raise HTTPException(status_code=500, detail="OpenWebUI API error")

    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

def determine_next_action(message: str) -> str:
    """Bestimmt die nächste Aktion basierend auf der Nachricht"""
    message_lower = message.lower()

    if any(word in message_lower for word in ["preis", "kosten", "angebot"]):
        return "create_quote"
    elif any(word in message_lower for word in ["problem", "fehler", "support"]):
        return "create_ticket"
    elif any(word in message_lower for word in ["termin", "buchung", "meeting"]):
        return "schedule_appointment"
    else:
        return "continue_chat"

# crm_integration.py
import requests
from typing import Dict, Any

class CRMIntegration:
    def __init__(self, crm_type: str, api_key: str, base_url: str):
        self.crm_type = crm_type
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def create_lead(self, customer_data: Dict[str, Any]) -> str:
        """Erstellt einen neuen Lead im CRM"""
        if self.crm_type == "salesforce":
            return self._create_salesforce_lead(customer_data)
        elif self.crm_type == "hubspot":
            return self._create_hubspot_contact(customer_data)
        else:
            raise ValueError(f"Unsupported CRM type: {self.crm_type}")

    def _create_salesforce_lead(self, customer_data: Dict[str, Any]) -> str:
        """Salesforce Lead erstellen"""
        endpoint = f"{self.base_url}/services/data/v52.0/sobjects/Lead"

        payload = {
            "FirstName": customer_data.get("first_name", ""),
            "LastName": customer_data.get("last_name", ""),
            "Email": customer_data.get("email", ""),
            "Phone": customer_data.get("phone", ""),
            "Company": customer_data.get("company", ""),
            "LeadSource": "Chatbot",
            "Description": customer_data.get("inquiry", "")
        }

        response = requests.post(endpoint, headers=self.headers, json=payload)

        if response.status_code == 201:
            return response.json()["id"]
        else:
            raise Exception(f"Failed to create Salesforce lead: {response.text}")

    def _create_hubspot_contact(self, customer_data: Dict[str, Any]) -> str:
        """HubSpot Contact erstellen"""
        endpoint = f"{self.base_url}/crm/v3/objects/contacts"

        payload = {
            "properties": {
                "firstname": customer_data.get("first_name", ""),
                "lastname": customer_data.get("last_name", ""),
                "email": customer_data.get("email", ""),
                "phone": customer_data.get("phone", ""),
                "company": customer_data.get("company", ""),
                "lead_source": "Chatbot"
            }
        }

        response = requests.post(endpoint, headers=self.headers, json=payload)

        if response.status_code == 201:
            return response.json()["id"]
        else:
            raise Exception(f"Failed to create HubSpot contact: {response.text}")

# analytics_config.yaml
metrics:
  user_engagement:
    - daily_active_users
    - session_duration
    - messages_per_session
    - conversation_completion_rate

  response_quality:
    - response_time
    - user_satisfaction_score
    - escalation_rate
    - resolution_rate

  business_impact:
    - leads_generated
    - support_tickets_reduced
    - customer_satisfaction_increase
    - cost_savings

dashboard:
  real_time_monitoring:
    - active_conversations
    - queue_length
    - response_times
    - error_rates

  weekly_reports:
    - usage_statistics
    - popular_topics
    - user_feedback
    - performance_trends

# feedback_system.py
from datetime import datetime
import sqlite3

class FeedbackSystem:
    def __init__(self, db_path: str = "chatbot_feedback.db"):
        self.db_path = db_path
        self.init_database()

    def init_database(self):
        """Datenbank für Feedback initialisieren"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute('''
            CREATE TABLE IF NOT EXISTS feedback (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                conversation_id TEXT,
                user_id TEXT,
                message TEXT,
                response TEXT,
                rating INTEGER,
                feedback_text TEXT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')

        conn.commit()
        conn.close()

    def collect_feedback(self, conversation_id: str, user_id: str,
                        message: str, response: str, rating: int,
                        feedback_text: str = ""):
        """Feedback sammeln und speichern"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute('''
            INSERT INTO feedback
            (conversation_id, user_id, message, response, rating, feedback_text)
            VALUES (?, ?, ?, ?, ?, ?)
        ''', (conversation_id, user_id, message, response, rating, feedback_text))

        conn.commit()
        conn.close()

    def get_feedback_summary(self, days: int = 30):
        """Feedback-Zusammenfassung für die letzten X Tage"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute('''
            SELECT
                AVG(rating) as avg_rating,
                COUNT(*) as total_feedback,
                COUNT(CASE WHEN rating >= 4 THEN 1 END) as positive_feedback
            FROM feedback
            WHERE timestamp >= datetime('now', '-{} days')
        '''.format(days))

        result = cursor.fetchone()
        conn.close()

        return {
            "average_rating": result[0],
            "total_feedback": result[1],
            "positive_feedback_count": result[2],
            "positive_feedback_percentage": (result[2] / result[1] * 100) if result[1] > 0 else 0
        }

# roi_calculation.yaml
investment:
  initial_cost: 15000 # EUR
  monthly_maintenance: 500 # EUR

savings:
  personnel_cost_reduction: 30000 # EUR/year
  efficiency_gains: 15000 # EUR/year
  customer_satisfaction_value: 10000 # EUR/year

roi_calculation:
  total_annual_savings: 55000 # EUR
  total_annual_cost: 21000 # EUR (15000 + 12*500)
  net_annual_benefit: 34000 # EUR
  payback_period: 5.3 # months
  annual_roi: 227% # (34000/15000)*100

# datenschutz_config.yaml
gdpr_compliance:
  data_processing:
    - purpose_limitation: 'Nur für Kundenservice und Support'
    - data_minimization: 'Minimale Datensammlung'
    - storage_limitation: 'Löschung nach 2 Jahren'
    - accuracy: 'Regelmäßige Datenaktualisierung'

  user_rights:
    - right_to_access: 'Datenauskunft möglich'
    - right_to_rectification: 'Datenkorrektur'
    - right_to_erasure: 'Recht auf Löschung'
    - right_to_portability: 'Datenübertragbarkeit'

  technical_measures:
    - encryption: 'Ende-zu-Ende Verschlüsselung'
    - access_control: 'Rollenbasierte Berechtigungen'
    - audit_logging: 'Vollständige Protokollierung'
    - data_backup: 'Regelmäßige Backups'

# security_setup.sh
#!/bin/bash

# Firewall-Konfiguration
ufw allow 3000/tcp  # OpenWebUI
ufw allow 11434/tcp # Ollama
ufw deny 8000/tcp   # ChromaDB (nur intern)

# SSL/TLS-Zertifikat
certbot --nginx -d chatbot.kmu-domain.de

# Backup-Script
cat > /opt/backup_chatbot.sh << 'EOF'
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
tar -czf /backup/chatbot_$DATE.tar.gz /opt/openwebui/data
find /backup -name "chatbot_*.tar.gz" -mtime +30 -delete
EOF

chmod +x /opt/backup_chatbot.sh
crontab -l | { cat; echo "0 2 * * * /opt/backup_chatbot.sh"; } | crontab -