Hybrid Queries with QBVectorColumn: Semantic Meets SQL

Servoy AI Runtime Plugin tutorial series hero image

This is a Servoy Tutorial on QBVectorColumn, the feature that takes semantic search in Servoy from “interesting” to “production-ready.” This is the fourth and final article in the AI Runtime Plugin series. If you have not read the earlier tutorials on chat completions and embeddings, tool calling, and PgVector stores with FoundSet embedding, go read those first. This article builds directly on the PgVector store and embedAll() patterns from Article 3.

In Article 3, I showed you how to embed product records into a PgVector store and search them with oStore.search(). That works, but it has a limitation: the search is purely semantic. If you want products similar to “lightweight laptop for travel” that are also under $2,000, in stock, and active, you have to do two passes. First the semantic search, then a second query to filter the results by price and stock. Two round-trips, two sort orders fighting each other, and you have to cap the semantic pass absurdly high to make sure you do not filter out all the good matches.

QBVectorColumn fixes this. It adds vector search directly to Servoy’s Query Builder, so you can combine semantic similarity with traditional WHERE clauses in a single query. One database round-trip. One sort order. PostgreSQL does all the work.

Two Functions, Two Jobs#

QBVectorColumn has two methods. Understanding which one to use where is the whole game.

vector_distance(embedding) returns a QBNumberColumn. It gives you a raw distance value where lower is better. Sort ascending to get the best matches first. This is the most efficient option for ranking and is what you should reach for when ordering results.

vector_score(embedding) returns a QBScoreColumn. It gives you a normalized 0-to-1 similarity score where higher is better. This is the one you add to the result set when you want to display the score to the user, and it has a special min_score() method for filtering.

Bottom-line: use vector_distance for sorting, use vector_score for display and filtering.

Getting the Query Vector#

Before you can use either function, you need the raw embedding vector for the user’s search query. This is the synchronous, single-text form of the embedding model’s embedding() method:

1
/**
2
 * Demonstrates the synchronous single-string form of embedding().
3
 * Returns a raw Array<Number> immediately (no Promise).
4
 * @author Gary Dotzlaw
5
 * @since 2026-04-17
6
 * @public
7
 */
8
function demoSyncEmbedding() {
9
    try {
10
            /**@type {String}*/
11
        const sApiKey = application.getServoyProperty('openai_api_key');
12

13
            /**@type {plugins.ai.EmbeddingModel}*/
14
        const oModel = plugins.ai.createOpenAiEmbeddingModelBuilder()
15
            .apiKey(sApiKey)
16
            .modelName('text-embedding-3-small')
17
            .build();
18

19
            /**@type {Array<Number>}*/
20
        const aVector = oModel.embedding('test phrase for embedding');
21

22
        application.output('type = ' + typeof aVector);
23
        application.output('isArray = ' + Array.isArray(aVector));
24
        application.output('length = ' + aVector.length);
25
        application.output('first value = ' + aVector[0]);
26
        application.output('getDimension = ' + oModel.getDimension());
27
    } catch (e) {
28
        application.output('Error in demoSyncEmbedding: ' + e.message, LOGGINGLEVEL.ERROR);
29
    }
30
}

Expected Output:

1
type = object
2
isArray = true
3
length = 1536
4
first value = 0.0167999267578125
5
getDimension = 1536

Notice: embedding() with a single string argument is synchronous. It returns the raw vector array immediately. Do not confuse this with the array form, which is asynchronous and returns a Promise. The single-string form is what you use for QBVectorColumn queries because you need the vector before you can build the query. The vector length always matches oModel.getDimension() — 1536 for text-embedding-3-small.

Sorting by Distance: vector_distance().asc#

Start with the simplest hybrid pattern: sort the foundset by semantic relevance to a query. The following example joins the base table to the embeddings table on the auto-captured PK, and sorts ascending by vector distance so the best matches come first:

1
/**
2
 * Sort a product foundset by semantic relevance to a query.
3
 * Demonstrates vector_distance() in query.sort.
4
 * @author Gary Dotzlaw
5
 * @since 2026-04-17
6
 * @public
7
 */
