OpenWebUI + Azure: Maschinenbauer spart €42k/Jahr mit Doku-Chatbot [Case Study]

graph TB
    A[Mitarbeiter] --> B[OpenWebUI<br/>Self-Hosted]
    B --> C[Load Balancer<br/>NGINX]
    C --> D[Private Network<br/>VPN Tunnel]
    D --> E[Azure AI Studio<br/>Deutschland West]
    E --> F[Fine-tuned GPT-4<br/>Private Deployment]

    B --> G[PostgreSQL<br/>Chat History]
    B --> H[Document Store<br/>Vector DB]
    H --> I[Embedded Documents<br/>15k+ Files]

    J[Active Directory] --> B
    K[Azure Monitor] --> E
    L[Prometheus] --> B

    style B fill:#e1f5fe
    style F fill:#e8f5e8
    style H fill:#fff3e0
    style I fill:#fce4ec

# docker-compose.yml für OpenWebUI
version: '3.8'
services:
  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY}
      - ENABLE_OAUTH=true
      - OAUTH_PROVIDER=azure
      - AZURE_CLIENT_ID=${AZURE_CLIENT_ID}
      - AZURE_CLIENT_SECRET=${AZURE_CLIENT_SECRET}
    ports:
      - "3000:8080"
    volumes:
      - open-webui:/app/backend/data
    networks:
      - webui-network
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: openwebui
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - webui-network

# Azure CLI Setup für Private Deployment
az cognitiveservices account create \
  --name "techmach-openai-private" \
  --resource-group "rg-techmach-ai" \
  --kind "OpenAI" \
  --sku "S0" \
  --location "germanywest" \
  --custom-domain "techmach-openai-private" \
  --public-network-access Disabled

# Private Endpoint für sicheren Zugriff
az network private-endpoint create \
  --resource-group "rg-techmach-ai" \
  --name "pe-openai-techmach" \
  --vnet-name "vnet-techmach" \
  --subnet "subnet-ai" \
  --private-connection-resource-id "/subscriptions/.../openai" \
  --connection-name "openai-connection"

# Automatisierte Dokumentenverarbeitung
import PyPDF2
import docx2txt
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import AzureOpenAIEmbeddings
from langchain.vectorstores import Chroma

class TechMachDocumentProcessor:
    def __init__(self):
        self.embeddings = AzureOpenAIEmbeddings(
            azure_endpoint="https://techmach-openai-private.openai.azure.com/",
            api_key=os.getenv("AZURE_OPENAI_KEY"),
            azure_deployment="text-embedding-ada-002",
            api_version="2024-02-01"
        )

    def process_technical_docs(self, directory_path):
        # Lade verschiedene Dateiformate
        loader = DirectoryLoader(
            directory_path,
            glob="**/*.{pdf,docx,txt,md}",
            loader_cls_kwargs={'encoding': 'utf-8'}
        )

        documents = loader.load()

        # Splitte für bessere Embedding-Performance
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
        )

        chunks = text_splitter.split_documents(documents)

        # Erstelle Vector Store
        vectorstore = Chroma.from_documents(
            documents=chunks,
            embedding=self.embeddings,
            persist_directory="./techmach_vectordb"
        )

        return vectorstore

