VectorETL

Vectoretl: Leichtes ETL -Framework für Vektordatenbanken

Vectoretl By Context Data ist ein modulares Framework, mit dem Daten und KI -Ingenieure in nur wenigen Minuten für ihre KI -Anwendungen verarbeitet werden können!

Vectoretl optimiert den Prozess der Konvertierung verschiedener Datenquellen in Vektor -Einbettungen und speichert sie in verschiedenen Vektor -Datenbanken. Es unterstützt mehrere Datenquellen (Datenbanken, Cloud -Speicher und lokale Dateien), verschiedene Einbettungsmodelle (einschließlich OpenAI, Coherin und Google Gemini) und mehrere Vektordatenbankziele (wie Pinecone, QDrant und Weaviate).

Diese Pipeline zielt darauf ab, die Erstellung und das Management von Vektorsuchsystemen zu vereinfachen und Entwicklern und Datenwissenschaftlern auf einfache Weise Anwendungen zu erstellen und zu skalieren, für die semantische Suche, Empfehlungssysteme oder andere vektorbasierte Vorgänge erforderlich sind.

Merkmale

• Modulare Architektur mit Unterstützung mehrerer Datenquellen, Einbettungsmodelle und Vektordatenbanken
• Batch -Verarbeitung für effizientes Umgang mit großen Datensätzen
• Konfigurierbares Chunking und Überlappung für Textdaten
• Einfache Integration neuer Datenquellen, Einbettungsmodelle und Vektordatenbanken

Dokumentation

Inhaltstabelle

1. Installation
2. Verwendung
3. Projektübersicht
4. Konfiguration
   • Quellkonfiguration
   • Verwenden von Unstrukturierter zur Verarbeitung von Quelldateien
   • Einbettung der Konfiguration
   • Zielkonfiguration
5. Beitragen
6. Beispiele
7. Dokumentation

1. Installation

pip install --upgrade vector-etl

oder

pip install git+https://github.com/ContextData/VectorETL.git

2. Nutzung

Dieser Abschnitt enthält Anweisungen zur Verwendung des ETL -Frameworks für Vektordatenbanken. Wir werden das Laufen abdecken, Konfigurationen validieren und einige häufige Verwendung von Beispielen angeben.

Option 1: Vektoretl in Ihre Python -Anwendung importieren (mit einer YAML -Konfigurationsdatei)

Angenommen, Sie haben eine Konfigurationsdatei, die der folgenden Datei ähnelt.

 source :
  source_data_type : " database "
  db_type : " postgres "
  host : " localhost "
  database_name : " customer_data "
  username : " user "
  password : " password "
  port : 5432
  query : " SELECT * FROM customers WHERE updated_at > :last_updated_at "
  batch_size : 1000
  chunk_size : 1000
  chunk_overlap : 0

embedding :
  embedding_model : " OpenAI "
  api_key : ${OPENAI_API_KEY}
  model_name : " text-embedding-ada-002 "

target :
  target_database : " Pinecone "
  pinecone_api_key : ${PINECONE_API_KEY}
  index_name : " customer-embeddings "
  dimension : 1536
  metric : " cosine "

embed_columns :
  - " customer_name "
  - " customer_description "
  - " purchase_history "

Sie können die Konfiguration dann in Ihr Python -Projekt importieren und sie automatisch von dort ausführen

 from vector_etl import create_flow

flow = create_flow ()
flow . load_yaml ( '/path/to/your/config.yaml' )
flow . execute ()

Option 2: Aus der Befehlszeile mit einer Konfigurationsdatei ausführen

Wenn Sie dieselbe YAML -Konfigurationsdatei von Option 2 oben verwenden, können Sie den Vorgang direkt aus Ihrer Befehlszeile ausführen, ohne ihn in eine Python -Anwendung importieren zu müssen.

Verwenden Sie den folgenden Befehl, um das ETL -Framework auszuführen:

vector-etl -c /path/to/your/config.yaml

Option 3: Importieren von Vectoretl in Ihre Python -Anwendung

 from vector_etl import create_flow

source = {
    "source_data_type" : "database" ,
    "db_type" : "postgres" ,
    "host" : "localhost" ,
    "port" : "5432" ,
    "database_name" : "test" ,
    "username" : "user" ,
    "password" : "password" ,
    "query" : "select * from test" ,
    "batch_size" : 1000 ,
    "chunk_size" : 1000 ,
    "chunk_overlap" : 0 ,
}

