VectorETL
1.0.0
VectorTl: Framework ETL léger pour les bases de données vectorielles
VectorTl by Context Data est un cadre modulaire conçu pour aider les données et les ingénieurs AI traitent les données de leurs applications en IA en quelques minutes!
VectorTl rationalise le processus de conversion de diverses sources de données en intégres vectoriels et de les stocker dans diverses bases de données vectorielles. Il prend en charge plusieurs sources de données (bases de données, stockage cloud et fichiers locaux), divers modèles d'intégration (y compris OpenAI, Cohere et Google Gemini), et plusieurs cibles de base de données vectorielles (comme Pinecone, Qdrant et Weavate).
Ce pipeline vise à simplifier la création et la gestion des systèmes de recherche de vecteurs, permettant aux développeurs et aux scientifiques des données de créer et d'échec facilement des applications qui nécessitent une recherche sémantique, des systèmes de recommandation ou d'autres opérations à base de vecteurs.
pip install --upgrade vector-etl
ou
pip install git+https://github.com/ContextData/VectorETL.git
Cette section fournit des instructions sur la façon d'utiliser le cadre ETL pour les bases de données vectorielles. Nous couvrirons en cours d'exécution, valider les configurations et fournirons quelques exemples d'utilisation courants.
En supposant que vous avez un fichier de configuration similaire au fichier ci-dessous.
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 "Vous pouvez ensuite importer la configuration dans votre projet Python et l'exécuter automatiquement à partir de là
from vector_etl import create_flow
flow = create_flow ()
flow . load_yaml ( '/path/to/your/config.yaml' )
flow . execute ()En utilisant le même fichier de configuration YAML à partir de l'option 2 ci-dessus, vous pouvez exécuter le processus directement à partir de votre ligne de commande sans avoir à l'importer dans une application Python.
Pour exécuter le framework ETL, utilisez la commande suivante:
vector-etl -c /path/to/your/config.yaml 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 ()Voici quelques exemples d'utilisation du cadre ETL pour différents scénarios:
vector-etl -c config/postgres_to_pinecone.yaml Où postgres_to_pinecone.yaml peut ressembler:
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 " vector-etl -c config/s3_to_qdrant.yaml Où s3_to_qdrant.yaml peut ressembler:
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 : [] Le cadre Vectorretl (Extract, Transform, Load) est un outil puissant et flexible conçu pour rationaliser le processus d'extraction des données de diverses sources, de le transformer en incorporations vectorielles et de charger ces intérêts en une gamme de bases de données vectorielles.
Il est construit avec la modularité, l'évolutivité et la facilité d'utilisation, ce qui en fait une solution idéale pour les organisations qui cherchent à tirer parti de la puissance de la recherche de vecteurs dans leur infrastructure de données.
Extraction de données polyvalente : le framework prend en charge un large éventail de sources de données, y compris les bases de données traditionnelles, les solutions de stockage cloud (comme Amazon S3 et Google Cloud Storage) et les plates-formes SaaS populaires (telles que Stripe et Zendesk). Cette polyvalence vous permet de consolider les données de plusieurs sources dans une base de données vectorielle unifiée.
Traitement de texte avancé : pour les données textuelles, le cadre met en œuvre des techniques sophistiquées de section et de chevauchement. Cela garantit que le contexte sémantique du texte est préservé lors de la création d'incorporation vectorielle, conduisant à des résultats de recherche plus précis.
Modèles d'incorporation de pointe : le système s'intègre aux principaux modèles d'intégration, notamment OpenAI, Cohere, Google Gemini et Azure OpenAI. Cela vous permet de choisir le modèle d'incorporation qui correspond le mieux à votre cas d'utilisation spécifique et à vos exigences de qualité.
Prise en charge de la base de données vectorielle multiple : Que vous utilisiez Pinecone, Qdrant, Weavate, Singlestore, Supabase ou LancedB, ce framework vous a couvert. Il est conçu pour interfacer de manière transparente avec ces bases de données de vecteur populaires, vous permettant de choisir celle qui répond le mieux à vos besoins.
Configurable et extensible : l'ensemble du framework est hautement configurable via des fichiers de configuration YAML ou JSON. De plus, son architecture modulaire facilite l'extension avec de nouvelles sources de données, des modèles d'intégration ou des bases de données vectorielles à mesure que vos besoins évoluent.
Ce cadre ETL est idéal pour les organisations qui cherchent à implémenter ou à mettre à niveau leurs capacités de recherche vectorielle.
En automatisant le processus d'extraction des données, de la création d'incorporces vectorielles et de les stocker dans une base de données vectorielle, ce cadre réduit considérablement le temps et la complexité impliqués dans la configuration d'un système de recherche de vecteur. Il permet aux scientifiques des données et aux ingénieurs de se concentrer sur la dérivation des informations et la création d'applications, plutôt que de s'inquiéter des subtilités du traitement des données et du stockage vectoriel.
L'ETL Framework utilise un fichier de configuration pour spécifier les détails de la source, du modèle d'intégration, de la base de données cible et d'autres paramètres. Vous pouvez utiliser le format YAML ou JSON pour le fichier de configuration.
Le fichier de configuration est divisé en trois sections principales:
source : Spécifie les détails de la source de donnéesembedding : définit le modèle d'incorporation à utilisertarget : décrit la base de données vectorielle cibleembed_columns : définit les colonnes qui doivent être intégrées (principalement pour les sources de données structurées) 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" ] 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 " {
"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 " ]
} La section source varie en fonction de la source_data_type . Voici des exemples pour différents types de sources:
{
"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 {
"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 " {
"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 À partir de la version 0.1.6.3, les utilisateurs peuvent désormais utiliser l'API sans serveur non structurée pour extraire efficacement les données d'une multitude de sources basées sur des fichiers.
Remarque: Ceci est limité à l'API sans structuration sans séparation et ne doit pas être utilisé pour le cadre open source non structuré
Ceci est limité aux fichiers [pdf, docx, doc, txt]
Afin d'utiliser non structuré, vous aurez besoin de trois paramètres supplémentaires
use_unstructured : (true / false) indicateur indiquant au framework pour utiliser l'API non structuréeunstructured_api_key : entrez votre clé d'API non structuréeunstructured_url : entrez votre URL de l'API à partir de votre tableau de bord non structuré # 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 ' La section embedding spécifie quel modèle d'intégration à utiliser:
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 La section target varie en fonction de la base de données vectorielle choisie. Voici un exemple pour Pinecone:
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 " La liste embed_columns spécifie quelles colonnes des données source doivent être utilisées pour générer les intégres (s'applique uniquement aux sources de base de données pour l'instant):
embed_columns :
- " column1 "
- " column2 "
- " column3 " La liste embed_columns n'est requise que pour les sources de données structurées (par exemple PostgreSQL, MySQL, Snowflake). Pour toutes les autres sources, utilisez une liste vide
embed_columns : []Pour protéger les informations sensibles comme les clés API et les mots de passe, envisagez d'utiliser des variables environnementales ou un système de gestion des secrets sécurisés. Vous pouvez ensuite les référer dans votre fichier de configuration:
embedding :
api_key : ${OPENAI_API_KEY}Cela vous permet de conserver vos fichiers de configuration dans le contrôle de version sans exposer les données sensibles.
N'oubliez pas d'ajuster votre configuration en fonction de vos sources de données spécifiques, de vos modèles d'intégration et de vos bases de données cibles. Reportez-vous à la documentation de chaque service afin de vous assurer que vous fournissez tous les paramètres requis.
Nous accueillons des contributions au Framework ETL pour les bases de données vectorielles! Que vous fixiez des bogues, que vous amélioriez la documentation ou que vous proposiez de nouvelles fonctionnalités, vos efforts sont appréciés. Voici comment vous pouvez contribuer:
Si vous rencontrez un bogue ou si vous avez une suggestion pour améliorer le cadre ETL:
Nous recherchons toujours des moyens d'améliorer le cadre ETL. Si vous avez des idées:
Nous accueillons activement vos demandes de traction:
main .Pour maintenir la cohérence tout au long du projet, veuillez respecter ces normes de codage:
L'amélioration de la documentation est toujours appréciée:
Si vous songez à ajouter une nouvelle fonctionnalité:
source_mods .get_source_class dans source_mods/__init__.py .embedding_mods .get_embedding_model dans embedding_mods/__init__.py .target_mods .get_target_database dans target_mods/__init__.py .Nous encourageons tous les utilisateurs à rejoindre notre serveur Discord pour collaborer avec l'équipe de développement de données de contexte et d'autres contributeurs afin de suggérer des mises à niveau, de nouvelles intégrations et des problèmes.
