1. Vorbereitung

Voraussetzungen

Für die Installation und den Betrieb des DataVaults benötigen Sie:

Software

  • Docker (Version 20.10.0 oder höher)
  • Docker Compose (Version 2.0.0 oder höher)

System-Anforderungen

  • Mindestens 4GB RAM
  • Mindestens 20GB freier Festplattenspeicher (abhängig von der Datenmenge)
  • CPU: 2 Kerne oder mehr empfohlen

Netzwerk

  • Ausgehende Verbindungen zu:
    • vault-proxy.meingpt.com (für die Verbindung zu meinGPT)
    • Ihrem gewählten Embedding-Service (falls Cloud-basiert)
    • Ihren Datenquellen (z.B. SharePoint, S3, etc.)

Embedding-Modell

Für den Betrieb des DataVaults ist ein Embedding-Modell notwendig. Hierfür muss entweder bei einem entsprechenden Cloud-Anbieter ein Modell deployt bzw. ein API-Key erstellt werden, oder ein Modell für den lokalen Betrieb ausgewählt werden.

Mehr informationen zur Auswahl eines Embedding-Modells finden Sie hier

Das wechseln des Embedding-Modells erfordert ein erneutes verarbeiten sämtlicher Daten, da die Embeddings untereinander nicht kompatibel sind. Dies kann mit erheblichen Kosten verbunden sein.

2. DataVault anlegen

Als erstes muss der neue DataVault in meinGPT erstellt werden. Hierbei werden die ID für den Vault und der geheime Schlüssel für den Vault erstellt, die in den folgenden Schritten benötigt werden. Befolgen Sie dazu folgende Schritte:

  1. Navigieren Sie auf app.meingpt.com zu den Einstellungen Ihres Unternehmens
  2. Öffnen Sie den Tab “Data Vaults”
  3. Klicken Sie auf “DataVault hinzufügen”. Es öffnet sich ein Dialogfenster
  4. Geben Sie einen beliebigen Namen für den DataVault ein und drücken Sie auf “create connection”. Das URL-Feld muss leer bleiben.
  5. Es öffnet sich ein Dialogfeld mit der ID und dem geheimen Schlüssel (Secret Key) des DataVault. Kopieren Sie beide zu einem sicheren Ort, da Sie für die folgenden Schritte benötigt werden.
  6. Schließen Sie das Dialogfeld.

In der Übersicht sollte jetzt der neue DataVault zu sehen sein. Der rote Punkt zeigt an, dass der Vault aktuell nicht erreichbar ist.

3. Docker Compose Datei erstellen

Die einfachste Möglichkeit, den DataVault zu deployen, ist die von uns bereitgestellte docker-compose.yaml Datei. Hier müssen lediglich einige Konfigurationswerte angepasst werden:

  • <DataVault-ID>: Die in Schritt 1 kopierte ID des DataVault
  • <Vault-Data-Path>: Der Pfad auf dem Host-System, unter dem die Dateien für die Synchronisierung zwischengespeichert werden sollen
  • <DB-Data-Path>: Der Pfad auf dem Host-System, unter dem die Dateien der Vektor-Datenbank gespeichert werden sollen.
docker-compose.yml
services:
  vault:
    image: meingpt/vault:latest
    restart: unless-stopped
    expose:
      - 8080
    depends_on:
      - weaviate
    networks:
      - vault_network
    volumes:
      - ./vault_config.yaml:/app/vault_config.yaml
      - <Data-Path>:/data/vault
    environment:
      VAULT_CONFIG_FILE_PATH: /app/vault_config.yaml
    env_file:
      - vault.env

  piko:
    image: ghcr.io/andydunstall/piko:latest
    command:
      - agent
      - http
      - <Vault-ID>
      - vault:8080
      - --connect.url
      - https://vault-proxy.meingpt.com
    networks:
      - vault_network

  weaviate:
    command:
      - --host
      - 0.0.0.0
      - --port
      - "8080"
      - --scheme
      - http
    image: cr.weaviate.io/semitechnologies/weaviate:1.28.2
    expose:
      - 8080
      - 50051
    volumes:
      - <DB-Data-Path>:/var/lib/weaviate
    restart: unless-stopped
    environment:
      QUERY_DEFAULTS_LIMIT: 100
      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: "true"
      PERSISTENCE_DATA_PATH: "/var/lib/weaviate"
      ENABLE_API_BASED_MODULES: "true"
      CLUSTER_HOSTNAME: "node1"
    networks:
      - vault_network
    healthcheck:
      test: "curl http://localhost:8080/v1/.well-known/ready"
      interval: 10s
      timeout: 1s

networks:
  vault_network:

4. DataVault konfigurieren

Vorlage anpassen

