Semantic search pipelines are built from several main components. These include vector embeddings, which represent text or data as numerical vectors; vector databases, designed for storing and querying these embeddings; and Approximate Nearest Neighbor (ANN) search, which enables efficient retrieval of similar vectors. Understanding the overall architecture, detailing how these elements combine, is fundamental for developing applications that can search based on meaning rather than just exact keyword matches.
A semantic search pipeline isn't a single monolithic block; it's a sequence of processing steps, typically involving distinct offline (indexing) and online (querying) phases.
The diagram illustrates the typical flow of data in a semantic search system, separated into the offline indexing phase and the online query phase.
Let's break down each stage shown in the diagram:
Indexing Phase (Offline)
This phase happens before users start searching. Its goal is to prepare your data and make it searchable within the vector database.
- Raw Data Ingestion: This is the starting point where you gather the data you want to make searchable. This could be text documents, product descriptions, images, audio files, or any other data type for which you can generate meaningful embeddings.
- Data Preprocessing & Chunking: Raw data often needs cleaning (removing irrelevant characters, HTML tags, etc.). More significantly for semantic search, large pieces of data (like long documents) usually need to be broken down into smaller, semantically coherent chunks. Why? Because embedding models typically have input length limitations, and more importantly, a single embedding represents the meaning of the entire input text. Embedding a whole book might average out its meaning too much; embedding smaller paragraphs or sections often yields more specific and useful vectors for search. We'll cover chunking strategies in the next section. Metadata associated with the original data (e.g., document ID, author, creation date, product category) should be preserved and linked to the corresponding chunks.
- Embedding Generation: Each processed data chunk is passed through a chosen embedding model (like Sentence-BERT for text, or CLIP for images/text). This transforms the chunk into a high-dimensional vector, capturing its semantic essence. This process can be computationally intensive, especially for large datasets, so batch processing and potentially GPU acceleration are common considerations.
- Indexing in Vector Database: The generated vectors, along with their associated metadata and a unique identifier for each chunk, are loaded into the vector database. The database then builds an ANN index (e.g., HNSW, IVF) over these vectors, as discussed in Chapter 3. This index structure allows for fast approximate similarity searches later. The metadata is also indexed, enabling filtered searches.
Query Phase (Online)
This phase occurs in real-time when a user submits a search query.
- User Query Input: The system receives the user's query (e.g., a sentence, a question, or even an image).
- Query Preprocessing: Similar to data preprocessing, the raw query might undergo some cleaning or normalization.
- Query Embedding Generation: This is a critical step. The exact same embedding model used during the indexing phase must be applied to the processed user query. This converts the query into a vector existing in the same semantic space as the indexed data vectors. Using different models would lead to incompatible vectors and meaningless search results.
- ANN Search: The query vector is sent to the vector database. The database uses its ANN index to efficiently find the vectors in the index that are closest (most similar, based on a chosen metric like cosine similarity or Euclidean distance) to the query vector. Typically, you request the top k nearest neighbors.
- Metadata Filtering (Optional): Vector databases often allow combining the vector similarity search with filtering based on the metadata stored alongside the vectors. This can happen before the vector search (pre-filtering, potentially narrowing the search space) or after the vector search (post-filtering, refining the top k candidates). For instance, a user might search for "machine learning articles" but only want results published in the last year. The vector search finds semantically relevant articles, and the metadata filter removes those outside the desired date range.
- Re-ranking (Optional): The raw similarity scores from the ANN search provide an initial ranking. However, you might want to refine this ranking using additional signals. For example, in a hybrid search system (discussed later in this chapter), you might combine the semantic similarity score with a traditional keyword relevance score (like BM25). You could also factor in document freshness, popularity, or user preferences. Re-ranking takes the initial set of candidates from the ANN search (and potentially filtering) and reorders them based on a potentially more complex relevance function.
- Result Presentation: The final, ranked list of results (usually references to the original data chunks or documents) is formatted and presented to the user.
This modular architecture allows each component to be optimized or potentially swapped out. For example, you could experiment with different embedding models or tune ANN index parameters without redesigning the entire pipeline. The key is the flow of data, transforming it into vectors, indexing them efficiently, and then using query vectors to find semantically similar items within that indexed space.
