qdrant client
v1.12.1
Biblioteca de clientes Python para o mecanismo de pesquisa de vetores QDRANT.
Biblioteca de clientes e SDK para o mecanismo de pesquisa de vetores QDRANT.
A biblioteca contém definições de tipo para toda a API QDRANT e permite fazer solicitações de sincronização e assíncrona.
O cliente permite chamadas para todos os métodos da API QDRANT diretamente. Ele também fornece alguns métodos auxiliares adicionais para operações frequentemente necessárias, por exemplo, upload de coleção inicial.
Veja o QuickStart para mais detalhes!
A documentação da API do cliente Python está disponível em python-client.qdrant.tech
pip install qdrant-client
O Python Client permite que você execute o mesmo código no modo local sem executar o QDRANT Server.
Simplesmente inicialize o cliente como este:
from qdrant_client import QdrantClient
client = QdrantClient ( ":memory:" )
# or
client = QdrantClient ( path = "path/to/db" ) # Persists changes to diskO modo local é útil para desenvolvimento, prototipagem e teste.
pip install qdrant-client[fastembed]
O Fastembed é uma biblioteca para criar incorporações rápidas de vetor na CPU. É baseado no tempo de execução do ONNX e permite executar a inferência na CPU com desempenho semelhante à GPU.
O cliente QDRANT pode usar o Fastembed para criar incorporação e carregá -los para o QDRANT. Isso permite simplificar a API e torná -la mais intuitiva.
from qdrant_client import QdrantClient
# Initialize the client
client = QdrantClient ( ":memory:" ) # or QdrantClient(path="path/to/db")
# Prepare your documents, metadata, and IDs
docs = [ "Qdrant has Langchain integrations" , "Qdrant also has Llama Index integrations" ]
metadata = [
{ "source" : "Langchain-docs" },
{ "source" : "Linkedin-docs" },
]
ids = [ 42 , 2 ]
# Use the new add method
client . add (
collection_name = "demo_collection" ,
documents = docs ,
metadata = metadata ,
ids = ids
)
search_result = client . query (
collection_name = "demo_collection" ,
query_text = "This is a query document"
)
print ( search_result )Fastembado também pode utilizar a GPU para incorporações mais rápidas. Para ativar o suporte à GPU, instale
pip install ' qdrant-client[fastembed-gpu] ' from qdrant_client import QdrantClient
# Initialize the client
client = QdrantClient ( ":memory:" ) # or QdrantClient(path="path/to/db")
client . set_model ( client . DEFAULT_EMBEDDING_MODEL , providers = [ "CUDAExecutionProvider" , "CPUExecutionProvider" ])NOTA:
fastembed-gpuefastembedsão mutuamente exclusivas. Você só pode instalar um deles.Se você instalou anteriormente
fastembed, pode ser necessário começar de um novo ambiente para instalarfastembed-gpu.
Para conectar -se ao servidor QDrant, basta especificar host e porta:
from qdrant_client import QdrantClient
client = QdrantClient ( host = "localhost" , port = 6333 )
# or
client = QdrantClient ( url = "http://localhost:6333" )Você pode executar o QDRANT Server localmente com o Docker:
docker run -p 6333:6333 qdrant/qdrant:latestVeja mais opções de lançamento no repositório QDRANT.
Você pode se registrar e usar o QDRANT Cloud para obter uma conta de camada gratuita com 1 GB de RAM.
Depois de ter sua chave de cluster e API, você pode se conectar a ela assim:
from qdrant_client import QdrantClient
qdrant_client = QdrantClient (
url = "https://xxxxxx-xxxxx-xxxxx-xxxx-xxxxxxxxx.us-east.aws.cloud.qdrant.io:6333" ,
api_key = "<your-api-key>" ,
)Crie uma nova coleção
from qdrant_client . models import Distance , VectorParams
client . create_collection (
collection_name = "my_collection" ,
vectors_config = VectorParams ( size = 100 , distance = Distance . COSINE ),
)Insira vetores em uma coleção
import numpy as np
from qdrant_client . models import PointStruct
vectors = np . random . rand ( 100 , 100 )
# NOTE: consider splitting the data into chunks to avoid hitting the server's payload size limit
# or use `upload_collection` or `upload_points` methods which handle this for you
# WARNING: uploading points one-by-one is not recommended due to requests overhead
client . upsert (
collection_name = "my_collection" ,
points = [
PointStruct (
id = idx ,
vector = vector . tolist (),
payload = { "color" : "red" , "rand_number" : idx % 10 }
)
for idx , vector in enumerate ( vectors )
]
)Procure por vetores semelhantes
query_vector = np . random . rand ( 100 )
hits = client . search (
collection_name = "my_collection" ,
query_vector = query_vector ,
limit = 5 # Return 5 closest points
)Procure vetores semelhantes com condição de filtragem
from qdrant_client . models import Filter , FieldCondition , Range
hits = client . search (
collection_name = "my_collection" ,
query_vector = query_vector ,
query_filter = Filter (
must = [ # These conditions are required for search results
FieldCondition (
key = 'rand_number' , # Condition based on values of `rand_number` field.
range = Range (
gte = 3 # Select only those results where `rand_number` >= 3
)
)
]
),
limit = 5 # Return 5 closest points
)Veja mais exemplos em nossa documentação!
Para ativar (normalmente, a coleção muito mais rápida), use o GRPC, use a seguinte inicialização:
from qdrant_client import QdrantClient
client = QdrantClient ( host = "localhost" , grpc_port = 6334 , prefer_grpc = True )A partir da versão 1.6.1, todos os métodos do cliente Python estão disponíveis na versão assíncrona.
Para usá -lo, basta importar AsyncQdrantClient em vez de QdrantClient :
from qdrant_client import AsyncQdrantClient , models
import numpy as np
import asyncio
async def main ():
# Your async code using QdrantClient might be put here
client = AsyncQdrantClient ( url = "http://localhost:6333" )
await client . create_collection (
collection_name = "my_collection" ,
vectors_config = models . VectorParams ( size = 10 , distance = models . Distance . COSINE ),
)
await client . upsert (
collection_name = "my_collection" ,
points = [
models . PointStruct (
id = i ,
vector = np . random . rand ( 10 ). tolist (),
)
for i in range ( 100 )
],
)
res = await client . search (
collection_name = "my_collection" ,
query_vector = np . random . rand ( 10 ). tolist (), # type: ignore
limit = 10 ,
)
print ( res )
asyncio . run ( main ())API GRPC e REST são suportadas no modo assíncrono. Mais exemplos podem ser encontrados aqui.
Este projeto usa ganchos Git para executar formatadores de código.
Instale pre-commit com pip3 install pre-commit e configure ganchos com pre-commit install .
O pré-compromisso requer python> = 3.8
