VectorETL
1.0.0
Vectoretl: estrutura leve ETL para bancos de dados vetoriais
Os dados do VectorETL By Context são uma estrutura modular projetada para ajudar os dados dos engenheiros de dados e a IA a processar dados para seus aplicativos de IA em apenas alguns minutos!
O Vectoretl simplifica o processo de conversão de diversas fontes de dados em incorporação de vetores e armazená -las em vários bancos de dados de vetores. Ele suporta várias fontes de dados (bancos de dados, armazenamento em nuvem e arquivos locais), vários modelos de incorporação (incluindo OpenAI, Cohere, e Google Gemini) e vários alvos de banco de dados vetoriais (como Pinecone, QDrant e Weaviate).
Este pipeline visa simplificar a criação e o gerenciamento de sistemas de pesquisa vetorial, permitindo que desenvolvedores e cientistas de dados construam e escalemos facilmente aplicativos que requerem pesquisa semântica, sistemas de recomendação ou outras operações baseadas em vetores.
pip install --upgrade vector-etl
ou
pip install git+https://github.com/ContextData/VectorETL.git
Esta seção fornece instruções sobre como usar a estrutura ETL para bancos de dados de vetores. Cobriremos as configurações de corrida, validação e forneceremos alguns exemplos de uso comum.
Supondo que você tenha um arquivo de configuração semelhante ao arquivo abaixo.
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 "Você pode importar a configuração para o seu projeto Python e executá -lo automaticamente a partir daí
from vector_etl import create_flow
flow = create_flow ()
flow . load_yaml ( '/path/to/your/config.yaml' )
flow . execute ()Usando o mesmo arquivo de configuração da YAML da opção 2 acima, você pode executar o processo diretamente da sua linha de comando sem precisar importá -lo para um aplicativo Python.
Para executar a estrutura ETL, use o seguinte 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 ()Aqui estão alguns exemplos de como usar a estrutura ETL para diferentes cenários:
vector-etl -c config/postgres_to_pinecone.yaml Onde postgres_to_pinecone.yaml pode 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 Onde s3_to_qdrant.yaml pode 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 : [] A estrutura VectorETL (Extrato, Transform, Carregar) é uma ferramenta poderosa e flexível projetada para otimizar o processo de extrair dados de várias fontes, transformá -lo em incorporação de vetores e carregando essas incorporações em uma variedade de bancos de dados de vetores.
É construído com modularidade, escalabilidade e facilidade de uso em mente, tornando -a uma solução ideal para organizações que desejam alavancar o poder da pesquisa de vetores em sua infraestrutura de dados.
Extração de dados versáteis : a estrutura suporta uma ampla variedade de fontes de dados, incluindo bancos de dados tradicionais, soluções de armazenamento em nuvem (como o Amazon S3 e o Google Cloud Storage) e as plataformas populares SaaS (como Stripe e Zendesk). Essa versatilidade permite consolidar dados de várias fontes em um banco de dados vetorial unificado.
Processamento avançado de texto : para dados textuais, a estrutura implementa técnicas sofisticadas de chunking e sobreposição. Isso garante que o contexto semântico do texto seja preservado ao criar incorporações de vetor, levando a resultados de pesquisa mais precisos.
Modelos de incorporação de última geração : o sistema se integra aos principais modelos de incorporação, incluindo OpenAI, Cohere, Google Gemini e Azure Openai. Isso permite que você escolha o modelo de incorporação que melhor se ajusta ao seu caso de uso específico e aos requisitos de qualidade.
Suporte ao banco de dados de múltiplos vetores : se você está usando Pinecone, QDRANT, WEAVIATE, SINGLESTORE, SUPABASE ou LANDEBB, essa estrutura o cobriu. Ele foi projetado para interagir perfeitamente com esses bancos de dados de vetores populares, permitindo que você escolha o que melhor atende às suas necessidades.
Configurável e extensível : toda a estrutura é altamente configurável através de arquivos de configuração YAML ou JSON. Além disso, sua arquitetura modular facilita a extensão com novas fontes de dados, modelos de incorporação ou bancos de dados de vetores à medida que suas necessidades evoluem.
Essa estrutura ETL é ideal para organizações que desejam implementar ou atualizar seus recursos de pesquisa vetorial.
Ao automatizar o processo de extração de dados, criando incorporações vetoriais e armazenando -os em um banco de dados vetorial, essa estrutura reduz significativamente o tempo e a complexidade envolvidos na configuração de um sistema de pesquisa vetorial. Ele permite que cientistas e engenheiros de dados se concentrem em derivar insights e criar aplicativos, em vez de se preocupar com os meandros do processamento de dados e do armazenamento vetorial.
A estrutura ETL usa um arquivo de configuração para especificar os detalhes da origem, modelo de incorporação, banco de dados de destino e outros parâmetros. Você pode usar o formato YAML ou JSON para o arquivo de configuração.
O arquivo de configuração é dividido em três seções principais:
source : especifica os detalhes da fonte de dadosembedding : define o modelo de incorporação a ser usadotarget : descreve o banco de dados de vetor de destinoembed_columns : define as colunas que precisam ser incorporadas (principalmente para fontes de dados estruturadas) 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 " ]
} A seção source varia com base no source_data_type . Aqui estão exemplos para diferentes tipos de origem:
{
"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 da versão 0.1.6.3, os usuários agora podem utilizar a API sem servidor do não estruturado para extrair dados com eficiência de uma infinidade de fontes baseadas em arquivo.
NOTA: Isso é limitado à API sem estrutura não estruturada e não deve ser usada para a estrutura de código aberto da não estrutura
Isso é limitado a arquivos [pdf, docx, doc, txt]
Para usar não estruturado, você precisará de três parâmetros adicionais
use_unstructured : (true/false) Indicador dizendo à estrutura para usar a API não estruturadaunstructured_api_key : insira sua chave de API não estruturadaunstructured_url : Digite seu URL da API no seu painel não estruturado # 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 ' A seção embedding especifica qual modelo de incorporação a 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 A seção target varia de acordo com o banco de dados vetorial escolhido. Aqui está um exemplo 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 " A lista embed_columns especifica quais colunas dos dados de origem devem ser usadas para gerar as incorporações (se aplica apenas às fontes de banco de dados por enquanto):
embed_columns :
- " column1 "
- " column2 "
- " column3 " A lista embed_columns é necessária apenas para fontes de dados estruturadas (por exemplo, PostgreSQL, MySQL, Snowflake). Para todas as outras fontes, use uma lista vazia
embed_columns : []Para proteger informações confidenciais, como chaves e senhas da API, considere usar variáveis de ambiente ou um sistema de gerenciamento de segredos seguros. Você pode fazer referenciá -los no seu arquivo de configuração:
embedding :
api_key : ${OPENAI_API_KEY}Isso permite manter seus arquivos de configuração no controle da versão sem expor dados confidenciais.
Lembre -se de ajustar sua configuração com base em suas fontes de dados específicas, modelos de incorporação e bancos de dados de destino. Consulte a documentação para cada serviço para garantir que você esteja fornecendo todos os parâmetros necessários.
Congratulamo -nos com contribuições para a estrutura ETL para bancos de dados de vetores! Esteja você corrigindo bugs, melhorando a documentação ou propondo novos recursos, seus esforços são apreciados. Veja como você pode contribuir:
Se você encontrar um bug ou tiver uma sugestão para melhorar a estrutura ETL:
Estamos sempre procurando maneiras de melhorar a estrutura do ETL. Se você tem idéias:
Congratulamo -nos ativamente com seus pedidos de tração:
main .Para manter a consistência ao longo do projeto, siga esses padrões de codificação:
Melhorar a documentação é sempre apreciada:
Se você está pensando em adicionar um novo recurso:
source_mods .get_source_class em source_mods/__init__.py .embedding_mods .get_embedding_model em embedding_mods/__init__.py .target_mods .get_target_database em target_mods/__init__.py .Incentivamos todos os usuários a ingressar no nosso servidor Discord a colaborar com a equipe de desenvolvimento de dados de contexto e outros colaboradores, a fim de sugerir atualizações, novas integrações e problemas.