embedding = {
    "embedding_model" : "OpenAI" ,
    "api_key" : ${ OPENAI_API_KEY },
    "model_name" : "text-embedding-ada-002"
}

target = {
    "target_database" : "Pinecone" ,
    "pinecone_api_key" : ${ PINECONE_API_KEY },
    "index_name" : "my-pinecone-index" ,
    "dimension" : 1536
}

embed_columns = [ "customer_name" , "customer_description" , "purchase_history" ]

flow = create_flow ()
flow . set_source ( source )
flow . set_embedding ( embedding )
flow . set_target ( target )
flow . set_embed_columns ( embed_columns )

# Execute the flow
flow . execute ()

Häufige Verwendungsbeispiele

Hier sind einige Beispiele für die Verwendung des ETL -Frameworks für verschiedene Szenarien:

1. Verarbeitung von Daten aus einer PostgreSQL -Datenbank zu Pinecone

vector-etl -c config/postgres_to_pinecone.yaml

Wo postgres_to_pinecone.yaml aussehen könnte:

 source :
  source_data_type : " database "
  db_type : " postgres "
  host : " localhost "
  database_name : " customer_data "
  username : " user "
  password : " password "
  port : 5432
  query : " SELECT * FROM customers WHERE updated_at > :last_updated_at "
  batch_size : 1000
  chunk_size : 1000
  chunk_overlap : 0

embedding :
  embedding_model : " OpenAI "
  api_key : ${OPENAI_API_KEY}
  model_name : " text-embedding-ada-002 "

target :
  target_database : " Pinecone "
  pinecone_api_key : ${PINECONE_API_KEY}
  index_name : " customer-embeddings "
  dimension : 1536
  metric : " cosine "

embed_columns :
  - " customer_name "
  - " customer_description "
  - " purchase_history " 

2. Bearbeiten von CSV -Dateien von S3 nach QDrant

vector-etl -c config/s3_to_qdrant.yaml

Wo s3_to_qdrant.yaml aussehen könnte:

 source :
  source_data_type : " Amazon S3 "
  bucket_name : " my-data-bucket "
  prefix : " customer_data/ "
  file_type : " csv "
  aws_access_key_id : ${AWS_ACCESS_KEY_ID}
  aws_secret_access_key : ${AWS_SECRET_ACCESS_KEY}
  chunk_size : 1000
  chunk_overlap : 200

embedding :
  embedding_model : " Cohere "
  api_key : ${COHERE_API_KEY}
  model_name : " embed-english-v2.0 "

target :
  target_database : " Qdrant "
  qdrant_url : " https://your-qdrant-cluster-url.qdrant.io "
  qdrant_api_key : ${QDRANT_API_KEY}
  collection_name : " customer_embeddings "

embed_columns : [] 

3. Projektüberblick

Das Vectoretl -Framework (Extrakt, Transformation, Last) ist ein leistungsstarkes und flexibles Tool, das den Prozess des Extrahierens von Daten aus verschiedenen Quellen, um sie in Vektor -Einbettungen zu verwandeln und diese Einbettungen in einen Bereich von Vektordatenbanken zu laden.

Es ist mit Modularität, Skalierbarkeit und Benutzerfreundlichkeit aufgebaut, was es zu einer idealen Lösung für Unternehmen macht, die die Leistung der Vektorsuche in ihrer Dateninfrastruktur nutzen möchten.

Schlüsselaspekte:

1. Vielseitige Datenextraktion : Das Framework unterstützt eine Vielzahl von Datenquellen, einschließlich herkömmlicher Datenbanken, Cloud -Speicherlösungen (wie Amazon S3 und Google Cloud Storage) und beliebten SaaS -Plattformen (wie Stripe und Zendesk). Mit dieser Vielseitigkeit können Sie Daten aus mehreren Quellen in eine einheitliche Vektor -Datenbank konsolidieren.

2. Erweiterte Textverarbeitung : Für Textdaten implementiert das Framework komplexierte Chunking- und überlappende Techniken. Dies stellt sicher, dass der semantische Kontext des Textes beim Erstellen von Vektoreinbettungen erhalten bleibt, was zu genaueren Suchergebnissen führt.