Die Konfiguration für den DataVault erfolgt über eine einzige YAML-Datei, die beim starten des service gelesen wird. Um diese zu erstellen, können Sie einfach in der Vorlage die folgenden Platzhalter ersetzen:

  • <DataVault-ID>: Die in Schritt 1 kopierte ID des DataVault
  • <DataVault-Secret>: Der in Schritt 1 kopierte geheime Schlüssel des DataVault
  • <EMBEDDING_MODEL_SECTION>: Konfiguration für das Embedding-Model
  • <EMBEDDING_MODEL_SECTION>: Konfiguration für Datenpools
vault-config.yaml
version: 1.0

vault:
  id: <DataVault-ID>
  data_dir: /data/vault
  secret: <DataVault-Secret>

weaviate:
  connection_type: "local"
  host: weaviate
  port: 8001
  grpc_host: weaviate
  grpc_port: 50051

embedding_model:
<EMBEDDING_MODEL_SECTION>

# Datapools will be configured in meinGPT
data_pools:
<DATA_POOL_SECTION>

Die Konfigurationsdatei für den Vault unterstützt das laden von Werten aus der Ugebungsvariablen mit der Syntax key: $ENVIRONMENT_VARIABLE. Dies ist besonder nützlich, wenn geheime Werte wie API-Schlüssel getrennt von der Konfiguration aufbewahrt werden sollen.

Embedding-Modell konfigurieren

Fügen Sie die Konfiguration für das von Ihnen in Schritt 1 gewählte Embedding Modell anstelle von <EMBEDDING_MODEL_SECTION> ein. Details zur Konfiguration von Embeddings finden Sie hier

Datenpools erstellen

Um einen neuen Datenpool zu erstellen, muss dieser analog zum DataVault selbst, in meinGPT erstellt werden. Folgen Sie dazu diesen Schritten:

  1. Navigieren Sie auf app.meingpt.com zu den Einstellungen Ihres Unternehmens
  2. Öffnen Sie den Tab “Datenpools”
  3. Klicken Sie auf “Pool hinzufügen”. Es öffnet sich ein Dialogfenster
  4. Wählen Sie den DataVault aus, zu dem der Pool gehören soll.
  5. Wählen Sie eine Quelle für den Datenpool aus. Anschließend öffnet sich die Einstellungseite des Datenpools, auf der Sie einen Namen und eine Beschreibung für den Pool eingeben können.
  6. Kopieren Sie die ID des Datenpools aus der Adressleiste der Seite. Die ID des Pools ist das letze URL-Segment nach dataPool/.
  7. Erstellen Sie die Konfiguration für den Datenpool entsprechend der Konfigurationsreferenz für Datenpools und fügen Sie diese anstelle von <DATA_POOL_SECTION> in der Konfigurationsdatei ein.
Beispiel-Konfiguration
data_pools:
  - id: cm6fqlzyw000xs1dqql1bg37p
    type: s3
    endpoint: fsn1.your-objectstorage.com
    access_key_id: $HETZNER_S3_ACCESS_KEY
    secret_access_key: $HETZNER_S3_SECRET_KEY
    bucket_name: meingpt-staging
    base_path: data-vault/wiki

5. Starten

Anschließend kann der DataVault mit dem Befehl

docker compose up -d

gestartet werden. Docker lädt automatisch die benötigten Images und startet diese in der richtigen Reihenfolge.

6. Überprüfen

Nach dem Start des DataVaults sollten Sie die folgenden Schritte durchführen, um sicherzustellen, dass alles korrekt funktioniert:

Logs überprüfen

Schauen Sie sich die Logs des Vault-Services an:

docker compose logs -f vault
  • Wenn die Konfiguration ungültig ist oder Werte fehlen, wird dies als erstes in den Logs angezeigt
  • Bei erfolgreicher Konfiguration sehen Sie Logs über die erfolgreiche Verbindung zu Weaviate und die Initialisierung des Vaults

Connection-Status überprüfen

Überprüfen Sie den Connection-Status in meinGPT:

  1. Navigieren Sie auf app.meingpt.com zu den Einstellungen Ihres Unternehmens
  2. Öffnen Sie den Tab “Data Vaults”
  3. Der Status-Indikator neben Ihrem DataVault sollte nun grün sein, was eine erfolgreiche Verbindung anzeigt

Synchronisation überprüfen

Der DataVault startet automatisch zu jeder vollen Viertelstunde (z.B. 10:00, 10:15, 10:30, …) einen Ingestion-Job. Um die Synchronisation zu überprüfen:

  1. Beobachten Sie die Logs auf Aktivität des Ingestion-Jobs:
docker compose logs -f vault | grep "ingestion"
  1. Überprüfen Sie das Data-Verzeichnis (<Vault-Data-Path>) auf neu synchronisierte Dateien

Der erste Synchronisationslauf kann längere Zeit in Anspruch nehmen, da zunächst alle verfügbaren Daten heruntergeladen und verarbeitet werden müssen. Nachfolgende Synchronisationen sind in der Regel deutlich schneller, da nur Änderungen verarbeitet werden.

Wenn diese Schritte erfolgreich sind, ist Ihr DataVault einsatzbereit und wird in regelmäßigen Abständen neue Daten synchronisieren.