A search engine can answer in few milliseconds and cannot find the product the client wanted. It can also give back reasonable coincidence with far too many irrelevant results. Latency and quality of recovery are different dimensions. Decide between MeilisResearch and Tipesense looking at only a performance graph - or a demo with three product names - leave out the questions that determine if the system will be useful as they grow: ranking, language, filters, freshness, permissions, ingestion and bug recovery.
That article doesn’t choose a universal winner. It propose an evaluation framework and architecture so that the search will be a reconstructed projection about business data, not another true source held at hand. The revised version status is MeilisResearch v1.56.2 and Tipesense v30.2 in the original dossier. On November 16, 2026 MeilisResearch also published v1.57.0. That later change was recorded here as a version alert and was not attributed to v1.57.0 capabilities and results of an unperformed test.
What problem does an index have to solve?
In a traditional search as LIKE '%camisa%', the database may have to inspect a lot of text. A search engine builds structures that connect standard terms with candidates: term → posts / documents. On this set applying rules of coincidence and order: exact words, prefixes, tolerance to errors, close terms, ranking attributes, filters and facets.
The mechanism doesn’t amount to “fuzzy score.” Before ranking there are tokenization, normalisation and decisions about what counts as word. USB-C, café, a A-102 code and a name itself can conduct differently. Also, lexic recovery isn’t the only option: both engines cover vector and hybrid search capabilities with additional commitments of embeddings, model and costs.
Nor does that mean that SQL will be unable to seek text. PostgreSQL Full Text Search uses tsvector, tsquery and indexes as GIN and SQLite FTS5 offers MATCH, prefixes, phrases and ranking. If these capabilities fulfill the required experience, adding another server can be an unnecessary complication. The change of architecture is warranted by measured recovery requirements, facets, type tolerance or UX, but with an alleged absolute inferiority of SQL.
Comparison begins with an important contract
Consider a fictitious catalogue of articles in Spanish and English. A search for cafe should propose if we also want to find café. usb c may require USB-C but an aggressive tolerance with model numbers can be bad. To validate these decisions we need a set of consultations and human judgements about what outcome is relevant, and not just to check that there’s a JSON response.
A small conceptual catalogue could contain records such as these, are fictitious data, no orders or actual products:
[
{"id":"p-001","tenant_id":"t-1","name":"Café molido 250 g","brand":"Aroma","category":"bebidas","price":8900},
{"id":"p-002","tenant_id":"t-1","name":"Cable USB-C 1 m","brand":"Link","category":"electrónica","price":4200},
{"id":"p-003","tenant_id":"t-1","name":"Camisa de lino","brand":"Norte","category":"ropa","price":23000},
{"id":"p-004","tenant_id":"t-2","name":"Camión de juguete","brand":"Rueda","category":"juguetes","price":15000}
]
The document from another tenant appears to prove isolation, and not to allow global searches. A real API should not deliver other logs by relying on a server-configurable filter.
Prepare at least these reference classes before comparing engines: exact matching, prefix, one or two character error, accents (cafe/café, camion/camión), plural / singular, dregs and code, own names, synonyms, filters and facets combined, recent change of price, deleted, zero results and concurrent loads. The result of each suit is assessed against a reasoned list of relevant documents.
MeilisResearch: ranking by rules and indexation tasks
Meilisearch exposes a configurable document index. Your ranking rules order candidates by subsequent criteria, tolerance to errors and matching per prefix participate in that process as required by the consultation and configuration. The behavior is not summarized by a single editing distance or a score that is universally comparable with other engines.
The amendments to the index are processed by means of asynchronous tasks. A successful HTTP by accepting document does not prove that they are currently available under search; the system that synchronizes should track the task status, detect faults and measure the delay between source change and result visibility.
The following example is an an illustrative search request and presupposes that the products index was created, set and ingested earlier. No credentials and no enforcement:
POST /indexes/products/search HTTP/1.1
Host: search.example.invalid
Content-Type: application/json
{
"q": "cafe molido",
"limit": 10,
"filter": "tenant_id = \"t-1\""
}
The attributes for which they are filtered should have been declared as leaked and the example does not itself constitute a secure multitenant isolation: backend should get the tenant of the authenticated identity and keep the privileged key out of the web interface. See opciones de filtros and gestión de claves.
Current documentation includes search light, semantics and hybrids. Enabling embeddings introduces new variables: what model is used, how the document is transformed, what language it operates, how much and how much it costs. A fair comparison first runs a lexical Benchmark with both settings and then a separate experiment for hybrid recovery. Licensing issues and conditions have to be revised by feature: MeilisResearch’s repository declares licenses MIT and BUSL-1.1, and a universal MIT license for each component.
Tipesense: collection scheme, filters and configurable ranking
Typesense builds collections with tipate fields and sets up the search using parameters such as query_by, filter_by, sort_by and type tolerance options. That makes an important part of the contract explicit: what fields are involved in recovery and how.
{
"name": "products",
"fields": [
{"name": "name", "type": "string"},
{"name": "brand", "type": "string"},
{"name": "category", "type": "string", "facet": true},
{"name": "price", "type": "int32", "sort": true},
{"name": "tenant_id", "type": "string", "facet": true}
]
}
That JSON illustrates a collection definition consistent with the model of the API de colecciones de Typesense. For example, documents should have a id chain field and whole price values matching with int32. Before deploying, valid definition with exact server version.
A typical query is expressed using URL parameters:
GET /collections/products/documents/search?q=cafe&query_by=name,brand&filter_by=tenant_id:=t-1&per_page=10
The syntax corresponds to an illustrative example, and not to an run search. The API key should be managed by backend and a scoped search key, when used for customers, should put consumer-friendly safety restrictions. Do not delegate permission to have the front remember to add ZXQHOLDER1 ZXQ. References: Search and API Keys.
Tipesense also document vector and hybrid search and Rankings combination options depend on mode and version. It doesn’t make sense to interpret a alpha value of a hybrid search as if it were equivalent to MeilisResearch’s * ranking rules * lexicales. The Tipesense server is GPL-3.0 and its official customers have different conditions as a repository and product and the commercial contract / license is reviewed by component.
What’s really comparable
| Dimension | MeilisResearch | Tipesense | What to measure |
|---|---|---|---|
| Lexical configuration | Successive ranking rules and configurable attributes | Search, relevance and order fields with API parameters | Precision @ k, NDCG @ k, reformulations |
| Type tolerance | own rules and standards | Search parameters and own rules | 1-2 letter errors, false positive |
| Retirement / autocomplete | Supported with his own rules | Supported with its own parameters | Relevant result at each press |
| Facets / filters | Intent Retractable Attribution Setup | Facettable fields and tipid filters | Extent, latency and cardinality |
| Semantics / hybrids search | Documented skills and review editing / configuration | Documented vector / hybrid skills | Reall, model, resources and separate latency |
| Ingestion | Asynchronous tasks to be monitored | Import / indexation API with your response semantics | Time to visibility, mistakes, reconstruction |
| Operation | Backups / snapshots, indexes, version, keys | Persistence, HA by display, keys, collection | RTO / RPO, actual cost and recovery |
| Licences | MIT + BUSL-1.1 with components | GPL-3.0 for server and separate customers | Retirement and editing restrictions |
The table does not assign ratings and results. A useful difference for a computer can be irrelevant to another if the true bottle neck is in sync or interface.
The search index should not be the true source
A robust model for products and permits is:
PostgreSQL (canonical data) → outbox / CDC / project job → search index → own API → interface.
The backend maintains a synchronization contract: all important changes, including deleted and tenant or permit changes, have to reach the index. An initial intake requires a cutting point and mechanism to apply later changes without losing operations. If the index fails, it should be capable of reconstruction from the source.
A * transactional outbox * pattern at PostgreSQL means that the business change and the projection message are registered in the same transaction:
-- Esquema ilustrativo; el consumidor y la recuperación no están incluidos.
CREATE TABLE search_outbox (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
entity_id text NOT NULL,
operation text NOT NULL CHECK (operation IN ('upsert', 'delete')),
payload jsonb,
created_at timestamptz NOT NULL DEFAULT now(),
processed_at timestamptz
);
BEGIN;
-- Cambio de negocio de ejemplo (suponiendo tabla products preexistente).
UPDATE products SET name = 'Café molido 250 g' WHERE id = 'p-001';
INSERT INTO search_outbox (entity_id, operation, payload)
VALUES ('p-001', 'upsert', '{"id":"p-001"}'::jsonb);
COMMIT;
The code presupposes that products.id accepts that string and that a row exists. The UPDATE should be checked for production, a consistent transactional event strategy should be used and the document currently sent from source or from a versioned payload. The outbox does not magically carry the index: a * worker * is required to read outstanding inputs, to re-try faults, to register attempts, to send changes in order per entity and to mark them with a long-term procedure. The delivery’s usually at least once, so the projection operations have to be idempowerful. A deletion should remove or invalidate your document, and not just stop updating it.
To control difficult faults regular reconciliation, monitoring of lag, devoting with the possibility to change index without cutting up consultations, versioning of schemes and mechanisms for elements that cannot be processed. An empty search system after a re-start isn’t just a Docker malfunction: it can become an insynchronization window that needs to be observed and recouped.
Tenant Isolation and Search Security
The most serious risk with a multitidal catalogue isn’t a type but to get back a document that the user doesn’t have access to. A client-controlled filter isn’t an authorisation border. The demand’s identity should determine what values are forced from the backend, what fields are exposed to results and what permits are passed through the projection. The ACL changes have to be spread and in highly dynamic leave scenarios it may be necessary to re-validate each result relative to the source.
The management and indexation keys should not live in public JavaScript or repositories. Even a restricted search key needs to review range, expiry, quota, login and abuse. Also, document indexation can display fields that were once only read under DBMS authorisation filters and to design an explicit list of indexable fields is safer than to indiscriminately copies the SQL row.
Search while you write: UX also has a cost
search-as-you-type combines network, cancellation, response order and accessibility. A browser can get an answer from an earlier consultation * after * from a more recent one. A minimum client-side pattern is to cancel the previous request and not give up obsolete results:
let previousController;
let latestQueryId = 0;
async function searchProducts(term) {
previousController?.abort();
const controller = new AbortController();
previousController = controller;
const requestId = ++latestQueryId;
try {
const response = await fetch('/api/search?q=' + encodeURIComponent(term), {
signal: controller.signal,
});
if (!response.ok) throw new Error('Search unavailable');
const products = await response.json();
if (requestId !== latestQueryId) return;
renderResults(products); // Implementación de UI fuera de este ejemplo.
} catch (error) {
if (error?.name === 'AbortError') return;
showSearchError(); // Implementación de UI fuera de este ejemplo.
}
}
Also you need * debounce * if you look with every change, keyboard navigation, charging / error states, accessible roles and case tests “without results.” The interface should not treat renderResults as a real function that exists on this page: the helpers of this fragment are illustrative integration points, not a complete executable demo.
To design an assessment that measures relevance and performance
A reproducible assessment should include fictitious dataset with stable seed, exact engine and client version, tokenizer and type tolerance configuration, filters, language, resources, warming, indexes and ingestion status. Separates training sets and timings from the evaluation set as ieters above ranking. Obtain important judgments before measuring and avoid judging only the first documents you best love.
- Quality:
Precision@k,Recall@kandNDCG@kwith an annotated set and with a zero-result rate and actual reformulations if there are consented telemetry. - Service: p50 / p95 / p99 latency, lengput, concurrence, CPU, RAM, index size and initial intake time.
- Freshness: time between commitment at source and visibility under search, delay of canceling and change of permits.
- Resilience: restoration from backup, reconstruction of index, reconciliation of inconsistencies and availability during reindication.
The basic lexical comparison should freeze corpus, consultations and judgements of relevance. The vector search requires another experiment with embeddings, dimension, model, normalization and stated parameters. Comparing a hybrid motor to another purely lexical without monitoring that factor does not allow us to figure out what software “best.”
No sign was run in this research and during this implementation. No p95 values, indexation speed, ranking results and quantitative winner. The proposed procedures require servers and an assessment body that have yet to be prepared.
The engineering decision
If your relational base already meets the queries, start there: índices, planner y búsqueda en PostgreSQL. If the product requires important textual results, type tolerance, facets and dedicated UX search, MeilisResearch and Typesense are reasonable candidates. The evaluation should decide what offers best relevance and operability for corpus and concrete restrictions, and what generates more convincing demo animation.
The final system isn’t limited to the search engine: includes authorization, projection, synchronization and recovery. The technical gain isn’t to accumulate services but to have a clear responsibility and a verifiable mechanism to remedy differences.
Main References: Meilisearch docs, Meilisearch releases, Typesense 30.2 API, PostgreSQL Full Text Search, SQLite FTS5.