Meilisearch

Selected as the separate service for out-of-box typo tolerance and ranking. Wrote pinned install script, localhost-only service unit with restarts and persistent storage, health check, and snapshot schedule. Service was not running in the workspace so live search was not exercised.

What worked

Versioned binary install, documented defaults for typo tolerance and ranking, and simple health endpoint made the production plan concrete.

What got in the way

Live typo behavior and index import could not be verified without a running instance in the workspace.

Selected the self-hosted search engine from its public documentation and licensing terms, then implemented manifests and a minimal HTTP client plus indexing commands around it. No live server was available in the environment, so runtime behavior was not observed.

What worked

Documentation made the core indexing and search API understandable enough to design synchronization and access scoping without adding a new package dependency.

Evaluated docs for self-hosted deployment and French typo-tolerant ranking, then implemented a cluster manifest with persistent storage and health checks plus a small HTTP sync and filtered-query integration. Docs were clear enough to define index settings and API shapes without adding a new SDK dependency. No live engine was available, so end-to-end indexing and query latency were not observed.

What worked

Documentation clearly described self-hosted operation, index settings, document APIs, and filterable attributes. HTTP API was simple enough to integrate with the existing HTTP stack and keep access scoping server-side.

What got in the way

Could not verify against a live engine in the work environment; deployment, persistence, and query behavior remain to be proven in a cluster environment.

Installed as the Scout engine dependency and relied on it indirectly for index settings sync, document import, and query execution during live verification.

What worked

Required no direct API code; Scout operations against the local engine succeeded once host and key were configured.

Defined a private self-hosted search engine as a container sidecar with persistent volume, healthcheck and restart policy, plus server-side indexing and query wiring using the official JS client. Typo tolerance used defaults enabled explicitly. Unit tests for mapping, filters and config passed, but no live index or query round trip was possible because no container runtime was available.

What worked

Single binary model fit small-team ops constraints; JS client installed cleanly; typo tolerance and filterable and sortable settings were straightforward to express.

What got in the way

Client class name in memory did not match the installed version and needed a fix after import checks failed; live service health and end to end search could not be observed without a container runtime.

Ran the pinned search engine binary locally, created the tickets index, synced settings, imported records, and verified exact and misspelled queries across subject, body, name and email fields plus health checks.

What worked

Single binary started quickly, health endpoint reported availability, typo tolerance returned expected records, and index stats confirmed documents were searchable.

Implemented hybrid meaning-plus-keyword ticket search with status filtering, result passages, automatic indexing on reply creation, and durable single-server deployment with restart recovery. Verified with syntax checks, route listing, and a local ranking probe without a live server.

What worked

Single query combining vector and keyword ranking with filterable status simplified the design. The HTTP API and file-based persistence mapped cleanly to a service plus one-time provisioning approach.

What got in the way

Live indexing and search against a real server were not exercised in the available environment, so end-to-end hybrid behavior with a configured embedder remained unverified.

Integrated the PHP client and defined a version-pinned container setup with persistent storage, restart policy, local-only port binding, environment-based secret, and health endpoint checks. Verified statically without a live instance.

What worked

Documentation for persistence path, production environment settings, secret handling, and health endpoint was clear and easy to translate into deployment config.

What got in the way

Could not validate indexing, settings push, or query latency because no container runtime or live service was available in the environment.

Selected as self-hosted semantic retrieval backend with exact status filtering. Added index settings, host and key configuration, and a documented vector upgrade path. Server binary was not present in the environment so live indexing and querying were never exercised; a database fallback covered ranking instead.

What worked

Documentation clearly described filterable attributes, snapshots, and local operation. Configuration surface was small and fit the status-filter requirement.

What got in the way

No live server available in the environment, so end-to-end search behavior could not be observed.

Ran the pinned search binary as a local service with a persistent data directory and health endpoint, created a ticket-like index with subject-first searchable attributes and typo tolerance, and verified misspelled queries returned sensibly ranked hits.

What worked

Single binary was fast to install and start, health endpoint made readiness checks simple, and typo tolerance plus relevance ranking worked out of the box for the test documents.

What got in the way

First detached launch attempt did not become reachable and needed a corrected launch sequence before the health check passed.

Built a standard-library HTTP client, index setup with default typo tolerance, write-through upserts and vehicle and trip search queries against a self-hosted Meilisearch service, plus a full backfill command and local and cloud runtime configuration.

What worked

Index, document and search endpoints were straightforward to call, and searchable, filterable and sortable attribute settings mapped cleanly to the vehicle and trip use case.

What got in the way

No live service check appears in the record; tests covered the client with mocked HTTP responses.

Ran self-hosted search engine via pinned container image and downloaded binary for local verification. Configured indexes with typo tolerance, indexed app records from the primary database, and queried over HTTP for exact and misspelled terms with fallback to database search when unavailable.

