> ## Documentation Index > Fetch the complete documentation index at: https://doc.lucidworks.com/llms.txt > Use this file to discover all available pages before exploring further. # Boost with Signals Stage export const schema = { "type": "object", "title": "Boost with Signals", "description": "Uses recommended items for search time boosting", "required": ["boostingMethod", "boostingParam"], "properties": { "skip": { "type": "boolean", "title": "Skip This Stage", "description": "Set to true to skip this stage.", "default": false, "hints": ["advanced"] }, "label": { "type": "string", "title": "Label", "description": "A unique label for this stage.", "hints": ["advanced"], "maxLength": 255 }, "condition": { "type": "string", "title": "Condition", "description": "Define a conditional script that must result in true or false. This can be used to determine if the stage should process or not.", "hints": ["code", "code/javascript", "advanced"] }, "asyncConfig": { "type": "object", "title": "Asynchronous Execution Config", "required": ["enabled", "asyncId"], "properties": { "enabled": { "type": "boolean", "title": "Enable Async Execution", "description": "Run the expensive data loading or processing part of this stage in a separate thread allowing the pipeline to continue executing. The results of this asynchronous execution can be merged into the pipeline request using a downstream \"Merge Async Results\" stage.", "default": false }, "asyncId": { "type": "string", "title": "Async ID", "description": "A unique value to use as reference in downstream \"Merge Async Results\" stages." } } }, "numRecommendations": { "type": "integer", "title": "Number of Recommendations", "description": "Number of documents to set for the main query to return.", "default": 10 }, "numSignals": { "type": "integer", "title": "Number of Signals", "description": "Number of signals to process when getting recommended items.", "default": 100 }, "aggrType": { "type": "string", "title": "Aggregation Type", "description": "A string type field with signal type and aggregated fields, stored in _signals_aggr collection.", "default": "click@doc_id,filters,query" }, "boostId": { "type": "string", "title": "Solr Field to Boost On", "description": "Which Solr field to use when applying recommendation boosts.", "default": "id" }, "boostingMethod": { "type": "string", "title": "Boost Method", "description": "The boost method to use. query-parser should be chosen if defType!=edismax for main query.", "enum": ["query-param", "query-parser"], "default": "query-param", "hints": ["advanced"] }, "boostingParam": { "type": "string", "title": "Boost Param", "description": "’Boost' multiplies scores by the boost values whereas 'bq' adds optional clauses to main query.", "enum": ["boost", "bq"], "default": "boost", "hints": ["advanced"] }, "scaleRange": { "type": "object", "title": "Scale Boosts", "description": "Scale the boost values to a [min,max] range", "required": ["scaleMin", "scaleMax"], "properties": { "scaleMin": { "type": "number", "title": "Minimum value of the scale range" }, "scaleMax": { "type": "number", "title": "Maximum value of the scale range" } }, "hints": ["advanced"] }, "queryParams": { "type": "array", "title": "Solr Query parameters", "description": "Parameters for querying Signal aggregation collection", "default": [{ "key": "qf", "value": "query_t" }, { "key": "pf", "value": "query_t^50" }, { "key": "pf", "value": "query_t~3^20" }, { "key": "pf2", "value": "query_t^20" }, { "key": "pf2", "value": "query_t~3^10" }, { "key": "pf3", "value": "query_t^10" }, { "key": "pf3", "value": "query_t~3^5" }, { "key": "mm", "value": "50%" }, { "key": "boost", "value": "map(query({!field f=query_s v=$q}),0,0,1,20)" }, { "key": "defType", "value": "edismax" }, { "key": "sort", "value": "score desc, weight_d desc" }], "hints": ["advanced"], "items": { "type": "object", "required": ["key"], "properties": { "key": { "type": "string", "title": "Parameter Name" }, "value": { "type": "string", "title": "Parameter Value" } } } }, "rollupField": { "type": "string", "title": "Rollup Field", "description": "Field to use for rolling up documents that have same doc id's", "hints": ["advanced"] }, "rollupWeightField": { "type": "string", "title": "Rollup weight field", "description": "Field to use for signal weights", "hints": ["advanced"] }, "rollupWeightStrategy": { "type": "string", "title": "Rollup weight strategy", "description": "Strategy to use for rolling up the weight: max or sum", "enum": ["sum", "max"], "hints": ["advanced"] }, "weightExpression": { "type": "string", "title": "Final Boost Weight Expression", "description": "Optional expression to compute the final boost weight using a combination of fields returned by Solr, such as score and weight_d. Set to weight_d for similar behavior as older versions ", "default": "math:log(weight_d + 1) + 10 * math:log(score+1)" }, "contextKey": { "type": "string", "title": "Document Weights Context Key", "description": "Context key to save docId:weight_d boosts to" } }, "category": "Results Relevancy", "categoryPriority": 6, "unsafe": false }; export const SchemaParamFields = ({schema}) => { const sanitize = str => { if (typeof str !== "string") return str; return str.replace(/^"(.*)"$/s, "$1").replace(/\\/g, "").replace(/"/g, "'"); }; const formatDescription = str => { const s = sanitize(str); return (/[.!?]\)*$/).test(s) ? s : `${s}.`; }; const {description, properties = {}, required: requiredProps = []} = schema; const visibleProps = useMemo(() => Object.entries(properties).filter(([, prop]) => !prop.hints?.includes("hidden")), [properties]); return
{description &&

{formatDescription(description)}

} {visibleProps.map(([name, prop]) => { const isRequired = requiredProps.includes(name); const hasDefault = prop.default !== undefined; const rawDefault = prop.default; const isComplexDefault = hasDefault && (typeof rawDefault === "object" || typeof rawDefault === "string" && (rawDefault.length > 20 || rawDefault.includes('"'))); const fieldProps = { key: name, body: prop.title || name, type: prop.type, ...prop.title && ({ post: [<>API property: {name}] }), ...isRequired && ({ required: true }), ...!isComplexDefault && hasDefault ? { default: sanitize(String(rawDefault)) } : {} }; const isObject = prop.type === "object" && prop.properties; const isArrayOfObjects = prop.type === "array" && prop.items?.type === "object" && prop.items.properties; return {prop.description &&

{formatDescription(prop.description)}

} {isComplexDefault &&

Default: 

                  
                    {JSON.stringify(rawDefault, null, 2)}
} {isArrayOfObjects &&

Object attributes: 

                
                  {'{\n'}
                  {Object.entries(prop.items.properties).map(([iname, iprop]) => <>
                      {`  ${iname}`}
                      {prop.items?.required?.includes(iname) &&  required}
                      {`: {\n    display name: ${sanitize(iprop.title || '')}\n    type: ${iprop.type}\n  }\n`}
                    )}
                  {'}'}
} {isObject && } ; })}
; }; export const LwTemplate = ({title = "Key questions to get you started", icon = "sparkles", cta = "Powered by Agent Studio", linkHref = "https://lucidworks.com/demo/?utm_source=docs&utm_medium=referral&utm_campaign=docs_cta_ai"}) => { const [isLoaded, setIsLoaded] = useState(false); useEffect(() => { const timer = setTimeout(() => { setIsLoaded(true); }, 500); return () => clearTimeout(timer); }, []); return
{isLoaded && ` }} />} Powered by Lucidworks Agent Studio
; }; [localhost link]: http://localhost:3000/docs/4/fusion-ai/reference/query-pipeline-stages/recommendation-boosting-query-stage [mintlify link]: https://doc.lucidworks.com/docs/4/fusion-ai/reference/query-pipeline-stages/recommendation-boosting-query-stage [old doc.lw link]: https://doc.lucidworks.com/fusion/5.9/511 The Boost with Signals query pipeline stage uses [aggregated signals](/docs/4/fusion-ai/concepts/signals-and-aggregations/aggregations/overview) to selectively boost items in the set of search results. Using the main query and the stage configuration parameters, this stage performs a secondary query to the `_signals_aggr` collection and returns updated boost weights for the items in the main query’s search results. Items that have received more user interaction also receive higher boost weights. See [Recommendation Methods](/docs/4/fusion-ai/concepts/boosting/recommendation-methods) for more information. This stage supports [asynchronous processing](/docs/4/fusion-server/concepts/querying/pipelines/query-pipelines). This stage accesses the `signals_aggr` collection. Before using it, verify that the following [permission](/docs/4/fusion-server/concepts/security/access-control/permissions) is set:\ `GET:/solr/_signals_aggr/select` ## Configuration overview The fields below are especially useful to understand when configuring this stage. | | | | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Number of Recommendations** `numRecommendations` | Sets the `rows` query param in the main query as the maximum number of query results which will be boosted by this pipeline stage. | | **Number of Signals** `numSignals` | Sets the `rows` query param in the query that searches the `_signals_aggr` collection, so only the specified number of aggregated signals are retrieved and used for boosting. When signals boosting is applied to a query, aggregated signals records are queried from the appropriate `_signals_aggr` collection to find out the popularity or boost weight for documents which have signals. `numSignals` limits the number of records to be queried from a `_signals_aggr` collection and used to calculate this boost. | | **Aggregation Type** `aggrType` | A filter to retrieve aggregated signals in the `_signals_aggr` collection per each aggregated signal’s `aggr_type_s` field value. | | **Solr Field to Boost On** `boostId` | The document field in the main collection on which to perform boosting. Typically it should use default field, which is `id`. This field corresponds to the **Rollup Field**/`rollupField` field. Together, these two fields act like a `\:\` pair in the query modification for boosting. | | **Boost Method** `boostingMethod` | This adds a query parameter to the original query, either “query-param” or “query-parser”. The result is `(“query-param” or “query-parser”) + Boost Param(“boost” or "bq")`, as in the examples below: “query-param”+"boost", result boost query param `boost="map(query(\{!field f='id' v=‘6239046,13026192}), 0, 0, 1, 27.1705)"` “query-parser”+"boost", result boost query param `bp_xxx_bbqx="map(query(\{!field f='id' v=‘6239046,13026192}), 0, 0, 1, 27.1705)"` When `Boost Param` uses `bq`, similar logic applies. When **Boost Param**/`boostingParam` uses “boost”, it works with both “query-param” and “query-parser”. | | **Rollup Field** `rollupField` | Indicates which aggregated signal document field the boost parameter will use for the final boosting. It works in combination with the **Solr Field to Boost On**/`boostId` field. This should be set to the field in the aggregated signal collection that stores the doc list that is aggregated as one record. By default it’s set to `doc_id_s`, because by default this is used in the [click\_signal\_aggr SQL job](/docs/4/fusion-ai/concepts/signals-and-aggregations/aggregations/sql-aggregations). | | **Rollup Weight Field** `rollupWeightField` | Indicates the final boost weight used to calculate the new score for docs retrieved by the main query. Similar to **Rollup Field**/`rollupField` above, this should be set to the field in the aggregated signal collection that stores the final weight that was calculated. By default it’s `weight_d`, because by default this is used in the [click\_signal\_aggr SQL job](/docs/4/fusion-ai/concepts/signals-and-aggregations/aggregations/sql-aggregations). | | **Final Boost Weight Expression** `weightExpression` | Calculates the final weight using the weight and score retrieved from the `_signals_aggr` collection. The default value is `math:log(weight_d + 1) + 10 * math:log(score+1)`. | ## Solr query parameters These parameters are used in the **Solr Query parameters**/`queryParams` field for retrieving signal aggregation docs from the `_signals_aggr` collection. These Solr query params will affect which aggregated signals are used for producing the boosting parameter on the main query. | | | | ---------------- | ----------------------------------------------------------------------------------------------------------------------- | | `qf=query_t` | Defines which field to query. In the default case, the query searches on the `query_t` field of aggregated signal docs. | | `pf=query_t^50` | Boosts docs within the set of retrieved docs using phrase matching. | | `pf2=query_t^20` | `pf2` is similar to `pf`; the difference is that `pf2` works on bigram phrases. | | `pf3=query_t^10` | `pf3` is similar to `pf`; the difference is that `pf3` works on trigram phrases. | ## FAQs **If there is `fq` in the main query, how is it matched with the correct aggregated signal?** In this case, you need to use the `lw.rec.fq` query parameter in the main query. `lw.rec.fq` can be parsed by the Boost with Signals stage, and therefore the filters specified in it can be added to the Solr query that is retrieving the aggregated signals. For example, if we have filter query param `fq=format:CD&fq=name:Latin`, this needs to be translated into `lw.rec.fq=filters_s:"format:cd $ name:latin"`. Values must be lowercase. The final main query should be: ```sh wrap theme={"dark"} http://localhost:8764/api/apollo/apps/demo_app/query-pipelines/demo_app/collections/demo_app/select?echoParams=all&wt=json&json.nl=arrarr&sort&start=0&q=apple&debug=true&rows=10&lw.rec.fq=filters_s:"format:cd $ name:latin" ``` Now the Boost with Signals stage will only retrieve aggregated signals that have the same filter query. If there are multiple `fq` values (for example, `format:cd` and `name:latin`), they are ordered alphabetically as strings and joined with " $" (a$ with a space on each side). In the example, `"format:cd $ name:latin"`. **What if my aggregated signals are in a different collection?** You can point the Boost with Signals stage to a different signal collection by adding a `collection` parameter in the `Solr Query Parameters` section. BwS collection ## Configuration When entering configuration values in the UI, use *unescaped* characters, such as `\t` for the tab character. When entering configuration values in the API, use *escaped* characters, such as `\\t` for the tab character.