8
function sortBySemanticDistance() {
9
    try {
10
            /**@type {String}*/
11
        const sApiKey = application.getServoyProperty('openai_api_key');
12

13
            /**@type {plugins.ai.EmbeddingModel}*/
14
        const oModel = plugins.ai.createOpenAiEmbeddingModelBuilder()
15
            .apiKey(sApiKey)
16
            .modelName('text-embedding-3-small')
17
            .build();
18

19
            /**@type {Array<Number>}*/
20
        const aVec = oModel.embedding('spicy sauce condiment');
21

22
            /**@type {QBSelect}*/
23
        const query = datasources.db.example_data.products.createSelect();
24
        query.result.addPk();
25

26
            /**@type {QBJoin}*/
27
        const joinEmb = query.joins.add(
28
            'db:/example_data/product_embeddings_test',
29
            QBJoin.INNER_JOIN,
30
            'emb'
31
        );
32
        joinEmb.on.add(joinEmb.columns.productid.eq(query.columns.productid));
33

34
        // Sort by vector_distance ascending (best matches first)
35
        query.sort.add(
36
            joinEmb.columns.embedding.vector_distance(aVec).asc
37
        );
38

39
            /**@type {JSFoundSet}*/
40
        const fs = datasources.db.example_data.products.getFoundSet();
41
        fs.loadRecords(query);
42

43
        application.output('loaded ' + fs.getSize() + ' records');
44
        for (let i = 1; i <= Math.min(5, fs.getSize()); i++) {
45
            application.output('  #' + i + ': ' + fs.getRecord(i).productname);
46
        }
47
    } catch (e) {
48
        application.output('Error in sortBySemanticDistance: ' + e.message, LOGGINGLEVEL.ERROR);
49
    }
50
}

Expected Output:

1
loaded 77 records
2
  #1: Louisiana Fiery Hot Pepper Sauce
3
  #2: Original Frankfurter grüne Soße
4
  #3: Louisiana Hot Spiced Okra
5
  #4: Northwoods Cranberry Sauce
6
  #5: Chef Anton's Cajun Seasoning

The top five results all relate to spicy sauces and condiments, even though only one of them contains the word “sauce” and none contain the word “spicy.” The database ranked them by semantic similarity, not keyword match.

Including the Score in the Result Set: vector_score()#

When you want to display the similarity score alongside product data, add vector_score() as a result column with an alias:

1
/**
2
 * Fetch a ranked product dataset with the similarity score as a column.
3
 * Demonstrates vector_score() in query.result with an alias.
4
 * @author Gary Dotzlaw
5
 * @since 2026-04-17
6
 * @public
7
 */
8
function fetchRankedProducts() {
9
    try {
10
            /**@type {String}*/
11
        const sApiKey = application.getServoyProperty('openai_api_key');
12

13
            /**@type {plugins.ai.EmbeddingModel}*/
14
        const oModel = plugins.ai.createOpenAiEmbeddingModelBuilder()
15
            .apiKey(sApiKey)
16
            .modelName('text-embedding-3-small')
17
            .build();
18

19
            /**@type {Array<Number>}*/
20
        const aVec = oModel.embedding('chocolate candy sweet');
21

22
            /**@type {QBSelect}*/
23
        const query = datasources.db.example_data.products.createSelect();
24

25
            /**@type {QBJoin}*/
26
        const joinEmb = query.joins.add(
27
            'db:/example_data/product_embeddings_test',
28
            QBJoin.INNER_JOIN,
29
            'emb'
30
        );
31
        joinEmb.on.add(joinEmb.columns.productid.eq(query.columns.productid));
32

33
        query.result.add(query.columns.productid);
34
        query.result.add(query.columns.productname);
35
        // Include the score in the result, aliased as 'relevance'
36
        query.result.add(
37
            joinEmb.columns.embedding.vector_score(aVec), 'relevance'
38
        );
39

40
        query.sort.add(
41
            joinEmb.columns.embedding.vector_distance(aVec).asc
42
        );
43

44
            /**@type {JSDataSet}*/
45
        const ds = databaseManager.getDataSetByQuery(query, 10);
46

47
        application.output('got ' + ds.getMaxRowIndex() + ' rows');
48
        for (let i = 1; i <= Math.min(5, ds.getMaxRowIndex()); i++) {
49
            application.output('  ' + ds.getValue(i, 2) + ' — score: ' + ds.getValue(i, 3));
50
        }
51
    } catch (e) {
52
        application.output('Error in fetchRankedProducts: ' + e.message, LOGGINGLEVEL.ERROR);
53
    }
54
}

Expected Output:

