> For the complete documentation index, see [llms.txt](https://qyverlabs.gitbook.io/qyverlabs-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://qyverlabs.gitbook.io/qyverlabs-docs/concepts/dynamic-parameters.md).

# Dynamic Parameters/Query Time weights

#### **Achieving High-Quality Retrieval with Qyver: Query Time Weighting**

Getting **high-quality results** from a **vector database query** is challenging. Through real-world **machine learning deployment**, we’ve learned two fundamental truths:

1\. **The richer your dataset, the better your retrieval results**—but only if **your embeddings fully represent that dataset**.\
2\. **Different use cases emphasize different data attributes**—your retrieval system must **prioritize what matters most**.

#### **How Qyver Handles This Challenge**

Instead of **embedding all data as a single text string**, **Qyver’s Spaces** allow you to:

* **Embed attributes separately** rather than forcing everything into a single vector.
* **Concatenate attribute-specific embeddings** into a **multimodal vector**.
* **Prioritize different data attributes dynamically** at **query time**, avoiding the need for **reranking**.

**The result?** **Faster, higher-quality retrieval**—without expensive **post-processing layers or reranking.**

***

## **Two Ways to Weight a Query**

Qyver enables **query weighting** in **two ways**:

#### **1. Weighting at Query Definition**

* **Set weights when defining a query**—experiment and optimize **without re-embedding your dataset**.

#### **2. Weighting at Query Execution**

* **Set weights dynamically when running the query**—fine-tune retrieval in real-time, **without re-indexing**.

Let’s see how both approaches work in Qyver.

***

### **1. Query Weighting at Definition**

By structuring **separate embeddings for different attributes**, **Qyver Spaces** allow you to **weight each attribute independently**.

#### **Example: Optimizing Search for Text vs. Popularity**

Let’s define a **schema** and **two Spaces**:

```python
@schema
class Paragraph:
    id: IdField
    body: String
    like_count: Integer

paragraph = Paragraph()

# Define separate embeddings for text similarity and numerical ranking
body_space = TextSimilaritySpace(
    text=paragraph.body, model="sentence-transformers/all-mpnet-base-v2"
)
like_space = NumberSpace(
    number=paragraph.like_count, min_value=0, max_value=100, mode=Mode.MAXIMUM
)

# Combine Spaces into an index
paragraph_index = Index([body_space, like_space])
```

#### **Adding Data to the System**

```python
source: InMemorySource = InMemorySource(paragraph)
executor = InMemoryExecutor(sources=[source], indices=[paragraph_index])
app = executor.run()

source.put([
    {"id": "paragraph-1", "body": "Glorious animals live in the wilderness.", "like_count": 75},
    {"id": "paragraph-2", "body": "Growing computation power enables advancements in AI.", "like_count": 10},
])
```

Now, let's define **two different queries**:

* **One that prioritizes text similarity** (weights text 2x more than likes).
* **One that prioritizes likes** (weights likes 2x more than text).

```python
body_query = (
    Query(
        paragraph_index,
        weights={
            body_space: 1.0,  # Text similarity weighted higher
            like_space: 0.5,
        },
    )
    .find(paragraph)
    .similar(body_space.text, "What makes the AI industry go forward?")
)

like_query = (
    Query(
        paragraph_index,
        weights={
            body_space: 0.5,
            like_space: 1.0,  # Like count weighted higher
        },
    )
    .find(paragraph)
    .similar(body_space.text, "What makes the AI industry go forward?")
)
```

### **Running the Queries**

**1. Prioritizing Text Similarity**

```python
body_result = app.query(body_query)
body_result.to_pandas()
```

**Expected Output:**

| body                                                 | like\_count | id          |
| ---------------------------------------------------- | ----------- | ----------- |
| Growing computation power enables advancements in AI | 10          | paragraph-2 |
| Glorious animals live in the wilderness              | 75          | paragraph-1 |

**2. Prioritizing Like Count**

```python
like_result = app.query(like_query)
like_result.to_pandas()
```

**Expected Output:**

| body                                                 | like\_count | id          |
| ---------------------------------------------------- | ----------- | ----------- |
| Glorious animals live in the wilderness              | 75          | paragraph-1 |
| Growing computation power enables advancements in AI | 10          | paragraph-2 |

#### **Why is this better?**

* **No re-embedding needed**—just adjust query weights.
* **No reranking needed**—Qyver retrieves **relevant results upfront**.

***

### **2. Dynamic Query Weighting at Execution**

In **production systems**, query logic is typically **predefined**. But **Qyver allows dynamic fine-tuning**, so data scientists or users can **adjust weighting at runtime**—without modifying query definitions.

#### **Defining a Query with Dynamic Parameters**

```python
query = (
    Query(
        paragraph_index,
        weights={
            body_space: Param("body_space_weight"),
            like_space: Param("like_space_weight"),
        },
    )
    .find(paragraph)
    .similar(body_space.text, Param("query_text"))
)
```

#### **Running the Query with Different Weights**

**1. Prioritizing Text Similarity**

```python
body_based_result = app.query(
    query,
    query_text="How computation power changed the course of AI?",
    body_space_weight=1,
    like_space_weight=0,
)

body_based_result.to_pandas()
```

**Expected Output:**

| body                                                 | like\_count | id          |
| ---------------------------------------------------- | ----------- | ----------- |
| Growing computation power enables advancements in AI | 10          | paragraph-2 |
| Glorious animals live in the wilderness              | 75          | paragraph-1 |

**2. Prioritizing Like Count**

```python
like_based_result = app.query(
    query,
    query_text="How computation power changed the course of AI?",
    body_space_weight=0,
    like_space_weight=1,
)

like_based_result.to_pandas()
```

**Expected Output:**

| body                                                 | like\_count | id          |
| ---------------------------------------------------- | ----------- | ----------- |
| Glorious animals live in the wilderness              | 75          | paragraph-1 |
| Growing computation power enables advancements in AI | 10          | paragraph-2 |

**Why is this powerful?**

* **Fine-tune relevance dynamically** without touching embeddings.
* **Empower users to control results** without developer intervention.

***

### **Final Thoughts**

#### **Qyver’s Query Time Weighting:**

1. **Weighting at Query Definition** → Experiment & optimize **without re-embedding data**.
2. **Weighting at Query Execution** → Allow **real-time fine-tuning** for **data scientists and users**.

**What does this mean for you?**

* **Faster, more relevant search results**—without reranking overhead.
* **Greater flexibility & adaptability**—retrieval adjusts dynamically.
* **No costly infrastructure changes**—just tweak the query weights!

**Like what we’re doing?** Give us a [star](https://github.com/qyverlabs/qyver)!