Hybrid Search

Opensolr Hybrid Search — find answers to your questions

Testing Opensolr AI Search — Vector Search, AI Hints & Doc...

Step-by-Step Guide
Testing Your Opensolr AI Search Engine
Four powerful features ship with every Opensolr Web Crawler index — intent-based Vector Search, instant AI Hints, one-click Document Reader, and hands-on Query Elevation.
CrawlIndexEmbedSolrSearch
Your complete AI search pipeline — fully managed, out of the box
Intent-Based Vector Search
Instead of matching exact keywords, vector search understands what you mean. A query like "winter hat" finds wool beanies, fleece earflap caps, and knit headwear — even when those exact words aren't on the page. Opensolr uses BGE-m3 embeddings (1024 dimensions) combined with traditional BM25 scoring for the best of both worlds: semantic understanding plus keyword precision.
winter hatAIBGE-m31024-dimensional vector embeddings98%Wool Winter Cap94%Knit Beanie Set89%Fleece Earflap Hat
Hybrid Scoring (BM25 + Vectors)BGE-m3 1024-dimMultilingual
AI Hints — Instant Answers from Your Content
Before your users even scroll through results, AI Hints delivers a concise, AI-generated answer right at the top of the page. It uses RAG (Retrieval-Augmented Generation) — the AI retrieves the most relevant passages from YOUR indexed content, then generates a focused answer. No hallucinations, no external data — every hint is grounded in your actual pages.
best pellet heater for garage?RAG: retrieves from YOUR indexed contentAI HintLook for 40,000+ BTU models with thermostatVentilation required for enclosed spacesSee top-rated pellet heaters in results below
RAG-PoweredGrounded in Your DataZero Hallucinations
Document Reader — Summarize Any Search Result
Every search result includes a "Read" button. Click it, and the AI reads the entire web page, extracts the key information, and generates a clean summary — in seconds. You can then download the summary as a PDF. No need to visit the page, skim through ads, or parse dense content yourself.
Best Pellet Heaters 2026 — Expert ReviewsComplete guide to choosing the right pellet heater...heatersguide.com/pellet-heaters-2026ReadAIReaderPage SummaryTop 5 pellet heaters ranked by efficiency, noise level,and value. Castle 12327 rated best overall at $1,299...Download PDF
One-Click SummariesPDF ExportKey Feature Extraction
Query Elevation — Pin & Exclude Search Results
Take full control of what your users see. Query Elevation lets you pin important results to the top or exclude irrelevant ones — directly from the Search UI, with zero code and no reindexing required. Perfect for promoting landing pages, burying outdated content, or curating high-value queries.
Search ResultsProduct Landing Pageyoursite.com/products/best-sellerPin↑ Pinned #1— forced to top for this queryDrag to reorder when multiple results are pinnedExcluded result — hidden from this query
  • Pin — Force a specific result to the top for a given search query
  • Exclude — Hide a result completely so it never appears for that query
  • Exclude All — Apply the rule globally, across every search query
  • Drag & drop — Reorder pinned results to control exactly which one shows first
Zero Code RequiredExclude Irrelevant ResultsPin & Reorder

Try It Live

Test these demo search engines with real vector search. Use conceptual, intent-based queries:

Try these conceptual queries to see how vector similarity goes beyond keyword matching:

  • climate disasters hurricanes floods wildfires
  • space exploration mars colonization economy
  • ancient microbes life beyond earth

Every demo page includes built-in dev tools — query parameter inspector, full Solr debugQuery output, crawl statistics, and search analytics.


Using the Solr API Directly

Direct API access for advanced users — learn more about hybrid search.

Example Solr endpoints (credentials: 123 / 123):

https://de9.solrcluster.com/solr/vector/select?wt=json&indent=true&q=*:*&rows=2
https://fi.solrcluster.com/solr/rueb/select?wt=json&indent=true&q=*:*&rows=2
https://chicago96.solrcluster.com/solr/peilishop/select?wt=json&indent=true&q=*:*&rows=2

Simple Lexical Query

curl -u 123:123 "https://de9.solrcluster.com/solr/vector/select?q=climate+change&rows=5&wt=json"

Pure Vector Query (KNN)

curl -u 123:123 "https://de9.solrcluster.com/solr/vector/select?q={!knn%20f=embeddings%20topK=50}[0.123,0.432,0.556,...]&wt=json"

Replace the vector array with your own embedding from the Opensolr AI NLP API.

Hybrid Query (Lexical + Vector)

