tessl/pypi-qdrant-client

Client library for the Qdrant vector search engine

—

Pending

Overview

Eval results

Files

Search & Query

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

Vector similarity search, recommendations, discovery, and hybrid search capabilities with filtering and result ranking.

Capabilities

Vector Similarity Search

Perform similarity search using query vectors with filtering and scoring options.

def query_points(
    self,
    collection_name: str,
    query: Union[QueryRequest, NumpyArray, QueryResponse, Document, str, List[float]],
    query_filter: Optional[Filter] = None,
    search_params: Optional[SearchParams] = None,
    limit: int = 10,
    offset: Optional[int] = None,
    with_payload: Union[bool, List[str], PayloadSelector] = True,
    with_vectors: Union[bool, List[str]] = False,
    score_threshold: Optional[float] = None,
    using: Optional[str] = None,
    timeout: Optional[int] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    **kwargs
) -> QueryResponse:
    """
    Search for similar vectors.

    Parameters:
    - collection_name: Name of the collection
    - query: Query vector, text, or search request
    - query_filter: Filter conditions for search results
    - search_params: Search algorithm parameters
    - limit: Maximum number of results to return
    - offset: Offset for pagination
    - with_payload: Include payload in results
    - with_vectors: Include vectors in results
    - score_threshold: Minimum score threshold
    - using: Vector name for multi-vector collections
    - timeout: Request timeout
    - shard_key_selector: Shard key for routing

    Returns:
        QueryResponse: Search results with scores
    """

def search(
    self,
    collection_name: str,
    query_vector: Union[List[float], NumpyArray, Tuple[str, List[float]]],
    query_filter: Optional[Filter] = None,
    search_params: Optional[SearchParams] = None,
    limit: int = 10,
    offset: int = 0,
    with_payload: Union[bool, List[str], PayloadSelector] = True,
    with_vectors: Union[bool, List[str]] = False,
    score_threshold: Optional[float] = None,
    append_payload: bool = True,
    consistency: Optional[ReadConsistency] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    timeout: Optional[int] = None,
    **kwargs
) -> List[ScoredPoint]:
    """
    Search for similar vectors (legacy method, use query_points instead).

    Parameters:
    - collection_name: Name of the collection
    - query_vector: Query vector or named vector tuple
    - query_filter: Filter conditions for search results
    - search_params: Search algorithm parameters
    - limit: Maximum number of results to return
    - offset: Offset for pagination
    - with_payload: Include payload in results
    - with_vectors: Include vectors in results
    - score_threshold: Minimum score threshold
    - append_payload: Append payload to results
    - consistency: Read consistency level
    - shard_key_selector: Shard key for routing
    - timeout: Request timeout

    Returns:
        List[ScoredPoint]: Search results with scores
    """

Usage examples:

import numpy as np
from qdrant_client import models

# Simple vector search
query_vector = np.random.rand(384).tolist()
results = client.query_points(
    collection_name="my_collection",
    query=query_vector,
    limit=10
)

# Search with filtering
results = client.query_points(
    collection_name="my_collection",
    query=query_vector,
    query_filter=models.Filter(
        must=[
            models.FieldCondition(
                key="category",
                match=models.MatchValue(value="important")
            )
        ]
    ),
    limit=5,
    score_threshold=0.7
)

# Multi-vector search
results = client.query_points(
    collection_name="multi_vector_collection",
    query=query_vector,
    using="text_vector",  # Specify which vector to use
    limit=10
)

Batch Search

Perform multiple searches in a single request.

def query_batch_points(
    self,
    collection_name: str,
    requests: List[QueryRequest],
    consistency: Optional[ReadConsistency] = None,
    timeout: Optional[int] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    **kwargs
) -> List[QueryResponse]:
    """
    Perform batch search queries.

    Parameters:
    - collection_name: Name of the collection
    - requests: List of query requests
    - consistency: Read consistency level
    - timeout: Request timeout
    - shard_key_selector: Shard key for routing

    Returns:
        List[QueryResponse]: Batch search results
    """