1
got 10 rows
2
  Chocolade — score: 0.7723287378081095
3
  Schoggi Schokolade — score: 0.739770648571818
4
  Teatime Chocolate Biscuits — score: 0.723661901327705
5
  Valkoinen suklaa — score: 0.7145571819702352
6
  Tarte au sucre — score: 0.7018570402395428

The score is a numeric value between 0 and 1 where higher means more similar. For text-embedding-3-small, real-world scores on clearly-related pairs typically land in the 0.6–0.8 range. Scores above 0.9 are unusual and usually mean the text is near-identical to the query.

Filtering by Score: min_score()#

The min_score() method filters rows whose similarity is below a threshold. It is chained on the result of vector_score():

1
/**
2
 * Load only products with similarity above a score threshold.
3
 * Demonstrates vector_score().min_score() as a WHERE filter.
4
 * @author Gary Dotzlaw
5
 * @since 2026-04-17
6
 * @public
7
 */
8
function filterByMinScore() {
9
    try {
10
            /**@type {String}*/
11
        const sApiKey = application.getServoyProperty('openai_api_key');
12

13
            /**@type {plugins.ai.EmbeddingModel}*/
14
        const oModel = plugins.ai.createOpenAiEmbeddingModelBuilder()
15
            .apiKey(sApiKey)
16
            .modelName('text-embedding-3-small')
17
            .build();
18

19
            /**@type {Array<Number>}*/
20
        const aVec = oModel.embedding('dairy cheese milk');
21

22
            /**@type {QBSelect}*/
23
        const query = datasources.db.example_data.products.createSelect();
24
        query.result.addPk();
25

26
            /**@type {QBJoin}*/
27
        const joinEmb = query.joins.add(
28
            'db:/example_data/product_embeddings_test',
29
            QBJoin.INNER_JOIN,
30
            'emb'
31
        );
32
        joinEmb.on.add(joinEmb.columns.productid.eq(query.columns.productid));
33

34
        // min_score: only rows scoring at or above 0.7
35
        query.where.add(
36
            joinEmb.columns.embedding.vector_score(aVec).min_score(0.7)
37
        );
38

39
        query.sort.add(
40
            joinEmb.columns.embedding.vector_distance(aVec).asc
41
        );
42

43
            /**@type {JSFoundSet}*/
44
        const fs = datasources.db.example_data.products.getFoundSet();
45
        fs.loadRecords(query);
46

47
        application.output('min_score(0.7) returned ' + fs.getSize() + ' products');
48
        for (let i = 1; i <= fs.getSize(); i++) {
49
            application.output('  #' + i + ': ' + fs.getRecord(i).productname);
50
        }
51
    } catch (e) {
52
        application.output('Error in filterByMinScore: ' + e.message, LOGGINGLEVEL.ERROR);
53
    }
54
}

Expected Output:

1
min_score(0.7) returned 2 of 77 total products
2
  #1: Queso Cabrales
3
  #2: Queso Manchego La Pastora

A couple of important details:

min_score() is chained on the result of vector_score(). It only exists on QBScoreColumn (the return type of vector_score). You cannot chain it on vector_distance(). If you try, you will get a method-not-found error.
The sort still uses vector_distance().asc. Even though we are filtering by score, sorting by distance is more efficient at the database level. They produce the same ordering (best matches first), just expressed differently.
The threshold matters. 0.7 is a reasonable starting point for “clearly relevant” matches with text-embedding-3-small. At 0.5, you get everything (most text pairs in the same domain score above 0.5). At 0.8+, you get only near-perfect semantic matches.

For the opposite approach, filtering by distance instead of score, use the standard numeric operators on QBNumberColumn:

1
/**
2
 * Filter products by vector distance using the standard .le() operator.
3
 * Demonstrates vector_distance().le() as a WHERE filter.
4
 * @author Gary Dotzlaw
5
 * @since 2026-04-17
6
 * @public
7
 */