3. Hochmoderne Einbettungsmodelle : Das System integriert sich in führende Einbettungsmodelle wie OpenAI, Cohere, Google Gemini und Azure OpenAI. Auf diese Weise können Sie das Einbettungsmodell auswählen, das am besten zu Ihren spezifischen Anwendungsfall- und Qualitätsanforderungen passt.

4. Support für mehrere Vektordatenbank : Egal, ob Sie PineCone, QDrant, Weaaviate, Singlestore, Supabase oder LancyB verwenden, dieses Framework hat Sie abgedeckt. Es wurde so konzipiert, dass es sich nahtlos mit diesen beliebten Vektor -Datenbanken verbinden, sodass Sie die auswählen können, die Ihren Anforderungen am besten entspricht.

5. Konfigurierbar und erweiterbar : Das gesamte Framework ist über YAML- oder JSON -Konfigurationsdateien hoch konfigurierbar. Darüber hinaus erleichtert die modulare Architektur es einfach, mit neuen Datenquellen, Einbettungsmodellen oder Vektordatenbanken zu erweitern, wenn sich Ihre Anforderungen entwickeln.

Dieses ETL -Framework ist ideal für Organisationen, die ihre Vektor -Suchfunktionen implementieren oder aktualisieren möchten.

Durch Automatisierung des Datenprozesses, das Erstellen von Vektor -Einbettungen und das Speichern von Daten in einer Vektordatenbank reduziert dieses Framework die Zeit und Komplexität, die mit der Einrichtung eines Vektorsuchsystems verbunden ist, erheblich. Es ermöglicht Datenwissenschaftlern und Ingenieuren, sich darauf zu konzentrieren, Erkenntnisse und Anwendungen zu erstellen, anstatt sich um die Feinheiten der Datenverarbeitung und der Vektorspeicherung zu sorgen.

4. Konfiguration

Das ETL -Framework verwendet eine Konfigurationsdatei, um die Details der Quelle, des Einbettungsmodells, der Zieldatenbank und anderer Parameter anzugeben. Sie können entweder das YAML- oder JSON -Format für die Konfigurationsdatei verwenden.

Konfigurationsdateistruktur

Die Konfigurationsdatei ist in drei Hauptabschnitte unterteilt:

1. source : Gibt die Datenquellendetails an
2. embedding : Definiert das zu verwendende Einbettungsmodell
3. target : Umrichtet die Zielvektordatenbank
4. embed_columns : Definiert die Spalten, die eingebettet werden müssen (hauptsächlich für strukturierte Datenquellen)

Beispielkonfigurationen

Importieren von Vectoretl in Ihre Python -Anwendung

 from vector_etl import create_flow

source = {
    "source_data_type" : "database" ,
    "db_type" : "postgres" ,
    "host" : "localhost" ,
    "port" : "5432" ,
    "database_name" : "test" ,
    "username" : "user" ,
    "password" : "password" ,
    "query" : "select * from test" ,
    "batch_size" : 1000 ,
    "chunk_size" : 1000 ,
    "chunk_overlap" : 0 ,
}

embedding = {
    "embedding_model" : "OpenAI" ,
    "api_key" : ${ OPENAI_API_KEY },
    "model_name" : "text-embedding-ada-002"
}

target = {
    "target_database" : "Pinecone" ,
    "pinecone_api_key" : ${ PINECONE_API_KEY },
    "index_name" : "my-pinecone-index" ,
    "dimension" : 1536
}

embed_columns = [ "customer_name" , "customer_description" , "purchase_history" ]

Eigenständige YAML -Dateikonfiguration (z. B. config.yaml)

 source :
  source_data_type : " database "
  db_type : " postgres "
  host : " localhost "
  database_name : " mydb "
  username : " user "
  password : " password "
  port : 5432
  query : " SELECT * FROM mytable WHERE updated_at > :last_updated_at "
  batch_size : 1000
  chunk_size : 1000
  chunk_overlap : 0

embedding :
  embedding_model : " OpenAI "
  api_key : " your-openai-api-key "
  model_name : " text-embedding-ada-002 "

target :
  target_database : " Pinecone "
  pinecone_api_key : " your-pinecone-api-key "
  index_name : " my-index "
  dimension : 1536
  metric : " cosine "
  cloud : " aws "
  region : " us-west-2 "

embed_columns :
  - " column1 "
  - " column2 "
  - " column3 " 

