Download the PHP package wapplersystems/meilisearch without Composer

ws_meilisearch — Meilisearch — Search, Hybrid & RAG

TYPO3 v14 extension providing Meilisearch-backed full-text search via the SEAL abstraction. Designed so the search backend stays swappable (Meilisearch today, Typesense / Elasticsearch tomorrow) without rewriting templates or services.

Features at a glance

Indexing

• Single unified per-site index, faceted by document type.
• Built-in schema providers: pages (via lochmueller/index), news (tx_news), FAL files (Tika-extracted PDF / Office / RTF / EPUB / plain text), and knowledge resources (curated DITA-OT / ZIP / URL imports).
• Per-doc embeddings stored under _vectors.default for hybrid search. Either Meilisearch fetches them via its REST embedder (auto-batched) or the extension precomputes them in PHP and pushes them with the document.
• Content language detection (n-gram, ISO 639-1) on every indexed document — a German PDF appearing in an EN-overlay gets contentLanguage=de and is filtered out for EN visitors.
• Zero-downtime reindex (opt-in): writes to a <index>_draft index and atomically swaps it into the primary on completion, so visitors never see a blank search during a reindex.
• sys_file existence sweep CLI to flag dead FAL rows missing=1 before reindex — keeps the indexer from spending hours on AWS-SDK retries against tombstoned bucket objects.

Search

• Typo tolerance with per-attribute and per-word exclusion (disableOnAttributes, disableOnWords, disableOnNumbers) — keep brand / product tokens and version numbers exact.
• Hybrid keyword + semantic search when an embedder is configured.
• Phrase search ("two words") and negation (-token) work out of the box.
• Matching strategy per call: last (drop trailing), frequency (drop most-frequent tokens first), all (strict AND — default for FE search).
• Synonyms, stop-words (with per-call override for RAG queries), custom ranking rules, distinct attribute, searchCutoffMs.
• Faceted navigation with disjunctive faceting for active facet attributes.
• Restrict to active site language + contentLanguage filter both applied on the search controller when opted in.

Frontend surfaces

• tx_wsmeilisearch_search Extbase plugin — Bootstrap-styled GET form with click-to-filter facets, AJAX result-fragment refresh, configurable per-plugin via FlexForm.
• tx_wsmeilisearch_rag Extbase plugin — RAG chat with cited sources, streaming token-by-token answer, conversation memory bounded per session.
• Live suggest dropdown — /_ws_meilisearch/suggest?q=… JSON endpoint
  • suggest.js widget, auto-attached to any FE input via a configurable CSS selector when the layout doesn't render the search-plugin template.
• Similar documents — /_ws_meilisearch/similar?id=… endpoint + Fluid ViewHelper <ws:similarDocuments sourceId="…" as="…"> for "Related content" widgets.
• Optional floating chat-widget bubble — bottom-right, opens the RAG plugin in a slide-up panel; target page configured via pageUid so it follows the active language overlay.

Retrieval-Augmented Generation (RAG)

• Cited-source chat answers grounded in Meilisearch hits.
• Provider-agnostic LLM layer: OpenAI, Anthropic, Mistral / Scaleway, Ollama, Infomaniak, and generic OpenAI-compatible REST endpoints. Switch via meilisearch.rag.provider.
• Configurable retrieval ladder: per-RAG matchingStrategy, stripStopWords with per-RAG word list, semanticRatio, three-stage fallback (frequency → last → drop-leading-token) so verb-led questions ("Wie gebe ich …?") never collapse to no_context.
• Conversation memory per browser session, bounded so the prompt stays within token budget.
• Streaming responses via Messenger / SSE — the visitor sees the answer being typed, not a 30 s spinner.

Quality assurance

• RAG regression tests — editor-maintained (question, expected) pairs in tx_wsmeilisearch_ragtest, scored via embedding cosine similarity. Per-test threshold, rolling 100-run history, sparklines in the BE tab.
• "Adopt actual as expected" button — index drift across reindexes produces minor wording changes that the cosine scorer punishes; operators promote a manually-OK'd actual as the new baseline instead of lowering the threshold globally.
• Stuck-task watchdog — cancels Meilisearch tasks parked in processing past a configurable threshold and emails the operator.
• Quota checks for commercial AI providers (Anthropic, OpenAI, Infomaniak) — email warning above the configured monthly threshold.

