Document indexing enables quick searching and retrieval of digital documents. In this guide, we will show you how to build an indexing system that supports fast search and lets you access reliable information quickly.

Here’s what we’ll cover:

- What exactly document indexing is and how documents become searchable.
- The importance of indexing and why it is critical for accessing reliable information.
- The types of industries that rely on indexing.
- The workflow behind document indexing, with explanations for each step.
- The key difference between scanning and indexing, and when you should use one over the other.
- Common indexing methods, such as field-based indexing, metadata indexing, and full-text indexing.
- The unique set of challenges that you can expect to encounter in document indexing.
- How you can build a real-time indexing system with the help of Meilisearch.

Let’s start with the first step: what document indexing actually is.

## What is document indexing?

Document indexing is a structured organization of digital documents based on information such as keywords, metadata, and other relevant fields. The sole purpose is to ensure that these documents can be found quickly when needed.

Document indexing is especially important for industries such as healthcare, where specific documents (patient records, reports, contracts, etc.) need to be immediately pulled from vast amounts of data.

## Why is document indexing important?

Document indexing is important because it simplifies information retrieval. Without it, teams would waste a lot of time having to review digital documents themselves, without automation, and being hampered by manual indexing errors.

When you eliminate human error in favor of information-based indexing based on metadata, names, dates, or other elements, you improve your bottom line. Information is instantly available, and no one spends more time than necessary finding exactly what they need.

So which industries benefit most from document indexing? Let’s see that below.

## What industries benefit most from document indexing?

Many industries rely heavily on large volumes of digital files and would greatly benefit from a fast and simple means to access relevant information.

These industries include:

- **Legal:** Law firms use indexing to sort and organize contracts and case files to keep up with court records. It also helps them not lose any case-critical documents.
- **Healthcare:** Hospitals use document indexing to keep track of patient charts, lab reports, and insurance forms.
- **Finance:** Banks can’t compromise on invoices, account numbers, and other digital information, so they rely on document indexing for records management.
- **Education:** The need to manage enrollment forms, transcripts, research materials, and attendance sheets makes document indexing essential for educational facilities.
- **Government:** Agencies often index permits, licenses, and public records so the public, as well as government offices, can access them.

## How does document indexing work?

