VectorETL
1.0.0
Vectoretl: marco ETL ligero para bases de datos vectoriales
¡Los datos de Vectoretl por contexto es un marco modular diseñado para ayudar a los ingenieros de datos e IA a procesar datos para sus aplicaciones de IA en solo unos minutos!
Vectoretl optimiza el proceso de convertir diversas fuentes de datos en integridades vectoriales y almacenarlas en varias bases de datos de vectores. Admite múltiples fuentes de datos (bases de datos, almacenamiento en la nube y archivos locales), varios modelos de incrustación (incluidos OpenAI, Cohere y Google Gemini) y varios objetivos de base de datos vectoriales (como Pinecone, Qdrant y Weaviate).
Esta tubería tiene como objetivo simplificar la creación y gestión de los sistemas de búsqueda de vectores, lo que permite a los desarrolladores y científicos de datos construir y escalar fácilmente aplicaciones que requieren búsqueda semántica, sistemas de recomendación u otras operaciones basadas en vectores.
pip install --upgrade vector-etl
o
pip install git+https://github.com/ContextData/VectorETL.git
Esta sección proporciona instrucciones sobre cómo usar el marco ETL para las bases de datos vectoriales. Cubriremos en ejecución, validando configuraciones y proporcionaremos algunos ejemplos de uso comunes.
Suponiendo que tiene un archivo de configuración similar al archivo a continuación.
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 "Luego puede importar la configuración en su proyecto Python y ejecutarla automáticamente desde allí.
from vector_etl import create_flow
flow = create_flow ()
flow . load_yaml ( '/path/to/your/config.yaml' )
flow . execute ()Usando el mismo archivo de configuración YAML de la opción 2 anterior, puede ejecutar el proceso directamente desde su línea de comando sin tener que importarlo a una aplicación Python.
Para ejecutar el marco ETL, use el siguiente comando:
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 ()Aquí hay algunos ejemplos de cómo usar el marco ETL para diferentes escenarios:
vector-etl -c config/postgres_to_pinecone.yaml Donde postgres_to_pinecone.yaml podría parecer:
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 Donde s3_to_qdrant.yaml podría parecer:
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 : [] El marco Vectoretl (Extract, Transform, Load) es una herramienta potente y flexible diseñada para optimizar el proceso de extraer datos de varias fuentes, transformarlo en incrustaciones de vectores y cargar estos incrustaciones en una gama de bases de datos vectoriales.
Está construido con modularidad, escalabilidad y facilidad de uso en mente, lo que lo convierte en una solución ideal para las organizaciones que buscan aprovechar el poder de la búsqueda vectorial en su infraestructura de datos.
Extracción de datos versátil : el marco admite una amplia gama de fuentes de datos, incluidas bases de datos tradicionales, soluciones de almacenamiento en la nube (como Amazon S3 y Google Cloud Storage) y plataformas SaaS populares (como Stripe y Zendesk). Esta versatilidad le permite consolidar datos de múltiples fuentes en una base de datos vectorial unificada.
Procesamiento de texto avanzado : para datos textuales, el marco implementa técnicas sofisticadas de fragmentación y superposición. Esto asegura que el contexto semántico del texto se conserve al crear integridades vectoriales, lo que lleva a resultados de búsqueda más precisos.
Modelos de incrustación de última generación : el sistema se integra con los modelos de incrustación líderes, incluidos OpenAI, Cohere, Google Gemini y Azure OpenAi. Esto le permite elegir el modelo de incrustación que mejor se adapte a su caso de uso específico y requisitos de calidad.
Soporte de la base de datos de vectores múltiples : ya sea que esté utilizando Pinecone, Qdrant, Weaviate, Singlestore, Supabase o LancedB, este marco lo tiene cubierto. Está diseñado para interactuar perfectamente con estas populares bases de datos vectoriales, lo que le permite elegir la que mejor se adapte a sus necesidades.
Configurable y extensible : todo el marco es altamente configurable a través de archivos de configuración YAML o JSON. Además, su arquitectura modular facilita la extensión con nuevas fuentes de datos, modelos de incrustación o bases de datos vectoriales a medida que sus necesidades evolucionan.
Este marco ETL es ideal para organizaciones que buscan implementar o actualizar sus capacidades de búsqueda vectorial.
Al automatizar el proceso de extracción de datos, crear integridades vectoriales y almacenarlos en una base de datos vectorial, este marco reduce significativamente el tiempo y la complejidad involucrados en la configuración de un sistema de búsqueda vectorial. Permite a los científicos e ingenieros de datos centrarse en derivar ideas y construir aplicaciones, en lugar de preocuparse por las complejidades del procesamiento de datos y el almacenamiento vectorial.
El marco ETL utiliza un archivo de configuración para especificar los detalles del modelo de fuente, el modelo de incrustación, la base de datos de destino y otros parámetros. Puede usar el formato YAML o JSON para el archivo de configuración.
El archivo de configuración se divide en tres secciones principales:
source : Especifica los detalles de la fuente de datosembedding : define el modelo de incrustación que se utilizarátarget : describe la base de datos de vector de destinoembed_columns : define las columnas que necesitan estar integradas (principalmente para fuentes de datos estructuradas) 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 sección source varía según el source_data_type . Aquí hay ejemplos para diferentes tipos de fuente:
{
"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 A partir de la versión 0.1.6.3, los usuarios ahora pueden utilizar la API sin servidor no estructurada para extraer datos de manera eficiente de una multitud de fuentes basadas en archivos.
Nota: Esto se limita a la API grave sin sentido no estructurada y no debe usarse para el marco de código abierto del no estructurado
Esto se limita a los archivos [PDF, DOCX, DOC, TXT]
Para usar no estructurado, necesitará tres parámetros adicionales
use_unstructured : (verdadero/falso) Indicador que le dice al marco que use la API no estructuradaunstructured_api_key : ingrese su tecla API no estructuradaunstructured_url : ingrese su URL API desde su tablero no estructurado # 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 sección embedding especifica qué modelo de incrustación usar:
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 sección target varía según la base de datos vectorial elegida. Aquí hay un ejemplo para 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 lista de embed_columns especifica qué columnas de los datos de origen deben usarse para generar los incrustaciones (solo se aplica a las fuentes de la base de datos por ahora):
embed_columns :
- " column1 "
- " column2 "
- " column3 " La lista de embed_columns solo para fuentes de datos estructuradas (por ejemplo, PostgreSQL, MySQL, Snowflake). Para todas las demás fuentes, use una lista vacía
embed_columns : []Para proteger la información confidencial como las teclas de API y las contraseñas, considere usar variables de entorno o un sistema de gestión de secretos seguros. Luego puede hacer referencia a estos en su archivo de configuración:
embedding :
api_key : ${OPENAI_API_KEY}Esto le permite mantener sus archivos de configuración en el control de versiones sin exponer datos confidenciales.
Recuerde ajustar su configuración en función de sus fuentes de datos específicas, los modelos de incrustación y las bases de datos de destino. Consulte la documentación para cada servicio para asegurarse de que proporcione todos los parámetros requeridos.
¡Agradecemos las contribuciones al marco ETL para las bases de datos vectoriales! Ya sea que esté arreglando errores, mejorando la documentación o proponiendo nuevas características, se agradecen sus esfuerzos. Así es como puedes contribuir:
Si encuentra un error o tiene una sugerencia para mejorar el marco ETL:
Siempre estamos buscando formas de mejorar el marco ETL. Si tienes ideas:
Agradecemos activamente sus solicitudes de extracción:
main .Para mantener la consistencia en todo el proyecto, adhiera a estos estándares de codificación:
La mejora de la documentación siempre es apreciada:
Si está pensando en agregar una nueva característica:
source_mods .get_source_class en source_mods/__init__.py .embedding_mods .get_embedding_model en embedding_mods/__init__.py .target_mods .get_target_database en target_mods/__init__.py .Alentamos a todos los usuarios a unirse a nuestro servidor Discord para colaborar con el equipo de desarrollo de datos de contexto y otros contribuyentes para sugerir actualizaciones, nuevas integraciones y problemas.