curl -u 123:123 "https://de9.solrcluster.com/solr/vector/select?q={!bool%20should=$lexicalQuery%20should=$vectorQuery}&lexicalQuery={!edismax%20qf=content}climate+change&vectorQuery={!knn%20f=embeddings%20topK=50}[0.12,0.43,0.66,...]&wt=json"

Combines traditional keyword scoring with semantic vector similarity — best of both worlds.


Getting Embeddings via Opensolr API

Generate vector embeddings for any text using these endpoints:

function postEmbeddingRequest($email, $api_key, $core_name, $payload) {
    $apiUrl = "https://api.opensolr.com/solr_manager/api/embed";
    $postFields = http_build_query([
        'email'      => $email,
        'api_key'    => $api_key,
        'index_name' => $core_name,
        'payload'    => is_array($payload) ? json_encode($payload) : $payload
    ]);

    $ch = curl_init($apiUrl);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => $postFields,
        CURLOPT_HTTPHEADER     => ['Content-Type: application/x-www-form-urlencoded'],
        CURLOPT_TIMEOUT        => 30,
    ]);

    $response = curl_exec($ch);
    curl_close($ch);
    return json_decode($response, true);
}

The response includes the vector embedding array you can pass directly to Solr.


Code Examples

PHP PHP

<?php
$url = 'https://de9.solrcluster.com/solr/vector/select?wt=json';
$params = [
    'q'            => '{!bool should=$lexicalQuery should=$vectorQuery}',
    'lexicalQuery' => '{!edismax qf=content}climate disasters',
    'vectorQuery'  => '{!knn f=embeddings topK=50}[0.12,0.43,0.56,0.77]'
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_USERPWD, '123:123');
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($params));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

echo $response;

Py Python

import requests
from requests.auth import HTTPBasicAuth

url = "https://de9.solrcluster.com/solr/vector/select"
params = {
    'q': '{!bool should=$lexicalQuery should=$vectorQuery}',
    'lexicalQuery': '{!edismax qf=content}climate disasters',
    'vectorQuery': '{!knn f=embeddings topK=50}[0.12,0.43,0.56,0.77]',
    'wt': 'json'
}

response = requests.post(url, data=params, auth=HTTPBasicAuth('123', '123'))
print(response.json())

JS JavaScript (AJAX)

<script>
fetch('https://de9.solrcluster.com/solr/vector/select?wt=json&q={!knn%20f=embeddings%20topK=10}[0.11,0.22,0.33]', {
    headers: { 'Authorization': 'Basic ' + btoa('123:123') }
})
.then(r => r.json())
.then(console.log);
</script>

Quick Reference

  • Adjust topK to control how many similar results to retrieve (usually 20-100).
  • Use {!bool should=...} for softer relevance mixing — vector similarity has more influence on ranking.
  • For best hybrid results, always combine both lexical and vector queries.
  • All demo search pages include built-in query inspector, debugQuery, crawl stats, and search analytics.
Ready to Add AI Search to Your Site?
Get a fully managed vector search engine with AI Hints and Document Reader — set up in minutes.
Read Full Answer

Search Tuning — Per-Index Relevancy Controls

Search Relevancy
Search Tuning — Fine-Tune How Your Search Ranks Results
Every index is different. A news site needs freshness. A product catalog needs exact matches. A knowledge base needs semantic understanding. Search Tuning gives you visual controls to shape relevancy per index — no code, no config files, instant effect.
DEFAULT SETTINGS
wireless headphones review
Sony WH-1000XM5 Review#1
Posted yesterday — comprehensive review...
Best Wireless Headphones 2024#2
Old roundup from 2 years ago...
Headphone Buying Guide#3
AFTER TUNING
wireless headphones review
Sony WH-1000XM5 ReviewFRESH
Posted yesterday — boosted by freshness...
Headphone Buying Guide#2
Semantically relevant — matched by meaning...
Best Wireless Headphones 2024#3
Older content ranked lower...
Freshness boost + semantic balance pushed the new review up and demoted stale content.

Where to Find It
Search Tuning lives inside Index Settings in your Opensolr dashboard. Open your index, click the gear icon or Index Settings, and expand the Search Tuning section. Every change saves automatically — move a slider, and your very next search uses the new settings.

The Six Controls

