Semantic Search with Hugging Face Models and Datasets

In this notebook you will build a working semantic search engine over movie reviews: Hugging Face turns text into vectors, and SingleStore stores and searches them with a single line of SQL.

Keyword search matches the characters you typed. If a review says "hilarious" and you search for "funny", keyword search finds nothing. Semantic search matches meaning instead. An embedding model converts each piece of text into a list of numbers — a vector — positioned so that texts with similar meanings land near each other. Finding relevant reviews then becomes a geometry question: which stored vectors point in most nearly the same direction as the vector for your query?

SingleStoreDB holds those vectors in a native VECTOR column and compares them with vector functions such as DOT_PRODUCT, executed in parallel across the cluster using Intel SIMD instructions. The search is ordinary SQL, so it composes with joins, filters, and aggregates over the rest of your data, and there is no separate vector database to operate alongside it.

The path through this notebook:

• create a database and install the embedding libraries

• load a small multilingual embedding model

• download 10,000 IMDB movie reviews and sample 100 of them

• turn each review into a 384-number vector

• store the reviews and their vectors in SingleStore

• search them by meaning with one SQL query

1. Create a workspace in your workspace group

S-00 is sufficient.

2. Create a database named semantic_search

3. Install and import required libraries

The embedding model comes from Hugging Face and is loaded through the Sentence Transformers library, which wraps a model together with the post-processing needed to turn its raw token-by-token output into one vector per piece of text.

Installing sentence-transformers also brings in transformers (the runtime that executes the model) and huggingface_hub (which downloads model weights and datasets from the Hub), so neither needs its own install line.

The version bounds are matched to what the hosted notebook image ships, in particular its PyTorch build. The cell prints the versions it ended up with and then checks that the model runtime initialized, so any mismatch surfaces here rather than several cells later. Loosening these bounds is the most likely way to break the notebook, so change them only if you know the image has moved.

4. Load the embedding model and create a get_embedding() function

We use sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2: a small, fast model trained so that sentences which paraphrase one another sit close together in vector space, across more than 50 languages. Every input, long or short, becomes a vector of 384 numbers.

A transformer emits one vector per token, so something has to condense those into a single vector for the whole text. This model's answer is mean pooling — average the token vectors, counting only real tokens and not padding. SentenceTransformer reads that choice, and the model's 128-token input limit, from the configuration published alongside the weights, which is why we load the model this way rather than assembling the pieces by hand.

Now a small helper that embeds one string at a time. The result is a numpy array of little-endian 32-bit floats, which is exactly the byte layout SingleStore's VECTOR(N, F32) type expects, so it can be stored without any conversion.

normalize_embeddings=True scales every vector to length 1. This is what makes the search in step 8 work the way you want: for unit-length vectors, the dot product equals the cosine of the angle between them. Scores then fall in a -1 to 1 range and mean "how similar in direction", instead of also reflecting how long each vector happens to be.

5. Load the dataset of movie reviews from Hugging Face into a DataFrame

ajaykarthick/imdb-movie-reviews is a collection of IMDB reviews, each labelled positive or negative. Its splits are stored as plain JSONL files, so hf_hub_download fetches test.jsonl (10,000 rows) from the Hub and pandas reads it directly. The file is cached locally, so re-running this cell does not download it again.

We then take a sample of 100 reviews to keep the embedding step quick. random_state fixes which 100, so re-running the notebook gives you the same sample and therefore the same search results.

6. Generate embeddings of the reviews and add them to your DataFrame

Handing the whole column to model.encode() lets the model embed 32 reviews per forward pass, which is much faster than calling get_embedding() once per row. normalize_embeddings is set here for the same reason as in step 4: the stored vectors have to be unit length for the dot product in step 8 to be a cosine similarity.

7. Insert data into SingleStore

The embeddings go into a VECTOR(384, F32) column, SingleStore's native vector type. It validates the dimension of every value on insert, prints readably in query results, and can be backed by a vector index. NOT NULL is required if you want to add such an index later, so it is worth declaring now.

Because the column type is the point, we write the CREATE TABLE ourselves rather than letting pandas infer a schema. Each vector is then sent as a hex string and converted by UNHEX, which hands SingleStore the packed 32-bit floats exactly as the model produced them, with no text round-trip through the numbers.

The second cell echoes the resulting table definition back, so you can see the vector column as the database understands it.

8. Run the semantic search algorithm with just one line of SQL

Your search string goes through the same model as the reviews did, which puts it in the same vector space. The query below then compares that one vector against all 100 stored vectors and returns the five nearest.

<*> is the infix operator for DOT_PRODUCT. Because every vector is unit length, the dot product is the cosine similarity between your query and the review: scores near 1 mean closely related in meaning, near 0 unrelated. SingleStore compiles the query to machine code and evaluates the dot products with SIMD instructions, spread in parallel across the cluster.

Try a search that shares no words at all with any review — movies about space travel, or the same idea written in another language, since this model is multilingual. Matches you get without a single word in common are the whole point of embedding search.

With 100 rows this is an exact scan of the table, which is the right choice at this size. At millions of rows you would add an approximate vector index to the same column, and the query itself would not change:

ALTER TABLE reviews ADD VECTOR INDEX ivf (review_embeddings)
    INDEX_OPTIONS '{"index_type":"IVF_PQFS", "metric_type":"DOT_PRODUCT"}';

9. Clean up