def search_batch(
    self,
    collection_name: str,
    requests: List[SearchRequest],
    consistency: Optional[ReadConsistency] = None,
    timeout: Optional[int] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    **kwargs
) -> List[List[ScoredPoint]]:
    """
    Perform batch search requests (legacy method).

    Parameters:
    - collection_name: Name of the collection
    - requests: List of search requests
    - consistency: Read consistency level
    - timeout: Request timeout
    - shard_key_selector: Shard key for routing

    Returns:
        List[List[ScoredPoint]]: Batch search results
    """

Recommendation Search

Find points similar to positive examples and dissimilar to negative examples.

def recommend(
    self,
    collection_name: str,
    positive: Optional[List[PointId]] = None,
    negative: Optional[List[PointId]] = None,
    query_filter: Optional[Filter] = None,
    search_params: Optional[SearchParams] = None,
    limit: int = 10,
    offset: int = 0,
    with_payload: Union[bool, List[str], PayloadSelector] = True,
    with_vectors: Union[bool, List[str]] = False,
    score_threshold: Optional[float] = None,
    using: Optional[str] = None,
    lookup_from: Optional[LookupLocation] = None,
    timeout: Optional[int] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    **kwargs
) -> List[ScoredPoint]:
    """
    Recommend points based on positive and negative examples.

    Parameters:
    - collection_name: Name of the collection
    - positive: List of positive example point IDs
    - negative: List of negative example point IDs
    - query_filter: Filter conditions for results
    - search_params: Search algorithm parameters
    - limit: Maximum number of results to return
    - offset: Offset for pagination
    - with_payload: Include payload in results
    - with_vectors: Include vectors in results
    - score_threshold: Minimum score threshold
    - using: Vector name for multi-vector collections
    - lookup_from: Collection to lookup examples from
    - timeout: Request timeout
    - shard_key_selector: Shard key for routing

    Returns:
        List[ScoredPoint]: Recommendation results
    """

def recommend_batch(
    self,
    collection_name: str,
    requests: List[RecommendRequest],
    consistency: Optional[ReadConsistency] = None,
    timeout: Optional[int] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    **kwargs
) -> List[List[ScoredPoint]]:
    """
    Perform batch recommendation requests.

    Parameters:
    - collection_name: Name of the collection
    - requests: List of recommendation requests
    - consistency: Read consistency level
    - timeout: Request timeout
    - shard_key_selector: Shard key for routing

    Returns:
        List[List[ScoredPoint]]: Batch recommendation results
    """

Discovery Search

Discover points that are similar to a target but different from provided context.

def discover(
    self,
    collection_name: str,
    target: Optional[PointId] = None,
    context: Optional[List[ContextExamplePair]] = None,
    query_filter: Optional[Filter] = None,
    search_params: Optional[SearchParams] = None,
    limit: int = 10,
    offset: int = 0,
    with_payload: Union[bool, List[str], PayloadSelector] = True,
    with_vectors: Union[bool, List[str]] = False,
    using: Optional[str] = None,
    lookup_from: Optional[LookupLocation] = None,
    timeout: Optional[int] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    **kwargs
) -> List[ScoredPoint]:
    """
    Discover points similar to target but distinct from context.

    Parameters:
    - collection_name: Name of the collection
    - target: Target point ID for discovery
    - context: Context example pairs
    - query_filter: Filter conditions for results
    - search_params: Search algorithm parameters
    - limit: Maximum number of results to return
    - offset: Offset for pagination
    - with_payload: Include payload in results
    - with_vectors: Include vectors in results
    - using: Vector name for multi-vector collections
    - lookup_from: Collection to lookup examples from
    - timeout: Request timeout
    - shard_key_selector: Shard key for routing

    Returns:
        List[ScoredPoint]: Discovery results
    """

def discover_batch(
    self,
    collection_name: str,
    requests: List[DiscoverRequest],
    consistency: Optional[ReadConsistency] = None,
    timeout: Optional[int] = None,
    shard_key_selector: Optional[ShardKeySelector] = None,
    **kwargs
) -> List[List[ScoredPoint]]:
    """
    Perform batch discovery requests.

    Parameters:
    - collection_name: Name of the collection
    - requests: List of discovery requests
    - consistency: Read consistency level
    - timeout: Request timeout
    - shard_key_selector: Shard key for routing

    Returns:
        List[List[ScoredPoint]]: Batch discovery results
    """