Field Weights
Control how much each field contributes to relevancy ranking. The four searchable fields are Title, Description, URI, and Text (full body). Use the master slider to quickly shift between title-focused ranking (great for navigational queries) and text-focused ranking (great for deep content search).
5.0
Title
4.0
Description
0.5
URI
0.01
Text
Default: Title 5.0, Description 4.0, URI 0.5, Text 0.01 — title-heavy. Drag the master slider right to give body text more influence, or type exact values into each field.
Freshness Boost
How much newer content is preferred over older content. Higher values push recently published or updated pages toward the top. Uses the document's creation_date field with a time-decay curve — recent documents get the biggest boost, which fades over days and weeks.
Range: 10 (barely noticeable) to 1000 (aggressively fresh). Default: 100. Only applies when search mode is set to "Fresh" — standard search ignores this setting.
Minimum Match
How many of the user's search words must appear in a document for it to be considered a match. Three presets:
Flexible
Show more results
Some words can be missing
Balanced
Most words must match
Good middle ground
Strict
All words must match
Fewest but most precise
Default: System-managed (adapts automatically for vector indexes). Choose a preset to override.
Semantic vs Keyword Balance
Controls how much weight goes to semantic (vector) understanding versus exact keyword matching. Only available on vector-enabled indexes (those with embeddings in the schema). Move left for keyword-heavy results, right for semantic-heavy.
More Keyword
More Semantic
Range: 0.0 (pure keyword) to 3.0 (heavily semantic). Default: 1.5 — balanced. The system also adapts dynamically based on query length (longer queries get more semantic weight), but your override takes priority.
Result Quality Threshold
The minimum relevance score a document must reach to appear in results. Raise it to filter out weak matches and show only highly relevant results. Lower it to be more inclusive and show everything that has some match.
Range: 0.0 (show everything) to 1.0 (only near-perfect matches). Default: 0.60 — filters out low-relevance noise while keeping useful results.
Results Per Page
How many search results are returned in each page. Applies to both the Opensolr Search UI and API responses. Higher values show more results but increase response size.
Range: 10 to 200. Default: 50. Adjust based on your UI layout — grid layouts work well with 20-30, list layouts with 50+.

How It Works — Under the Hood

1
You move a slider
Change any control in the Search Tuning panel. The value saves automatically after a 400ms debounce — no Save button needed.
2
Stored per index
Your custom value is saved to your index configuration. A NULL value means "use system defaults" — so resetting a control removes the override entirely.
3
Applied on next search
When a search request comes in, the engine loads your custom values and applies them as overrides on top of the system defaults. No reindexing, no restart. The very next query uses your tuning.

Reset Behavior

Every control has its own Reset button that restores it to the system default. There's also a Reset All to Defaults button at the bottom of the panel that clears all customizations at once.

Reset Individual Control
Click the Reset button next to any control. The value goes back to system default and the override is removed from your index. System defaults include adaptive behavior — for example, vector indexes automatically adjust semantic weight based on query length.
Reset All to Defaults
Clears every custom value at once. Your index goes back to behaving exactly like it did before you opened Search Tuning. All adaptive behaviors are restored.

Quick Recipes

News Site Prioritize fresh articles
Set Freshness Boost to 500-800. Set Minimum Match to Flexible. Leave field weights at defaults — titles already have the highest weight, and news articles have strong titles.
Knowledge Base Semantic understanding first
Set Semantic vs Keyword to 2.0-2.5 (more semantic). Set Minimum Match to Flexible. Set Field Weights — increase Text weight to 1.0+ so body content has more influence. Freshness doesn't matter for evergreen docs, keep it low (10-30).
E-Commerce Exact product matches
Set Minimum Match to Strict — users searching for "blue wireless headphones" should see results with all three words. Keep Semantic at 1.0-1.5 so typos still work. Set Result Quality Threshold to 0.70+ to cut weak matches. Results Per Page at 20-30 for grid layouts.
Blog / Content Site Deep content discovery
Increase Text field weight to 0.5-1.0 (use the master slider toward "Text-focused"). Set Freshness at 100-200 for moderate recency bias. Minimum Match on Balanced. Semantic at 2.0 for natural-language queries that blog readers tend to use.

Defaults at a Glance

Control Default Value Range
Title Weight 5.0 0 – 20
Description Weight 4.0 0 – 20
URI Weight 0.5 0 – 20
Text Weight 0.01 0 – 20
Freshness Boost 100 10 – 1,000
Minimum Match System-managed Flexible / Balanced / Strict
Semantic vs Keyword 1.5 0.0 – 3.0
Result Quality Threshold 0.60 0.0 – 1.0
Results Per Page 50 10 – 200

