tessl/pypi-qdrant-client

Client library for the Qdrant vector search engine

—

Pending

Overview

Eval results

Files

Collection Management

Name: tessl/pypi-qdrant-client
Author: tessl

Collection creation, deletion, configuration, and metadata management including vector space configuration, optimization settings, and aliasing.

Capabilities

Collection Creation

Create collections with vector space configuration and optimization parameters.

def create_collection(
    self,
    collection_name: str,
    vectors_config: Union[VectorParams, VectorsConfig],
    shard_number: Optional[int] = None,
    replication_factor: Optional[int] = None,
    write_consistency_factor: Optional[int] = None,
    on_disk_payload: Optional[bool] = None,
    hnsw_config: Optional[HnswConfig] = None,
    optimizers_config: Optional[OptimizersConfig] = None,
    wal_config: Optional[WalConfig] = None,
    quantization_config: Optional[QuantizationConfig] = None,
    init_from: Optional[InitFrom] = None,
    timeout: Optional[int] = None,
) -> bool:
    """
    Create a new collection.

    Parameters:
    - collection_name: Name of the collection
    - vectors_config: Vector space configuration
    - shard_number: Number of shards for collection
    - replication_factor: Replication factor for collection
    - write_consistency_factor: Write consistency factor
    - on_disk_payload: Store payload on disk
    - hnsw_config: HNSW index configuration
    - optimizers_config: Optimization configuration
    - wal_config: Write-ahead log configuration
    - quantization_config: Quantization settings
    - init_from: Initialize from existing collection
    - timeout: Request timeout

    Returns:
        bool: True if collection created successfully
    """

Usage examples:

from qdrant_client import models

# Simple vector collection
client.create_collection(
    collection_name="simple_collection",
    vectors_config=models.VectorParams(size=384, distance=models.Distance.COSINE)
)

# Multi-vector collection
client.create_collection(
    collection_name="multi_vector_collection",
    vectors_config={
        "image": models.VectorParams(size=512, distance=models.Distance.COSINE),
        "text": models.VectorParams(size=384, distance=models.Distance.COSINE)
    }
)

# Advanced configuration
client.create_collection(
    collection_name="optimized_collection",
    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
    hnsw_config=models.HnswConfig(
        m=16,
        ef_construct=100,
        full_scan_threshold=10000
    ),
    quantization_config=models.ScalarQuantization(
        scalar=models.ScalarQuantizationConfig(
            type=models.ScalarType.INT8,
            always_ram=True
        )
    )
)

Collection Information

Retrieve collection metadata and statistics.

def get_collection(self, collection_name: str) -> CollectionInfo:
    """
    Get collection information.

    Parameters:
    - collection_name: Name of the collection

    Returns:
        CollectionInfo: Collection metadata and statistics
    """

def get_collections(self) -> CollectionsResponse:
    """
    List all collections.

    Returns:
        CollectionsResponse: List of collection descriptions
    """

def collection_exists(self, collection_name: str) -> bool:
    """
    Check if collection exists.

    Parameters:
    - collection_name: Name of collection to check

    Returns:
        bool: True if collection exists
    """

Collection Updates

Modify existing collection configuration.

def update_collection(
    self,
    collection_name: str,
    optimizer_config: Optional[OptimizersConfig] = None,
    collection_params: Optional[CollectionParams] = None,
    timeout: Optional[int] = None,
    **kwargs
) -> bool:
    """
    Update collection configuration.

    Parameters:
    - collection_name: Name of the collection
    - optimizer_config: New optimizer configuration
    - collection_params: New collection parameters
    - timeout: Request timeout

    Returns:
        bool: True if collection updated successfully
    """

Collection Deletion

Remove collections and their data.

def delete_collection(
    self,
    collection_name: str,
    timeout: Optional[int] = None
) -> bool:
    """
    Delete collection.

    Parameters:
    - collection_name: Name of the collection to delete
    - timeout: Request timeout

    Returns:
        bool: True if collection deleted successfully
    """

Collection Aliases

Create and manage collection aliases for flexible naming.

def create_alias(
    self,
    alias_name: str,
    collection_name: str,
    timeout: Optional[int] = None,
    **kwargs
) -> bool:
    """
    Create collection alias.

    Parameters:
    - alias_name: Name of the alias
    - collection_name: Target collection name
    - timeout: Request timeout

    Returns:
        bool: True if alias created successfully
    """