# RAG Pipeline für technische Anfragen
class TechMachRAG:
    def __init__(self, vectorstore, azure_client):
        self.vectorstore = vectorstore
        self.azure_client = azure_client

    def query_technical_knowledge(self, question, top_k=5):
        # Suche relevante Dokumente
        relevant_docs = self.vectorstore.similarity_search(
            question,
            k=top_k
        )

        # Erstelle Kontext aus gefundenen Dokumenten
        context = "\n\n".join([doc.page_content for doc in relevant_docs])

        # Prompt für technische Antworten
        prompt = f"""
        Du bist ein Experte für [Maschinenbau](/blog/ki-gestützter-maschinenbau-für-großunternehmen-optimierung-d) und technische Dokumentation.

        Kontext aus Firmendokumentation:
        {context}

        Frage: {question}

        Antworte präzise und technisch korrekt. Wenn die Information nicht im Kontext steht, sage das deutlich.
        Gib immer die Quelle der Information an.
        """

        response = self.azure_client.chat.completions.create(
            model="gpt-4-techmach-finetuned",
            messages=[
                {"role": "system", "content": "Du bist ein technischer Assistent für Maschinenbau."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=1000,
            temperature=0.2
        )

        return response.choices[0].message.content

# Erstelle Training-Dataset aus Firmendokumentationen
import json

class FineTuningDataPreparation:
    def create_training_data(self):
        training_examples = []

        # Beispiel: FAQ aus Technik-Support
        examples = [
            {
                "messages": [
                    {"role": "system", "content": "Du bist Experte für TechMach Maschinen."},
                    {"role": "user", "content": "Wie stelle ich die Hydraulikpumpe der Serie TM-500 ein?"},
                    {"role": "assistant", "content": "Die Hydraulikpumpe der TM-500 Serie wird über das Druckventil V3 eingestellt. Referenz: Handbuch TM-500-HYD-2023, Seite 47. Schritte: 1) Maschine in Wartungsposition, 2) Druck auf 150 bar einstellen..."}
                ]
            },
            # ... weitere 2000+ Beispiele
        ]

        return training_examples

    def upload_to_azure(self, training_data):
        # Upload zu Azure OpenAI für Fine-Tuning
        file_response = openai.File.create(
            file=open("techmach_training.jsonl", "rb"),
            purpose="fine-tune"
        )

        # Starte Fine-Tuning Job
        fine_tune_response = openai.FineTuningJob.create(
            training_file=file_response.id,
            model="gpt-4-0613",
            suffix="techmach-v1"
        )

        return fine_tune_response

# nginx.conf für Reverse Proxy mit Security
server {
    listen 443 ssl http2;
    server_name chat.techmach.internal;

    # SSL Konfiguration
    ssl_certificate /etc/ssl/certs/techmach.crt;
    ssl_certificate_key /etc/ssl/private/techmach.key;
    ssl_protocols TLSv1.2 TLSv1.3;

    # Security Headers
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;

    # Rate Limiting
    limit_req zone=api burst=10 nodelay;

    location / {
        # Client Certificate Verification
        ssl_verify_client on;
        ssl_client_certificate /etc/ssl/certs/ca.crt;

        proxy_pass http://openwebui:8080;
        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;

        # WebSocket Support für Real-time Chat
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

# Azure AD Integration für MFA
from azure.identity import DefaultAzureCredential
from msal import ConfidentialClientApplication

class TechMachAuth:
    def __init__(self):
        self.app = ConfidentialClientApplication(
            client_id=os.getenv("AZURE_CLIENT_ID"),
            client_credential=os.getenv("AZURE_CLIENT_SECRET"),
            authority="https://login.microsoftonline.com/techmach-tenant-id"
        )

    def authenticate_user(self, username, password, mfa_code):
        # Step 1: Username/Password
        result = self.app.acquire_token_by_username_password(
            username=username,
            password=password,
            scopes=["https://graph.microsoft.com/.default"]
        )

        if "access_token" not in result:
            return False, "Invalid credentials"

        # Step 2: MFA Verification
        mfa_result = self.verify_mfa_token(mfa_code, result["access_token"])

        return mfa_result, "Authentication successful"

# OCR + [Computer Vision](/blog/ki-qualitaetskontrolle-bilderkennung-produktion) für technische Zeichnungen
from azure.cognitiveservices.vision.computervision import ComputerVisionClient
import cv2

class TechnicalDrawingProcessor:
    def extract_text_from_drawing(self, image_path):
        # Preprocessing für bessere OCR
        image = cv2.imread(image_path)
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        enhanced = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

        # Azure Computer Vision OCR
        result = self.cv_client.read_in_stream(enhanced, raw=True)

        # Extrahiere technische Annotationen
        technical_text = self.parse_technical_annotations(result)
        return technical_text

# Multi-Modal Search in Text + Bildern
class MultiModalSearch:
    def search_across_modalities(self, query):
        # Text Search
        text_results = self.vector_search(query)

        # Image Search (technische Zeichnungen)
        image_results = self.image_similarity_search(query)

        # CAD-Metadaten Search
        cad_results = self.cad_metadata_search(query)

        # Kombiniere und ranke Ergebnisse
        combined_results = self.rank_and_combine([
            text_results, image_results, cad_results
        ])

        return combined_results

// React Dashboard für Nutzungsstatistiken
const TechMachAnalytics = () => {
  const [metrics, setMetrics] = useState({
    dailyQueries: 0,
    topSearchTerms: [],
    userSatisfaction: 0,
    documentCoverage: 0,
  })

  return (
    <Dashboard>
      <MetricCard
        title="Tägliche Anfragen"
        value={metrics.dailyQueries}
        trend="+15% vs. letzte Woche"
      />
      <SearchTermsChart data={metrics.topSearchTerms} />
      <SatisfactionScore score={metrics.userSatisfaction} />
      <DocumentCoverageMap coverage={metrics.documentCoverage} />
    </Dashboard>
  )
}