FAQ

Do I need to reindex after changing tuning settings?
No. Search Tuning controls are applied at query time, not index time. Your changes take effect on the very next search request.
What happens if I don't customize anything?
Everything stays at system defaults. The search engine uses battle-tested defaults that work well for most use cases, including adaptive behavior for vector indexes that adjusts parameters based on query length.
Does Semantic vs Keyword show up for all indexes?
No. It only appears on vector-enabled indexes — those using the embeddings field for semantic search. Non-vector indexes use pure keyword search, so the control isn't shown.
Does Freshness Boost always apply?
Only when the user searches with Fresh mode enabled (the "Fresh" toggle on the search UI, or fresh=yes in the API). Standard search does not apply freshness boosting regardless of this setting.
Can I set different tuning for different indexes?
Yes — that's the whole point. Every index has its own Search Tuning settings. A news index can have high freshness and flexible matching, while a product index on the same account has strict matching and low freshness. Each index is tuned independently.

Ready to Tune Your Search?
Open Index Settings in your dashboard and expand Search Tuning. Changes take effect on the very next search.
Read Full Answer

Hybrid Search in Opensolr: A Modern Approach

Hybrid Search in Apache Solr: Modern Power, Classic Roots

The Evolution of Search: From Keywords to Vectors 🔍➡️🧠

Important Pre-Req.

First make sure you have this embeddings field in your schema.xml (works with):
<!--VECTORS-->
<field name="embeddings" type="vector" indexed="true" stored="true" multiValued="false" required="false" />
<fieldType name="vector" class="solr.DenseVectorField" vectorDimension="1024" similarityFunction="cosine"/>

⚠️ Pay very close attention to the vectorDimension, as it has to match the embeddings that you are creating with your LLM Model. If using the Opensolr Index Embedding API, this has to be exactly: 1024. This works with the Opensolr Embed API Endpoint which uses the BAAI/bge-m3 embedding model.


Opensolr Also supports the native Solr /schema API, so you can also run these two, in order to add your fields to the schema.xml.
$ curl -u <INDEX_USERNAME>:<INDEX_PASSWORD> https://<OPENSOLR_INDEX_HOST>solr/<OPENSOLR_INDEX_NAME>/schema/fieldtypes -H 'Content-type:application/json' -d '{
  "add-field-type": {
    "name": "vector",
    "class": "solr.DenseVectorField",
    "vectorDimension": 1024,
    "similarityFunction": "cosine"
  }
}'

$ curl -u <INDEX_USERNAME>:<INDEX_PASSWORD> https://<OPENSOLR_INDEX_HOST>solr/<OPENSOLR_INDEX_NAME>/schema/fields -H 'Content-type:application/json' -d '{
  "add-field": {
    "name":"embeddings",
    "type":"vector",
    "indexed":true,
    "stored":false, // true if you want to see the vectors for debugging
    "multiValued":false,
    "required":false,
    "dimension":1024,  // adjust to your embedder size
    "similarityFunction":"cosine"
  }
}'

Seocond make sure you have this in solrconfig.xml for atomic updates to use with the Opensolr Index Embedding API:
<!-- The default high-performance update handler -->
<updateHandler class="solr.DirectUpdateHandler2">
      
        <updateLog>
          <int name="numVersionBuckets">65536</int>
          <int name="maxNumLogsToKeep">10</int>
          <int name="numRecordsToKeep">10</int>
        </updateLog>

.....

</updateHandler>

Already on Opensolr? Web Crawler indexes come with hybrid search ready out of the box — the embeddings field, BGE-m3 vectors, and the hybrid query pipeline are all pre-configured. No schema edits, no embedding setup. The manual setup above is for custom Opensolr indexes or self-hosted Solr.


Why Vector Search Isn’t a Silver Bullet ⚠️

As much as we love innovation, vector search still has a few quirks:

  • Mystery Rankings: Why did document B leapfrog document A? Sometimes, it’s anyone’s guess. 🕳️
  • Chunky Business: Embedding models are picky eaters—they work best with just the right size of text chunks.
  • Keyword Nostalgia: Many users still expect the comfort of exact matches. “Where’s my keyword?” they ask. (Fair question!)

Hybrid Search: The Best of Both Worlds 🤝

Hybrid search bridges the gap—combining trusty keyword (lexical) search with smart vector (neural) search for results that are both sharp and relevant.

