qdrant client
v1.12.1
Python Client Library pour le moteur de recherche vectoriel QDRANT.
Bibliothèque client et SDK pour le moteur de recherche vectoriel QDRANT.
La bibliothèque contient des définitions de type pour toutes les API QDRANT et permet de faire des demandes de synchronisation et de synchronisation.
Le client permet directement les appels pour toutes les méthodes API QDRANT. Il fournit également des méthodes d'assistance supplémentaires pour les opérations fréquemment requises, par exemple le téléchargement initial de la collection.
Voir QuickStart pour plus de détails!
La documentation de l'API du client Python est disponible sur Python-Client.qdrant.tech
pip install qdrant-client
Le client Python vous permet d'exécuter le même code en mode local sans exécuter QDRANT Server.
Initialisez simplement le client comme ceci:
from qdrant_client import QdrantClient
client = QdrantClient ( ":memory:" )
# or
client = QdrantClient ( path = "path/to/db" ) # Persists changes to diskLe mode local est utile pour le développement, le prototypage et les tests.
pip install qdrant-client[fastembed]
FastEmbed est une bibliothèque pour créer des incorporations vectorielles rapides sur CPU. Il est basé sur l'ONNX Runtime et permet d'exécuter l'inférence sur CPU avec des performances de type GPU.
Le client QDrant peut utiliser FastMed pour créer des intégres et les télécharger sur QDRANT. Cela permet de simplifier l'API et de le rendre plus intuitif.
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 )FastMed peut également utiliser GPU pour des intégres plus rapides. Pour activer la prise en charge du GPU, installez
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" ])Remarque:
fastembed-gpuetfastembeds'excluent mutuellement. Vous ne pouvez en installer qu'un.Si vous avez précédemment installé
fastembed, vous devrez peut-être commencer à partir d'un environnement frais pour installerfastembed-gpu.
Pour vous connecter au serveur QDrant, spécifiez simplement l'hôte et le port:
from qdrant_client import QdrantClient
client = QdrantClient ( host = "localhost" , port = 6333 )
# or
client = QdrantClient ( url = "http://localhost:6333" )Vous pouvez exécuter le serveur QDrant localement avec Docker:
docker run -p 6333:6333 qdrant/qdrant:latestVoir plus d'options de lancement dans le référentiel QDrant.
Vous pouvez vous inscrire et utiliser QDRANT Cloud pour obtenir un compte de niveau gratuit avec 1 Go de RAM.
Une fois que vous avez votre cluster et votre clé API, vous pouvez vous connecter comme ceci:
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>" ,
)Créer une nouvelle collection
from qdrant_client . models import Distance , VectorParams
client . create_collection (
collection_name = "my_collection" ,
vectors_config = VectorParams ( size = 100 , distance = Distance . COSINE ),
)Insérer des vecteurs dans une collection
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 )
]
)Rechercher des vecteurs similaires
query_vector = np . random . rand ( 100 )
hits = client . search (
collection_name = "my_collection" ,
query_vector = query_vector ,
limit = 5 # Return 5 closest points
)Rechercher des vecteurs similaires avec un état de filtrage
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
)Voir plus d'exemples dans notre documentation!
Pour activer (généralement, beaucoup plus rapide) le téléchargement de collection avec GRPC, utilisez l'initialisation suivante:
from qdrant_client import QdrantClient
client = QdrantClient ( host = "localhost" , grpc_port = 6334 , prefer_grpc = True )À partir de la version 1.6.1, toutes les méthodes du client Python sont disponibles en version asynchrone.
Pour l'utiliser, importez simplement AsyncQdrantClient au lieu 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 ())L'API GRPC et REST sont prises en charge en mode asynchrone. Plus d'exemples peuvent être trouvés ici.
Ce projet utilise des crochets GIT pour exécuter des formateurs de code.
Installez pre-commit avec pip3 install pre-commit et configurez des crochets avec pre-commit install .
Le pré-engagement nécessite Python> = 3,8