Operations

• Backend module under System → Meilisearch with tabs: Overview · Test search & RAG · Diagnostics · Knowledge resources · RAG tests · Analytics.
• Analytics tab: top queries, zero-result queries, source breakdown (search / suggest / similar), hybrid-vs-keyword rate, with 1/7/30/90-day windows. Opt-in per site; stores only aggregable signals — no IPs, no session ids, no user agents.
• Throttled reindex via meilisearch.indexing.requestsPerMinute (token bucket) when the embedding provider rate-limits per minute.
• CLI commands: reindex, apply-settings, setup-index-config, doctor, ask, document, tika-probe, abort-stuck-tasks, check-quotas, import-knowledge-resources, run-rag-tests, sys-file-sweep.

System requirements

Installation

The extension lives as a local package in packages/wapplersystems/meilisearch/, already picked up by the root composer.json. To install:

This pulls in:

• cmsig/seal — engine + schema abstraction
• cmsig/seal-meilisearch-adapter — Meilisearch backend
• meilisearch/meilisearch-php — official PHP SDK

DDEV setup

Two services drop into .ddev/:

• docker-compose.meilisearch.yaml — Meilisearch server on port 7700 (also reachable via Traefik at https://<project>.ddev.site:7701 for the built-in dashboard).
• docker-compose.tika.yaml — Apache Tika server on port 9998, used for text extraction from PDF / Office files (Phase 2). Optional — leave the meilisearch.tika.url site setting empty to disable FAL indexing.

After ddev restart:

Configuration

Enable the Site Set on the desired site in config/sites/<id>/config.yaml:

Then set the connection in config/sites/<id>/settings.yaml:

deduplicateFiles defaults to false (every site indexes every FAL file). Set to true for strict per-site results — the indexer then follows sys_file_reference → page → site and only includes files referenced from at least one page of the current site. Files referenced only from non-page records (e.g. be_users.avatar) are skipped entirely.

Index filtering

Three optional settings under meilisearch.indexing keep junk files (icons, configs, backups) out of the corpus. They run at the iterator level in FileSchemaProvider, so filtered files never become docs — no wasted Tika roundtrips, faster reindex.

The three filters compose: a file must pass the extension gate (whitelist if set, otherwise blacklist) AND the image-size gate before being eligible for indexing. Comparison is case-insensitive and leading dots are stripped (.YAML matches yaml).

Definitions live in Configuration/Sets/WsMeilisearch/settings.definitions.yaml so settings are typed and editable through the Backend Sites module.

Hybrid search (Phase 3)

To enable vector + keyword hybrid search, set meilisearch.embedder.* in the site settings and enable the vectorStore experimental feature on the Meilisearch server (one-time, server-wide):

Then pick a source:

ws_meilisearch:reindex --rebuild pushes the embedder configuration to Meilisearch before populating documents, so the first hybrid query after rebuild sees a fully vectorized corpus. Note that --rebuild drops the index and therefore throws away every existing vector — everything is re-embedded from scratch. Without it, the reindex writes in place and only pays for documents that actually changed (see Incremental re-indexing).

Incremental re-indexing (what a reindex actually costs)

Every document carries two fingerprints, written by DocumentBatchWriter:

Before writing a batch, the indexer reads those two fields back for the documents it is about to push (a cheap request — ids and two short strings, no vectors) and then decides per document:

• docHash unchanged → not written at all (in-place mode)
• embedHash unchanged → the existing vector is copied over and the new keyword fields are written; the embedding provider is not called
• otherwise → embed, then write

Vectors are only transferred for the middle case, in a second request — a 3584-dimension vector is ~70 KB of JSON, so fetching them unconditionally would trade a token bill for a bandwidth bill.

This is what makes re-indexing a large corpus affordable. Without it, every full reindex re-embeds every document: on a 45.000-document index against a rate-limited provider that means the run stalls in a silent 429 retry loop and never finishes.

The CLI reports the breakdown, so a run that is about to become expensive is visible immediately:

Bootstrap. Documents indexed before fingerprinting existed carry neither hash. A document that has a vector of the expected dimension is adopted: its vector is treated as current and re-used, so the first run after upgrading costs zero embeddings. Pass --force-embed to re-embed regardless — needed after an embedder model change, and the one flag that can exhaust a provider quota on purpose.

Zero-downtime mode (meilisearch.indexing.zeroDowntime) cannot skip: every document has to land in the draft index or the swap would publish an index with holes. Fingerprints and vectors are then read from the primary and copied into the draft — still no embedding cost, but the vectors do go over the wire.

Rate control and failure handling

With meilisearch.embedder.precompute: true the embeddings are fetched by PHP, so this integration owns the call rate:

tokensPerMinute is the setting that matters on providers that meter tokens rather than requests (Scaleway answers INSUFFICIENT QUOTA … quota tokens per minute. Slow down). A requests-per-minute cap does nothing against it: a handful of full page texts can exhaust a minute's token budget in a single call.

You usually do not have to configure it. Every response carries the provider's own accounting, and it is trusted over the local estimate:

The reported limit becomes the default budget, and a request that no longer fits into remaining waits out reset before it is sent. The local chars/4 estimate only has to carry the very first call; from then on the numbers are the provider's. If the provider answers 429 anyway, the retry path honours Retry-After, clears the window and backs off.

For scale: at 200.000 tokens/minute, re-embedding a 45.000-document corpus of ~2000 tokens each takes over seven hours of uninterrupted provider time. That is the bill the fingerprinting above avoids.

maxInputChars bounds a single document's contribution. It is part of embedHash, so changing it invalidates the cached vectors and the affected documents are re-embedded on the next run.

Failures are loud. With a userProvided embedder Meilisearch rejects any document that arrives without _vectors.default, and it does so asynchronously in its own task queue — a vectorless push looks successful from PHP while the document never lands. Documents whose embedding failed are therefore not pushed at all:

• ws_meilisearch:reindex counts them, prints a warning and exits non-zero,
• the EXT:index crawl bridge lets the error escape so the Messenger message fails and is retried later, instead of being acked with the page silently missing,
• three consecutive failed embedding batches abort the run rather than marking the whole corpus as failed one batch at a time.

Frontend: ?hybrid=1 on the results URL flips to hybrid mode; the hybridAvailable flag is exposed to Fluid so the toggle stays hidden on sites without an embedder. semanticRatio (0..1) is read from site settings and can be overridden per request via the options parameter of SearchService::search().

Relevance boosting

Two independent knobs let you push some documents above others at equal text relevance. They compose multiplicatively into a single boost float stored on every document, which Meilisearch sorts on via the boost:desc custom ranking rule.

Per-type (integrator), Site Settings — meilisearch.boosts.types.<type>, one float per document type (1.0 = neutral):

Per-record (editor), backend field — tx_wsmeilisearch_boost, a 5-step select on pages, tx_news_domain_model_news and tx_wsmeilisearch_knowledge_resource (tab "Search"). Editors pick a relative weight; the indexer multiplies it onto the type default:

Example: a High news article (1.5) of a type weighted 1.2 ends up at boost = 1.8. Honoring the editor field can be switched off with meilisearch.boosts.recordOverrideEnabled: false (type defaults still apply). Tables without the field (e.g. sys_file, whatsnew) use the type default only.

Activation: the boost field is always written, but only influences ranking once boost:desc is present in meilisearch.defaults.rankingRules — place it before attribute so it breaks ties before the match-position rule:

boost:desc is a tie-breaker: it reorders documents that are otherwise equal on words/typo/proximity. A file with a genuinely stronger text match still outranks a higher-boosted page — boost cannot rescue a weaker hit, only order equally-relevant ones. Changing per-type values or the ranking rule needs ws_meilisearch:apply-settings; changing a record's field re-indexes that record automatically on save (back-fill a whole type with ws_meilisearch:index-record <table>). The editor field is labelled and described inline in the backend (EN + DE).

Retrieval-Augmented Generation (Phase 4)

Pick an LLM provider in site settings and the WsMeilisearch / Rag Extbase plugin becomes a "ask the site" chat. Search runs first (hybrid by default if an embedder is configured); the top hits become context for the LLM, which returns a grounded answer with [id=...] citation markers.

Citations: the default system prompt instructs the LLM to mark facts with [id=<hit-id>] and the controller extracts them via regex, returning a citedIds list alongside the rendered answer so the template can show a "Sources" block.

Caching / replay: listen to BeforeLlmCallEvent and set $response to a cached value to skip the LLM call entirely. Useful for tests and for FAQ-style questions that don't need a fresh generation per visit.

CLI for debugging without rendering the FE plugin:

Multi-turn conversation memory (opt-in):

When enabled, the controller stores the last N (question, answer) pairs in the anonymous TYPO3 frontend user session (cookie-backed by TYPO3 itself). RagService splices them between the system prompt and the new user turn, so the LLM sees: [system, prior_user, prior_assistant, …, current_user_with_context]. A new ?action=reset URL on the RAG plugin clears the stored state so a visitor can start over. Sources from past turns are not re-displayed; the controller only keeps citedIds for the template to show as "this answer cited X".

Backend module (Phase 5)

After installing the extension, an admin-only entry System → Meilisearch shows up. The overview action lists every site with:

• index name + live document count (queried from Meilisearch on render)
• embedder source from settings + an active / not pushed badge based on what Meilisearch actually has applied
• RAG provider from settings (or disabled when empty)
• per-row Reindex / Rebuild buttons (Rebuild prompts for confirmation because it drops the index — search is unavailable for the rebuild window)

The Test search & RAG sub-page lets an editor type a query and an LLM question against any site without leaving the BE — useful for verifying that a freshly tuned documentTemplate or systemPrompt behaves as expected before pushing settings to production.

The Diagnostics sub-page shows, per site, the desired embedder configuration (from settings.yaml) next to the actual one stored on the Meilisearch server, plus the configured RAG provider with its model / URL / conversation-memory flags. Two maintenance buttons:

• Re-push embedder — runs EmbedderConfigurator::ensureForSite() for the chosen site. Flashes one of configured, unchanged, disabled, skipped so admins can tell whether the call actually changed anything.
• Ping provider — sends a one-shot ping → pong round-trip to the configured LLM provider (bypassing retrieval, so it's a pure endpoint health check). Flashes the latency and a truncated reply, or the error message if the provider is unreachable / misconfigured.

Help-doc importers

Beyond the auto-indexed core record types (pages, news, FAL files), the extension ships a generic help-doc record type (tx_wsmeilisearch_helpdoc, type=help in the unified index) and five pluggable importers that populate it from very different sources. The intent: a single search + RAG corpus that can absorb a vendor's DITA documentation, an editor's PDF upload, a fileadmin sync, a zip drop, and an external URL list — without each source needing its own schema or controller.

All importers extend a single contract (HelpDocSourceImporter) and are picked up via DI auto-tagging. Adding a sixth source means implementing the interface — no controller / CLI / template changes.

Built-in importers

Common behaviour:

• Apache Tika extracts body text from every supported file format (PDF, DOCX, HTML, RTF, EPUB, Markdown, plain text, Office, …). Anything outside Tika's mime allowlist still gets indexed by title (HTML pages additionally get a strip_tags fallback so they're searchable by content).
• FAL is the file store. Every imported file becomes a sys_file and is attached to the helpdoc row's media field via sys_file_reference. Search results can deep-link to the original file; source_path carries the canonical URL or path.
• Per-importer subfolders keep uploads separate from zip extracts and URL fetches inside the operator-chosen target — uploads/, zips/, urls/ are auto-created beside each other under the target. The folders are created segment-by-segment so a first-time editor can pick 1:/whatever-i-want/ without prepping fileadmin.
• Identifier scheme: <sanitised-filename>-f<falUid> — stable across renames, unique even when two files share a basename, and predictable enough for downstream cross-references.

Configuration

Two site settings drive the help-doc pipeline:

tx_wsmeilisearch_helpdoc is shipped by ext_tables.sql and registered in indexedTables by default — running ws_meilisearch:reindex after the first import pushes the rows into the unified per-site index.

Backend workflow

The Help docs tab on the System → Meilisearch module gives operators one form per importer slug:

• Run import (dita-ot) — source path + language directory + optional purge before importing.
• Upload single document (single-file) — file + title + abstract
  • language + document kind + target folder.
• Batch-import from FAL folder (folder) — source folder picker + recursive opt-in + language + document kind.
• Upload ZIP bundle (zip-bundle) — file + language + document kind + "preserve subfolders" toggle + target folder.
• Import from URL list (url-list) — textarea (one URL per line, # comments + blanks skipped) + language + document kind + timeout + max size + target folder.

The Purge by language card next to these forms hard-deletes every helpdoc row in the chosen language with a confirm-checkbox guard. Reindex is not triggered automatically — every form trailer reminds the operator to run ws_meilisearch:reindex (or use the Overview tab) afterwards.

The Browse buttons on every folder field open TYPO3's standard FAL folder picker as a modal. The modern URL parameters (?fieldReference=…&useEvents=1) are used instead of the legacy bparams pipe-string, so the picker dispatches a CustomEvent on its iframe and avoids the postMessage origin gauntlet inherent to nested backend modals.

CLI workflow

The dispatch CLI is ws_meilisearch:import-help-docs. The --importer=<slug> switch picks the implementation; every other parameter is interpreted via the importer's describeFields() schema.

The CLI prints a progress bar per item, lists every per-item failure verbatim (Tika skip, HTTP error, FAL consistency rejection, …), and returns the imported / skipped / mediaCopied triple in the final success line. Generic -f name=value pairs always override the shorthand options.

Safety notes per importer

• url-list does NOT enforce a domain allowlist. BE-only access is the trust boundary; do not expose the form to anonymous users. Only http/https schemes are accepted; size cap (default 50 MB) and per-URL timeout (default 30 s) prevent slow servers / oversized responses from wedging the batch.
• zip-bundle rejects entries containing .., leading /, or null bytes (zip-slip), caps at 1000 entries (zip-bomb guard), and silently skips dotfiles (.DS_Store, __MACOSX/, …).
• MIME / extension mismatch. TYPO3 v14's ResourceConsistencyService rejects files whose actual content (per finfo) disagrees with the URL-derived extension. The url-list importer runs finfo on the response body and picks the matching extension so DITA-OT XHTML pages (which declare <?xml version="1.0"?> and get classified as text/xml) land as .xml instead of .html.

Adding a custom importer

Implement HelpDocSourceImporter in your extension's Classes/Service/Import/Importer/:

The _instanceof rule in Configuration/Services.yaml auto-tags it as ws_meilisearch.source_importer, so it appears in both --list-importers and the BE Help-docs tab without further wiring. Use the injected HelpDocRepository for FAL + Tika + persistence — the helpers handle target-folder auto-creation, sanitisation, and the standard media reference attachment.

RAG quality regression

Editor-maintained (question, expected answer, threshold) triples live in tx_wsmeilisearch_ragtest. The runner asks the configured RAG provider each question, embeds expected + actual via the site's embedder, and scores cosine similarity against the per-row similarity_threshold — pass / fail / error. Idempotent and safe to run on cron; the same engine is reachable from three places so ad-hoc triage and unattended runs never drift.

Three trigger paths, one engine

Threshold-tuning is per-test

Cosine similarity scores depend heavily on the embedder and on text length. 0.85 is a sane default for nomic-embed-text on full-paragraph expected answers; short German texts often score 0.80+ even on semantically-unrelated content because of shared vocabulary. The operator picks the threshold per row based on how strict the match needs to be:

• 0.70 → permissive, catches paraphrases but also tolerates "no information" replies
• 0.85 → strict semantic match
• 0.95 → near-verbatim agreement

Embedding clients

HelpDocSourceImporter-style plugin pattern. The right client is picked by matching meilisearch.embedder.source against each registered client's supports() vote:

Add another provider by implementing EmbeddingClientInterface; the _instanceof rule in Services.yaml auto-tags it and the registry picks it up.

Per-run history + sparklines

Every run also writes a row to tx_wsmeilisearch_ragtest_run (test uid, status, score, actual answer, crdate). A rolling per-test prune keeps the table at RagTestRunner::HISTORY_KEEP=100 rows so growth is bounded without operator cron. The BE tab pre-renders an inline SVG sparkline of the last 30 scores per test — Y axis is fixed 0..1 so two sparklines compare visually across tests, and the <title> carries count / min / max / last for hover detail.

Exit-code taxonomy (CLI + scheduler)

Same distinction maps to the scheduler task return value: false only when a FAIL happened; ERROR-only runs stay true so the scheduler doesn't latch on transient infrastructure noise.

Quota checks for commercial providers

ws_meilisearch:check-quotas walks every site, fans out to a QuotaProvider per configured commercial backend (Infomaniak / OpenAI / Anthropic), and emails a warning when usage crosses meilisearch.quota.threshold (default 80%). Idempotent — only emails when over threshold. Exit 1 when any provider is over, so cron monitors latch.

Configuration

Infomaniak limitation: Verified 2026-06-07 against Infomaniak's production API with a Manager-scope token: there is currently NO usage endpoint for AI Tools. /1/ai returns product reachability

• status but no token counts; product-scoped paths (/1/ai/<id>/usage, /quota, /spending, …) all return 404. The Infomaniak provider does what it can — confirm reachability + point the operator at manager.infomaniak.com/v3/ai/products/<id>/usage for manual gauge reading. Until Infomaniak exposes an API the "current state" badge stays ERROR with that explanatory message rather than faking a green light.

Adding a custom provider

Implement QuotaProviderInterface, return QuotaStatus::ok(...) / ::error(...). The _instanceof tag auto-registers it; the runner dispatches by matching the site's configured provider slug.

Scheduler task (Phase 5)

FullReindexTask registers under Administration → Scheduler as Meilisearch: Full Reindex. TYPO3 v14 native task — fields are TCA-driven on tx_scheduler_task, no AdditionalFieldProviderInterface:

• Site identifier — empty for all sites, or one TYPO3 site identifier (matches the directory under config/sites/).
• Rebuild — drop + recreate the Meilisearch index before populating. Only enable after schema changes; the index is unavailable for the duration.
• Skip embedder push — leave the embedder settings on Meilisearch untouched. Use for troubleshooting a wedged hybrid setup while still keeping the document corpus fresh.

Typical cadences:

• Nightly incremental: site=main, rebuild=off, skip-embedder=off
• After deploy with new SchemaProvider fields: one-shot run with rebuild=on, skip-embedder=off (recreates schema + re-vectorizes)
• After embedder rotation: rebuild=off, skip-embedder=off (forces a re-push of embedder settings)

CLI

Keeping the crawl queue consumed (production)

Page indexing is asynchronous: index:queue only enqueues work, and the bridge writes to Meilisearch when a worker consumes the message. Without a permanent consumer the queue silently grows and the page corpus goes stale without a single error anywhere — no failed task, no log entry, just an index that stops changing. On the LINEAR production host that went unnoticed for ten days and 8.675 messages.

Do not schedule this with cron. Use a systemd template so a dead worker is replaced in seconds rather than at the next tick, and so systemctl status and journald give you a handle on it:

Three points that are easy to get wrong:

• --memory-limit must stay below PHP's own memory_limit, otherwise the worker is killed by PHP instead of exiting cleanly, and the message it was working on is left unacked.
• --time-limit recycles the process against memory creep; Restart=always is what brings it back, so the two belong together.
• Run several instances — the Doctrine transport uses SELECT … FOR UPDATE SKIP LOCKED, so workers never take the same message. Match the count to the box (three is sensible on four cores); page rendering, not Meilisearch, is the bottleneck.

What's wired

Examples

End-to-end snippets in Examples/ — pick the closest match to your setup and adapt:

Frontend plugin invariants

• All forms are method="get" — the result page must be fully reproducible from the URL so the browser back button never asks "Resubmit form?".
• resultsAction PRG-redirects any POST to GET as a defensive measure for third-party callers that might violate the GET convention.
• ^tx_wsmeilisearch_search is excluded from cHash because GET form submission discards the action URL's query string. action / controller values are still validated by Extbase against the registered actions list, so a forged URL cannot invoke arbitrary controllers.
• Facet checkboxes auto-submit on change (this.form.requestSubmit()), so users don't need a separate "Apply filters" button.

Per-instance overrides via FlexForm

The Search plugin ships a FlexForm so the same wsmeilisearch_search CType can be configured differently per content element. Every field is optional — empty inherits from the Site Settings default.

Useful when a per-language search page wants the language filter forced on while the global search page wants cross-language results — same install, same site settings, different plugin instances.

Adding a new record type

Implement SchemaProviderInterface. Auto-wired and auto-tagged via _instanceof in Configuration/Services.yaml, no manual registration.

Optional getAdditionalFields() lets a provider contribute extra SEAL schema fields (e.g. price as IntegerField sortable + filterable). The factory dedupes by field name across providers.

Roadmap

Done:

• Basic indexing + Fluid plugin with typo tolerance & facets
• FAL / Tika indexing (PDF / Office / RTF / EPUB / plain text)
• Hybrid search + auto-embeddings (OpenAI / HuggingFace / Ollama / REST / userProvided / Scaleway / Infomaniak presets)
• PHP-precomputed embeddings (meilisearch.embedder.precompute) with token-bucket throttle against rate-limited providers
• RAG module with configurable LLM provider (OpenAI / Anthropic / Mistral / Scaleway / Ollama / Infomaniak / REST)
• Backend module (Overview, Diagnostics, Test, Knowledge resources, RAG tests, Analytics) + scheduler tasks
• Knowledge-resource importers (DITA-OT / single-file / FAL folder / ZIP bundle / URL list) with shared plugin contract
• RAG regression tests with cosine-similarity scoring, BE tab + sparklines, adopt-actual-as-expected baseline promotion
• Commercial-provider quota checks with email warnings
• Content-language detection (n-gram, ISO 639-1) + content-language filter
• Live suggestions endpoint + JS dropdown with optional auto-attach
• Similar documents endpoint, middleware, Fluid ViewHelper
• Zero-downtime reindex via atomic index swap
• Search analytics (top / zero-result / source breakdown / hybrid rate)
• Stuck-task watchdog

Open / under consideration:

• Search-analytics retention cleanup task (currently rows accumulate indefinitely; manual DELETE works)
• Click-tracking + CTR per query (analytics rows currently cover query-side only)
• Layout-level search-form auto-attach with shipped CSS (selector setting is in place, no default selector yet)
• Locales (per-field language tokenizer hint) — Meilisearch 1.13+
• Index swap probe job to verify swap pipeline end-to-end before first production use

Limitations

Hybrid / embedder

• Meilisearch's vectorStore experimental feature must be enabled (one PATCH on /experimental-features). Sending embedders settings to a server with the feature off returns a 400 and aborts the reindex.
• userProvided embedder requires every document to ship its own vector in _vectors.default. The precompute mode handles this automatically; if you turn precompute off and select userProvided directly, the schema providers won't fill the vector field.
• API-key rotation isn't auto-detected — Meilisearch redacts the key on read-back, so the configurator can't diff "new" vs "redacted" to decide whether to PATCH. Touch any other embedder setting (or run --rebuild) to force a re-push after key rotation.
• Hybrid result hits skip the SEAL adapter — frontend code that inspects fields beyond the unified schema may see slightly different shapes between keyword and hybrid results.

RAG

• Streaming requires unbuffered hosting. The /_ws_meilisearch/rag/stream SSE endpoint works in DDEV out of the box, but production behind Nginx needs proxy_buffering off / fastcgi_buffering off on that path.
• Conversation memory is opt-in via meilisearch.rag.conversation.enabled = true. Default is stateless.
• Citation extraction is regex-based — models that wrap markers in prose ("see [id=foo and id=bar]") only get the first id captured. Tune the system prompt per model.
• No token budgeting on maxContextHits × maxContextChars; a very long question + many large hits can blow past small-model context windows.
• No cost / rate-limit guard on the FE — pair with a BeforeLlmCallEvent listener (response cache, per-session rate limit) for production deployments.

Indexing

• DataHandler hooks during a zero-downtime reindex write to the live primary; the swap then overwrites those updates. Editorial changes made during a multi-hour reindex may need a follow-up record-level reindex.