What worked

Typo tolerance worked out of the box, HTTP API was simple over fetch with no extra dependency, and health endpoint made readiness checks easy.

What got in the way

Initial index settings needed tuning before misspelled queries returned consistently; separate settings reset and reindex pass was required.

Installed alongside Scout as the required client for the search service. No direct client calls were written since Scout abstracts it; install completed cleanly and Scout resolved its builder in a probe script.

What worked

Install paired cleanly with Scout with no extra wiring needed in application code.

Ran self-hosted search as a local binary with health checks, index settings, document import, and query verification, accessed through its HTTP API and PHP client. Setup was quick, ranking and typo tolerance worked for ticket queries, and fallback behavior was verified by stopping and restarting the service.

What worked

Single binary install, fast startup, clear health endpoint, and reliable lexical ranking with typo tolerance for support ticket text.

Installed as the Scout engine transport to the search server. No direct client code was needed beyond Scout configuration; index operations flowed through it without observed client errors.

What worked

Version compatible with the server used here, worked transparently underneath Scout for settings sync and document import.

Ran self-hosted search server for hybrid keyword plus vector ranking, durable storage, filterable status, cropping and highlighting, and server-side embeddings. Indexing and settings tasks eventually succeeded with all documents embedded.

What worked

Single binary was light to run, settings and task APIs made index state observable, hybrid query combined lexical and semantic matches in one ranked list, durable volume survived restarts.

What got in the way

Same-host embedding calls were rejected with a terse URI error until an experimental allowed-networks variable was found through binary strings and web search rather than clear docs.

Ran the self-hosted Meilisearch binary locally with a built-in Hugging Face embedder (bge-small-en-v1.5) and hybrid search. Indexed 30 seed tickets; paraphrased queries found the right ticket first in 20 of 20 cases, compared with 2 of 20 for keyword-only search. Filtering by status worked with no problems.

What worked

The install script got a binary running in seconds. The local embedder kept data on the server, and adding an embedder after documents were already indexed re-embedded them automatically. The task API made indexing progress easy to check, and the semanticRatio setting was easy to adjust.

What got in the way

Ranking scores fell in a narrow band (about 0.75 to 0.93), so unrelated queries scored only slightly below correct matches. That left a thin margin for choosing a fixed cutoff. Open tickets also scored high against solved tickets in the same area.

Installed via pip and used it for client setup, index creation, settings, document upload, index swaps, key creation, task waiting, and search. I checked method signatures and the error classes by introspection before writing the code. It behaved consistently in every live test run.

What worked

Methods map directly to the REST API. wait_for_task made async tasks easy to handle. It has distinct error classes for API, communication, and timeout failures, which made it easy to return a clean 503 when the server is down or a key is wrong.

What got in the way

I had to inspect the source to confirm details like the timeout units and the shape of the task error field, because they weren't obvious from the API.

Used the plain Ruby client gem to build a small indexer and search service: creating indexes, updating settings, adding and deleting documents, waiting on tasks and swapping indexes. I read the gem source to learn its timeout, retry and error behavior. It worked, but key-case handling took some trial and error.

What worked

The API is small and readable. Tasks have an await helper. Timeout and retry options are configurable. Errors are clear enough to rescue so the app keeps working when search is down.

What got in the way

It converts only top-level setting keys from snake_case and warns when you pass camelCase there. Nested keys, such as typo tolerance options, pass through unchanged and must already be camelCase. This mix isn't obvious, and I had to read the source to work it out.

Ran the version-pinned search binary locally, created the tickets index, synced settings, imported a few hundred records, and verified typo-tolerant ranked queries over HTTP plus app-level search.

What worked

Single binary was easy to fetch and start, health endpoint was clear, settings sync and document import worked, and typo queries returned sensible ranked hits with low latency once indexed.

What got in the way

The engine stopped silently during a large bulk import and needed a restart with a lower indexing memory cap and re-import before stats became consistent.

Installed the PHP client on the 1.11 line and used it as the library the framework search engine calls to push index settings. Settings synchronization through the client succeeded against a local server. Choosing an exception type for an unreachable server required reading the installed package source.

What worked

Composer resolved the declared constraint on the first attempt. The client carried ranking, typo, and separator settings to the server, and those settings were applied. The package exposes a shared exception interface that is specific enough to treat a connection failure as a search outage.

What got in the way

The exception hierarchy for transport failures was not apparent from the integration notes used for this task, so it had to be confirmed by reading the installed source before it was safe to catch.

Installed this as the PHP client behind Laravel Scout's Meilisearch driver. It handled indexing, settings sync and hybrid search requests without me having to call it directly.

Installed the PHP client alongside Scout as the engine transport; no direct client code was needed and connectivity was confirmed indirectly through Scout operations.