8
function filterByMaxDistance() {
9
    try {
10
            /**@type {String}*/
11
        const sApiKey = application.getServoyProperty('openai_api_key');
12

13
            /**@type {plugins.ai.EmbeddingModel}*/
14
        const oModel = plugins.ai.createOpenAiEmbeddingModelBuilder()
15
            .apiKey(sApiKey)
16
            .modelName('text-embedding-3-small')
17
            .build();
18

19
            /**@type {Array<Number>}*/
20
        const aVec = oModel.embedding('tea green herbal');
21

22
            /**@type {QBSelect}*/
23
        const query = datasources.db.example_data.products.createSelect();
24
        query.result.addPk();
25

26
            /**@type {QBJoin}*/
27
        const joinEmb = query.joins.add(
28
            'db:/example_data/product_embeddings_test',
29
            QBJoin.INNER_JOIN,
30
            'emb'
31
        );
32
        joinEmb.on.add(joinEmb.columns.productid.eq(query.columns.productid));
33

34
        // Distance filter: only rows within distance 0.7 of the query vector
35
        query.where.add(
36
            joinEmb.columns.embedding.vector_distance(aVec).le(0.7)
37
        );
38

39
        query.sort.add(
40
            joinEmb.columns.embedding.vector_distance(aVec).asc
41
        );
42

43
            /**@type {JSFoundSet}*/
44
        const fs = datasources.db.example_data.products.getFoundSet();
45
        fs.loadRecords(query);
46

47
        application.output('distance <= 0.7 returned ' + fs.getSize() + ' products');
48
        for (let i = 1; i <= Math.min(5, fs.getSize()); i++) {
49
            application.output('  #' + i + ': ' + fs.getRecord(i).productname);
50
        }
51
    } catch (e) {
52
        application.output('Error in filterByMaxDistance: ' + e.message, LOGGINGLEVEL.ERROR);
53
    }
54
}

Expected Output:

1
distance <= 0.7 returned 6 products
2
  #1: Chartreuse verte
3
  #2: Chai
4
  #3: Teatime Chocolate Biscuits
5
  #4: Original Frankfurter grüne Soße
6
  #5: Aniseed Syrup

Use min_score(0.7) when you think in terms of “how similar is this?” Use vector_distance(...).le(n) when your domain expresses a specific distance tolerance.

The Full Hybrid Query#

Okay, here is where all four articles come together. Let’s take a real scenario. Your users are searching a product catalog. They type “lightweight laptop for travel.” A semantic search happily returns laptops that mention “portable,” “ultra-thin,” “commuter-friendly,” and similar ideas, even if the word “lightweight” appears nowhere. So far, nothing new. But the user also needs to filter to products under $2,000 that are currently in stock, ranked by relevance. That filter is boring traditional SQL. The ranking is semantic.

Before QBVectorColumn, you had to do two passes: semantic search first, then filter the PKs in a second query. Two round-trips, two sort orders fighting each other, and you had to cap the semantic pass absurdly high to make sure you did not filter out all the good matches. With QBVectorColumn, it is one query.

The embeddings produced by embedAll() in Article 3 live in the separate product_embeddings_test table we configured earlier. That table has a productid column (from the declared metaDataColumn) and an embedding vector column. To do a hybrid query, we join the embeddings table back to products and use vector_distance on the embedding column:

1
/**
2
 * Hybrid semantic + SQL search over the product catalog.
3
 * Combines vector_distance sort, vector_score in result, and SQL filters.
4
 * @author Gary Dotzlaw
5
 * @since 2026-04-17
6
 * @public
7
 */
8
function hybridProductSearch() {
9
    try {
10
            /**@type {String}*/
11
        const sApiKey = application.getServoyProperty('openai_api_key');
12

13
            /**@type {plugins.ai.EmbeddingModel}*/
14
        const oModel = plugins.ai.createOpenAiEmbeddingModelBuilder()
15
            .apiKey(sApiKey)
16
            .modelName('text-embedding-3-small')
17
            .build();
18

19
            /**@type {Array<Number>}*/
20
        const aVec = oModel.embedding('seafood fish ocean');
21

22
            /**@type {QBSelect}*/
23
        const query = datasources.db.example_data.products.createSelect();
24

25
            /**@type {QBJoin}*/
26
        const joinEmb = query.joins.add(
27
            'db:/example_data/product_embeddings_test',
28
            QBJoin.INNER_JOIN,
29
            'emb'
30
        );
31
        joinEmb.on.add(joinEmb.columns.productid.eq(query.columns.productid));
32

33
        // Result columns for display
34
        query.result.add(query.columns.productid);
35
        query.result.add(query.columns.productname);
36
        query.result.add(query.columns.unitprice);
37
        query.result.add(
38
            joinEmb.columns.embedding.vector_score(aVec), 'relevance'
39
        );
40

41
        // Traditional SQL filter: only products that are not discontinued
42
        query.where.add(query.columns.discontinued.eq(0));
43

44
        // Semantic sort: best matches first
45
        query.sort.add(
46
            joinEmb.columns.embedding.vector_distance(aVec).asc
47
        );
48

49
            /**@type {JSDataSet}*/
50
        const ds = databaseManager.getDataSetByQuery(query, 10);
51

52
        application.output('hybrid query returned ' + ds.getMaxRowIndex() + ' rows');
53
        for (let i = 1; i <= Math.min(5, ds.getMaxRowIndex()); i++) {
54
            application.output('  ' + ds.getValue(i, 2) +
55
                ' — $' + ds.getValue(i, 3) +
56
                ' — relevance: ' + (ds.getValue(i, 4) ? ds.getValue(i, 4).toFixed(3) : 'null'));
57
        }
58
    } catch (e) {
59
        application.output('Error in hybridProductSearch: ' + e.message, LOGGINGLEVEL.ERROR);
60
    }
61
}

