""" sqlite_qdrant_cloud.py Pipeline script to stream embeddings and metadata from a local SQLite database and upsert them into a Qdrant collection hosted on a remote/cloud Qdrant instance. This file preserves the original runtime behavior but adds extensive inline documentation, module-level descriptions, and detailed docstrings for each function. The intent is to make the file easier to understand and maintain. Ensure qdrant_client is installed in your environment (`pip install qdrant-client`). """ import os import shutil import time from pathlib import Path from typing import Iterator import numpy as np import pandas as pd from dotenv import load_dotenv from qdrant_client import QdrantClient, models from rich.console import Console from rich.progress import ( BarColumn, MofNCompleteColumn, Progress, TextColumn, TimeElapsedColumn, TimeRemainingColumn, ) from sqlalchemy import create_engine, text # -------------------------------------------------------------------------------- # Environment and configuration # -------------------------------------------------------------------------------- # # The script reads configuration from the environment (optionally from a .env # file placed next to the repository). The important variables are: # # - QDRANT_BASE_URL: Base URL for the Qdrant instance (including host:port) # - Optionally any requests/SSL cert override variables if needed by the network # # We call `load_dotenv()` to provide local convenience for development; in CI or # production environments you may provide env vars through normal OS mechanisms. # load_dotenv() # Load environment variables from .env file (if present) # Path to the local SQLite database that stores the chunk-level embedding table. # The table expected by this script is `embeddingcontent` and contains one row # per chunk, with an `embedding` column (binary blob of float32 bytes). DB_PATH = (Path(__file__).parent / "openrag.db").resolve() # Create a SQLAlchemy engine pointing to that SQLite database. We use the engine # both for an initial COUNT(*) query (to drive the progress bar) and as the # connection object passed into pandas' `read_sql(..., chunksize=...)`. engine = create_engine(f"sqlite:///{DB_PATH}") # Constants for the Qdrant collection and the named-vector key. # These must match how the vectors were originally named if migrating or # interoperating with other systems. # Name of the Qdrant collection to search QDRANT_COLLECTION_NAME = os.environ["COLLECTION_NAME"] console = Console() # -------------------------------------------------------------------------------- # SSL / CA bundle environment defaults # -------------------------------------------------------------------------------- # # Some environments require explicit cert bundle configuration. These defaults # are present to help avoid requests/urllib SSL issues when the environment # doesn't already provide these variables. They point to a repo-local PEM file # in the original project; adjust or remove as needed for your deployment. # if "SSL_CERT_FILE" not in os.environ: os.environ["SSL_CERT_FILE"] = "cisco_umbrella_root_ca.pem" if "REQUESTS_CA_BUNDLE" not in os.environ: os.environ["REQUESTS_CA_BUNDLE"] = "cisco_umbrella_root_ca.pem" # -------------------------------------------------------------------------------- # Database streaming helpers # -------------------------------------------------------------------------------- def get_total_rows(eng) -> int: """ Return the total row count for the `embeddingcontent` table. This function executes a simple and fast `SELECT COUNT(*)` query. It is used to provide an accurate total to the progress bar without loading all rows into memory. Parameters ---------- eng: A SQLAlchemy Engine connected to the SQLite DB. Returns ------- int The number of rows in the `embeddingcontent` table. Notes ----- - This intentionally does not fetch any row data; it only returns the scalar count. - If the table does not exist or the DB is inaccessible, SQLAlchemy will raise an exception — callers should be prepared to handle that. """ with eng.connect() as con: result = con.execute(text("SELECT COUNT(*) FROM embeddingcontent")) # scalar_one() is used to ensure we get exactly one scalar result back. return result.scalar_one() def stream_chunks(eng, batch_size: int) -> Iterator[pd.DataFrame]: """ Stream the `embeddingcontent` table in fixed-size DataFrame chunks. This wrapper returns a generator/iterator of pandas DataFrame objects by delegating to `pd.read_sql(..., chunksize=batch_size)`. Using `chunksize` ensures that only one batch (one DataFrame) is materialized at a time, which keeps memory usage bounded and predictable even for very large SQLite files. Parameters ---------- eng: A SQLAlchemy Engine connected to the SQLite DB. batch_size: Number of rows to fetch per yielded DataFrame. Returns ------- Iterator[pd.DataFrame] An iterator which yields DataFrame chunks in ascending `chunk_id` order. Each yielded DataFrame contains the columns present in the `embeddingcontent` table, including the binary `embedding` column. Notes ----- - The returned iterator may be backed by a SQL cursor depending on the pandas/sqlalchemy runtime; this is the core mechanism that avoids loading the full table into memory. - The `# type: ignore[return-value]` is present on the return to bypass a static typing mismatch between pandas' dynamic iterator return and the static function signature. """ return pd.read_sql( # type: ignore[return-value] "SELECT * FROM embeddingcontent ORDER BY chunk_id", eng, chunksize=batch_size, ) # -------------------------------------------------------------------------------- # Qdrant insertion helper # -------------------------------------------------------------------------------- def insert_to_qdrant( qdrant_client: QdrantClient, collection_name: str, batch_df: pd.DataFrame ): """ Insert a batch of rows into a Qdrant collection. This function converts rows from the provided DataFrame into Qdrant `PointStruct` objects and performs a single `upsert` call for the entire batch for efficiency. Expected DataFrame columns -------------------------- - chunk_id: primary key for the chunk (kept as-is, Qdrant accepts str/int) - embedding: binary blob containing float32 bytes for the vector - product_id, content_type, heading_h1, heading_h2, heading_h3, section_heading, heading_level, chunk_text, title, date_published, url, program_name: metadata fields that will be placed in the Qdrant payload Parameters ---------- qdrant_client: An initialized `qdrant_client.QdrantClient` instance connected to the target Qdrant instance. collection_name: The target Qdrant collection name to upsert into. batch_df: A pandas DataFrame representing a chunk of rows obtained from the `embeddingcontent` table. Behavior and important notes ---------------------------- - Rows with NULL `embedding` are skipped (no vector to store). - The `embedding` binary blob is converted to a list of floats using `np.frombuffer(..., dtype=np.float32)` and stored directly in the point (the Qdrant collection uses a single unnamed vector config). - Metadata is written into the `payload` dict of each point. - Any additional fields present in the DataFrame could be added to the payload if desired; the current implementation uses a curated list. - Qdrant can accept integer or string IDs; this script uses `row["chunk_id"]` as provided by the database. """ points = [] # Iterate through rows in the batch DataFrame. Using `.iterrows()` is # acceptable here because we intentionally keep batch sizes modest. for _, row in batch_df.iterrows(): # Skip rows that have no embedding stored. if row["embedding"] is None: continue # Convert raw float32 bytes -> Python list of floats for Qdrant. # `np.frombuffer` avoids an extra copy when possible. point = models.PointStruct( id=row["chunk_id"], vector=list(np.frombuffer(row["embedding"], dtype=np.float32)), payload={ # The following payload fields mirror the embeddingcontent # schema. They are included so that when searching in Qdrant, # the payload can be returned along with nearest neighbor hits. "product_id": row["product_id"], "content_type": row["content_type"], "heading_h1": row["heading_h1"], "heading_h2": row["heading_h2"], "heading_h3": row["heading_h3"], "heading_level": row["heading_level"], "page_start": row["page_start"], "page_end": row["page_end"], "chunk_text": row["chunk_text"], "title": row["title"], "date_published": row["date_published"], "url": row["url"], "program_name": row["program_name"], "abstract": row["abstract"], "keywords": row["keywords"], }, ) points.append(point) # Perform a batch upsert for the entire points list. Upserting in batches # is much faster than individual point inserts. qdrant_client.upsert(collection_name=collection_name, points=points) # -------------------------------------------------------------------------------- # Qdrant collection creation helper # -------------------------------------------------------------------------------- def create_collection(q_cl: QdrantClient): """ Create a Qdrant collection configured for the project's embeddings. This function: - Deletes the collection if it already exists (purging prior data). This behavior ensures a fresh collection is created on each run. - Creates the collection with a single unnamed vector config (1024-dim, COSINE distance). Vectors are stored on disk for large collections. - Applies binary quantization to reduce vector storage size. - Tuned HNSW and optimizer configs for efficient ingestion of large datasets (see reference for design rationale). Parameters ---------- q_cl: An instance of `qdrant_client.QdrantClient` already connected to the target Qdrant host. Notes ----- - Deleting and recreating a collection is destructive. If you prefer to append to an existing collection, modify this function to skip deletion. - Vector config: COSINE distance, 1024 dimensions, on-disk storage. - Quantization: Binary quantization (reduces storage by ~32x for binary- compatible vectors). `always_ram=True` keeps quantized lookup tables in RAM for fast decoding. - HNSW: m=6 (lower branching factor for memory efficiency), ef_construct=200, on-disk=False (index graph stays in RAM). - Max segment size: 5,000,000 vectors per segment for faster search. Reference ---------- - https://qdrant.tech/course/essentials/day-4/large-scale-ingestion/ """ # If the collection already exists, remove it so we start fresh. if q_cl.collection_exists(QDRANT_COLLECTION_NAME): q_cl.delete_collection(QDRANT_COLLECTION_NAME) # Create the collection with a named vector configuration. This sample uses # `Distance.COSINE` as the similarity metric and specific HNSW tuning params. q_cl.create_collection( collection_name=QDRANT_COLLECTION_NAME, vectors_config=models.VectorParams( size=int(os.getenv("DENSE_VECTOR_DIM", 1024)), distance=models.Distance.COSINE, on_disk=True, ), quantization_config=models.BinaryQuantization( binary=models.BinaryQuantizationConfig( always_ram=True, # Keep quantized vectors in RAM ) ), optimizers_config=models.OptimizersConfigDiff( max_segment_size=5_000_00, # Create larger segments for faster search ), hnsw_config=models.HnswConfigDiff( m=6, # Lower m to reduce memory usage ef_construct=200, on_disk=False, # Keep the HNSW index graph in RAM ), ) # Note: quantization is set via BinaryQuantization in the collection # creation above (not disabled). The original "disabled" comment has been # updated to reflect the actual binary quantization that is applied. # -------------------------------------------------------------------------------- # Main entrypoint # -------------------------------------------------------------------------------- if __name__ == "__main__": # Configure a progress bar with several useful columns: # - percentage, a visual bar, completed/total count, elapsed, and ETA. start_time = time.time() progress_bar = Progress( TextColumn("[progress.percentage]{task.percentage:>3.0f}%"), BarColumn(), MofNCompleteColumn(), TextColumn("•"), TimeElapsedColumn(), TextColumn("•"), TimeRemainingColumn(), console=console, ) # The original script removed a local `qdrant_db` directory; this legacy # cleanup is preserved for parity. It is safe to leave but has no effect # on cloud-hosted Qdrant unless your local environment also stored data. shutil.rmtree((Path(__file__).parent / "qdrant_db").resolve(), ignore_errors=True) # Build a Qdrant client connected to the configured base URL. The # environment variable QDRANT_BASE_URL must be set (or the script will raise). qdrant_cloud = QdrantClient( url=os.environ["QDRANT_BASE_URL"], https="https" in os.environ["QDRANT_BASE_URL"], prefer_grpc=False, timeout=3000, ) # Create the collection (this will delete & recreate if it already exists). create_collection(qdrant_cloud) # Print the current number of points in the (newly-created) collection. # For a fresh collection this should normally be zero. console.print( f"Number of Existing Points: {qdrant_cloud.count(collection_name=QDRANT_COLLECTION_NAME, exact=True).count}" ) # Batch size used when streaming rows and inserting into Qdrant. BATCH_SIZE = 1000 # First obtain a count of how many rows we will process so the progress bar # has an accurate total and ETA. This is a cheap SQL query. total = get_total_rows(engine) console.print(f"[bold orange]Total rows in SQLite: {total:,}") # Stream in batches and upsert each batch into Qdrant. with progress_bar as p: task = p.add_task("Transferring to Qdrant...", total=total) for chunk_df in stream_chunks(engine, BATCH_SIZE): insert_to_qdrant( collection_name=QDRANT_COLLECTION_NAME, batch_df=chunk_df, qdrant_client=qdrant_cloud, ) # Advance the progress bar by the number of rows processed in this chunk. p.advance(task, len(chunk_df)) # Final status message: print the number of points now in the collection. console.print( f"[bold green]Done. Qdrant collection count: {qdrant_cloud.count(collection_name=QDRANT_COLLECTION_NAME, exact=True).count}" ) console.print( f"[bold green]Total Elapsed Time : {time.time() - start_time:.2f} seconds" )