Eigenständige JSON -Dateikonfiguration (z. B. config.json)

{
  "source" : {
    "source_data_type" : " database " ,
    "db_type" : " postgres " ,
    "host" : " localhost " ,
    "database_name" : " mydb " ,
    "username" : " user " ,
    "password" : " password " ,
    "port" : 5432 ,
    "query" : " SELECT * FROM mytable WHERE updated_at > :last_updated_at " ,
    "batch_size" : 1000 ,
    "chunk_size" : 1000 ,
    "chunk_overlap" : 0
  },

  "embedding" : {
    "embedding_model" : " OpenAI " ,
    "api_key" : " your-openai-api-key " ,
    "model_name" : " text-embedding-ada-002 "
  },

  "target" : {
    "target_database" : " Pinecone " ,
    "pinecone_api_key" : " your-pinecone-api-key " ,
    "index_name" : " my-index " ,
    "dimension" : 1536 ,
    "metric" : " cosine " ,
    "cloud" : " aws " ,
    "region" : " us-west-2 "
  },

  "embed_columns" : [ " column1 " , " column2 " , " column3 " ]
}

Konfigurationsabschnitte erläutert

Quellkonfiguration

Der source variiert basierend auf dem source_data_type . Hier sind Beispiele für verschiedene Quelltypen:

Datenbankquelle

{
  "source_data_type" : " database " ,
  "db_type" : " postgres " ,  # or "mysql", "snowflake", "salesforce"
  "host" : " localhost " ,
  "database_name" : " mydb " ,
  "username" : " user " ,
  "password" : " password " ,
  "port" : 5432 ,
  "query" : " SELECT * FROM mytable WHERE updated_at > :last_updated_at " ,
  "batch_size" : 1000 ,
  "chunk_size" : 1000 ,
  "chunk_overlap" : 0
}

 source :
  source_data_type : " database "
  db_type : " postgres "  # or "mysql", "snowflake", "salesforce"
  host : " localhost "
  database_name : " mydb "
  username : " user "
  password : " password "
  port : 5432
  query : " SELECT * FROM mytable WHERE updated_at > :last_updated_at "
  batch_size : 1000
  chunk_size : 1000
  chunk_overlap : 0 

S3 Quelle

{
  "source_data_type" : " Amazon S3 " ,
  "bucket_name" : " my-bucket " ,
  "key" : " path/to/files/ " ,
  "file_type" : " .csv " ,
  "aws_access_key_id" : " your-access-key " ,
  "aws_secret_access_key" : " your-secret-key "
}

 source :
  source_data_type : " Amazon S3 "
  bucket_name : " my-bucket "
  key : " path/to/files/ "
  file_type : " .csv "
  aws_access_key_id : " your-access-key "
  aws_secret_access_key : " your-secret-key " 

Quelle für Google Cloud Storage (GCS)

{
  "source_data_type" : " Google Cloud Storage " ,
  "credentials_path" : " /path/to/your/credentials.json " ,
  "bucket_name" : " myBucket " ,
  "prefix" : " prefix/ " ,
  "file_type" : " csv " ,
  "chunk_size" : 1000 ,
  "chunk_overlap" : 0
}

 source :
  source_data_type : " Google Cloud Storage "
  credentials_path : " /path/to/your/credentials.json "
  bucket_name : " myBucket "
  prefix : " prefix/ "
  file_type : " csv "
  chunk_size : 1000
  chunk_overlap : 0 

Verwenden von Unstrukturierter zur Verarbeitung von Quelldateien

Ab Version 0.1.6.3 können Benutzer nun die serverlose API des unstrukturierten API des Unstrukturierten verwenden, um Daten effizient aus einer Vielzahl von dateibasierten Quellen zu extrahieren.

HINWEIS: Dies ist auf die unstrukturierte Severseless -API beschränkt und sollte nicht für das Open -Source -Framework des unstrukturierten Rahmens verwendet werden

Dies beschränkt sich auf [PDF, DOCX, DOC, TXT] -Dateien

Um unstrukturiert zu verwenden, benötigen Sie drei zusätzliche Parameter

1. use_unstructured : (true/false) Anzeige, das dem Framework mitteilt, dass sie die unstrukturierte API verwenden soll
2. unstructured_api_key : Geben Sie Ihre unstrukturierte API -Taste ein
3. unstructured_url : Geben Sie Ihre API -URL aus Ihrem unstrukturierten Dashboard ein

 # Example using Local file