Expected Output:

1
hybrid query returned 10 rows
2
  Boston Crab Meat — $18.4 — relevance: 0.726
3
  Ikura — $31 — relevance: 0.676
4
  Longlife Tofu — $10 — relevance: 0.655
5
  Nord-Ost Matjeshering — $25.89 — relevance: 0.654
6
  Chef Anton's Cajun Seasoning — $22 — relevance: 0.654

Let’s walk through what makes this special:

oModel.embedding(sQuery) returns the raw vector. This is the synchronous, single-text version. It gives you back the array of floats so you can pass the vector into the query builder.
The JOIN connects products to product_embeddings_test on productid. The embeddings table was created by embedAll() in Article 3, with the PK declared as a metaDataColumn on the store builder. So emb.productid is a real column on the embeddings table, and it matches the source productid one-to-one.
vector_score(aVec) goes into the result set with an alias. Reading relevance from each result row lets you display the score to the user if you want. The score is a number between 0 and 1.
The WHERE clause is pure QBSelect. The discontinued = 0 filter executes in the database alongside the vector scoring. In your own queries, add stock, price, tenant isolation, and any other traditional conditions — all in the same query.
The sort uses vector_distance().asc. Lower distance means a better match, and sorting on distance is more efficient than sorting on the derived score. This is the pattern you should reach for when you want the top-N most similar records.

PostgreSQL ranks by relevance, applies the filters, and returns 25 rows. One query. One round-trip. This is the query you could not write cleanly before. A LIKE search over product names would miss half of what the user wants. A semantic-only search would return dream-laptops priced at $9,000 that are out of stock. QBVectorColumn lets you combine both, and the database does the work.

Loading a Foundset from a Hybrid Query#

The hybridProductSearch function above returns a JSDataSet with multiple columns for display. But if you want to load the results into a foundset for a standard Servoy form, use the PK-only pattern:

1
/**
2
 * Hybrid semantic search that loads results into a foundset.
3
 * @author Gary Dotzlaw
4
 * @since 2026-04-17
5
 * @public
6
 *
7
 * @param {String} sQuery the user's natural-language query
8
 * @param {Number} nMaxPrice the maximum unit price filter
9
 */
10
function hybridSearchToFoundset(sQuery, nMaxPrice) {
11
    try {
12
            /**@type {String}*/
13
        const sApiKey = application.getServoyProperty('openai_api_key');
14

15
            /**@type {plugins.ai.EmbeddingModel}*/
16
        const oModel = plugins.ai.createOpenAiEmbeddingModelBuilder()
17
            .apiKey(sApiKey)
18
            .modelName('text-embedding-3-small')
19
            .build();
20

21
            /**@type {Array<Number>}*/
22
        const aQueryVector = oModel.embedding(sQuery);
23

24
            /**@type {QBSelect}*/
25
        const query = datasources.db.example_data.products.createSelect();
26
        query.result.addPk();
27

28
            /**@type {QBJoin}*/
29
        const joinEmb = query.joins.add(
30
            'db:/example_data/product_embeddings_test',
31
            QBJoin.INNER_JOIN,
32
            'emb'
33
        );
34
        joinEmb.on.add(joinEmb.columns.productid.eq(query.columns.productid));
35

36
        query.where.add(query.columns.discontinued.eq(0));
37
        query.where.add(query.columns.unitsinstock.gt(0));
38
        query.where.add(query.columns.unitprice.le(nMaxPrice));
39

40
        query.sort.add(
41
            joinEmb.columns.embedding.vector_distance(aQueryVector).asc
42
        );
43

44
        foundset.loadRecords(query);
45
        application.output('Loaded ' + foundset.getSize() + ' products');
46
    } catch (e) {
47
        application.output('Error in hybridSearchToFoundset: ' + e.message, LOGGINGLEVEL.ERROR);
48
        plugins.dialogs.showErrorDialog('Error', 'Search failed: ' + e.message, 'OK');
49
    }
50
}