How It Works

  1. Double the Fun: Run a classic keyword query and a KNN vector search at the same time, creating two candidate lists.
  2. Clever Combining: Merge and rank for maximum “aha!” moments.

Tuning the Balance: On Opensolr, Search Tuning gives you a visual slider to control the balance between keyword and semantic scoring (0.0 = pure keyword, 3.0 = heavily semantic). The system also adapts dynamically based on query length — short queries lean keyword, longer queries lean semantic.


Apache Solr Does Hybrid Search (Despite the Rumors) 💡

Contrary to the grapevine, Solr can absolutely do hybrid search—even if the docs are a little shy about it. If your schema mixes traditional fields with a solr.DenseVectorField, you’re all set.


Candidate Selection: Boolean Query Parser to the Rescue 🦸‍♂️

Solr’s Boolean Query Parser lets you mix and match candidate sets with flair:

Union Example

q={!bool should=$lexicalQuery should=$vectorQuery}&
lexicalQuery={!type=edismax qf=text_field}term1&
vectorQuery={!knn f=vector topK=10}[0.001, -0.422, -0.284, ...]

Result: All unique hits from both searches. No duplicates, more to love! ❤️

Intersection Example

q={!bool must=$lexicalQuery must=$vectorQuery}&
lexicalQuery={!type=edismax qf=text_field}term1&
vectorQuery={!knn f=vector topK=10}[0.001, -0.422, -0.284, ...]

Result: Only the most relevant docs—where both worlds collide. 🤝


You also have to be mindful of the Solr version you are using, since we were able to make this work only on Solr version 9.0. Beware this did not work on Solr 9.6! Only reranking queries worked on Solr 9.6 (as shown below).

Basically, at this point, here are all the paramerers we sent Solr, to make this hybrid search working on Solr version 9.0:

Classic Solr Edismax Search combined with dense vector search (UNION)

{
  "mm":"1<100% 2<70% 3<45% 5<30% 7<20% 10<10%",
  "df":"title",
  "ps":"3",
  "bf":"recip(rord(timestamp),1,1500,500)^90",
  "fl":"score,meta_file_modification_date*,score,og_image,id,uri,description,title,meta_icon,content_type,creation_date,timestamp,meta_robots,content_type,meta_domain,meta_*,text",
  "start":"0",
  "fq":"+content_type:text*",
  "rows":"100",
  "vectorQuery":"{!knn f=embeddings topK=100}[-0.024160323664546,...,0.031963128596544]",
  "q":"{!bool must=$lexicalQuery must=$vectorQuery}",
  "qf":"title^10 description^5 uri^3 text^2 phonetic_title^0.1",
  "pf":"title^15 description^7 uri^9",
  "lexicalQuery":"{!edismax qf=$qf bf=$bf ps=$ps pf=$pf pf2=$pf2 pf3=$pf3 mm=$mm}trump tariffs",
  "pf3":"text^5",
  "pf2":"tdescription^6"
}

Solr 9.6 reranking query. (It also works in Solr 9.0):

{
  "mm":"1<100% 2<70% 3<45% 5<30% 7<20% 10<10%",
  "df":"title",
  "ps":"3",
  "bf":"recip(rord(timestamp),1,1500,500)^90",
  "fl":"score,meta_file_modification_date*,score,og_image,id,uri,description,title,meta_icon,content_type,creation_date,timestamp,meta_robots,content_type,meta_domain,meta_*,text",
  "start":"0",
  "fq":"+content_type:text*",
  "rows":"100",
  "q":"{!knn f=embeddings topK=100}[-0.024160323664546,...,0.031963128596544]",
  "rqq":"{!edismax qf=$qf bf=$bf ps=$ps pf=$pf pf2=$pf2 pf3=$pf3 mm=$mm}trump tariffs",
  "qf":"title^10 description^5 uri^3 text^2 phonetic_title^0.1",
  "pf":"title^15 description^7 uri^9",
  "pf3":"text^5",
  "pf2":"tdescription^6",
  "rq":"{!rerank reRankQuery=$rqq reRankDocs=100 reRankWeight=3}"
}

A few remarks:

🎹 This is based on the classic Opensolr Web Crawler Index, that does most of it's work within the fields: title, description, text, uri.

📰 Index is populated with data crawled from various public news websites.

🔗 We embedded a concatenation of title, description and the first 50 sentences of text.

💼 We use the Opensolr Query Embed API, to embed our query at search-time.

🏃🏻‍♂️ You can see this search in action, here.

👩🏻‍💻 You can also see the Solr data and make your own queries on it. This index' Solr API, is here.