Document indexing works by identifying key information in digital documents. This information is then used to store these digital documents in an organized [indexing system](https://meilisearch.com/docs/learn/indexing/indexing_best_practices). For instance, we can use keywords, tags, and metadata to make indexed documents easy to search.

![A graph listing the steps in the inner workings of document indexing.](https://unable-actionable-car.media.strapiapp.com/How_Document_Indexing_Works_26490bc137.png)

### 1\. Document ingestion

The first step is to gather all documents you want indexed. They can be collected from websites, external databases, internal knowledge bases, etc.

### 2\. Text processing

The text is cleaned and prepared so that the search engine can understand it. This can include processes such as lowercasing letters, removing stop words such as ‘and’ and ‘the’, stemming or lemmatization (reducing words to their base form), and similar.

### 3\. Metadata extraction

Key information, or metadata, is identified in each document. Key information can be specific keywords, names, barcodes, dates, or similar.

### 4\. Index building

Finally, the search catalog is built based on the extracted metadata. When a user types in a query, the system pulls up relevant documents in the blink of an eye.

## How is document indexing different from document scanning?

Document indexing and document scanning work together, but they solve different problems in information management.

The role of scanning is to convert paper documents into digital documents. Indexing is the step that comes after scanning.

![Document Indexing vs Document Scanning.png](https://unable-actionable-car.media.strapiapp.com/Document_Indexing_vs_Document_Scanning_d84112d388.png)

In short, scanning digitizes documents, and indexing makes them findable.

## What are common methods of document indexing?

Document indexing can be done in a variety of ways, depending on the types of documents, workflow needs, and the volume of digital files being managed.

1.  **Manual indexing:** A person enters document information and organizes everything by hand. Manual indexing offers control but it takes too much time, and there’s always the possibility of human error.
2.  **Metadata-based indexing:** As the name suggests, the documents are organized using metadata elements, such as file name, authors, dates, etc.
3.  **OCR-based indexing:** Text is extracted from paper documents or scanned documents using optical character recognition. It helps turn paper into digital documents that can be indexed automatically.
4.  **Automated indexing:** Algorithms or systems apply tags or [full-text indexing](https://www.meilisearch.com/blog/how-full-text-search-engines-work) without any manual work. This works well when dealing with large volumes of document-based data.

## What types of information are used for indexing?

Using specific data points makes it easier to organize files and filter results, just as arranging your closet by color makes it easier to find items you want.

Common types of information used for document indexing include:

- **Keywords:** The phrases that indicate the main subject of the document.
- **Metadata:** Specific details of the document, such as the file name, author, title, etc.
- **Document type:** The classification labels of documents, such as invoices, reports, forms, etc.
- **Identifiers:** Values like an invoice number, account number, or customer ID.
- **Dates:** Creation, modification, or event dates for easy sorting.
- **Tags or categories:** Assigning tags or categories helps group related files together.
- **Extracted text:** The type of content that is captured through full-text indexing or OCR for deep search.

Based on this set of data points, it becomes relatively easy to retrieve accurate information from the indexing system.

Let’s look at how indexing supports information retrieval.

## What is the role of indexing in information retrieval?

Indexing is the backbone of information retrieval because it provides a structured map of digital documents. By storing keywords, different identifiers, and metadata, it groups relevant information together.

Document indexing eliminates the need for manual scanning and strengthens the search functionality across databases and document management systems. If your indexing process is clean, even extensive collections cannot hinder retrieval.

Now, let’s examine the challenges that go hand in hand with document indexing.

## What challenges are common in document indexing?

Document indexing can become overwhelming when organizations have to manage large volumes of digital files and rely on unoptimized processes. These issues affect retrieval accuracy and long-term information management.

Here are some of the most common challenges teams face:

- **Inconsistent tagging:** Different teams label documents differently. As a result, the indexing system becomes unreliable. The fix for this is a set of standardized tags, categories, and vocabulary.
- **Human error:** Manual entry leads to mistakes such as missing fields, typos, and mislabeling. The best way to fix this is to shift toward automated indexing.
- **Poor metadata quality:** Weak or incomplete metadata makes document retrieval difficult. Clear rules for required fields, such as dates or invoice numbers, significantly improve the structure.
- **Unscannable or low-quality documents:** When the quality of scanned documents is poor, even the best OCR cannot make them readable. Better scanning tools for data extraction should help here.

Let’s see how automated document indexing works with Meilisearch in real environments.

## How automated document indexing works with Meilisearch

Meilisearch eliminates the need for manual work, replacing it with fast, optimized, searchable indexes in real time. It extracts key document attributes and organizes them into an optimized indexing system.

Here are the main steps to indexing your documents using Meilisearch:

### 1\. Import and prepare your documents

The first step is to load the documents into your workflow. These documents can come from various sources, such as APIs, storage buckets, scanned documents, or even existing databases. Meilisearch accepts JSON, so there’s no problem in pushing the field titles, dates, tags, etc.

```json
_curl \\_

_\-X POST 'http://localhost:7700/indexes/documents/documents' \\_

_\-H 'Content-Type: application/json' \\_

_\--data-binary @documents.json_

```

### 2\. Extract key fields and metadata

Extraction is key for identifying attributes within each file, such as metadata, keywords, categories, and so on.

For example, if a document comes from OCR, the extracted text instantly becomes a part of full-text indexing.

Meilisearch categorizes files and enriches indexed documents to improve [relevant information retrieval](https://www.meilisearch.com/blog/latent-semantic-indexing).


```json
_{_

_"id": "doc_01",_

_"title": "Insurance Claim Form",_

_"date": "2024-01-19",_

_"account_number": "298231",_

_"content": "Full OCR text goes here..."_

_}_
```

### 3\. Index documents and enable search features

Indexing uploads the enriched documents into Meilisearch. Immediately, the engine builds indexes and applies features, enabling various search functionalities such as typo tolerance and synonyms.

```json
_curl \\_

_\-X PATCH 'http://localhost:7700/indexes/documents/settings' \\_

_\-H 'Content-Type: application/json' \\_

_\--data '{_

_"searchableAttributes": \["title", "content"\],_

_"filterableAttributes": \["date", "account_number"\]_

_}'_
```

### 4\. Apply custom ranking and optimize relevance

Now comes the step that defines ranking rules based on the priorities you set, such as dates, status, or file names. Different types of documents require different priority levels.

```json
_curl \\_

_\-X PATCH 'http://localhost:7700/indexes/documents/settings' \\_

_\--data '{_

_"rankingRules": \[_

_"words",_

_"typo",_

_"proximity",_

_"attribute",_

_"sort",_

_"exactness"_

_\]_

_}'_
```

### 5\. Keep the index updated in real time

Lack of index updates can cause bugs and inconsistencies. Meilisearch supports incremental updates so that any new or modified documents become searchable immediately. This takes away time-consuming manual updates and keeps business operations running smoothly.

Thanks to these real-time updates, document management systems always reflect the most current data.

```json
_curl \\_

_\-X POST 'http://localhost:7700/indexes/documents/documents' \\_

_\--data '\[{ "id": "doc_01", "status": "updated" }\]'_
```

## Document indexing in modern information systems

Modern systems rely heavily on document indexing because they require up-to-date information and accurate retrieval. Scaling is also a big reason automated indexing has flourished in recent years.

Through effective indexing, you can optimize all document-related processes for your business, including search accuracy, fast access across workflows, and document management.

How document indexing works, methods, implementation, & more

Text clustering organizes unstructured data by grouping similar documents without any labels. It identifies underlying themes, enabling users to enhance their research.

Here’s what this guide covers:

* What text clustering is and how it helps sequester text into groups based on meaning.
* The mechanism behind text clustering, from preprocessing to algorithms.
* Popular methods for text clustering, such as K-means, DBSCAN, and hierarchical clustering.
* A brief look at the benefits and applications of text clustering and how you can take advantage of it.
* For hardcore developers, we’ll look at a step-by-step Python workflow that builds, visualizes, and evaluates clusters.
* Most common text clustering mistakes and challenges for scaling businesses.
* How to use Meilisearch to make clusters searchable and useful.

Let’s get into it!

## What is text clustering?

Text clustering is an unsupervised learning technique used by AI models to group similar text documents based on their content. Its primary purpose is to help determine themes in large datasets without pre-defined labels, especially when you want to separate text into different clusters within a broader natural language processing workflow. 

It’s most commonly used to organize and analyze customer reviews, news articles, and research documents, among other types of content.

Let’s see how text clustering works behind the scenes.

## How does text clustering work?

![How Text Clustering Works.png](https://unable-actionable-car.media.strapiapp.com/How_Text_Clustering_Works_d67d9a7362.png)

Text clustering consists of the following stages:

1. **Text preprocessing:** Raw text is cleaned by removing unnecessary whitespace, special characters, and URLs. Then it is tokenized or broken apart into smaller units (words or phrases). Stop word removal (such as ‘a’ and ‘the’) and stemming and lemmatization (reducing words to their root form) can also be part of this stage.
2. **Embedding:** Pre-processed text gets converted into numerical vectors. The techniques used here include term frequency-inverse document frequency (TF-IDF), Word2Vec, and transformer-based embeddings such as BERT. 
3. **Clustering:** In the third stage, clustering algorithms, such as K-means, DBSCAN, and hierarchical clustering, are applied. These algorithms assess the vector space created in stage two and group similar vectors into clusters.
4. **Evaluation:** To assess how well the documents fit within the clusters, use metrics such as the Adjusted Rand Index (ARI) or the silhouette score. Techniques such as principal component analysis also enable more precise visualization when assessing separation quality.

Let’s take a closer look at the clustering algorithms that are most effective for different types of text data.

## What algorithms are used in text clustering?

Every algorithm handles text data differently, based on the dataset’s size, shape, and noise. 

The most commonly used clustering methods include K-means, DBSCAN, hierarchical clustering, and newer approaches such as spectral clustering and Gaussian Mixture Models (GMMs). 

![Algorithms Used in Text Clustering.png](https://unable-actionable-car.media.strapiapp.com/Algorithms_Used_in_Text_Clustering_ee4a86486d.png)

Let’s break down the most widely used methods:


### 1. K-means

K-means is a method in which each data point is assigned to the cluster with the nearest mean (centroid) thereby dividing the data into k clusters. The centroid positions are repeatedly recalculated to be the mean of all data points in a specific cluster. The process is repeated until the centroid positions are no longer changing. 

This method performs really well on large datasets. However, it can struggle with noisy or overlapping text data.


### 2. DBSCAN

DBSCAN (Density-Based Spatial Clustering of Applications with Noise) groups data points that are closely packed and marks the distant ones as outliers. 

It works well for irregularly shaped clusters. It also doesn’t need you to predefine the number of clusters, so it works really well for grouping social media posts or product reviews.


### 3. Hierarchical clustering

Hierarchical clustering builds a tree-like structure that shows relationships among documents. You can cut this tree at different levels, forming clusters of varying granularity. 

This comes in handy when dealing with smaller datasets where the relationships between entities are more important than processing speed.


### 4. Spectral clustering and GMM 

Spectral clustering relies on similarity matrices to cluster data. It is computationally more expensive, but the payoff is its effectiveness when dealing with non-linear structures. 

Gaussian Mixture Models (GMM) models assume that the data points are generated from Gaussian distributions. As a result, they allow soft cluster assignments. This is useful when you’re dealing with documents that span multiple topics. 

## What are the benefits of text clustering?

The main function of text clustering is to help teams access large amounts of data in a structured, easily digestible manner. It eliminates manual labeling and complex arrangements.

Here are the benefits of text clustering: 

1. **Automated organization:** Text clustering eliminates the need for manual sorting and tagging.
2. **Discovery of hidden patterns:** Clustering reveals themes across datasets, such as the general sentiment in customer reviews or customer support tickets.
3. **Scalable analysis:** Clustering enables large-scale analytics without disrupting operations.
4. **Better search and recommendations:** Text clustering groups related documents to help search engines surface results that share the same theme. For example, if a user searches for ‘running shoes,’ the system can also return documents from clusters focused on durability, fit, or trail performance.
5. **Data-driven insights:** For instance, support tickets may cluster around billing issues, login problems, or feature requests, enabling teams to quickly see which issues users struggle with the most.

Now that you know how valuable it is, let’s explore where text clustering is most useful in practice.

## What are the main applications of text clustering?

Text clustering is most helpful in industries with a continual, daily influx of unstructured data. It can be used for: 

1. **Document organization:** Enterprises regularly group similar documents, emails, or reports, making extensive archives searchable and easier to manage.
2. **Easy search results retrieval:** Clustering yields better search results faster by significantly improving relevance. 
3. **Customer feedback analysis:** When customer feedback is organized efficiently, businesses can analyze it to improve the customer experience.
4. **Academic and research use:** Researchers can cluster papers, abstracts, or citations to identify overlapping topic areas and stay up to date with emerging trends.

Next up is why embeddings play a critical role in clustering quality.

## Why use embeddings for text clustering?

Embedding converts text into numerical vectors, capturing its semantic meaning. Based on this, clustering algorithms can group documents by intent and context, rather than just by shared keywords. 

AI models such as BERT and Word2Vec are built on deep learning and generate high-dimensional embeddings that capture the nuance of words and their meanings. Techniques like dimensionality reduction also simplify the underlying vector space, making the clusters much more contextually relevant and meaningful.

## How do you perform text clustering in Python?

The Python workflow we will outline here has four steps. With the help of modern libraries like spaCy and scikit-learn, you can easily move from messy text to production-ready clusters. 

Once you have them, integrating with search engines like Meilisearch is a breeze: 

### 1. Pre-processing and tokenization

First things first, we need to normalize the text we have and remove any noise. 

For this, you will convert the text to lower case, remove punctuation and stop words, and then apply stemming. Here’s what it looks like:


```python
import re, nltk, spacy
from nltk.corpus import stopwords

# Download once if needed
# nltk.download('punkt'); nltk.download('stopwords')
# python -m spacy download en_core_web_sm

nlp = spacy.load("en_core_web_sm")
stop_words = set(stopwords.words("english"))

def preprocess(text):
    text = re.sub(r"http\S+|[^a-zA-Z\s]", " ", text.lower())
    doc = nlp(text)
    tokens = [token.lemma_ for token in doc if token.text not in stop_words and len(token.text) > 2]
    return " ".join(tokens)

docs_clean = [preprocess(doc) for doc in raw_docs]
```


The text is now standardized and tokenized, ready for feature extraction and [semantic indexing](https://www.meilisearch.com/blog/latent-semantic-indexing).


### 2. Vectorization and embedding generation

You need to choose a vector representation that matches your goal and scale: 


* TF-IDF: lightweight and interpretable.
* Word2Vec / GloVe: semantic similarity via word embeddings.
* BERT / Transformer models: contextual, sentence-level embeddings for highest accuracy.



 ```python
from sklearn.feature_extraction.text import TfidfVectorizer
from sentence_transformers import SentenceTransformer

# TF-IDF representation
tfidf = TfidfVectorizer(max_features=50000, ngram_range=(1, 2))
X_tfidf = tfidf.fit_transform(docs_clean)

# Transformer-based embeddings
model = SentenceTransformer("all-MiniLM-L6-v2")
X_emb = model.encode(docs_clean, normalize_embeddings=True)
```



Another option is to store embeddings in Meilisearch to enable hybrid (keyword + vector) retrieval later.


### 3. Clustering algorithms in Python

After vectorization, you will need to select an algorithm suited to your data distribution:



* K-means for balanced, spherical clusters.
* DBSCAN for noisy or irregular data.
* Agglomerative (hierarchical) for dendrogram-based analysis.



 ```python
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering

# K-means
kmeans = KMeans(n_clusters=10, n_init=10, random_state=42)
labels_km = kmeans.fit_predict(X_emb)

# DBSCAN
dbscan = DBSCAN(eps=0.3, min_samples=5, metric="cosine")
labels_db = dbscan.fit_predict(X_emb)

# Hierarchical
agg = AgglomerativeClustering(n_clusters=10, linkage="ward")
labels_ag = agg.fit_predict(X_emb)
```



Remember that each algorithm has its own set of trade-offs. Before you consider scaling, try benchmarking with small subsets first.


### 4. Evaluation of clusters and integration into search-oriented workflow

You will need to evaluate the quality of your clusters using both intrinsic and extrinsic metrics:



* *Silhouette Score*, *Davies-Bouldin*, or *Calinski-Harabasz* for structure quality.
* *Adjusted Rand Index (ARI)* if ground-truth labels exist.

Visualize using PCA or t-SNE for interpretability.


```python
from sklearn.metrics import silhouette_score, adjusted_rand_score
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt

sil_score = silhouette_score(X_emb, labels_km, metric="cosine")
print(f"Silhouette score: {sil_score:.3f}")

pca = PCA(n_components=2)
coords = pca.fit_transform(X_emb)
plt.scatter(coords[:,0], coords[:,1], c=labels_km, cmap="tab10", s=10)
plt.show()
```


Store each document with its `cluster_id` and index it in Meilisearch. This will provide you with all the perks of using Meilisearch, including typo-tolerance, filtering, and [hybrid-vector](https://www.meilisearch.com/blog/semantic-vs-vector-search) keyword search.

Let’s address the key challenges you’ll face when applying text clustering in real-world projects.


## What are the challenges in text clustering?

Useful as it is, text clustering comes with several practical challenges that can affect the accuracy and scalability of your projects:

1. **High dimensionality:** Text data often produces thousands of features, especially with TF-IDF embeddings. It has a very high dimensionality. You can reduce dimensions using PCA or t-SNE, but this can ultimately distort distances.
2. **Ambiguous language:** Algorithms have difficulty accurately grouping semantically similar documents when language elements vary in meaning, such as when sarcasm or slang is used.
3. **Hard to scale:** Large text datasets demand memory-efficient clustering. Algorithms like K-means scale well, but methods like hierarchical clustering can be too computationally expensive.
4. **Choosing the correct number of clusters:** Without labels, deciding how many clusters to create is subjective. Some metrics, such as silhouette score or the elbow method, can provide guidance, but this is still mainly a trial-and-error process.

Next, let’s look at common mistakes teams make when clustering text data.

## What are common mistakes in text clustering?

The following are some of the most common mistakes in text clustering that you need to be aware of, because even minor oversights can become costly very quickly:

1. **Slacking on pre-processing:** If you make it a habit to skip cleaning steps, such as stop word removal, you will end up with noisy, inconsistent clusters. Plus, irrelevant tokens will inflate your already high dimensionality, leading to poorer model performance.
2. **Choosing the wrong clustering algorithm:** For instance, if you apply the K-means algorithm to non-spherical data, there might be a split between related documents and a merge between non-related documents. 
3. **Ignoring evaluation metrics:** Without validation using silhouette or ARI scores, clusters may look good, but statistically, they will be a mess.
4. **Overlooking embeddings:** If you rely solely on TF-IDF, you might miss out on the contextual meaning. Transformer embeddings, such as BERT or MiniLM, deliver much better separation. 

## When should you use text clustering over classification?

You should use text clustering when there is a shortage of labeled data, and you want to discover its overarching themes. Text clustering is best when you want to explore new datasets or identify emerging topics with flexible clustering models. 

On the other hand, text classification comes in handy when you’re dealing with predefined labels and the data categories are already known.

## How do you choose the number of clusters?

Choosing the right number of clusters is part science, part best-guess. 

The elbow method plots the sum of squared Euclidean distances to identify a point at which adding more clusters yields suboptimal returns. 

On another note, silhouette analysis measures how well a document fits within the aligned cluster, as opposed to others within the same dimensional space. 

By combining these metrics with domain knowledge and reviewing your clustering results, you get the most meaningful outcomes.

## What is the difference between text clustering and topic modeling?

Text clustering and topic modeling both organize large text datasets. However, the goals they serve are different. 

Clustering is used to find relevant documents within a cluster. This helps in building search systems or recommendation engines.  

Topic modeling, on the other hand, uncovers latent themes within a collection. Methods such as latent Dirichlet allocation (LDA) or non-negative matrix factorization (NMF) assign multiple topics to each document, with probabilities indicating the prevalence of each topic in that document. 

This is more useful in content analysis or summarizing large corpora. 

In short, clustering focuses on grouping similar documents, while topic modeling focuses on interpreting what they’re about.

## Bringing it all together: mastering text clustering for real-world insights

Text clustering gives structure to disorganized text documents. It ensures that text can be analyzed and searched for insights, especially when you deal with document clustering at scale. 

Text clustering supports better information retrieval and workflows powered by modern language models and deep learning. All of this leads to smarter analytics and data-driven decision-making for a business.

What is text clustering? A complete guide

## Summary

Meilisearch versions v1.8 to v1.34.0 are vulnerable to an authenticated, blind Server-Side Request Forgery (SSRF) attack, and we recommend that open-source users update immediately to Meilisearch v1.34.1 or later. 

Customers of Meilisearch Cloud do not need to take any specific action, as the Cloud environment is protected against exploitation of this vulnerability. The vulnerability has not yet been assigned a CVE number; it has CVE Request 1975471 for CVE ID.

## Technical details

In Meilisearch versions v1.8 to v1.34.0, a user with an API key with *write permissions* to the configuration of the Meilisearch instance could set up Meilisearch to send POST or GET requests to domains and IPs local to the private network of the Meilisearch instance, effectively bypassing the firewall.

Meilisearch v1.34.1 fixes the vulnerability by forbidding Meilisearch from making any requests to an host resolving to a non-global IP, in the sense of the [IANA IPv4 Special-Purpose Address Registry](https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml) or the [IANA IPv6 Special-Purpose Address Registry](https://www.iana.org/assignments/iana-ipv6-special-registry/iana-ipv6-special-registry.xhtml). If you need this functionality in your Meilisearch instance, you can set private IP networks as allowed with the `--experimental-allow-ip-networks` parameter after reviewing the security implications.

We detected no signs of exploitation on [Meilisearch Cloud](https://cloud.meilisearch.com/). We recommend that any self-hosted Meilisearch instance apply [defense in depth and least privilege principles](https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html#imdsv2-in-aws) and have the most limited possible access to the private network.

## Acknowledgments

Thanks to Gabriel Rodrigues (aka Texugo), for reporting this vulnerability and for helping us improve the security of Meilisearch.

Security update: Meilisearch v1.34.1 fixes an SSRF vulnerability 

# Meilisearch Monthly: January 2026

Welcome to the first 2026 edition of Meilisearch Monthly! We’re kicking off the new year with major performance and security improvements, along with a sneak peek at some highly requested features we’re working on.

---

## **Product Updates: What’s New at Meilisearch**

## Just dropped: SSO & SCIM

We are excited to share that our **Enterprise Identity and Access** features are now live. Designed for teams requiring secure, centralized authentication, these features ensure your Identity Provider (IdP) remains the single source of truth.

- **SAML-based SSO:** Users can now log in using their company accounts (Okta, Azure AD, or Google Workspace) instead of managing separate passwords.
- **Auto-Provisioning:** When a user authenticates via SSO, the system can automatically create their account, add them to your organization, and assign them to a default team.
- **SCIM-based User Lifecycle Management:** Available as a separate add-on, SCIM allows your IdP to automatically create, update, and—most importantly—de-provision users.
- **Immediate Revocation:** When a user is removed in your IdP, their access is revoked immediately in Meilisearch, ensuring no orphaned access remains.
    
    
![SSO.gif](https://unable-actionable-car.media.strapiapp.com/SSO_09d9616fd1.gif)

<aside>

👉 [Get in touch](https://meet.meilisearch.com/meetings/meilisearch/get-in-touch) with us to enable SSO for your organization 🔒 

</aside>

### Search analytics in GA - now enabled for all Cloud projects.

Here’s what that means for you:

- **Always-on insights**: Minimal setup with analytics working directly on your project URL - no more edge proxy required.
- **20% faster searches**: With the edge removed, you get the same great analytics with significantly lower latency.
- **Federated search? Fully supported.** Events from multi-search queries are now tracked accurately and visible in your dashboard.

Whether you're tracking performance or laying the groundwork for search personalization, Meilisearch’s built-in analytics are now production-ready and built into the experience by default.

👉 [Try analytics now
](https://cloud.meilisearch.com/login)

> 💡 *Using the edge.meilisearch.com URL? You don’t need to switch right away, but we recommend updating to your project URL **before February 26, 2026**.*
> 

### New Year, New Sharding Improvements

We are starting the year by making our sharding capabilities even more flexible. Meilisearch now allows you to **add new shards dynamically** as your data or traffic grows. This allows you to:

- **Scale horizontally** without rethinking your entire architecture.
- **Maintain fast speeds** via federated search across all shards.
- **Split indices** across multiple instances seamlessly.

> **What’s Next?** Replicated sharding is officially on the horizon to bring even more resilience and flexibility to your stack.
> 

📍 See our updated public roadmap [here](https://www.notion.so/Public-Meilisearch-Roadmap-2cb4b06b651f80868508c2c1409c1b10?pvs=21).

### Performance: 7x Faster Indexing

We’ve been optimizing how we handle big payloads under the hood. Our latest tests show that indexing speed has improved by **7x** when extracting large datasets.

Additionally, we are running tests to switch to AWS **Graviton** machines, which are already showing promising **20% performance gains**. 


<aside>

###  ❗️ Vector search alert:
> If you’re using vector search in production, we strongly recommend updating to **v1.32.0**. This release includes important bug fixes and boosts relevance across hybrid and pure vector queries. The update is backward-compatible, so migrating should be smooth.

</aside>


### Semantic Search with Gemini Embeddings

We have a new embeddings guide. It walks you through the process of setting up Meilisearch with Gemini embeddings to enable semantic search capabilities.

👉 Check it out [here](https://www.meilisearch.com/docs/guides/embedders/gemini)

---

## **Community & Ecosystem**

## Meilisearch at FOSDEM 2026:

Our engineering team is gearing up for FOSDEM, excited to connect with one of the most passionate open source communities in Europe!

- If you’re attending, don’t miss our talk on Language support in Meilisearch - a deep dive into how we’re building a truly multilingual search engine that developers love.
- 👉 Join the conversation ahead of the event in our [community chat room](https://fosdem.org/2026/schedule/event/GS7B8Y-meilisearch-laguage-support/)

## Meilisearch is a Rust Foundation gold sponsor:

We’re proud to support the Rust ecosystem as a Gold Sponsor of the [Rust Foundation](https://rustfoundation.org/). Rust plays a major role in how we build fast, safe, and efficient search. This partnership is a nod to our roots and a signal of our long-term commitment to open source performance at scale.

Meilisearch January updates

How to build a search engine: A complete guide for developers

The durability and potential of your retrieval-augmented generation (RAG) system depend on the database you choose for it. In RAG information retrieval, vector databases and knowledge graphs serve distinct roles: the former focuses on similarities between vector representations, while the latter focuses on relationships between entities. 

In this guide, we will cover:

* What exactly knowledge graphs and vector databases are, and how they work within an RAG AI system.
* The process through which RAG retrieves and augments information to generate user-friendly responses.
* When you should go for a knowledge graph, and when you should use vector search.
* An in-depth comparison of their data models, along with their scalability and retrieval performance. 
* A look into the advantages and limitations of both, and whether or not they can be combined for a better yield.
* How you can use real-world tools and frameworks to build RAG pipelines that are strong and scalable.

By the end, you will have a solid idea of which setup will work best for your goals, data, and production requirements. 

Let’s get into it.

## What is a knowledge graph?

A knowledge graph is, well, a graph of knowledge. It’s a structured data model that represents entities such as people, places, numbers, and other data points, along with the relationships between them. Using nodes and edges, a knowledge graph organizes information and deciphers the connections within it to answer complex or hidden queries for users. 

A graph structure enables the system to apply reason to the data and uncover the real connections needed to answer complex queries. 

In AI applications and RAG, knowledge graphs are primarily used for contextual reasoning and compliance monitoring, where the depth and explainability of answers are paramount.

## What is a vector database?

A [vector database](https://www.meilisearch.com/blog/what-is-a-vector-database) runs on vector embeddings. These are more easily understood as numerical representations of text, images, and even audio that capture meaning instead of full-fledged keywords. These vectors are indexed using similarity search algorithms, such as cosine similarity or HNSW. 

The most popular vector databases, such as Pinecone and Weaviate, power RAG apps by allowing fast retrieval across massive datasets. Most modern semantic and generative AI systems use vector retrieval as their backbone. 

## How does RAG work?

[Retrieval-augmented generation](https://www.meilisearch.com/blog/what-is-rag) is a power-up for large language models (LLMs). It grounds their outputs in external data and adds a smarter, context-aware layer. It works in three steps that are seemingly very simple:

![How RAG Works.png](https://unable-actionable-car.media.strapiapp.com/How_RAG_Works_4bbeaa79f9.png)

1. A retriever traverses the knowledge base or vector database to find documents similar to the user’s query. 
2. The retrieved documents and their context are handed off to the LLM.
3. The LLM generates an answer that’s supported by the context and addresses the user’s query.

With this externally fetched context, the likelihood of AI hallucinations or generic answers is significantly reduced.

## Do you need a vector database for RAG?

A dedicated vector database can significantly improve retrieval precision, but it isn’t always a prerequisite for a functional RAG pipeline. 

Plenty of teams use hybrid search engines that combine [full-text search](https://www.meilisearch.com/blog/how-full-text-search-engines-work), keyword extraction, and vector embeddings within a single layer. The benefit of doing this is that they don’t need to rely on multiple services or heavy infrastructure. 

For example, Meilisearch offers a simple way to set up your workflow through a single <code><em>/chat</em></code> endpoint. It can perform retrieval and generation in a single API call, unlike the traditional multi-step RAG approach. 

## When should you use a knowledge graph for RAG?

A knowledge graph is ideal for RAG systems that have structured or interconnected data. It excels in scenarios where the ‘how’ is just as important as the ‘why,’ such as in medical research, financial compliance, analytics, and business data. 

A knowledge graph enables multi-hop reasoning by modeling entities such as people, organizations, roles, and products. It understands the relationships between these entities and helps your LLM trace how the answer was retrieved, not just the information. 

## When is a vector database better for RAG?

A vector database is a good option when you’re dealing with unstructured or high-volume semantic data. This can include documents, support tickets, research papers, and so on. 

In all situations where meaning matters more than the relationships, you want to use a [vector database for RAG](https://www.meilisearch.com/blog/vector-dbs-rag). 

Since it stores the data in the form of vector embeddings, the retriever can use semantic similarity and deliver the relevant information you’re looking for. 

All of this makes vector databases the go-to option for search, summarization, and content summarization. Unlike knowledge graphs, they scale easily and return results in milliseconds.

## What are the key differences between knowledge graphs and vector databases?

If you’re looking for the main difference between [knowledge graphs and vector databases](https://www.meilisearch.com/blog/graph-rag-vs-vector-rag), you’ll find it in how they model and retrieve information. 

Let’s take a look at some specifics for both. 

![Knowledge graph vs vector database.png](https://unable-actionable-car.media.strapiapp.com/Knowledge_graph_vs_vector_database_4d6864f956.png)

Need reasoning and traceability? Knowledge graphs are your best bet. 

On the other hand, if you want semantic matching and scalability, go with vector databases. 

That said, modern RAG systems often combine the best of both worlds for quick recall and solid reasoning.

## What are the advantages of using knowledge graphs in RAG?

Knowledge graphs provide the structure and reasoning that enable RAG systems to understand how data points are connected, rather than treating each point in isolation.

The benefits of employing knowledge graphs in RAG include:

1. **Relational reasoning on point:** Knowledge graphs capture relationships between entities and are helpful in domain-specific contexts such as legal or medical research.
2. **Easy to explain:** Developers enjoy the traceability of knowledge graphs through nodes and edges because it gives results that can be audited.
3. **Upholding the context:** Data linked through knowledge graphs helps the LLM maintain context coherence across future prompts or windows.
4. **Semantic precision:** Knowledge graphs reduce noise and improve the quality of retrieval.

## What are the advantages of using vector databases in RAG?

Here’s why RAG pipelines rely heavily on vector databases:

1. **Effortless scalability:** Since vector databases can handle millions of embeddings without a hitch, you never have to worry about increased latency across large-scale datasets. 
2. **High speed and performance:** Vector databases can deliver results within milliseconds without compromising accuracy or quality.
3. **Easy handling of unstructured data:** They’re optimized to work smoothly with text, audio, and even image embeddings. This is particularly useful in chatbots.
4. **Flexible and low-cost:** Their architecture supports easy scaling without complex infrastructure.

Modern retrieval systems, such as Meilisearch, [combine vector search, full-text search](https://www.meilisearch.com/solutions/hybrid-search), and reranking in a single engine. This hybrid approach targets both speed and reasoning for retrieval.

## What are the limitations of knowledge graphs in RAG?

Even though they are helpful in specific cases, knowledge graphs have limitations that you need to keep in mind before putting all your retrieval eggs in this basket: 

1. **Hard to develop:** As effective as knowledge graphs are, building and maintaining them takes significant time. Development teams need to work on schema design, ontology mapping, and, of course, manual relationship curation.
2. **Can’t scale as easily:** More edges and nodes mean multiple hops. These traversals degrade retrieval performance. 
3. **Don’t handle unstructured data well:** When the content is text-heavy, it doesn’t fit well into node-edge structures. This limits recall breadth and might limit responses.
4. **Maintenance is expensive:** Frequent schema updates and data versioning increase overhead.

## What are the limitations of vector databases in RAG?

Vector databases aren’t without drawbacks either. Let’s look at a few:

1. **No transparency:** Since the similarity scores are based on math, it’s tough to trace why certain documents were retrieved. As such, you cannot justify outputs either. 
2. **Not for complex relationships:** Vector databases don’t do well with structured relationships because they can’t support entity hierarchies or established relationships between them.
3. **Operational complexity:** Ever heard of ‘glue code’? That’s what you get when integrating vector databases with retrievers and generators. It leads to a high infrastructure overhead that nobody wants. The best modern hybrid systems have already simplified this. For example, Meilisearch does so by bundling retrieval and generation into a single endpoint, reducing the number of orchestration layers and the LLM's call volume.

## How can you combine knowledge graphs and vector databases in RAG?

Combining a knowledge graph and vector database in a single RAG pipeline enables teams to capture both semantic similarity and structured relationships.* *As a result, you get stronger reasoning and pinpoint precision.

Let’s take the example of Meilisearch. It handles high-recall retrieval and grounding by running a hybrid search. In addition, a knowledge graph layer can be set up to trace entity relationships and perform multi-hop reasoning. 

This architecture is useful for enterprise-scale data where both speed and explainability are a must. Meilisearch’s <code><em>/chat</em></code> endpoint handles both retrieval and generation in a single call, while the knowledge graph adds a traceability layer on top.

## How does semantic search differ in knowledge graphs and vector databases?

[Semantic search](https://www.meilisearch.com/blog/semantic-search) behaves differently across these two systems because of how each one represents meaning.

In knowledge graphs, meaning revolves around entities and their relationships. The retrieval then depends on these logical connections and relationships. You’ll find it most useful in domains such as law or healthcare, where there’s no room for error. 

In vector databases, semantic search is tied to embeddings that rely on similarity algorithms to generate answers for users. It’s fast and efficient. For example, if a user searches for ‘HR policy’, it will find content by matching the query with relevant documents, such as ‘employee handbook.’ You won’t even need to define this relationship.

## What are popular vector databases used for RAG?

Let’s explore the most commonly used vector DB tools: 

* **Meilisearch:** The perfect modern hybrid blend. Meilisearch is a search engine with a built-in vector store and hybrid retrieval. It also provides the `/chat` API, which unifies understanding, reranking, and generation into a single layer. Here’s a not-so-secret fact: it often replaces a standalone vector database in production-grade RAG pipelines.
* **Pinecone:** A staple in the industry when it comes to managed vector DBs. It’s known for its low latency and high reliability.
* **Weaviate:** An open-source option that supports hybrid search and schema-based reasoning. Plus, it integrates with most major embedding models.
* **Qdrant:** Qdrant is popular because it is lightweight and developer-friendly. It’s been optimized primarily for real-time similarity search.
* **Milvus:** This one has been designed specifically for enterprise workloads with a distributed architecture and high-throughput performance.

## Examples of knowledge graph platforms for RAG

Let’s now look at some examples of knowledge graph platforms that have been popular with development teams. 

* **Neo4j:** One of the most widely used graph databases. It is the ideal option if you want to store entities and edges with Cypher queries that support semantic reasoning.
* **Amazon Neptune:** Amazon Neptune is a fully managed graph service, optimized for RDF and property graph models.
* **Ontotext GraphDB:** As the name suggests, this one was designed for ontology-driven graphs and semantic search. It is widely used in sectors such as publishing and life sciences. 
* **ArangoDB:** A multi-model database supporting both graph and document queries for flexible, hybrid RAG applications.

## How do you choose between a knowledge graph and a vector database for RAG?

The perfect foundation for your RAG system depends on your data structure, reasoning needs, and operational goals. Here are the factors you must consider before finalizing this decision:

* **Data type:** The data you’re working with is the main factor that determines the foundation you need. If your data is structured, go for a knowledge graph. If it’s unstructured, go with a vector DB. 
* **Explainability:** Choose a knowledge graph when you need traceability and reasoning paths. Vector databases excel when you only need similarity-based retrieval.
* **Scale and performance:** Vector databases handle massive datasets and low-latency retrieval better. Knowledge graphs give up retrieval speed but make up for it with deeper reasoning and richer context.
* **Maintenance and integration:** Knowledge graphs require schema definition and maintenance, whereas vector databases integrate easily into modern AI pipelines.

If you want a deeper understanding of RAG, here are the different [types of RAG](https://www.meilisearch.com/blog/rag-types) to know, along with the [RAG techniques](https://www.meilisearch.com/blog/rag-techniques) and [tools](https://www.meilisearch.com/blog/rag-tools) that drive the modern AI wave.

## Choosing the right path: knowledge graph vs. vector database for RAG

Modern RAG systems are as effective as they are because of the foundations on which they are built. Both knowledge graphs and vector databases are a part of this foundation. 

The choice between them will always depend on your needs, and most teams today lean toward a hybrid approach to better prepare for future needs.

Knowledge graph vs. vector database for RAG: which is best?

Retrieval-augmented generation (RAG) is revolutionizing how businesses use artificial intelligence to interact with data. By enabling enhanced AI responses, organizations can leverage AI to complete tasks faster, make more informed decisions, and deliver more effective customer support. 

Here are the main topics we cover in this article:

* Businesses use RAG mainly for customer support, contract reviews, enterprise search, and reporting.
* Industries such as finance, law, healthcare, retail, and technology benefit most from RAG systems.
* Common challenges of RAG for business include data privacy, integration, cost, and scalability, all of which require robust testing.
* RAG implementation involves setting goals, connecting data, selecting tools, fine-tuning models, and continuous monitoring to ensure optimal performance.
* Best practices for utilizing RAG in your business include data cleaning, user training, system security, and performance monitoring.
* New trends focus on agentic RAG, multimodal data, and domain-specific tools for businesses.

Let’s explore each of these points in more depth, starting with defining retrieval-augmented generation and what it means for business. 

## What is retrieval-augmented generation (RAG) for business?

[Retrieval-augmented generation](https://www.meilisearch.com/blog/what-is-rag), or RAG, is a system that enhances the context of a large language model (LLM) and improves its responses. It works by pulling recent, relevant information from trusted sources and using it to generate its response. This means that the AI model can augment its training data with new insights and provide more accurate, context-aware answers. 

In a business setting, using RAG in an AI system enhances customer support, market analysis, and knowledge management. It also helps teams work more efficiently. 

Using RAG [internal search](https://www.meilisearch.com/blog/internal-search), teams can access relevant information more quickly, communicate more effectively, and make informed choices backed by accurate data.

## How does RAG work in business AI?

For RAG to be effective, it must be connected to an external knowledge source. This could include business databases, internal documents, or online sources. 

Once connected, the RAG workflow follows three major steps:

1. **Business data retrieval:** Based on a user query, the language model determines which additional information is needed to provide a correct, relevant answer. It then searches the external resources it has access to for any helpful information related to the query. 
2. **Augmentation:** In this stage, the retrieved data is added to the language model’s input. This provides the necessary context to ground its reasoning. For example, if a user asks, ‘What is the trend in support requests over the past three months?’ RAG accesses the customer support database and retrieves the information for the last three months. The final LLM input then becomes the initial user question plus the retrieved numbers from the previous three months. 
3. **Response generation:** The model leverages both its existing knowledge and new information to generate a precise, informed response. 

In a business setting, this process can help employees get insights from company records. It can also allow customer service representatives to provide fact-based answers. 

RAG bridges the gap between business knowledge and real-time understanding, making AI responses more factual.

## What are the benefits of RAG for businesses?

Retrieval-augmented generation helps companies make the most of their data. Here’s how:

* **Improved decision-making:** RAG provides business leaders with access to accurate, up-to-date information from multiple business sources. For example, a retail company owner can use RAG to analyze sales reports, customer feedback, and market data before launching a new product. 
* **Better customer support:** Customer service teams can deliver quick, accurate answers by combining stored knowledge with real-time retrieval. A bank’s chatbot, for instance, can use RAG to retrieve policy updates and provide personalized answers with the help of this extra information.
* **Increased productivity and cost savings:** Employees spend less time searching for data and more time focusing on tasks that matter. This improves efficiency and reduces operational costs.
* **Higher accuracy and reduced hallucinations:** Since RAG relies on verified data, it limits the risk of AI generating wrong or made-up information. 
* **Competitive edge:** Businesses using RAG can respond more quickly to market changes, provide better insights, and maintain stronger customer relationships. A consulting firm, for example, can use RAG to summarize industry reports across multiple fields and produce informed recommendations within minutes.

Overall, RAG helps organizations work smarter by combining the depth of company knowledge with the speed and understanding of modern AI.

## What are examples of RAG applications in business?

Here are some ways RAG can help businesses enhance performance and deliver value to their customers. 

![RAG applications in business.png](https://unable-actionable-car.media.strapiapp.com/RAG_applications_in_business_62f59ded4c.png)

### 1. Customer support

Customer support representatives can now confidently use AI systems to provide real-time answers. 

In the telecommunications industry, for example, a customer support representative can use RAG-powered chatbots to get prompt answers to billing-related questions and network issues. This improves the company’s response time while providing personalized answers to the customer.

### 2. Contract analysis

RAG can help review and interpret complex contracts. It retrieves relevant clauses, compares terms, and highlights potential risks in a contract. Law firms and large corporations use this system to speed up contract reviews. 

With RAG, reviewers cut through the noise and gain a bird's-eye view of what needs to be acted upon before approval. It reduces manual effort, prevents oversight, and ensures compliance with legal standards.

### 3. Enterprise search 

Businesses often struggle with data scattered across multiple platforms. RAG-based enterprise search tools help by retrieving the most relevant information from different systems and presenting it clearly and concisely. 

For example, employees at consulting firms can use RAG search to quickly find research materials for a project without having to dig through folders. 

### 4. Business intelligence 

RAG enhances business intelligence by integrating generative AI summaries with the latest company data. It can retrieve insights from dashboards, reports, and external market data, then generate clear summaries. With historical records, a RAG-powered AI can even perform predictive analysis and make forecasts. 

For instance, a retail business can use RAG to analyze seasonal sales and suggest strategies for better inventory planning. This use case enables executives to see the bigger picture and act proactively based on past events.

### 5. Financial reporting

Finance teams use RAG to automate report generation and ensure accuracy in their figures. RAG models extract data from accounting systems, invoices, transaction logs, and other sources for the reports. 

For example, investment firms can use RAG AI to produce timely reports for stakeholders. 

###  6. Audit assistants

Auditors can use RAG to retrieve various records and highlight anomalies, streamlining a tedious manual process. 

For example, internal audit teams in large corporations can use RAG tools to verify compliance with policies and identify unusual transactions. This saves time while ensuring no critical detail is overlooked.

### 7. Sales enablement 

Sales teams can use RAG to stay informed about customer needs and market trends. RAG can access information such as the latest industry trends, client interactions, competitor activities, or relevant internal limitations to suggest personalized pitches. 

This helps sales teams quickly identify customer pain points and close deals faster.

## Which industries benefit most from RAG?

Multiple industries are turning to RAG AI to boost efficiency. Below are examples:

* **Finance:** In the banking and investment sector, using RAG helps with faster financial reporting, fraud detection, and market analysis.
* **Law:** Legal firms use RAG tools to review contracts, locate precedents, and identify key points for their cases. It can save hours of manual research.
* **Healthcare:** Doctors and medical researchers use RAG-powered LLMs to quickly retrieve patient data or treatment guidelines. It allows them to cut through the noise and presents them with everything they need to make an accurate diagnosis.
* **Technology:** Technology companies use RAG to optimize their workflows. Many tech teams rely on [RAG tools](https://www.meilisearch.com/blog/rag-tools) to manage vast data sources, support product development, and enhance customer-facing AI tools.
* **Retail:** For retail businesses, RAG helps analyze sales data, track trends, and improve customer support with real-time insights.

## What is agentic RAG for business intelligence?

[Agentic RAG](https://www.meilisearch.com/blog/agentic-rag) gives the AI-powered system more autonomy to reason and make decisions using both internal and external data. 

![How Agentic RAG Works.png](https://unable-actionable-car.media.strapiapp.com/How_Agentic_RAG_Works_23208c3263.png)

Unlike standard RAG, which only retrieves and responds, agentic RAG can perform tasks. These tasks range from simple ones, such as automatically responding to customer inquiries, to more complex ones, such as analyzing sales data and generating reports independently. 

In terms of business intelligence, agentic RAG helps teams automate deeper analysis and generate insights with minimal human effort. 

### How does agentic RAG enhance business intelligence?

Agentic RAG enables smarter querying and automates complex analytical tasks, allowing AI systems to work more independently. 

Instead of returning textual results alone, agentic RAG can use APIs to perform tasks such as sending emails. This makes it scalable for both large companies and small business startups that need real-time insights. 

Agentic RAG enhances automation across business operations by combining intelligent reasoning with tangible actions.

## What are the common challenges when implementing RAG in business?

While RAG offers excellent value, adopting it in real-world business settings presents a few challenges that require careful planning and strategy:

* **Data privacy:** A significant concern that large businesses face is protecting sensitive information. They must ensure that customer records and internal knowledge stay secure, especially when using external knowledge sources. It is vital that they set clear access rules and use encryption to help maintain data integrity.
* **Integration:** Merging RAG with existing systems can be tricky. It requires aligning databases, APIs, and workflows so that the model retrieves relevant content efficiently. Regular testing and clear metrics help confirm that the integration works as it should.
* **Scalability:** As datasets grow, maintaining speed and accuracy can be difficult. It is advisable to use cloud solutions and augmentation processes to ensure the system stays fast and scalable.
* **Cost:** Setting up and maintaining RAG models can be expensive. Businesses can reduce costs by starting small (that is, focusing on a few key areas) and then scaling gradually as their performance improves.
* **Domain adaptation:** Every industry has its own language and data style. Without fine-tuning, RAG might misinterpret specific terms. Training with domain-specific examples and using AI agents for continuous learning can improve precision.

Now, let’s see the steps involved in implementing RAG for business.

## What are the steps to implement RAG for business?

Implementing RAG is best with a well-thought-out plan that ensures the system aligns with your business goals. Here are the key steps:

1. Start by defining what you want RAG to achieve for your business.
2. Bring together all your key data sources (documents, customer data, and external feeds) and ensure they are well organized and accessible.
3. Choose a reliable RAG tool that supports both data retrieval and language generation.
4. Fine-tune the model with your company’s own data so it understands your specific terms and context.
5. Establish clear rules for deployment, particularly regarding data privacy and system integration.
6. [Evaluate the RAG model's performance](https://www.meilisearch.com/blog/rag-evaluation) using straightforward, measurable metrics such as accuracy and response time.
7. Continue improving the system by updating your knowledge sources and refining outputs over time.

### What data sources should be integrated?

For RAG to deliver accurate, valuable results, it needs access to data sources that reflect your business's daily operations. Good sources include CRM systems, which store customer records and interaction histories, and support tickets, which capture real issues and solutions that can train chatbots to respond better. 

Knowledge bases and internal repositories, such as policy documents, manuals, or reports, also play a role in improving the quality of outputs. 

For example, using Meilisearch in a retail business can help index product details, reviews, and FAQs. This makes it easy for RAG to retrieve precise information during customer queries. 

The goal is to ensure that every response the system generates is supported by reliable data derived from actual business activities. Integrating these data sources builds a solid foundation for context-aware communication.

### How to choose a RAG platform

To choose the right RAG platform, you must first understand your business needs and long-term goals:

* A good platform should be scalable, meaning that it can handle more data and users as your company grows. 
* You want a system that integrates smoothly with your existing tools, such as CRMs, databases, or chat applications. 
* Look for platforms that offer strong technical support for your business workflows. 
* If your team is new to AI-driven systems, choose models that provide clear guidance throughout setup and maintenance. 
* Cost is another crucial factor; consider not only the up-front price but also ongoing expenses, such as storage or model updates. 

Whether you have a small startup or a large organization, the right platform should facilitate simple, adaptable implementation. Taking the time to assess these factors ensures your RAG solution delivers consistent performance and value over time.

### What are the best practices for RAG deployment?

To achieve the best results with a RAG system, establish a foundation that ensures clean, secure, and user-friendly data. Here are some practical steps to follow:

* Begin by cleaning the data to remove duplicates or any irrelevant content.
* Train users to create targeted user queries, ensuring they can interact effectively with generative models.
* Use embeddings that capture the proper context. The correct embedding enables the model to retrieve information that truly aligns with the user’s intent.
* Keep an eye on the AI system performance and monitoring. Track how well it handles different queries and identify where updates are required.
* Prioritize security by managing access to sensitive files and maintaining compliance with data protection policies.

[RAGs are different from other types of LLMs](https://www.meilisearch.com/blog/rag-types); let’s now explore these differences.

## How is RAG different from standalone LLMs in business?

The key difference between RAG and standalone language models is in how they handle information. 

A standalone LLM relies entirely on what it learned during training, which means its responses are limited to older data and may sometimes be inaccurate or out of context. 

RAG enhances reliability by retrieving current information from verified sources before generating a response. Its outputs are more trustworthy for business use. 

You will experience fewer errors and better alignment with real-time business operations using RAG.

## What are the latest trends in business RAG solutions?

Several new trends are shaping how businesses use [RAG techniques](https://www.meilisearch.com/blog/rag-techniques) to improve efficiency. Here are some of them:

* **Agentic RAG:** This trend grants RAG systems greater autonomy. They can now perform actions, run analyses, or summarize reports without waiting for human prompts. This automates business workflows, making them more responsive.
* **Multimodal data:** Modern RAG tools are learning to work with more than just text. They can now retrieve and understand images, audio, and videos. This allows companies to use more data types without being limited to textual data alone.
* **Real-time updates:** Businesses want to use AI systems that reflect live changes. Real-time information retrieval ensures that AI responses always include the latest news or company data.
* **Vertical-specific tools:** New RAG platforms are now designed to fit specific industries. These tailored RAG tools understand the domain-specific terms and data types used by businesses in particular sectors. 

## Bringing it all together: the future of RAG for business

RAG is shaping the next phase of business intelligence by connecting training data, logical reasoning, and real-time insight. It is better than the traditional language models because it grounds its answers in verified company information. 

From improving decision-making and customer support to powering automation, RAG is proving to be transformative. 

Retrieval-Augmented Generation (RAG) for business: Full guide

Typesense pricing: Is it worth it or consider Meilisearch? October 2025

**Typesense** has established itself as a powerful open-source search engine that gives developers exceptional control over their search implementation. With its flexible query-time configuration and resource-based pricing model, it offers an alternative to both Elasticsearch's complexity and Algolia's usage-based costs.

To create this **Typesense review**, I've analyzed the platform extensively. I believe it's the ideal choice if:

* You need flexible query-time configuration over your search parameters  
* You prefer resource-based pricing rather than per-document costs  
* You want detailed control over ranking and relevancy  
* You're comfortable with more initial configuration for greater flexibility  
* You need a self-hostable solution with strong API capabilities

However, Typesense might *not* be the best choice if:

* You want the simplest possible setup with minimal configuration  
* You prefer the flexibility of choosing between subscription tiers or resource-based pricing  
* You need to get a search implementation running in minutes  
* You're looking for more opinionated defaults that work great out-of-the-box  
* You want a gentler learning curve with extensive getting-started resources

In this case, you should consider **Meilisearch**: an open-source search engine that prioritizes simplicity and developer experience above all else, offering a smoother onboarding experience and faster time-to-production while maintaining excellent search performance.

*Because of that, I've included a detailed look at Meilisearch later in this Typesense review, as an alternative for teams seeking simplicity over configurability.* 

<Callout intent="tip">
If you're eager to explore a more streamlined approach to search, you can [start with Meilisearch's free trial here.](https://www.meilisearch.com/cloud)
</Callout>

## What is Typesense?

**Typesense** was [co-founded by Jason Bosco and Kishore Nallan](https://www.flagsmith.com/podcast/typesense), with the idea originating in 2015 as a nights-and-weekends project. 

![1 - What is Typesense.png](https://unable-actionable-car.media.strapiapp.com/1_What_is_Typesense_1457a5276e.png)

The founders were frustrated with Elasticsearch's complexity and wanted to democratize search by creating a lightweight, high-performance engine that would be intuitive to use out of the box.

The first open-source version launched in 2018, and by 2020, both founders had left their full-time jobs to focus on Typesense after a successful Hacker News post generated significant interest. The company has remained self-funded and revenue-funded, deliberately avoiding venture capital to maintain a sustainable approach.

[Built in C++ for maximum performance](https://github.com/typesense/typesense), Typesense typically delivers search results in under 50 milliseconds while handling typos automatically (enabled by default) and supporting configurable synonyms and complex filtering. The platform offers both keyword and vector search capabilities, making it suitable for traditional search as well as AI-powered semantic search applications.

Today, Typesense serves developers and businesses who need a powerful yet manageable alternative to Elasticsearch's operational overhead or Algolia's usage-based pricing. It's particularly valued by teams who want control over their search infrastructure without sacrificing performance or relevance.

## Typesense Pros & Cons

| Pros | Cons |
| :---- | :---- |
| ✅ [Query-time flexibility](https://typesense.org/docs/guide/ranking-and-relevance.html) for sorting and filtering | ❌ Steeper initial learning curve |
| ✅ [Resource-based pricing](https://cloud.typesense.org/) instead of per-record costs | ❌ No permanent free cloud tier |
| ✅ [Multi-node clustering](https://typesense.org/docs/guide/high-availability.html) with high availability | ❌ Requires more configuration for optimal results |
| ✅ Exceptional performance with C++ implementation | ❌ Documentation assumes technical proficiency |
| ✅ Strong API with extensive customization options | ❌ Enterprise pricing requires consultation |

## Typesense Review: How it Works & Key Features

### Query-Time Flexibility and Configuration

**Typesense's** standout feature is its ability to configure search parameters at query time rather than index creation. 

Unlike platforms that require separate indices for different sort orders or configurations, Typesense allows dynamic adjustment of fields to search, facet, and rank through API parameters.

This flexibility extends to sorting, where a single index can provide results sorted by price ascending, price descending, or relevance without creating duplicate indices. The platform calculates [facet counts using three strategies](https://typesense.org/docs/guide/faqs.html#faceting): exhaustive for exact counts on smaller sets, top\_values using reverse indexing for large sets, and automatic selection based on the query.

![2 - Query-Time Flexibility and Configuration.png](https://unable-actionable-car.media.strapiapp.com/2_Query_Time_Flexibility_and_Configuration_5d05eb3706.png)
Source: [*Typesense*](https://typesense.org/docs/guide/faqs.html#faceting)

Search-time parameter changes update automatically without re-indexing, significantly reducing operational overhead for certain configuration changes. However, schema modifications and structural changes still require recreating collections and re-indexing data.

### Search and Ranking Capabilities

The search functionality uses a [tie-breaking algorithm](https://typesense.org/docs/guide/ranking-and-relevance.html) with customizable ranking rules applied sequentially. Default rules include frequency of overlapping tokens, edit distance for typo tolerance, and custom field-based sorting. Documents with exact matches are prioritized, though this behavior can be disabled.

The system handles up to two typos for longer words by default, with configurable thresholds based on word length. [Synonyms can be one-way or multi-way](https://typesense.org/docs/27.0/api/synonyms.html), allowing terms like "blazer," "coat," and "jacket" to be treated as equivalent.

[Natural Language Search capabilities](https://typesense.org/docs/guide/natural-language-search.html) leverage large language models to analyze conversational queries into structured search parameters. When enabled, queries are sent to configured LLMs like OpenAI's GPT or Google's Gemini, which translate them into search terms, filters, and sorting instructions.

![3 - Search and Ranking Capabilities.png](https://unable-actionable-car.media.strapiapp.com/3_Search_and_Ranking_Capabilities_58d5e2535d.png)
Source: [*Typesense*](https://www.youtube.com/watch?v=xyXccgMqBow&t=1s)

### Data Management and Indexing

[Collections in **Typesense**](https://typesense.org/docs/26.0/api/collections.html) function like database tables, containing documents with defined schemas. The platform supports flexible schemas through auto-schema detection, allowing fields to be automatically detected and typed, though new documents are adjusted to match the inferred types.

Real-time indexing ensures new or updated documents become searchable immediately. The system uses [RocksDB for storage](https://deepwiki.com/typesense/typesense/5.2-schema-definition-and-field-management), creating multiple inverted indexes to optimize various search features. Text processing and tokenization handle segmentation and normalization automatically.

The platform provides [idempotent endpoints for document management](https://typesense.org/docs/26.0/api/documents.html). Adding a document with an existing primary key replaces the entire document, while partial updates modify only specified fields. Bulk operations through the import API significantly improve performance for large-scale data changes.

### API Architecture and Access Control

**Typesense's** [REST-ful API uses a comprehensive key-based security model](https://typesense.org/docs/guide/data-access-control.html). 

When protected by a master key, all routes except /health require authentication. The system automatically generates a Default Admin API key upon initialization.

[Scoped API keys](https://typesense.org/docs/28.0/api/api-keys.html) enable multi-tenancy by embedding search parameters within HMAC-digested tokens. These keys ensure users can only access their permitted data without the ability to override filters. The API supports fine-grained permissions controlling access per collection, per action, and even per field.

Integration options include [official client libraries](https://typesense.org/docs/guide/installing-a-client.html) for JavaScript, Python, PHP, and Ruby, plus community-maintained libraries for Go, Java, .NET, and other languages. The platform also provides UI components like the [InstantSearch.js adapter](https://typesense.org/docs/guide/migrating-from-algolia.html) for seamless migration from Algolia.

![4 - API Architecture and Access Control.png](https://unable-actionable-car.media.strapiapp.com/4_API_Architecture_and_Access_Control_e417aa1b85.png)
Source: [*Typesense*](https://www.youtube.com/watch?v=IoRS3gzV3JA)

## Where Typesense Falls Short

While Typesense excels at providing flexibility and control, several considerations become apparent for teams prioritizing simplicity and rapid deployment.

**Configuration Complexity:** The platform's strength in customization can become a challenge for simple use cases. Teams wanting basic search functionality must navigate extensive configuration options that may be unnecessary for their needs. The flexibility that allows query-time parameter adjustment requires understanding numerous settings and their interactions.

**Pricing Model Considerations:** While resource-based pricing offers advantages for certain workloads, it requires more calculation than fixed-tier models. The [pay-per-hour cluster pricing](https://cloud.typesense.org/pricing/calculator) (starting from around $7 per month for basic configurations) makes cost prediction dependent on understanding your resource requirements. Unlike platforms that offer both subscription and resource-based options, Typesense's single pricing approach may not suit all budget planning preferences.

**Documentation and Onboarding:** The platform assumes technical proficiency, with documentation targeting developers comfortable with distributed systems and search concepts. Teams without dedicated search expertise may need more time for initial setup, from determining appropriate memory allocation to configuring ranking rules effectively.

These considerations reflect Typesense's optimization for flexibility and control. For teams that value quick deployment, flexible pricing options, and minimal configuration, these constraints may influence their platform choice.

## Top Typesense Alternative for Simplicity: Meilisearch

**Meilisearch** takes a different approach to search by prioritizing developer experience and simplicity. 

![5 - Top Typesense Alternative for Simplicity.png](https://unable-actionable-car.media.strapiapp.com/5_Top_Typesense_Alternative_for_Simplicity_8619e9d308.png)

[Founded in 2018](https://techcrunch.com/2022/10/10/meilisearch-lands-15m-investment-to-grow-its-search-as-a-service-business/) by Quentin de Quelen, Clément Renault, and Thomas Payet, the platform emerged from frustration with existing search solutions that required extensive configuration to achieve basic functionality.

Where Typesense offers flexibility through configuration, Meilisearch provides excellence through carefully designed defaults that work well for most use cases.

### Zero-Configuration Excellence

**Meilisearch** operates on a ["plug-and-play" philosophy](https://www.meilisearch.com/) where search functionality is optimized from the start. The platform requires no initial configuration for typo tolerance, relevancy ranking, or search-as-you-type functionality. These features are enabled and optimized by default.

Setting up a search experience involves three steps: installing Meilisearch, adding documents, and performing searches. Document addition automatically triggers indexing with tokenization and normalization. The system immediately handles typos, with [one typo allowed for five-character words and two for nine-character words](https://www.meilisearch.com/docs/learn/relevancy/typo_tolerance_settings).

![6 - Zero-Configuration Excellence.png](https://unable-actionable-car.media.strapiapp.com/6_Zero_Configuration_Excellence_0303564d3e.png)
Source: [*Meilisearch*](https://www.meilisearch.com/docs/learn/relevancy/ranking_rules)

The [ranking rules apply automatically](https://www.meilisearch.com/docs/learn/relevancy/ranking_rules) in a reasonable order: matching word count, typo count, word proximity, attribute importance, custom sorting, and exactness. This default configuration delivers relevant results for most applications without adjustments.

### Transparent and Predictable Pricing

**Meilisearch** offers unique flexibility with both subscription-based and resource-based pricing models.

The subscription approach provides [clear pricing tiers](https://www.meilisearch.com/pricing) that make budgeting straightforward: the Build plan starts at $30 per month (including 50,000 searches and 100,000 documents), while the Pro plan at $300 per month includes 250,000 searches and 1,000,000 documents.

![meilisearch-pricing.png](https://unable-actionable-car.media.strapiapp.com/meilisearch_pricing_5986ddaecf.png)

For organizations preferring to pay for actual resource consumption, Meilisearch now offers resource-based pricing as an alternative. 

This dual pricing approach provides unmatched flexibility, allowing teams to choose the model that best fits their usage patterns and budget requirements. Whether you need the predictability of fixed tiers or the scalability of resource-based pricing, Meilisearch adapts to your needs.

[Overage charges are transparent](https://help.meilisearch.com/articles/5542905035-what-happens-if-i-exceed-my-plan-limits): $0.40 per 1,000 additional searches and $0.30 per 1,000 additional documents on the Build plan. This flexibility in pricing models allows teams to optimize costs based on their specific workload characteristics. A 14-day free trial lets teams evaluate the platform with actual workloads before committing.

The [open-source version](https://github.com/meilisearch/meilisearch) remains completely free for self-hosting under the MIT license, with core features available for most use cases (enterprise features like sharding require separate licensing).

### AI-Powered Search Made Simple

**Meilisearch** seamlessly integrates AI capabilities through [automated embedding generation.](https://www.meilisearch.com/docs/learn/ai_powered_search/getting_started_with_ai_search#generate-auto-embeddings) 

![8 - AI-Powered Search Made Simple.png](https://unable-actionable-car.media.strapiapp.com/8_AI_Powered_Search_Made_Simple_9a75c812fb.png)
Source: [*Meilisearch*](https://www.youtube.com/watch?v=0tPsBrmtf3o)

The platform connects directly with [OpenAI, Hugging Face, or any REST-based embedding provider](https://www.meilisearch.com/docs/reference/api/settings). Configuration involves simply providing API keys and selecting models.

Document templates enhance embedding quality by specifying which fields contribute to vector generation. For a movie database, templates like "A movie titled: " provide context for better semantic understanding. The [hybrid search parameter](https://www.meilisearch.com/docs/reference/api/search) allows fine-tuning the balance between keyword and semantic results through a simple ratio setting.

Vector storage, embedding generation, and hybrid ranking happen automatically once configured. Developers don't need to manage separate vector databases or coordinate multiple search systems.

### Developer-First Design Philosophy

Every aspect of **Meilisearch** reflects its commitment to developer experience. 

The RESTful API features clear, predictable endpoints with comprehensive documentation. [Official SDKs](https://meilisearch.dev/docs/learn/resources/sdks) for major languages include .NET, Dart, Go, Java, JavaScript, PHP, Python, Ruby, Rust, and Swift.

The [mini-dashboard](https://github.com/meilisearch/mini-dashboard) provides immediate visual feedback during development. [Search preview, analytics, and index management](https://updates.cloud.meilisearch.com/publications/new-integrated-search-preview-and-revamped-index-settings) are accessible through a clean interface. The platform provides descriptive error messages to aid debugging.

![9 - Developer-First Design Philosophy.png](https://unable-actionable-car.media.strapiapp.com/9_Developer_First_Design_Philosophy_2886d1d977.png)
Source: [*Meilisearch*](https://www.youtube.com/watch?v=Lgv8iTdWDQc)

Integration guides for popular frameworks like [Laravel](https://www.meilisearch.com/docs/guides/laravel_scout), Rails, and Strapi provide step-by-step implementation instructions. The platform's typo tolerance, filtering, and faceting work consistently across all SDKs, with server-side implementation ensuring uniform behavior.

## Typesense or Meilisearch: Comparison Summary

| Feature | Typesense | Meilisearch |
| :---- | :---- | :---- |
| **Setup Complexity** | ⭐⭐⭐⭐ Auto-schema detection available | ⭐⭐⭐⭐⭐ Works out-of-the-box |
| **Query Flexibility** | ⭐⭐⭐⭐⭐ Extensive query-time options | ⭐⭐⭐⭐ Good flexibility with simpler approach |
| **Pricing Flexibility** | ⭐⭐⭐ Resource-based only | ⭐⭐⭐⭐⭐ Both subscription and resource-based options |
| **Performance** | ⭐⭐⭐⭐⭐ Sub-50ms with C++ | ⭐⭐⭐⭐⭐ Sub-50ms with Rust |
| **AI/Vector Search** | ⭐⭐⭐⭐⭐ Auto-embedding generation | ⭐⭐⭐⭐⭐ Auto-embedding generation |
| **Documentation** | ⭐⭐⭐⭐ Comprehensive, technical | ⭐⭐⭐⭐⭐ Accessible, example-rich |
| **Default Relevancy** | ⭐⭐⭐⭐ Configurable defaults | ⭐⭐⭐⭐⭐ Optimized out-of-the-box |

## Final Verdict

The choice between Typesense and Meilisearch ultimately depends on your team's priorities and technical requirements.

**👉 Choose Typesense if** you value maximum control over your search implementation and need the flexibility to adjust configurations dynamically. 

It's ideal for teams with dedicated search expertise who want to fine-tune every aspect of their search experience. The resource-based pricing model and query-time flexibility make it more suitable for applications with complex, varying search requirements where the investment in configuration complexity pays dividends in customization capabilities.

[*Get started with Typesense here.*](https://typesense.org/)

**👉 Choose Meilisearch if** you want a great and quick search experience without extensive configuration. 

It's perfect for teams that need search to just work, with defaults that deliver excellent results immediately. The unique combination of subscription-based and resource-based pricing options provides unmatched flexibility, allowing you to choose the model that best fits your budget and usage patterns. The streamlined developer experience and automated AI features make it the pragmatic choice for most applications where time-to-market and simplicity are valued over infinite configurability.

[*Get started with Meilisearch here.*](https://www.meilisearch.com/)

Both platforms deliver exceptional search performance and can handle production workloads effectively. Your choice depends on whether you prefer investing time in configuration for maximum flexibility or leveraging intelligent defaults for rapid deployment, and whether you value having multiple pricing options to optimize costs for your specific use case.

Meilisearch latest news and company updates