The key difference: query.result.addPk() instead of explicit columns. This is the standard QBSelect pattern for foundset loading. The foundset comes back sorted by semantic relevance, filtered by your business rules, and ready to display in any standard Servoy form. No special components, no custom rendering. It is just a foundset.

Combining Score Filtering with SQL Filtering#

You can use both min_score() and traditional WHERE clauses in the same query. This gives you the tightest possible result set: semantically relevant AND matching your business criteria AND above a quality threshold:

1
// Only products with relevance above 0.6, under $20, in stock, not discontinued
2
query.where.add(
3
    joinEmb.columns.embedding.vector_score(aQueryVector).min_score(0.6)
4
);
5
query.where.add(query.columns.unitprice.le(20));
6
query.where.add(query.columns.unitsinstock.gt(0));
7
query.where.add(query.columns.discontinued.eq(0));
8

9
query.sort.add(
10
    joinEmb.columns.embedding.vector_distance(aQueryVector).asc
11
);

The min_score filter runs at the database level, which means PostgreSQL eliminates low-relevance rows before sorting and returning. This is more efficient than fetching a large result set and filtering client-side.

When to Use Each Approach#

You now have three different ways to do semantic search in Servoy. Here is when to use each one:

oStore.search() from Articles 1 and 3: Use this when you want a quick similarity search and do not need SQL filters. It is the simplest approach. Good for search-as-you-type features, tool function fallbacks, and any case where the embedding store has everything you need.

QBVectorColumn with foundset.loadRecords(): Use this when you need semantic search combined with SQL filters and want the results in a standard foundset. This is the production pattern for search features embedded in existing Servoy forms.

QBVectorColumn with getDataSetByQuery(): Use this when you need the similarity score in the result set for display, or when you are building a custom search results view that shows relevance alongside product data.

The Complete Picture#

If you have been following along through all four articles, you now have the full AI Runtime Plugin toolkit:

Article 1: Chat completions with Promises and streaming, conversation memory, provider switching between OpenAI and Gemini, basic embeddings with in-memory stores, token tracking, and the chat-with-your-data SQL generation pattern.
Article 2: Tool calling with the double-build pattern, multi-tool agents, the vector-fallback pattern for smart tool functions, built-in tools, and security practices for agentic workflows.
Article 3: PgVector persistent stores that survive server restarts, embedAll() for foundset embedding with automatic PK metadata, custom metadata columns, PDF document chunking and RAG, and batch strategies for keeping embeddings in sync.
Article 4: QBVectorColumn for hybrid queries that combine semantic similarity with traditional SQL filters in a single database round-trip, score-based filtering with min_score(), distance-based filtering, and the foundset loading pattern for production search features.

That covers every feature of the plugins.ai plugin. The plugin is the foundation, and these patterns show you how to build real features on top of it. From here, the interesting work is in combining these building blocks for your specific application: a help assistant that uses RAG over your documentation, a smart search that replaces LIKE queries across your entire application, an agent that automates multi-step workflows your users currently do by hand.

That concludes this Servoy tutorial series on the AI Runtime Plugin. I hope you enjoyed it, and I look forward to bringing you more Servoy tutorials in the future.

The Series#

This is Part 4 of a four-part series on the Servoy AI Runtime Plugin:

Getting Started with the Servoy AI Runtime Plugin. Chat completions, streaming, conversation memory, embeddings, and your first semantic search.
Tool Calling with the AI Runtime Plugin: Agentic Servoy. Register Servoy methods as tools and let the LLM decide when to call them.
Embedding Your Servoy Data for Semantic Search. PgVector production stores, FoundSet embedAll(), and PDF document chunking.
Hybrid Queries with QBVectorColumn: Semantic Meets SQL (this article). Combine semantic similarity with traditional WHERE clauses in a single database round-trip.