source :
  source_data_type : " Local File "
  file_path : " /path/to/file.docx "
  file_type : " docx "
  use_unstructured : True
  unstructured_api_key : ' my-unstructured-key '
  unstructured_url : ' https://my-domain.api.unstructuredapp.io '

# Example using Amazon S3
source :
  source_data_type : " Amazon S3 "
  bucket_name : " myBucket "
  prefix : " Dir/Subdir/ "
  file_type : " pdf "
  aws_access_key_id : " your-access-key "
  aws_secret_access_key : " your-secret-access-key "
  use_unstructured : True
  unstructured_api_key : ' my-unstructured-key '
  unstructured_url : ' https://my-domain.api.unstructuredapp.io ' 

Einbettung der Konfiguration

Der embedding gibt an, welches Einbettungsmodell verwendet werden soll:

 embedding :
  embedding_model : " OpenAI "  # or "Cohere", "Google Gemini", "Azure OpenAI", "Hugging Face"
  api_key : " your-api-key "
  model_name : " text-embedding-ada-002 "  # model name varies by provider 

Zielkonfiguration

Der target variiert basierend auf der ausgewählten Vektordatenbank. Hier ist ein Beispiel für Tinecone:

 target :
  target_database : " Pinecone "
  pinecone_api_key : " your-pinecone-api-key "
  index_name : " my-index "
  dimension : 1536
  metric : " cosine "
  cloud : " aws "
  region : " us-west-2 " 

Säulen einbetten

In der Liste der embed_columns gibt an, welche Spalten aus den Quelldaten zum Generieren der Einbettungen verwendet werden sollten (gilt nur für die Datenbankquellen vorerst):

 embed_columns :
  - " column1 "
  - " column2 "
  - " column3 "

Die Liste der embed_columns -Liste ist nur für strukturierte Datenquellen (z. B. Postgresql, MySQL, Snowflake) erforderlich. Verwenden Sie für alle anderen Quellen eine leere Liste

 embed_columns : []

Umgang mit sensiblen Informationen

Um sensible Informationen wie API -Schlüssel und -kennwörter zu schützen, sollten Sie Umgebungsvariablen oder ein sicheres Geheimnismanagementsystem verwenden. Sie können diese dann in Ihrer Konfigurationsdatei verweisen:

 embedding :
  api_key : ${OPENAI_API_KEY}

Auf diese Weise können Sie Ihre Konfigurationsdateien in der Versionskontrolle aufbewahren, ohne sensible Daten freizulegen.

Denken Sie daran, Ihre Konfiguration anhand Ihrer spezifischen Datenquellen, Einbettungsmodelle und Zieldatenbanken anzupassen. In der Dokumentation für jeden Dienst finden Sie sicher, dass Sie alle erforderlichen Parameter bereitstellen.

5. Beitrag

Wir begrüßen Beiträge zum ETL -Framework für Vector -Datenbanken! Egal, ob Sie Fehler beheben, die Dokumentation verbessern oder neue Funktionen vorschlagen, Ihre Bemühungen werden geschätzt. So können Sie dazu beitragen:

Meldungsprobleme

Wenn Sie auf einen Fehler stoßen oder einen Vorschlag zur Verbesserung des ETL -Frameworks haben:

1. Überprüfen Sie die GitHub -Probleme, um festzustellen, ob das Problem oder Vorschlag bereits gemeldet wurde.
2. Wenn nicht, öffnen Sie ein neues Problem. Geben Sie einen klaren Titel und eine klare Beschreibung und so viele relevante Informationen wie möglich an, einschließlich:
   • Schritte zum Fortpflanzung (für Fehler)
   • Erwartete Verhalten
   • Tatsächliches Verhalten
   • Ihr Betriebssystem und Ihre Python -Version
   • Relevante Teile Ihrer Konfigurationsdatei (denken Sie daran, sensible Informationen zu entfernen)

Verbesserungen vorschlagen

Wir suchen immer nach Möglichkeiten, den ETL -Framework besser zu machen. Wenn Sie Ideen haben:

1. Eröffnen Sie eine neue Ausgabe auf GitHub.
2. Verwenden Sie einen klaren und beschreibenden Titel.
3. Geben Sie eine detaillierte Beschreibung der vorgeschlagenen Verbesserung an.
4. Erklären Sie, warum diese Verbesserung für die meisten Benutzer nützlich wäre.