📦 For content the crawler can't reach, the Data Ingestion API lets you push documents via REST — each document automatically gets BGE-m3 embeddings, sentiment analysis, and language detection.

🔐 Credentials are: Username: 123 / Password: 123 -> Enjoy! 🥳


Cheat Sheet

🤥 Below is a cheat-sheet, of the fields and how you're supposed to use them if you run knn queries. Solr is very picky about what goes with knn and what doesn't. For example, for the Union query, we were unable to use highlighting. But, if you follow the specs below, you'll probably won't be getting any Query can not be null Solr errors... (or will you? 🤭)


What Belongs Inside {!edismax} in lexicalQuery? 🧾

Parameter Inside lexicalQuery Why
q ✅ YES Required for the subquery to function
qf, pf, bf, bq, mm, ps ✅ YES All edismax features must go inside
defType ❌ NO Already defined by {!edismax}
hl, spellcheck, facet, rows, start, sort ❌ NO These are top-level Solr request features

💡 Hybrid Query Cheat Sheet

Here’s how to do it right when you want all the bells and whistles (highlighting, spellcheck, deep edismax):

# TOP-LEVEL BOOLEAN QUERY COMPOSING EDISMAX AND KNN
q={!bool should=$lexicalQuery should=$vectorQuery}

# LEXICAL QUERY: ALL YOUR EDISMAX STUFF GOES HERE
&lexicalQuery={!edismax q=$qtext qf=$qf pf=$pf mm=$mm bf=$bf}

# VECTOR QUERY
&vectorQuery={!knn f=vectorField topK=10}[0.123, -0.456, ...]

# EDISMAX PARAMS
&qtext='flying machine'
&qf=title^6 description^3 text^2 uri^4
&pf=text^10
&mm=1<100% 2<75% 3<50% 6<30%
&bf=recip(ms(NOW,publish_date),3.16e-11,1,1)

# NON-QUERY STUFF
&hl=true
&hl.fl=text
&hl.q=$lexicalQuery
&spellcheck=true
&spellcheck.q=$qtext
&rows=20
&start=0
&sort=score desc

In Summary

Hybrid search gives you the sharp accuracy of keywords and the deep smarts of vectors—all in one system. With Solr, you can have classic reliability and modern magic. 🍦✨

"Why choose between classic and cutting-edge, when you can have both? Double-scoop your search!"


Opensolr: Hybrid Search Without the Complexity

Everything above — schema fields, embedding pipelines, boolean query composition, reranking — is what you wire up manually on your own Solr. On Opensolr, the hard parts are handled for you:

  • Web Crawler Indexes — Hybrid search works out of the box. The crawler automatically generates 1024-dim BGE-m3 embeddings for every page it crawls. No schema setup, no embedding code. Point it at a URL and you have a hybrid search engine. (Web Crawler)

  • One-Click Embeddings — Have an existing index? The Embedding API generates vectors for every document in your index with one call. No external model hosting, no batch scripts. (Index Embedding API)

  • Search Tuning — A visual slider controls the keyword vs semantic balance per index (0.0 = pure keyword BM25, 3.0 = heavily semantic). The system also adapts dynamically based on query length. No config files, instant effect. (Search Tuning)

  • Query Elevation — When the hybrid algorithm ranks something wrong for a specific query, pin the right document to the top or exclude the wrong one. Instant, no reindexing. (Query Elevation)

  • Click Analytics — See which hybrid results users actually click. High impressions with low CTR means the keyword/semantic balance needs adjusting — or the result needs pinning. (Click Analytics)

  • Data Ingestion API — Push documents from databases, APIs, or internal systems. Every document gets automatic BGE-m3 embeddings, sentiment analysis, and language detection — same enrichment pipeline as the crawler. (Data Ingestion API)

  • EDisMax + Vectors — The lexicalQuery examples in this guide use EDisMax for the keyword side. Same parameters (qf, pf, mm, ps), same behavior — Opensolr just removes the infrastructure work.

  • Error Audit — Hybrid queries can fail silently (wrong vector dimensions, missing fields, malformed KNN syntax). Error Audit captures every Solr error from the last 7 days, parsed and searchable — so you catch these before users do.

The hybrid search concepts in this guide apply directly on Opensolr — same Solr, same query syntax. The difference is you skip the embedding infrastructure, the schema plumbing, and the scoring guesswork.

Happy hybrid searching! 🥳

Read Full Answer

Loading more articles...