Search Configuration

Search Parameters

class SearchParams(BaseModel):
    hnsw_ef: Optional[int] = None  # Size of the dynamic candidate list
    exact: bool = False  # Whether to use exact search
    quantization: Optional[QuantizationSearchParams] = None
    indexed_only: bool = False  # Search only indexed vectors

class QuantizationSearchParams(BaseModel):
    ignore: bool = False  # Ignore quantization during search
    rescore: Optional[bool] = None  # Rescore with original vectors
    oversampling: Optional[float] = None  # Oversampling factor

Filter Conditions

class Filter(BaseModel):
    must: Optional[List[Condition]] = None  # All conditions must match
    must_not: Optional[List[Condition]] = None  # None of conditions must match
    should: Optional[List[Condition]] = None  # At least one condition should match
    min_should: Optional[MinShould] = None  # Minimum should conditions to match

class FieldCondition(BaseModel):
    key: str  # Payload field name
    match: Optional[MatchCondition] = None
    range: Optional[RangeCondition] = None  
    geo_bounding_box: Optional[GeoBoundingBox] = None
    geo_radius: Optional[GeoRadius] = None
    geo_polygon: Optional[GeoPolygon] = None
    values_count: Optional[ValuesCount] = None

class MatchCondition(BaseModel):
    value: Union[str, int, bool]  # Exact match value
    any: Optional[List[Union[str, int, bool]]] = None  # Match any of these values
    except_: Optional[List[Union[str, int, bool]]] = None  # Match except these values
    text: Optional[str] = None  # Full-text search

class RangeCondition(BaseModel):
    lt: Optional[float] = None  # Less than
    gt: Optional[float] = None  # Greater than
    gte: Optional[float] = None  # Greater than or equal
    lte: Optional[float] = None  # Less than or equal

Geographic Filters

class GeoRadius(BaseModel):
    center: GeoPoint  # Center point
    radius: float  # Radius in meters

class GeoBoundingBox(BaseModel):
    top_left: GeoPoint  # Top-left corner
    bottom_right: GeoPoint  # Bottom-right corner

class GeoPolygon(BaseModel):
    exterior: GeoLineString  # Exterior boundary
    interiors: Optional[List[GeoLineString]] = None  # Interior holes

class GeoPoint(BaseModel):
    lon: float  # Longitude
    lat: float  # Latitude

Search Results

Result Types

class ScoredPoint(BaseModel):
    id: PointId
    version: int
    score: float
    payload: Optional[Payload] = None
    vector: Optional[Union[List[float], Dict[str, List[float]]]] = None
    shard_key: Optional[ShardKey] = None
    order_value: Optional[OrderValue] = None

class QueryResponse(BaseModel):
    points: List[ScoredPoint]

class RecommendRequest(BaseModel):
    positive: Optional[List[PointId]] = None
    negative: Optional[List[PointId]] = None
    filter: Optional[Filter] = None
    params: Optional[SearchParams] = None
    limit: int = 10
    offset: int = 0
    with_payload: Optional[WithPayload] = None
    with_vector: Optional[WithVector] = None
    score_threshold: Optional[float] = None
    using: Optional[str] = None
    lookup_from: Optional[LookupLocation] = None

class DiscoverRequest(BaseModel):
    target: Optional[PointId] = None
    context: Optional[List[ContextExamplePair]] = None
    filter: Optional[Filter] = None
    params: Optional[SearchParams] = None
    limit: int = 10
    offset: int = 0
    with_payload: Optional[WithPayload] = None
    with_vector: Optional[WithVector] = None
    using: Optional[str] = None
    lookup_from: Optional[LookupLocation] = None

class ContextExamplePair(BaseModel):
    positive: PointId
    negative: PointId

Consistency Options

class ReadConsistency(BaseModel):
    type: ReadConsistencyType
    factor: Optional[int] = None

class ReadConsistencyType(str, Enum):
    ALL = "all"      # Read from all replicas
    MAJORITY = "majority"  # Read from majority of replicas
    QUORUM = "quorum"     # Read from quorum of replicas

Install with Tessl CLI