def delete_alias(
    self,
    alias_name: str,
    timeout: Optional[int] = None,
    **kwargs
) -> bool:
    """
    Delete collection alias.

    Parameters:
    - alias_name: Name of the alias to delete
    - timeout: Request timeout

    Returns:
        bool: True if alias deleted successfully
    """

def get_aliases(self, **kwargs) -> AliasesResponse:
    """
    List all collection aliases.

    Returns:
        AliasesResponse: List of collection aliases
    """

Configuration Types

Vector Configuration

class VectorParams(BaseModel):
    size: int  # Vector dimension
    distance: Distance  # Distance metric
    hnsw_config: Optional[HnswConfig] = None
    quantization_config: Optional[QuantizationConfig] = None
    on_disk: Optional[bool] = None  # Store vectors on disk

class Distance(str, Enum):
    COSINE = "Cosine"
    EUCLID = "Euclid"
    DOT = "Dot"
    MANHATTAN = "Manhattan"

# Multi-vector configuration
VectorsConfig = Dict[str, VectorParams]

HNSW Configuration

class HnswConfig(BaseModel):
    m: Optional[int] = None  # Number of bi-directional links
    ef_construct: Optional[int] = None  # Size of dynamic candidate list
    full_scan_threshold: Optional[int] = None  # Threshold for full scan
    max_indexing_threads: Optional[int] = None  # Max indexing threads
    on_disk: Optional[bool] = None  # Store HNSW graph on disk
    payload_m: Optional[int] = None  # Number of payload-aware links

Quantization Configuration

class ScalarQuantization(BaseModel):
    scalar: ScalarQuantizationConfig

class ScalarQuantizationConfig(BaseModel):
    type: ScalarType  # INT8 or UINT8
    quantile: Optional[float] = None  # Quantile for quantization
    always_ram: Optional[bool] = None  # Keep quantized vectors in RAM

class ScalarType(str, Enum):
    INT8 = "int8"
    UINT8 = "uint8"

class ProductQuantization(BaseModel):
    product: ProductQuantizationConfig

class ProductQuantizationConfig(BaseModel):
    compression: CompressionRatio  # Compression ratio
    always_ram: Optional[bool] = None

class CompressionRatio(str, Enum):
    X4 = "x4"
    X8 = "x8" 
    X16 = "x16"
    X32 = "x32"
    X64 = "x64"

class BinaryQuantization(BaseModel):
    binary: BinaryQuantizationConfig

class BinaryQuantizationConfig(BaseModel):
    always_ram: Optional[bool] = None

Optimizer Configuration

class OptimizersConfig(BaseModel):
    deleted_threshold: Optional[float] = None  # Threshold for deleted points
    vacuum_min_vector_number: Optional[int] = None  # Min vectors for vacuum
    default_segment_number: Optional[int] = None  # Default segments per shard
    max_segment_size: Optional[int] = None  # Max segment size
    memmap_threshold: Optional[int] = None  # Memory mapping threshold
    indexing_threshold: Optional[int] = None  # Indexing threshold
    flush_interval_sec: Optional[int] = None  # Flush interval in seconds
    max_optimization_threads: Optional[int] = None  # Max optimization threads

WAL Configuration

class WalConfig(BaseModel):
    wal_capacity_mb: Optional[int] = None  # WAL capacity in MB
    wal_segments_ahead: Optional[int] = None  # WAL segments ahead

Collection Information Types

class CollectionInfo(BaseModel):
    status: CollectionStatus
    optimizer_status: OptimizerStatus
    vectors_count: Optional[int] = None
    indexed_vectors_count: Optional[int] = None
    points_count: Optional[int] = None
    segments_count: int
    config: CollectionConfig
    payload_schema: Dict[str, PayloadIndexInfo]

class CollectionStatus(str, Enum):
    GREEN = "green"  # All good
    YELLOW = "yellow"  # Optimization in progress
    RED = "red"  # Some shards are not available

class CollectionConfig(BaseModel):
    params: CollectionParams
    hnsw_config: HnswConfig
    optimizer_config: OptimizersConfig
    wal_config: WalConfig
    quantization_config: Optional[QuantizationConfig] = None

Install with Tessl CLI