Anfragen ziehen

Wir begrüßen Ihre Pull -Anfragen aktiv:

1. Geben Sie das Repo auf und erstellen Sie Ihren Zweig vom main .
2. Wenn Sie Code hinzugefügt haben, der getestet werden sollte, fügen Sie Tests hinzu.
3. Wenn Sie die APIs geändert haben, aktualisieren Sie die Dokumentation.
4. Stellen Sie sicher, dass die Testsuite übergeht.
5. Stellen Sie sicher, dass Ihr Code den vorhandenen Stilkonventionen folgt (siehe Codierungsstandards unten).
6. Geben Sie diese Pull -Anfrage aus!

Codierungsstandards

Um die Konsistenz während des gesamten Projekts aufrechtzuerhalten, halten Sie sich bitte an diese Codierungsstandards:

1. Folgen Sie Pep 8 Style Guide für Python Code.
2. Verwenden Sie sinnvolle Variablennamen und fügen Sie bei Bedarf Kommentare hinzu.
3. Schreiben Sie Docstrings für alle Funktionen, Klassen und Module.
4. Halten Sie die Funktionen klein und konzentrieren sich auf eine einzige Aufgabe.
5. Verwenden Sie Typ-Tipps, um die Code-Lesbarkeit zu verbessern und potenzielle Typ-bezogene Fehler zu fangen.

Dokumentation

Die Verbesserung der Dokumentation wird immer geschätzt:

• Wenn Sie in der Dokumentation einen Tippfehler oder einen Fehler finden, können Sie eine Pull -Anfrage bei der Korrektur abgeben.
• Für wesentliche Änderungen der Dokumentation öffnen Sie bitte zunächst ein Problem, um die vorgeschlagenen Änderungen zu besprechen.

Neue Funktionen hinzufügen

Wenn Sie darüber nachdenken, eine neue Funktion hinzuzufügen:

1. Öffnen Sie ein Problem, um die Funktion zu diskutieren, bevor Sie mit der Entwicklung beginnen.
2. Für neue Datenquellen:
   • Fügen Sie eine neue Datei in das Verzeichnis source_mods hinzu.
   • Implementieren Sie die erforderlichen Methoden wie in der Basisklasse definiert.
   • Aktualisieren Sie die Funktion get_source_class in source_mods/__init__.py .
3. Für neue Einbettungsmodelle:
   • Fügen Sie eine neue Datei in das Verzeichnis embedding_mods hinzu.
   • Implementieren Sie die erforderlichen Methoden wie in der Basisklasse definiert.
   • Aktualisieren Sie die Funktion get_embedding_model in embedding_mods/__init__.py .
4. Für neue Vektordatenbanken:
   • Fügen Sie eine neue Datei im Verzeichnis target_mods hinzu.
   • Implementieren Sie die erforderlichen Methoden wie in der Basisklasse definiert.
   • Aktualisieren Sie die Funktion get_target_database in target_mods/__init__.py .

Testen

• Schreiben Sie Unit -Tests für neue Funktionen oder Fehlerbehebungen.
• Stellen Sie sicher, dass alle Tests bestehen, bevor Sie eine Pull -Anfrage einreichen.
• Anstrengen Sie eine hohe Testabdeckung, insbesondere für kritische Teile der Codebasis.

Nachrichten begehen

• Verwenden Sie klare und aussagekräftige Feststellungsnachrichten.
• Starten Sie die Commit -Nachricht mit einer kurzen Zusammenfassung (bis zu 50 Zeichen).
• Geben Sie bei Bedarf detailliertere Erklärungen in nachfolgenden Zeilen an.

Überprüfungsprozess

• Alle Einsendungen, einschließlich Einreichungen von Projektmitgliedern, erfordern eine Überprüfung.
• Zu diesem Zweck verwenden wir Github Pull -Anfragen.
• Rezensenten können Änderungen anfordern, bevor eine Pull -Anfrage zusammengeführt werden kann.

Gemeinschaft (Zwietracht)

Wir ermutigen alle Benutzer, sich unserem Discord -Server anzuschließen, um mit dem Kontextdatenentwicklungsteam und anderen Mitwirkenden zusammenzuarbeiten, um Upgrades, neue Integrationen und Probleme vorzuschlagen.