Most developers spend weeks building retrieval systems from scratch, wrestling with vector databases and embedding models, only to discover their LLM still hallucinates answers.

The irony? While everyone talks about RAG as the solution to grounding AI responses in real data, the implementation complexity often defeats the purpose entirely.

[LlamaIndex](https://www.llamaindex.ai/) changes this equation by collapsing what used to be a month-long engineering project into a few dozen lines of code, without sacrificing the sophistication that makes retrieval-augmented generation actually work. Instead of building infrastructure, you can focus on what matters: turning your company's knowledge into intelligent, accurate responses that your users can trust.

## Understanding LlamaIndex and RAG for advanced search applications

LLMs are great at generating text, but they can make mistakes or use outdated info. RAG fixes this by connecting language models to up-to-date, relevant data.

### Introducing LlamaIndex: your toolkit for building RAG pipelines

If RAG is the strategy for smarter LLM applications, LlamaIndex is the toolkit that makes it happen. Building a [RAG system](https://www.meilisearch.com/blog/how-to-build-a-rag-pipepline) is like preparing a gourmet meal: you need quality ingredients (your data), the right tools (to process and understand that data), and a recipe (the workflow). LlamaIndex provides all of this.

Formerly GPT Index, LlamaIndex is an open-source framework that simplifies building RAG systems. It offers components that manage your data’s journey, from ingestion to indexing to integration with LLMs for answer generation.

### Core components of a LlamaIndex RAG system: from raw data to smart answers

![rag pipeline architecture diagram](https://unable-actionable-car.media.strapiapp.com/rag_pipeline_architecture_diagram_56e14cbdbd.avif)



Turning a raw document into a context-aware answer with LlamaIndex follows five clear stages:

- **Loading:** Bring your data into the system. LlamaIndex supports many document loaders, making it easy to import PDFs, text files, websites, APIs, and more.
- **Indexing:** Convert loaded documents into [vector embeddings](https://meilisearch.com/blog/what-are-vector-embeddings), numerical representations capturing the meaning of your text. This helps find relevant information even if queries use different words.
- **Storing:** Save your index and metadata to avoid reprocessing large datasets every time you start your application.
- **Querying:** When a user asks a question, LlamaIndex transforms the query into an embedding and searches the indexed data for the most relevant text chunks. It can also apply [advanced search strategies](https://meilisearch.com/blog/introducing-hybrid-search) to improve results.
- **Generation:** The retrieved context and user query go to an LLM, which crafts a human-like answer grounded in your specific data.

**This workflow ensures the LLM always accesses precise, relevant information.**

### Key benefits of using LlamaIndex for RAG development

Using LlamaIndex for RAG projects streamlines development. It simplifies complexity by abstracting data connection, transformation, and retrieval details. This lets developers build sophisticated RAG applications with less boilerplate code.

LlamaIndex’s modular design lets you swap components—embedding models, vector stores, or LLMs—to fit your needs and budget. This flexibility is crucial as AI technology evolves.

For tech leaders and developers, this means faster iteration, more reliable applications, and the ability to deliver intelligent, data-driven experiences.

## Building your foundational LlamaIndex RAG pipeline: a step-by-step guide

Let’s build a LlamaIndex RAG system that answers questions using your own documents. We’ll go step by step, from project setup to asking your first queries. This guide uses Meilisearch documentation files as an example, but you can apply these steps to any documents.

### Setting up your development environment for a LlamaIndex RAG project

Start by preparing a Node.js environment. Make sure you have **Node.js version 18 or higher (20+ recommended)**. Check your version with:

```bash
node -v
```

Create a new project directory and initialize it:

```bash
mkdir rag-tutorial
cd rag-tutorial
npm init -y
```

This creates a folder named `rag-tutorial`, moves you into it, and sets up a basic Node.js project.

Update your `package.json` to use modern JavaScript modules and TypeScript. It should include:

- `"type": "module"` for ES module syntax
- Scripts to run TypeScript files with `tsx`

Example:

```json
{
  "name": "rag-tutorial",
  "version": "1.0.0",
  "type": "module",
  "main": "rag-llamaindex.ts",
  "scripts": {
    "start": "tsx rag-llamaindex.ts",
    "interactive": "tsx interactive-rag.ts",
    "test-setup": "tsx test-setup.ts"
  }
}
```

Install the necessary npm packages:

```bash
npm install llamaindex @llamaindex/openai @llamaindex/readers dotenv tsx
```

<Callout intent="note">
	
	Starting with Node.js v23.6.0, developers can run TypeScript files directly without manual transpilation. This feature became default in v24.1.0.
	
	
</Callout>

Each package serves a purpose:

- `llamaindex`: Core LlamaIndex.TS library
- `@llamaindex/openai`: Connects to OpenAI models for text generation and embeddings
- `@llamaindex/readers`: Tools for reading data from various sources, including `SimpleDirectoryReader`
- `dotenv`: Loads environment variables from a `.env` file to keep API keys secure
- `tsx`: Runs TypeScript files directly in Node.js

Set up your OpenAI API key by creating a `.env` file in your project root:

```text
OPENAI_API_KEY=your_actual_openai_key_here
```

Replace the placeholder with your real key to keep credentials private.

Create folders for your data and index storage:

```bash
mkdir data storage
```

- `data` will hold your documents
- `storage` will save the processed index

Add a `tsconfig.json` file for TypeScript configuration:

```json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "node",
    "allowSyntheticDefaultImports": true,
    "esModuleInterop": true,
    "strict": true,
    "skipLibCheck": true
  }
}
```

With this setup, your environment is ready. Next, bring in your data.

### Ingesting and loading diverse data sources effectively with LlamaIndex

Now, feed your LlamaIndex RAG system some knowledge. For this tutorial, we use Markdown (`.mdx`) files from Meilisearch documentation, but you can use PDFs, web pages, or database entries.

Copy your `.mdx` files into the `data` directory. For example:

```bash
# Copy documentation files to data directory
# find ../documentation -name "*.mdx" -exec cp {} ./data/ ;
```

Ensure your `data/` folder contains the files you want to index.

Use `SimpleDirectoryReader` from `@llamaindex/readers/directory` to read these files. In your main TypeScript file (e.g., `rag-llamaindex.ts`), import and use it like this:

```typescript
import "dotenv/config";
import { SimpleDirectoryReader } from "@llamaindex/readers/directory";

const reader = new SimpleDirectoryReader();
const documents = await reader.loadData("./data");
console.log(`📄 Loaded ${documents.length} documents.`);
```

Each file becomes a `Document` object containing its content and metadata.

LlamaIndex supports many data formats. You can combine multiple sources into a single index to create a comprehensive knowledge base.

With your documents loaded, you’re ready to index them.

### Indexing data for optimal retrieval: creating your first LlamaIndex vector store

Make your documents searchable by meaning, not just keywords. Vector indexing organizes text using numerical vectors that capture semantic meaning.

Set it up like this:

```typescript
import { VectorStoreIndex, storageContextFromDefaults, Settings } from "llamaindex";
import { openai, OpenAIEmbedding } from "@llamaindex/openai";
```

- `VectorStoreIndex`: Manages the vector index
- `storageContextFromDefaults`: Handles where your index is saved
- `Settings`: Configures language and embedding models
- `openai` and `OpenAIEmbedding`: Set up OpenAI’s LLM and embedding models

Configure your models:

```typescript
Settings.llm = openai({ 
  model: "gpt-4o",
  temperature: 0.0,
  maxTokens: 1024
});

Settings.embedModel = new OpenAIEmbedding({
  model: "text-embedding-ada-002",
});
```

This setup ensures **factual, focused answers and efficient embeddings**.

Build your index with:

```typescript
console.log("🔄 Creating vector embeddings... (this may take a few minutes)");
const storageContext = await storageContextFromDefaults({ persistDir: './storage' });
const index = await VectorStoreIndex.fromDocuments(documents, { storageContext });
console.log("💾 Index built and saved to storage.");
```

This process:

- Splits documents into smaller chunks for better retrieval
- Converts each chunk into a vector using the embedding model
- Stores vectors and text chunks in the index
- Saves the index to the `./storage` directory for future use

Depending on your data size, this may take a few minutes. Once done, your system can answer questions.

<Callout intent="success">
Looking for the best search experience in town? Deliver lightning-fast search results that will keep your users engaged and boost your conversion rates.
[Explore Meilisearch Cloud](https://meilisearch.com/cloud)
</Callout>

### Implementing the query engine and generating responses with your basic LlamaIndex RAG

With your data indexed, ask questions and get intelligent answers. LlamaIndex’s query engine handles this smoothly.

Get your `VectorStoreIndex` and create a query engine:

```typescript
const queryEngine = index.asQueryEngine({ 
  similarityTopK: 5
});
```

The `similarityTopK` parameter controls how many relevant chunks the engine retrieves per query.

Ask a question like this:

```typescript
const question = "What is Meilisearch and what are its main features?";
const result = await queryEngine.query({ query: question });

console.log("📖 Answer:");
console.log(result.toString());
```

Behind the scenes:

- Your question converts into a vector
- The engine finds the most relevant document chunks
- These chunks form the context
- LlamaIndex builds a prompt including your question and context
- The LLM generates an answer grounded in your data
- The answer is returned and displayed

Here is an example of the final result against the Meilisearch documentation:

![untitled](https://unable-actionable-car.media.strapiapp.com/untitled_361dc96a33.gif)



This ensures **answers are accurate and based on your documents, not just the LLM’s pre-trained knowledge**.

Now you have a working LlamaIndex RAG pipeline. Next, let’s improve efficiency for repeated use.

### Persisting and efficiently reusing your LlamaIndex for subsequent RAG operations

LlamaIndex can persist the index, saving time and cost. Indexing involves chunking documents and making API calls for embeddings, which can be resource-intensive. You don’t want to repeat this every time you run your app.

Persistence uses `storageContext` and a `loadOrBuildIndex` function. When building the index:

```typescript
const storageContext = await storageContextFromDefaults({ persistDir: './storage' });
const index = await VectorStoreIndex.fromDocuments(documents, { storageContext });
```

This saves the index to `./storage`.

On later runs, try loading the saved index first:

```typescript
try {
  const storageContext = await storageContextFromDefaults({ persistDir: './storage' });
  const index = await VectorStoreIndex.init({ storageContext });
  console.log("✅ Loaded existing index from storage.");
} catch (error) {
  console.log("📚 Building new index from documentation files...");
  // ...build logic
}
```

If a saved index exists, it loads instantly—no need to reprocess documents or embeddings.

Benefits include:

- **Cost savings** by avoiding repeated embedding API calls
- **Time savings** since loading is faster than rebuilding
- **Efficiency** as heavy processing happens only once
- **Automatic management** with minimal effort

This persistence makes your LlamaIndex RAG system practical and efficient, ensuring your initial processing investment pays off over time.

With these steps, you’ve built a foundational LlamaIndex RAG pipeline: from setup and data ingestion to indexing, querying, and efficient reuse. This base is ready for further enhancements as your needs grow.

## Optimizing your LlamaIndex RAG for production-level performance and relevance

You’ve built your foundational LlamaIndex RAG pipeline. Now, refine every step—from data preparation to delivering insights—to maximize performance, relevance, and efficiency. This process requires understanding how all components work together to create a system that is not only smart but truly effective.

### Master advanced data chunking strategies for superior LlamaIndex RAG context

Think of your documents as vast libraries and chunks as the pages or paragraphs your LLM reads. Giving the LLM an entire book for one question is overwhelming, but a single, out-of-context sentence isn’t enough. **Chunking finds the “just right” snippet for effective understanding.**

#### Summary retrieval

Default chunking (around 512 tokens) is a good start, but production systems need more nuance. One effective method is **decoupling retrieval and synthesis chunks**:

- Embed concise summaries of each feature section for broad retrieval.
- When a query matches a summary, pull detailed, sentence-level chunks from that section for the LLM to synthesize the answer.

This approach is like using a table of contents to find the right chapter, then reading specific paragraphs within it.

#### Structured retrieval

**Structured retrieval** adds another layer. If your data has metadata—such as product categories, version numbers, or author tags—use it to narrow the search space before semantic search begins. For example, if a user asks about a feature in “version 3.0,” filter to only v3.0 documents. This pre-filtering makes vector search faster and more focused.

Also, use **dynamic chunk retrieval**. Different questions require different amounts of context:

- Simple factual queries may need only a few small chunks.
- Complex comparative questions benefit from more or larger chunks.

Adjusting the number and size of retrieved chunks based on query complexity ensures the LLM gets the optimal context, improving answers and reducing token usage.

### Enhance LlamaIndex RAG retrieval with reranking and hybrid search techniques

After retrieving candidate chunks using vector similarity (often controlled by `similarityTopK`), the process isn’t complete. Vector search finds semantically similar content, but “similar” doesn’t always mean “most relevant.”

[**Hybrid search**](https://www.meilisearch.com/blog/hybrid-search) **combines semantic search with keyword-based search**. For example, if a user looks for documentation on a specific API error code like “ERR_CONN_RESET_005,” pure vector search might find general connection error documents. A hybrid approach uses the exact error code as a keyword to pinpoint documents containing that string, then applies semantic similarity to understand context. This blend often yields more precise results, especially for queries with specific entities or codes.

Refining the initial set of retrieved chunks is also important. After fetching the top K chunks, you can rerank them based on:

- Direct keyword overlaps.
- Scores from a smaller, faster model assessing relevance to the question.

This ensures the LLM receives the best possible context.

“Multi-step searches” further improve retrieval. An initial query identifies a broad topic or document set, then a focused follow-up query (possibly generated by the LLM) dives deeper into that subset. This coarse-to-fine approach enhances final context quality.

### Select optimal embedding models and LLMs for your specific LlamaIndex RAG use case

Choosing the [right embedding model](https://meilisearch.com/blog/choosing-the-best-model-for-semantic-search) and LLM is like selecting the engine and transmission for a car—it affects performance, cost, and suitability. There is no universal best; it depends on your needs.

Experiment with different embedding models and dimensionality. The `text-embedding-ada-002` model from OpenAI balances performance and cost well.

However, if your data is specialized—such as legal or medical texts—a domain-specific fine-tuned model may perform better. Higher-dimensional embeddings capture more nuance but increase computational and storage costs, so balance is key.

For the generative LLM, `gpt-4o` offers a strong mix of cost and quality. For high-volume, low-latency chatbots, smaller, faster, and cheaper LLMs may be more suitable, even if they sacrifice some response nuance. For complex research or analysis, investing in a top-tier model can be worthwhile. Adjust settings like `temperature` (e.g., `0.0` for factual Q&A) and `maxTokens` to fine-tune behavior and control costs.

Consider an ecommerce example:

- Use a fast, affordable LLM for simple product questions.
- Use a more powerful model and higher `similarityTopK` for complex comparisons.

Conditional model selection optimizes both user experience and operational costs.

### Evaluate your LlamaIndex RAG pipeline with key metrics and benchmarking for success

After refining chunking, retrieval, and model selection, evaluate your system regularly to ensure it performs well.

Focus on these key areas:

- **Retrieval quality**: Are retrieved chunks relevant? Use human evaluation to review top K documents for sample queries and check if they are on-topic and informative.
- **Generation quality**: Are LLM answers accurate, coherent, and faithful to context? Avoid hallucinations. Human judgment is crucial early on.
- **End-to-end performance**: How fast does the system respond? Include embedding, retrieval, and generation time. Latency matters for user-facing apps.
- **Cost-effectiveness**: Track API calls for embeddings and generation. Check if optimizations like chunking or `similarityTopK` tuning reduce costs without hurting quality.

For example, a RAG system helping developers navigate a codebase might succeed if:

- Developers spend less time searching for information.
- Answers to technical questions are more accurate.
- Users provide positive feedback.
- Fewer follow-up questions go to human colleagues.

Benchmark against a “golden dataset” of human-verified question-answer pairs to measure progress. Tweaking components like embedding models, chunk size, or prompts should improve these benchmarks.

## Your next steps in the RAG revolution

Building a production-ready LlamaIndex RAG system transforms how your applications handle knowledge retrieval and generation. It makes it move beyond static responses to dynamic, context-aware interactions with your data.

The combination of LlamaIndex's streamlined development experience with robust production patterns creates a foundation that scales from prototype to enterprise deployment.



LlamaIndex RAG tutorial: step-by-step implementation

Here's a recap of everything that happened this month!

## 🔔 Reminder to upgrade

[![Release notes Meilisearch 1.15](https://unable-actionable-car.media.strapiapp.com/meilisearch_1_15_e1b23d5c0c.png)](https://www.meilisearch.com/blog/meilisearch-1-15)

Don't forget to upgrade to Meilisearch 1.15 to benefit from improved AI search with composite embedders and embedding cache. v1.15 is coming soon!

[Read the release notes](https://www.meilisearch.com/blog/meilisearch-1-15)

## 📰 In the news

### 🔍 Why traditional hybrid search falls short (and how we fixed it)

How Meilisearch's innovative scoring system revolutionizes hybrid search and delivers more relevant results than traditional rank fusion methods.

[Read the blog post](https://www.meilisearch.com/blog/fixing-hybrid-search)

### 🔍 What 1,000 Contributors Taught Me About Open-Source

Our Head of Engineering, Clémentine, reflects on the lessons she’s learned from leading an open-source project—and what it takes to foster a strong, engaged community.

[Read the blog post](https://blog.curqui.com/what-1000-contributors-taught-me-about-open-source)

### 🗄️ Get early access to our new resource-based pricing

Previously reserved for Enterprise plans, our resource-based model is finally open to all.

[Get early access](https://eu1.hubs.ly/H0lf50s0?utm_campaign=newsletter&utm_source=blog&utm_medium=june-25-updates)

### 🚀 Help us shape search personalisation — book a call!

We're exploring search personalization in Meilisearch and would love to hear about your needs and use case.

[Book a call](https://cal.com/team/meilisearch/search-personalization-discovery-call?utm_source=blog&utm_medium=june-25-updates)

## 🤗 Made with Meilisearch

One of our community members has built [Meilisearch extension for Magento 2](https://github.com/walkwizus/magento2-module-meilisearch)!

This integration lets you replace Magento's default search engine with Meilisearch, bringing lightning-fast and relevant search results to your online store.

They’re looking for feedback on the integration—give it a try and let them know what you think!

You can also check out the [live demo](https://demo-meilisearch.walkwizus.com/) to see it in action.

[![meili-magento2.png](https://unable-actionable-car.media.strapiapp.com/meili_magento2_e38319eba7.png)](https://github.com/walkwizus/magento2-module-meilisearch)

_We’re always looking to promote new projects from the community. Post yours in the [#built-with-meilisearch](https://dub.sh/meili-discord?utm_campaign=newsletter&utm_source=blog&utm_medium=june-25-updates) Discord channel!_

---

Receive this updates in your inbox by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=newsletter&utm_source=blog&utm_medium=june-25-updates). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_campaign=newsletter&utm_source=blog&utm_medium=june-25-updates) and participate in our [Product Discussions](https://github.com/orgs/meilisearch/discussions).

For anything else, join our developers community on [Discord](https://dub.sh/meili-discord?utm_campaign=newsletter&utm_source=blog&utm_medium=june-25-updates).

Meilisearch June updates

Here's a counterintuitive truth about modern AI development: the most sophisticated language models often perform worse than simpler alternatives when deployed in production.

Companies spend thousands of dollars fine-tuning state-of-the-art models, only to discover that a lightweight approach using RAG delivers better results at a fraction of the cost.

The fine-tuning vs RAG debate isn't just about technical preferences. It's about understanding when complexity becomes your enemy and when simplicity scales. Most teams make this choice based on outdated assumptions about what "better AI" actually means in real-world applications.

## Fine-tuning vs RAG: understanding the key differences

Deciding how to adapt a LLM involves choosing between fine-tuning, which builds deep expertise into the model, and Retrieval-Augmented Generation (RAG), which links the LLM to the latest relevant information. Both aim to enhance the LLM’s capabilities but use different approaches.

### What is retrieval-augmented generation?

Imagine a top student, not going back to class, but instead gaining access to an endless, well-organized library and a team of expert researchers. That’s the idea behind RAG.

Instead of embedding all knowledge within the model, RAG lets the LLM pull relevant information from external sources right before responding. These sources can include your company’s knowledge base, real-time news feeds, or large document collections.

![RAG workflow diagram explanation](https://unable-actionable-car.media.strapiapp.com/RAG_workflow_diagram_explanation_53f23eb06c.avif)

RAG works by:

- Breaking external data into manageable pieces and converting each into a numerical “embedding” that captures its meaning.
- Storing these [embeddings](https://meilisearch.com/blog/what-are-vector-embeddings) in a specialized [vector database](https://meilisearch.com/blog/what-is-a-vector-database) designed for fast searches.
- Turning the user’s query into an embedding.
- [Searching the database](https://www.meilisearch.com/blog/how-do-you-search-in-a-database-with-llm) to find the most relevant information.
- Including this retrieved data in the prompt given to the LLM, providing up-to-date, contextual knowledge.
- Having the LLM craft a response using both its built-in understanding and the freshly retrieved information.

<Callout intent="note">
	Keep in mind that RAG responses may take a bit longer to generate as the system needs time to search through external databases and retrieve relevant information before the LLM can craft its response. The exact delay depends on your RAG system's architecture and the size of your knowledge base.	
</Callout>

**RAG grounds responses in specific, current, and verifiable facts, reducing the risk of outdated or inaccurate answers.** It updates knowledge in real time without changing the model itself.

<Callout intent="note">
	Curious about implementing a RAG workflow in practice? Explore this step-by-step guide on [how to build a RAG pipeline](https://www.meilisearch.com/blog/how-to-build-a-rag-pipepline).	
</Callout>

### What is fine-tuning?

Take the same highly educated graduate. Fine-tuning sends him to a specialized training program. You take a pre-trained model and train it further on a smaller, carefully chosen dataset tailored to your field or task. This could include areas such as legal analysis, medical interpretation, or your company’s unique language.

The goal is not just to add facts, but to adjust the model’s internal workings so it becomes an expert in your area. This process involves providing targeted examples and tweaking its internal settings while preserving its broad knowledge. The result is a model that understands the subtle details of its specialty, often improving accuracy significantly.

It is especially powerful for **shaping the model’s output style, tone, and formatting rules**, enabling consistent answers. Fine-tuning also leads to low-latency inference: because curated knowledge is baked directly into the model, there’s no delay from pulling external data.

Additionally, fine-tuned models operate independently of external databases, **providing advantages in privacy, offline capability, and cost-effective serving at scale**. If you need your AI to “think and speak” like an expert, or to deliver high precision on repetitive, clearly defined tasks, fine-tuning delivers that lasting edge.

<Callout intent="note">	
	Looking for an easy way to start fine-tuning your own OpenAI models? Check out [OpenAI’s fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning) for straightforward, step-by-step instructions and best practices to optimize your models for your unique use case.
</Callout>

## Choosing the right approach: fine-tuning or RAG?

Deciding between fine-tuning and Retrieval-Augmented Generation (RAG) means selecting the best tool for your specific challenge. Each method has strengths that fit different scenarios. Consider these key factors to choose the best approach (or a combination) for your project and users.

![](https://unable-actionable-car.media.strapiapp.com/fine_tuning_versus_rag_50c84257a9.avif)

### Data freshness and update frequency

If your AI assistant discusses stable topics like historical events, fine-tuning on curated texts creates a consistent, knowledgeable expert. The information becomes part of the model.

For real-time tasks like stock market analysis or breaking news summaries, the data changes constantly. Fine-tuning would require frequent retraining, which is impractical. RAG excels here by connecting to dynamic external databases. It pulls the latest articles, market data, or updates as they happen. **RAG keeps information current without constant retraining, making it ideal for applications needing up-to-the-minute data.**

### Domain specificity and task complexity

Consider how specialized your AI must be. For a virtual legal aide needing deep contract law knowledge, fine-tuning is best. It helps the model absorb proprietary data, jargon, and reasoning patterns. This creates an expert that understands facts, style, tone, and domain rules.

**Fine-tuning suits tasks requiring high precision in stable, complex fields like medical text interpretation or compliance.**

RAG works well for broader domains or when expertise involves gathering information from many sources. For example, a customer support bot for a fast-changing SaaS product benefits from RAG. It accesses the latest FAQs, troubleshooting guides, and community discussions, providing relevant answers even for new issues.

**RAG focuses on finding the right information rather than becoming the ultimate expert.**

### Cost and resource considerations

Fine-tuning large models demands a significant upfront investment (a bunch of GPU computes time for each training). It also requires careful curation, cleaning, and annotation of high-quality, domain-specific datasets, which can slow progress. However, once fine-tuned, the model runs efficiently without relying on external retrieval.

RAG lowers the barrier to entry by starting with a pre-trained base model. The main costs involve building and maintaining retrieval infrastructure like vector databases and indexing pipelines. While it avoids frequent retraining, ongoing inference costs may be higher due to retrieval steps. Fine-tuned models risk becoming outdated as base LLMs improve, requiring further investment. **RAG offers flexibility and long-term efficiency in fast-changing environments.**

### Data governance and security implications

Data location and access matter, especially in regulated industries or with sensitive information.

Fine-tuning simplifies data governance and privacy. The entire process can stay within your infrastructure, embedding knowledge in the model. Once deployed, it can operate offline without external access. This helps comply with regulations like GDPR or HIPAA and gives tighter data control.

RAG interacts with external knowledge bases, which introduces privacy and security concerns. You must ensure retrieval doesn’t expose sensitive data and that external sources are secure and compliant. Using third-party APIs or databases subjects you to their security and data policies. **RAG requires robust retrieval pipelines and careful data residency and access controls to maintain security.**

### Performance, latency, and scalability

User experience depends on response speed and accuracy. Fine-tuned models deliver **faster responses** because answers come directly from internal knowledge. This low latency suits real-time applications like chatbots or instant translation. Fine-tuned models also offer high precision for trained tasks.

RAG adds a retrieval step before generating responses, which increases delay. Even with fast search engines, RAG responses can be 30-50% slower than fine-tuned models. This delay may be acceptable for detailed reports or research but can hinder real-time use. Scaling RAG requires managing both the LLM and retrieval system, including vector databases and indexing.

## Hybrid approaches: combining fine-tuning and RAG

**Combining fine-tuning and RAG creates a more powerful system** that leverages the strengths of both approaches.

Fine-tuning provides deep domain expertise and specialized language understanding, while RAG ensures access to current, relevant information. This hybrid approach delivers enhanced contextual understanding, improved accuracy, and more nuanced outputs. For example, a financial advisory bot can combine expert knowledge with real-time market data.

**Implementing hybrid systems requires careful design,** beyond simply adding RAG to a fine-tuned model. Emerging strategies include Domain-Adaptive Pre-training (DAP), Retrieval Augmented Fine-Tuning (RAFT), and Hybrid Instruction-Retrieval Fine-Tuning.

Real-world applications, such as Document Retrieval-Augmented Fine-Tuning (DRAFT) for compliance assessment, show promising results with 7% improved correctness over baseline models.

<Callout intent="note">
	Success depends on preventing fine-tuned models from over-relying on internal knowledge while ignoring retrieved information.
</Callout>

## Making the right choice for your AI strategy

The fine-tuning vs RAG decision ultimately comes down to understanding your specific use case, data requirements, and long-term goals.

While fine-tuning excels in static domains requiring deep expertise and consistent outputs, RAG shines when you need dynamic, up-to-date information with transparent sourcing.

Fine-tuning vs RAG: Choosing the right approach

Firebase is a BaaS (Backend as a Service) platform. One of its backend services is the Cloud Firestore, which allows you to perform full-text search using a third-party extension.

Firebase users can query document collections in Cloud Firestore with a set of functions available in SDKs for several programming languages, including Swift, Kotlin, Python, Java, PHP, Ruby, and more.

Cloud Firestore does not provide native indexing, so users must use third-party services for document indexing and performing AI-powered searches.

This tutorial will guide you through the steps to index documents from Cloud Firestore using the [Meilisearch extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch).

## 1. Deploy Meilisearch

You first need to have Meilisearch running on a cloud service. You can either self-host it or use [Meilisearch Cloud](https://www.meilisearch.com/cloud) for an easier setup.

![image5.png](https://unable-actionable-car.media.strapiapp.com/image5_15f2d9cbbd.png)

This step is required because Meilisearch will provide the indexation of Firebase documents and search capabilities. Meilisearch utilizes machine learning (ML) models to convert documents (JSON files) into vector embeddings, which are stored in a vector space for fast and real-time database retrieval.

To install Meilisearch locally, you can run the following cURL command:


```sh
# Install Meilisearch
curl -L https://install.meilisearch.com | sh
```


Then you need to run Meilisearch:


```sh
# Launch Meilisearch
./meilisearch --master-key="aSampleMasterKey"
```


Let’s now see how to create a Firebase project connected to Meilisearch using the [Meilisearch extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch).

## 2. Create a Firebase project

Note: You can skip this step if you already have a Firebase Project with a Firebase database containing your documents.

Once you have Meilisearch up and running, you can create a Firebase project, configure it, and add a Firestore database.

There are several ways to configure a project on Firebase. You can do it directly on the [Firebase Console](https://console.firebase.google.com/) or use the [API](https://firebase.google.com/docs/projects/api/workflow_set-up-and-manage-project).

![image23.png](https://unable-actionable-car.media.strapiapp.com/image23_2100dd9bbe.png)

On the console, your project’s page looks like this:

![image24.png](https://unable-actionable-car.media.strapiapp.com/image24_3e3f17f124.png)

On the left side, click ‘Build’ and choose ‘Firestore Database.’

![image3.png](https://unable-actionable-car.media.strapiapp.com/image3_1976cbbf78.png)

From there, you can start adding documents to your new database.

![image6.png](https://unable-actionable-car.media.strapiapp.com/image6_5297a42b83.png)

Now let’s see how to connect [firestore-meilisearch](https://github.com/meilisearch/firestore-meilisearch) to Cloud Firestore.

## 3. Install Meilisearch’s Firebase extension

If you look at the extensions in your Firestore Cloud page, you won’t find Meilisearch as a default. Therefore, you need to install it from the [Firebase Extensions Hub](https://extensions.dev/extensions/meilisearch/firestore-meilisearch).

![image14.png](https://unable-actionable-car.media.strapiapp.com/image14_579572e53f.png)

You need to activate the [Blaze pricing plan to add this and other extensions](https://firebase.google.com/pricing?authuser=0). You will be charged a small amount (typically around $0.01/month) for the Firebase resources required by this extension, even if it is not used.

![image17.png](https://unable-actionable-car.media.strapiapp.com/image17_27fac8457a.png)

If you don’t have a billing account, you can quickly create one in the [Google Cloud Console](https://cloud.google.com/billing/docs/how-to/manage-billing-account). Once done, you can activate the extension and set up a budget amount.

![image20.png](https://unable-actionable-car.media.strapiapp.com/image20_33bc9c5dec.png)

The billing account is successfully connected to the Blaze pricing plan with these steps.

![image4.png](https://unable-actionable-car.media.strapiapp.com/image4_70d7ece7bc.png)

The next step to activate the [firestore-meilisearch](https://github.com/meilisearch/firestore-meilisearch) extension is to review the APIs in your Firebase project. If you don’t have the required ones enabled, you’ll be asked to activate them.

![image11.png](https://unable-actionable-car.media.strapiapp.com/image11_60c2a351ea.png)

After enabling the APIs, you’ll be granted a service account. Finally, you’ll be asked to configure the extension, which includes setting a location, a collection path, the fields to index, and the Meilisearch index name, host, and key (optionally). 

In the following example, we created a collection for movies:

![image1.png](https://unable-actionable-car.media.strapiapp.com/image1_2882d97b25.png)

You’re now ready to install the extension, which takes between three and five minutes.

![image21.png](https://unable-actionable-car.media.strapiapp.com/image21_f8058db5af.png)

Once installed, you can test Meilisearch, but first, you need to check if you have a collection in your Firebase project with the same name as the one configured in the extension.

![image2.png](https://unable-actionable-car.media.strapiapp.com/image2_c13c720cbe.png)

If not, you can visit the [project’s dashboard](https://console.firebase.google.com/) and add your collection accordingly.

![image19.png](https://unable-actionable-car.media.strapiapp.com/image19_2925f03110.png)

This is the data we are using in our example:

title: The Hobbit: An Unexpected Journey

poster &lt;[https://image.tmdb.org/t/p/w500/yHA9Fc37VmpUA5UncTxxo3rTGVA.jpg](https://image.tmdb.org/t/p/w500/yHA9Fc37VmpUA5UncTxxo3rTGVA.jpg)>

overview: Bilbo Baggins, a hobbit enjoying his quiet life, is swept into an epic quest by Gandalf the Grey and thirteen dwarves who seek to reclaim their mountain home from Smaug, the dragon.

release_date: 1353888000

Once you have added this movie, you should be able to see it when accessing Meilisearch’s search preview:

![image7.png](https://unable-actionable-car.media.strapiapp.com/image7_db9ecdd0ae.png)

Well done! You have successfully installed the Meilisearch Firestore extension!

When you add, update, and delete documents from your Firestore collection, they will be mirrored in Meilisearch.


### Managing your extension

To access the overview panel of the extension, first click on the ‘Extensions’ tab on Firebase’s sidebar menu, then find the Meilisearch extension and click on ‘Manage.’ Finally, click on ‘Extension configuration’ and you can now change the collection, host, index, and so on.

![image13.png](https://unable-actionable-car.media.strapiapp.com/image13_7ac6468575.png)

Accessing your logs allows you to monitor your cloud functions and obtain different levels of information. You may access an extension’s logs via the ‘Extensions’ tab. Alternatively, you can also visit the ‘Functions’ tab and select ‘Logs,’ as indicated in the image below.

![image10.png](https://unable-actionable-car.media.strapiapp.com/image10_a35bee898c.png)

## 4. Set up a search interface

In the previous chapter, we successfully installed and configured the Meilisearch extension on Firestore. Now it’s time to query data using a simple search engine application. Here we will see how to create a search bar for your project using this [GitHub repository](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch).


### Populating your Firestore collection with data

The first step is to add more documents to our Firestore database. In our case, we will use this [collection of movies](https://www.meilisearch.com/movies.json). Refer to the Firebase documentation for more information on adding and managing [data](https://github.com/meilisearch/firestore-meilisearch).

Once you have finished adding content to your Firestore database, visit your Meilisearch search preview to check that Meilisearch has successfully indexed your documents.

![image12.png](https://unable-actionable-car.media.strapiapp.com/image12_92dfdaf356.png)

### Search in your document

Now let's create a great search experience. There are many ways to do this, but we’ll keep it simple this time and use [instant-meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch), our plugin for the instant-search JavaScript library.

Create an index.html file in your preferred development environment. This HTML page should contain a search bar and a box to contain the returned search results:


```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Meilisearch demo</title>
    <link rel="stylesheet" href="<https://cdn.jsdelivr.net/npm/instantsearch.css/themes/algolia-min.css>" />
</head>
<body>
    <div>
        <div id="searchbox"></div>
        <div id="hits"></div>
      </div>
  
      <script src="<https://cdn.jsdelivr.net/npm/@meilisearch/instant-meilisearch/dist/instant-meilisearch.umd.min.js>"></script>
      <script src="<https://cdn.jsdelivr.net/npm/instantsearch.js@4>"></script>
      <script>
          const searchClient = instantMeiliSearch(
              'your Meilisearch url',
              'your Meilisearch API key'
            )
            const search = instantsearch({
              indexName: 'movies',
              searchClient
            })

            search.addWidgets([
              instantsearch.widgets.searchBox({
                container: '#searchbox',
              }),
              instantsearch.widgets.hits({
                container: '#hits',
                templates: {
                  item: `
                    <div style="text-align:center;">
                      <div class="hit-name">
                        {{#helpers.highlight}}{ "attribute": "title" }{{/helpers.highlight}}
                      </div>
                      </br>
                      <div>
                        <img src="{{poster}}" width="200px" />
                      </div>
                    </div>
                  `,
                },
              }),
            ])

            search.start()
      </script>
</body>
</html>

```


Remember to replace the example’s configuration with your own dataset. This might include the indexName if you named your index something other than ‘movies,’ your instance’s URL, and your API authentication token.

If everything went well, you should be able to access your index.html file and start searching right away:

![image15.png](https://unable-actionable-car.media.strapiapp.com/image15_80c0be763b.png)

Congrats! You have added full-text search capability to your Cloud Firestore. Your Firebase collection and your Meilisearch index will automatically stay in sync as long as the firestore-meilisearch extension is installed.


## How is Firebase search used?

Firebase offers full-text search capabilities on indexed fields through third-party solutions. Common use cases include:


* **User profiles**: Filtering users by name or email.
* **Product catalogs**: Searching items by category or price.
* **Blog posts**: Finding articles by title or tags.
* **Geolocation**: Querying places using geo data.


### Does Firebase have vector search?

No. Firebase lacks a built-in [vector search](https://www.meilisearch.com/blog/introducing-vector-search) for semantic or AI-powered queries. However, the Meilisearch [extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch) enables vector search by indexing Firestore documents, allowing similarity-based searches.


### Does Firebase support full-text search?

No. Firebase only supports exact string matching. For features like typo-tolerance, synonyms, or ranked results, the Meilisearch [extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch) indexes Firestore data to deliver fast, flexible full-text search.


## Enable reliable search in your Firebase app with Meilisearch

Adding search to your Firebase app doesn’t have to be a complex process. In fact, you can give users fast, accurate results with the proper setup. 

The key is to start simple, scale smart, and use Meilisearch.

How to implement search in Firebase

How to build a RAG pipeline: А step-by-step guide

[In Meilisearch v1.6](https://www.meilisearch.com/blog/meilisearch-1-6), we revolutionized search by combining the precision of full-text search with the intelligence of AI. This hybrid approach isn't just another feature—it's a fundamental reimagining of how search should work. Today, we'll pull back the curtain on our implementation and show why Meilisearch's unique approach to hybrid search delivers superior results.

Join us as we explore the mechanics of hybrid search, examine conventional implementation methods, and reveal how Meilisearch's innovative solution raises the bar for search relevance.

## What is hybrid search?

Search is always about finding the documents that are the most relevant to a user’s query.

Hybrid search is about combining the results of two complementary approaches to search: full-text search and semantic search.

[Full-text search](https://www.meilisearch.com/blog/how-full-text-search-engines-work) analyzes the words that appear in a query in a lexical manner, excelling at correcting typos and completing incomplete queries. It is also fast, and its results are easy to understand in retrospect.

[Semantic search](https://www.meilisearch.com/blog/semantic-search) leverages Large Language Model (LLM) technology to understand the meaning of words in the query. It excels at finding documents that contain synonyms to the user’s query and other similar concepts.

Both search approaches build a list of relevant documents according to their respective methods. Hybrid search combines these lists to produce a final list of results.

The golden question is, how to combine them?

![Diagram containing two lists of documents as shapes (squares for full-text, diamonds or triangles for semantic), and an arrow with an interrogation mark that produces a new list of documents containing both kinds of shapes](https://unable-actionable-car.media.strapiapp.com/how_to_merge_55aea77e87.png)

## The traditional way of mixing results is flawed

The traditional method of mixing the results from both lists is called [_Reciprocal Rank Fusion_ (RRF)](https://medium.com/@devalshah1619/mathematical-intuition-behind-reciprocal-rank-fusion-rrf-explained-in-2-mins-002df0cc5e2a), because it considers the **rank** of the documents in each list of results, and uses that as a basis to compute the final list of results.

In this context, the rank of the document refers to its position in the list of results, indicating how close it appears to the top.

For example, in a list of 20 documents, the result ranked first can be attributed 20 points. RRF can then attribute points to documents in each of the lists, sum the points for each document, and reorder the documents accordingly. Here’s a [detailed explanation](https://learn.microsoft.com/en-us/azure/search/hybrid-search-ranking) about an implementation of RRF on Azure AI Search.

However, this method of mixing results is flawed, because to function properly, it assumes that documents from all the lists of results are of comparable relevance: that is, all the documents in all lists are “good documents” that we want to return.

![Keyword search. Pikachu uses "imprecise query". It's super effective!](https://unable-actionable-car.media.strapiapp.com/pikachu_hybrid_search_f4f9e6c29f.jpg)

But, like Pokémons, each search method is vulnerable to different types of search queries. Covering for the weakness of the other method is the whole point of mixing them!

So let’s say you’re using a query that is fine for semantic search, but gives underwhelming results for keyword search. Using RRF, you might get some variant of the following:

![Illustrated example of the downfall of rank fusion](https://unable-actionable-car.media.strapiapp.com/RFF_merge_789ff4e216.png)

Recursive rank fusion is like wasting fine chocolate by mixing it with spoiled milk!

To address this issue, we require additional information about the documents listed in our results.

## Ranking is not enough: Scoring documents

The main idea is that you can score _how_ relevant a document is from 0 (not relevant at all) to 1 ("perfect” match), independently of its rank in the list.

Naturally, documents closer to the top of the list are more relevant, but the first document might be anywhere between 0 and 1. Then, you compare the scores in both lists and rank the documents across both lists that way.

Fortunately, Meilisearch already scores documents for full-text search (for more details about this, refer to [our previous article about scoring](https://www.meilisearch.com/blog/from-ranking-to-scoring)), and semantic search natively ranks documents depending on how similar they are to the query (although the details are complicated).

So we have a score for both full-text search and semantic search, but can we compare them?

## Making the scores comparable

When you have two scores ranging from 0.0 to 1.0, it can be tempting to compare them, but for this to work, similarly relevant documents must be scored similarly with both methods.

One difficulty that arises when performing this comparison is that the models used in semantic search tend to use only a portion of the full vector space they could use, resulting in vectors that have a similarity of at least 0.5 even for texts that appear entirely dissimilar. Furthermore, even very similar texts might be capped in similarity around 0.7, which will cause them to rank lower than good full-text results.

Fortunately, Meilisearch provides the tools to solve that particular problem. Meilisearch allows you to perform an affine transformation to the scores of the semantic search, so that the scores can be offset by the observed mean similarity between vectors, and the results that are packed around that mean similarity can be spread more in the 0.0, 1.0 space. For more details, refer to [the documentation on the](https://www.meilisearch.com/docs/reference/api/settings#distribution) `distribution` [field](https://www.meilisearch.com/docs/reference/api/settings#distribution).

For models known to Meilisearch (such as OpenAI models), a suitable default distribution is already applied to configured embedders, so users don’t have to configure it themselves!

With this operation, our scores are comparable, and depending on the query, the method that produces the most relevant documents will be favored by the hybrid search

![Failing example, running with Meilisearch, yields better results](https://unable-actionable-car.media.strapiapp.com/meili_merge_9bb48a7b7d.png)

## What else goes into making hybrid search right?

Scoring documents is a decisive relevancy advantage of Meilisearch over the traditional approach based on Reciprocal Rank Fusion, but there are a lot more aspects involved in making hybrid search right:

- We developed our bespoke vector store, [arroy](https://github.com/meilisearch/arroy), to leverage our database backend (LMDB) and meet our performance target. Arroy supports Approximate Nearest Neighbor search, multiple distances, native document filters, and binary quantization. Arroy doesn’t block a reader while writing or a writer while reading, and allows for incremental updates.
- We kept flexibility in mind with the mantra of making easy things simple, and hard things possible: users that are new to hybrid search can quickly setup an embedder with our default provider and configuration, but users can also carefully optimize their embedding process with multiple supported provider (or even the ability to provide your own with [REST embedders](https://www.meilisearch.com/docs/learn/ai_powered_search/configure_rest_embedder) and [user-provided embeddings](https://www.meilisearch.com/docs/learn/ai_powered_search/search_with_user_provided_embeddings)) and [document templates](https://www.meilisearch.com/docs/learn/ai_powered_search/document_template_best_practices) to customize how documents are turned into text to embed.
- Best-in-class full-text search engine, seamlessly integrated with semantic search, with support for efficient and expressive [sorting and filtering](https://www.meilisearch.com/docs/learn/filtering_and_sorting/working_with_dates) of documents.

Search is foundational; it needs to be rock solid to reliably serve the needs of your application. Meilisearch’s hybrid search implementation scores documents to merge results while preserving their relevancy. Scores also power the [federated search](https://www.meilisearch.com/docs/learn/multi_search/multi_search_vs_federated_search#what-is-federated-search%3F), a generalized version of semantic search that unifies results from multiple lists of intermediate hits.

Our users use federated search to perform hybrid searches across multiple vector stores, frequently combining image and text search requests.

## Why Meilisearch's hybrid search stands apart

Meilisearch's innovative approach to hybrid search goes beyond simply combining full-text and semantic search results.

By implementing a sophisticated scoring system instead of traditional rank fusion, carefully calibrating score comparability, and building a robust technical foundation with arroy, we've created a hybrid search solution that consistently delivers more relevant results.

This thoughtful implementation ensures that the strengths of each search method are preserved while compensating for their weaknesses, setting a new standard for search relevance in modern applications.

Why traditional hybrid search falls short (and how we fixed it)

Imagine you're building a blog in Rails, and your users keep misspelling post titles in the search bar, only to find no results. Frustrating, right? 

What if your Rails app or website had a search feature that’s lightning-fast *and *smart enough to handle typos?

Meilisearch is your answer. It's a lightweight, typo-tolerant, and lightning-fast search engine that offers a seamless developer experience and out-of-the-box relevancy tuning.

You can make a search engine with Ruby on Rails in Meilisearch by:

1. Setting up Meilisearch and installing dependencies.
2. Configuring Meilisearch in the Rails app.
3. Defining a model and enabling Meilisearch indexing.
4. Populating and indexing data.
5. Implementing a backend and frontend.
6. Customizing settings.

A Ruby on Rails–powered search engine can be used for building e-commerce platforms, blogs, or searchable knowledge bases. Regardless of your use case, a search engine built with Ruby on Rails in Meilisearch comes with a slick search interface that’s both powerful and user-friendly.

## 1. Set up Meilisearch and install dependencies

First, we need to get Meilisearch up and running and integrate it with our Rails app. This will lay the foundation for your search engine.

Meilisearch is open source and free if you choose to [host it locally](https://www.meilisearch.com/docs/learn/self_hosted/getting_started_with_self_hosted_meilisearch). Or, you can choose Meilisearch Cloud for a fully managed hosting experience, with no need to handle infrastructure or updates yourself. 

For this tutorial, we’ll use a local instance, which is perfect for testing. You’ll need Ruby 3.0+ and Rails 6.1+ to ensure compatibility. Older versions may still allow it to function, but they are not officially supported.

The `meilisearch-rails` gem simplifies the integration, handling indexing and syncing with your database. Let’s install Meilisearch and add the gem to your project.

To install Meilisearch locally, follow the instructions in the official [Meilisearch documentation on GitHub](https://github.com/meilisearch/meilisearch-rails). You can download the binary and run it with a simple command. Once running, Meilisearch is accessible at [http://127.0.0.1:3000](http://127.0.0.1:3000).

Open your `Gemfile `and, with `gem` in the command line, add:


```ruby
gem install meilisearch-rails

source 'https://rubygems.org'

gem 'meilisearch-rails'
```


Run `bundle install` to install the gem. If you hit any issues, double-check your Ruby and Rails versions, as the gem requires recent versions for full compatibility.

With Meilisearch and the gem installed, we’re ready to configure our Rails app to connect to it.


## 2. Configure Meilisearch in your Rails app

Now, let’s configure our Rails app to connect to Meilisearch. Think of this step as setting the coordinates that guide your app to the search engine.

Create a new configuration file to specify the `MEILISEARCH_HOST `and `MEILISEARCH_API_KEY`. This ensures smooth and secure communication between your app and Meilisearch. 

In development, you can skip the API key, but in production, it’s essential for maximum security. Proper configuration, such as what we’re doing now, prevents connection errors and ensures smooth indexing and searching.

Create a new file at `config/initializers/meilisearch.rb`:


```ruby
Meilisearch::Rails.configuration = {
  meilisearch_url: ENV.fetch('MEILISEARCH_HOST', 'http://localhost:7700'),
  meilisearch_api_key: ENV.fetch('MEILISEARCH_API_KEY', 'YourMeilisearchAPIKey')
}
```


If you’re using Meilisearch Cloud, replace the URL with your cloud instance’s address, which is available after signing up for Meilisearch Cloud. For local development, the default URL works fine. If you encounter connection issues, ensure Meilisearch is running and the URL is correct.

Now that our app knows where to find Meilisearch, let’s set up a model to index data.


## 3. Define a model and enable Meilisearch indexing

This step is where the magic starts: we’ll make our data searchable by indexing it with Meilisearch. Indexing means cataloging your information and data so Meilisearch can quickly find matches during user searches.

For this example, we’ll use the hypothetical Rails model `Article` and include the `MeiliSearch::Rails` module to enable automatic indexing. You’ll decide which attributes to index, like `title `and `body`, and configure how they’re used in searches. Meilisearch syncs with your database via `ActiveRecord `callbacks, so you don’t have to worry about updating it manually.

First, generate a model if you don’t have one:


```ruby
rails generate model Article title:string body:text category:string
rails db:migrate
```


Then, open `app/models/article.rb` and add:


```ruby
class Article < ApplicationRecord
  include MeiliSearch::Rails

  meilisearch do
    attribute :title, :body, :category
    searchable_attributes [:title, :body]
    filterable_attributes [:category]
    sortable_attributes [:created_at]
  end
end
```


Here’s what’s happening:

* `attribute` lists the fields requiring indexing.
* `searchable_attributes` are fields users can search.
* `filterable_attributes` allow filtering of the results, e.g., by category.
* `sortable_attributes `enable sorting, e.g., by creation date.

Here, choosing the right attributes is crucial. For example, indexing `title` and `body` makes sense for a blog, but you might want to add `tags` or `author` depending on your use case. Choose only the most relevant fields to index for better performance and faster search results.

With our model ready, let’s add some data to the index.


## 4. Populate and index sample data

To test our search engine, we need data to search through. For this purpose, we will populate our database with sample articles.

Using a seed file, we’ll create sample records that Meilisearch will automatically index. This will let you see how Meilisearch handles real data and prepare you for testing search queries. Meilisearch’s efficiency really shines here, as it can index thousands of records at lightning speeds.

To start, create or update `db/seeds.rb` with the articles you want searched:


```ruby
# Clear existing articles — use only in development or testing!
Article.destroy_all
articles = [
  { title: "Ruby on Rails Basics", body: "Learn the fundamentals of Rails.", category: "Beginner" },
  { title: "Advanced Rails Techniques", body: "Dive into complex Rails features.", category: "Advanced" },
  { title: "Rails Performance Tips", body: "Optimize your Rails app.", category: "Performance" },
  { title: "Building APIs with Rails", body: "Create robust APIs in Rails.", category: "API" },
  { title: "Rails Security Best Practices", body: "Secure your Rails application.", category: "Security" }
]
articles.each { |article| Article.create!(article) }
puts "Articles seeded!"
```


Then, run:


```ruby
rails db:seed
```


Meilisearch will index these records automatically using the aforementioned `ActiveRecord `callbacks. To verify, you can use Meilisearch’s API or dashboard to check the `articles `index. If (correct) data isn’t appearing, ensure your Meilisearch instance is running and the configuration is correct.

Now, things get even more interesting — it’s time to implement the search functionality.


<Callout intent="tip">
Ready to try it out? See Meilisearch’s search capability in full force in a [free trial](https://www.meilisearch.com/cloud)!
</Callout>


## 5. Implement backend search functionality

First, we’ll create a controller to handle search queries and display accurate results.

This step sets up a `SearchController `to process user input and fetch results from Meilisearch. The `meilisearch-rails` gem makes this easy by providing a `search `method that returns `ActiveRecord `objects, so you can treat results like regular model instances. Additionally, Meilisearch’s typo tolerance ensures users get relevant results even with misspellings.

Create `app/controllers/search_controller.rb`:


```ruby
class SearchController < ApplicationController
  def index
    @query = params[:q]
    @results = Article.search(@query) if @query.present?
  end
end
```


Update your routes in `config/routes.rb`:


```ruby
Rails.application.routes.draw do
  get 'search', to: 'search#index'
end
```


Create a view at `app/views/search/index.html.erb`:


```erb
<h1>Search Articles</h1>
<%= form_with url: search_path, method: :get, local: true do %>
  <%= text_field_tag :q, params[:q], placeholder: "Search articles..." %>
  <%= submit_tag "Search" %>
<% end %>

<% if @results %>
  <h2>Results for "<%= @query %>"</h2>
  <ul>
    <% @results.each do |result| %>
      <li><strong><%= result.title %></strong>: <%= result.body %></li>
    <% end %>
  </ul>
<% end %>
```


Visit [http://localhost:3000/search](http://localhost:3000/search) and try queries like ‘Ralis’ (a typo for ‘Rails’). Meilisearch’s typo tolerance will still return relevant results, as expected. If results aren’t appearing at all, or they seem to be incorrect, check your model’s indexing settings or Meilisearch logs.

Now, let’s take it up a notch with a frontend search interface through our [JavaScript API Client](https://github.com/meilisearch/meilisearch-js/) or [Instant Meilisearch plugin](https://github.com/meilisearch/instant-meilisearch).


## 6. Add a frontend search with instant Meilisearch

For a search-as-you-type experience, we’ll integrate Meilisearch’s simple frontend interface using `instant-meilisearch`.

This step enables dynamic, instant search functionality in your app, giving users an interactive experience as they type. Meilisearch’s impressive response speed — with response times ≤50ms — ensures results appear almost instantly. We’ll use a simple JavaScript setup, but you can extend it with [frameworks like React](https://www.meilisearch.com/with/react) for a polished UI.

Install the library via `npm `(or `yarn`). Note: this assumes your Rails app is already set up with a JavaScript bundler such as Webpacker or Importmaps.


```
npm install @meilisearch/instant-meilisearch
```


Create `app/javascript/search.js`:


```js
import { instantMeiliSearch } from '@meilisearch/instant-meilisearch';

const searchClient = instantMeiliSearch(
  '',// URL of Meilisearch instance
  '' // Meilisearch API key
);

const search = async (query) => {
  const response = await searchClient.search([{
    indexName: 'articles',
    query
  }]);
  const resultsDiv = document.getElementById('results');
  resultsDiv.innerHTML = response.hits.map(hit => `<div>${hit.title}: ${hit.body}</div>`).join('');
};

document.getElementById('search-input').addEventListener('input', (e) => {
  search(e.target.value);
});
```


Update `app/views/search/index.html.erb`:


```erb
<h1>Search Articles</h1>
<input type="text" id="search-input" placeholder="Search articles...">
<div id="results"></div>
```


As before, test the search at [http://localhost:3000/search](http://localhost:3000/search). Typing ‘Rail’ should show results instantly.

Next, let’s explore our customization options.


## 7. Customize Meilisearch settings

To make your search engine even better, you can tweak Meilisearch’s settings to fit your product’s needs.

Meilisearch allows you to customize ranking rules, synonyms, and stop words to improve search relevance. For example, you might want ‘Rails’ and ‘Ruby on Rails’ to be treated as synonyms, or prioritize results based on recency.

For instance, here is how to adjust ranking rules to prioritize certain fields:


```ruby
Article.meilisearch_index.update_settings({
  rankingRules: [
    "words",
    "typo",
    "proximity",
    "attribute",
    "sort",
    "exactness",
    "created_at:desc"
  ]
})
```


These settings ensure newer articles rank higher. Feel free to play around and test different configurations to see what works best for your users.

Finally, let’s ensure your search index stays in sync with your database for the most accurate results.


## 8. Handle updates and deletions

The `meilisearch-rails` gem automatically handles indexing when you create or update records. However, it’s still worth understanding how to manage updates and deletions yourself, especially if you’re building more complex web applications. This will ensure your search results always reflect the latest data and avoid stale or missing entries.

To manually delete a record from your index:


```ruby
article = Article.find(1)
article.remove_from_index!
Article.destroy! # Removes from Meilisearch index
```


If you need to reindex all records, for example, after changing any indexed attributes, run:


```
Article.reindex!
```


To clear your index entirely, use:


```
Article.clear_index!
```


Be cautious with reindexing large datasets, however, as it can be resource-intensive. In production environments, you can schedule such tasks during low-traffic periods.


## Can I make a search engine with Ruby on Rails for free?

Yes, you can build a search engine with Ruby on Rails and Meilisearch at no cost for development and small-scale production.

Meilisearch’s open-source version is free to self-host on your own servers or local machine, and the `meilisearch-rails` gem has no licensing fees. For development, this is ideal, as you only need a server to run Meilisearch. 

For production, however, hosting costs depend on your infrastructure. Small apps can run on affordable servers, while the costs may skyrocket for larger projects.

Meilisearch Cloud offers a 14-day free trial without requiring a credit card, making it perfect for testing. Post-trial, pricing scales with usage (documents and search requests), starting with the Build plan for small businesses at $30/month.

Let’s compare Meilisearch to other open-source search engines.

## What are the best open-source search engines for Ruby on Rails?

Open-source search engines provide powerful, license-free solutions for adding search to Rails apps. Here are the top options:

* **Meilisearch**: Known for its speed (under 50ms) and simplicity, Meilisearch integrates seamlessly with Rails via the `meilisearch-rails` gem. It’s ideal for small to medium apps, offering [typo-tolerance](https://www.meilisearch.com/blog/typo-tolerance) and search-as-you-type features. Its lightweight nature makes it easy to set up and maintain yourself, while also providing a hosted option for a maintenance-free experience.
* **Elasticsearch**: A robust engine, Elasticsearch excels in handling large datasets and complex queries. Gems like Searchkick simplify integration. It’s perfect for enterprise apps but requires more resources and setup than Meilisearch.
* **Solr**: Solr offers advanced functionalities like full-text search and faceting. The Sunspot gem provides Rails integration. It’s highly configurable, which can get complex for smaller projects.
* **Typesense**: A lightweight alternative for creating search engines for Ruby on Rails, Typesense offers fast, typo-tolerant search. While it lacks a dedicated Rails gem, its API is easy to use for simple setups.

Now, let’s look at other languages for building search engines.


## What programming languages besides Ruby are used to build search engines?

Aside from Ruby, several programming languages are well-suited for building search engines, each with its unique strengths. Some common languages you can use to build search engines are:


* **JavaScript**: Using Node.js, you can build server-side search with libraries like Lunr or integrations with Meilisearch. JavaScript’s asynchronous nature is great for real-time search. Learn how to [build a search engine in JavaScript](https://www.meilisearch.com/blog/javascript-search-engine).
* **PHP**:Frameworks like Laravel use Scout to integrate with Meilisearch, making PHP a solid choice for web apps that include search engines. Learn how to [build a search engine in PHP](https://www.meilisearch.com/blog/php-search-engine).
* **Golang**: Golang’s performance and concurrency make it ideal for high-speed search engines. Libraries like Bleve support full-text search, further increasing its applicability. Learn how to [build a search engine with Golang](https://www.meilisearch.com/blog/golang-search-engine).

## Creating a search engine in Ruby on Rails made simple

Building a search engine with Ruby on Rails and Meilisearch is easier than you’d think. Set up Meilisearch, index data, add a backend and frontend, and customize the settings to your heart’s content. Meilisearch’s speed, typo-tolerance, and seamless Rails integration make it a top choice for developers looking for fast search engine configuration.

Full tutorial on how to design a search engine with Ruby on Rails

If you want to build a fast and reliable search engine, the simplest answer is Golang and Meilisearch Go SDK. Combine these, and not only can you index your content as it should be, but you can also search queries within milliseconds and keep everything lightweight as ever.

In this guide, you’ll learn how to:

* Set up Go and connect it to Meilisearch
* Index structured data using JSON
* Build a clean API for real-time search

We’re going to share a method that is simple, fast, and works at scale flawlessly. This guide will help you avoid all the heavy frameworks and large teams that only slow you down. So, if you’re ready to build a lightweight search in Golang, let’s begin.

## 1. Set up your Golang development environment

First, you must prepare your Go environment and install the Meilisearch Go SDK. This is the primary prerequisite for building your search engine. It’s crucial because it enables your system to actually run Go code and communicate with your Meilisearch instance. 

Start by initializing your Go module:


```
go mod init search-engine
```


Then, install the Meilisearch SDK:


```
go get github.com/meilisearch/meilisearch-go
```


Again, we must confirm that Go is installed and Meilisearch runs locally or in the cloud. Then can use this setup to [index data](https://www.meilisearch.com/blog/introducing-indexer-2024) and handle queries for API creation. 

Once your environment is ready, you can connect to Meilisearch and start building.


## 2. Connect to a search engine database

Before all the indexing and searching, your Golang project must connect to a Meilisearch instance.

Meilisearch is an open-source, lightning-fast search engine that supports real-time search. It is also capable of [typo tolerance](https://www.meilisearch.com/blog/typo-tolerance) and full-text indexing, making your search even more potent. It’s time to connect the Meilisearch Go SDK to your database and perform search operations. 

Here’s how to initialize the client in Go:


```go
package main

import (
  "github.com/meilisearch/meilisearch-go"
)

func main() {
  client := meilisearch.NewClient(meilisearch.ClientConfig{
    Host: "http://127.0.0.1:7700",
    APIKey: "masterKey",
  })

  // Use `client` to index documents and run search queries
}
```


Remember, if you’re using the hosted version, you must replace the host URL with the respective Meilisearch Cloud address. 

Once connected, your Go application can add documents, create indexes, and run lightning-fast search queries with Meilisearch’s JSON-based API.


## 3. Create your document indexing logic

Is your Go app connected to Meilisearch already? Next up is indexing your data. Since Meilisearch works using JSON docs, you must define your content in structs before pushing it to the search engine. This enables [full-text search](https://www.meilisearch.com/blog/how-full-text-search-engines-work), filters, and fast retrieval.

Here’s how to index documents in Go:


```go
type Movie struct {
  ID     int    `json:"id"`
  Title  string `json:"title"`
  Genre  string `json:"genre"`
}

movies := []Movie{
  {ID: 1, Title: "Inception", Genre: "Sci-Fi"},
  {ID: 2, Title: "The Matrix", Genre: "Action"},
}

res, err := client.Index("movies").AddDocuments(movies)
if err != nil {
  log.Fatal(err)
}
```


Each document becomes searchable immediately after it is indexed. You can create multiple indexes like “products,” “posts,” or “users,” depending on your project. Document indexing is the backbone of your [Golang search engine](https://www.meilisearch.com/blog/golang-search-engine#{step-name}). This is the reason why Meilisearch can parse and retrieve results in milliseconds.


## 4. Build the search API and frontend

The connection is set, and the documents have been indexed. It is time to build the search functionality into your Golang application. The aim is to create an API endpoint that takes the search query to Meilisearch and returns the desired results. This is where features such as full-text search, typo tolerance, and filtering truly matter.

Here’s a simple search handler in Go:

```go
http.HandleFunc("/search", func(w http.ResponseWriter, r *http.Request) {
  query := r.URL.Query().Get("q")
  searchRes, err := client.Index("movies").Search(query, &meilisearch.SearchRequest{})
  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }
  json.NewEncoder(w).Encode(searchRes.Hits)
})
```


Another good news is that this endpoint can be integrated with various frontend frameworks, such as React, Vue, plain HTML, and JavaScript. The accuracy and speed of all search results depend on the Meilisearch Go SDK.


## 5. Test and refine your Golang search engine

With your Golang search engine running, it's time to test real queries and improve your results, using all the capabilities we have covered so far. 

The next step is to search queries using partial matches, typos, and filters. Track how Meilisearch ranks and returns results. Measure speed. Review how your backend handles load. If using the Meilisearch Go SDK, confirm that your API responds in milliseconds and parses JSON documents accurately.

Want deeper insights? If you're using [Meilisearch Cloud](https://www.meilisearch.com/cloud), check the built-in analytics:

* Track top search terms
* Monitor failed searches
* Analyze performance by endpoint

Refine your transformer logic, tweak `rankingRules`, adjust typo tolerance, or set filters like `filterableAttributes`.


## What are some examples of Golang search engine uses?

If your goal is to build a fast search engine that’s equally responsive and lightweight, Golang is ideal. It provides a bonus set of features, including typo tolerance, ranking rules, and filterable results, when combined with the Meilisearch Go SDK.

Let’s look at some of the most frequent and efficient [use cases for search engines](https://www.meilisearch.com/blog/golang-search-engine#examples) in Go.

* **App search:** This is one of the most prominent uses of a Go search engine. Startups using lightweight applications with custom algorithms and text analysis often opt for this. Plus, they get a responsive UI and can use tokenization to handle dynamic query input in literal milliseconds.
* **Site search for blogs and documentation:** You can use Golang with Meilisearch to build fast, Boolean-enabled search features that support conjunction and disjunction queries. It can crawl and index Markdown or JSON content from static site generators like Gatsby or Hugo.
* **eCommerce product search:** When customers visit your e-commerce store, they don’t have the time for time-consuming or inaccurate search results. You will lose that customer instantly. \
To avoid such situations, developers use Golang with Meilisearch to create smart search functionality that retains customers through filters such as price, tags, category, and in-stock items.
* **Internal tool search:** It is also used in internal systems for teams. For instance, a team handling tools without a dedicated search system will frustrate members because they cannot find the tool they seek. \
On the other hand, if you use Go and Meilisearch, you can build an instant search system with quick and accurate response times. It utilizes the principles of tokenization and exact matching to return search results from your dashboards, CRMs, and inventory tools.
* **Knowledge base and help desk search:** When someone needs help, they don’t want to dig through articles. Meilisearch resolves this by giving them instant search results through Boolean logic and tokenization. Add Golang on top of this, and you can tie all of this together rather nicely. 
* **Regulated industry search (legal, healthcare, finance):** Private records are private for a reason. They are only available to a certain number of people. And these people expect to find these private records instantly. For instance, large datasets like legal contracts or medical files must be indexed properly so the search engine can bring them up quickly. 

Search engines built with Golang and Meilisearch are better than those without them, especially regarding performance, relevance, and customization. 


## Which languages besides Go are used to build a search engine?

We’ve learned how great Go is, and how it gets even better when paired with Meilisearch. Well, it’s not your only option. Various other programming languages can also help you develop real-time search features that might get the job done. Let’s look at some below:


* You can [build a search engine in JavaScript](https://www.meilisearch.com/blog/javascript-search-engine) if you're working with interactive frontend frameworks like React or Vue. JavaScript is perfect for browser-based apps that need fast, client-side search.
* Developers who want to work with data-heavy applications often [build search engines using Python](https://www.meilisearch.com/blog/python-search-egine). It’s a flexible backend language that works well for indexing large datasets and performing complex queries.
* For server-rendered applications and CMS platforms, you can [build a search engine with PHP](https://www.meilisearch.com/blog/php-search-engine). It’s ideal for adding search to WordPress, Laravel, or custom e-commerce backends.

Whichever you choose, Meilisearch offers SDKs and documentation to help you integrate search fast.


## Can I build a search engine in Golang for free?

You can build a full-featured search engine in Golang for free using open-source tools like [Meilisearch](https://github.com/meilisearch/meilisearch-go). Golang and Meilisearch are free to use and offer powerful capabilities out of the box—no licensing fees or paid tiers to get started.

You can run Meilisearch locally or host it on your own infrastructure without paying anything. Even if you scale later, it remains cost-effective with minimal setup and maintenance. The Meilisearch Go SDK handles everything from indexing to real-time queries with clean code and full documentation.

If you want a fast, flexible, and affordable search engine, Golang and Meilisearch are a great pair.


## Building a Search Engine in Golang Made Simple

Building a search engine in Golang doesn’t need to be complicated. With the Meilisearch Go SDK, you can create a fast, lightweight, and scalable search solution using just a few lines of code.

Golang’s performance makes it ideal for backend services, while Meilisearch supports full-text search, typo tolerance, and efficient indexing with clean query string handling. You can define various query types depending on your content and use case.

Whether you're indexing JSON documents or managing custom data structures, the setup is simple and fast. This makes it great for app search, e-commerce, internal tools, or site search. If you’ve worked with BleveSearch or understand Rust syntax, you'll find the transition smooth and the developer experience clean.

Building a search engine in Golang: A comprehensive guide

If you’re looking for a fail-proof, fast and scalable search functionality to directly add to your static site, the answer is Gatsby search. With just a few clicks, Gatsby search enables any user to look for relevant content across a Gatsby site, so you don’t have to worry about traditional navigation. 

Gatsby users can implement search by using plugins such as `gatsby-plugin-meilisearch`, `gatsby-plugin-local-search`, or by connecting external search APIs. These tools use GraphQL queries to index data from Markdown, JSON, or HTML files and support client-side or pre-rendered search components.

This article is your guide on how to add a real-time, full-text search engine to your Gatsby site. We’ll also cover details about the plugins, configurations, and writing GraphQL queries. And on top of that, you’ll learn how to transform data and deploy a working search index. 

Let’s start by going through the steps to add search to any Gatsby project using Meilisearch. 

## 1. Install the Meilisearch plugin for your Gatsby site

The first step is to install an open-source plugin: <code>[gatsby-plugin-meilisearch](https://www.gatsbyjs.com/plugins/gatsby-plugin-meilisearch/)</code>. Why? 

This `gatsby-plugin` is the connection between your Gatsby site and Meilisearch instance using defined API credentials. The main benefit is that it allows your project to generate a live search index during build time. Additionally, it supports [full-text search](https://www.meilisearch.com/blog/how-full-text-search-engines-work), filters, and smooth client-side search operations. So, let’s begin.

Use npm:


```
npm install gatsby-plugin-meilisearch
```


After installation, go to your `gatsby-config.js file`. This is where you define site settings and Gatsby plugin options. Add the plugin to the plugins array with the correct host and apiKey for your Meilisearch instance.


```js
// gatsby-config.js

module.exports = {
  plugins: [
    {
      resolve: 'gatsby-plugin-meilisearch',
      options: {
        host: 'http://localhost:7700',
        apiKey: 'masterKey',
      },
    },
  ],
}
```


You can learn more about this plugin on [GitHub](https://github.com/meilisearch/gatsby-plugin-meilisearch).

This sets up the foundation for your search engine. Next, you’ll define the search index and configure the data you want to fetch.


## 2. Configure the search index and GraphQL query

Once you have installed the `gatsby-plugin-meilisearch`, you need to define the content you want to send to Meilisearch. This will happen inside `gatsby-config.js`, where you set up the indexes array. 

Each entry represents a search index. This is also where you specify the GraphQL query and index name aligned with how you transform the data. 

Here’s an example configuration:


```js
// gatsby-config.js

module.exports = {
  plugins: [
    {
      resolve: 'gatsby-plugin-meilisearch',
      options: {
        host: 'http://localhost:7700',
        apiKey: 'masterKey',
        indexes: [
          {
            indexUid: 'pages_index',
            query: `
              {
                allSitePage {
                  nodes {
                    path
                  }
                }
              }
            `,
            transformer: data =>
              data.allSitePage.nodes.map((node, index) => ({
                id: index,
                path: node.path,
              })),
          },
        ],
      },
    },
  ],
}
```


This `graphql` query fetches data from your Gatsby site pages. The transformer function prepares it for indexing by assigning each entry a unique ID. This guarantees Meilisearch can now store and return the relevant search results properly.


## 3. Build and index your Gatsby content

Now, it’s time to build and index the content. We’ve already configured the [search index](https://www.meilisearch.com/blog/introducing-indexer-2024) and GraphQL. When you run `gatsby build`, `gatsby-plugin-meilisearch` takes the data from your Gatsby site and pushes it to your Meilisearch instance. This step connects your local content with a real-time search index.

To run the build:


```
gatsby build
```


Once complete, you’ll see a message like:


```
success gatsby-plugin-meilisearch - Documents added to Meilisearch
```


This is confirmation that your data has been indexed. The Meilisearch dashboard or local instance will help you inspect the indexed content. 

If you forget this step, your search query will not return any results since there will be no content to search through.

You can also refer to the official [Gatsby plugin documentation](https://www.gatsbyjs.com/plugins/gatsby-plugin-meilisearch/) for additional options, such as `batchSize`, `skipIndexing`, or custom settings like `searchableAttributes`.

Now that your content is indexed, it's time to connect the search UI.


## 4. Add a search component to your Gatsby frontend

Building a user interface comes after your Gatsby site content is indexed. To simplify this, you can use a search component like <code>[docs-searchbar.js](https://www.meilisearch.com/blog/add-a-search-bar-to-your-gatsby-project-using-meilisearch)</code>. It works because it integrates with Meilisearch and supports the search functionality we’re building.

Start by installing the package:


```
yarn add docs-searchbar.js
```


Then, in your `src/components` folder, locate the appropriate `JS file` (like <code>[AppBar.js](http://AppBar.js)</code>). Now, import the search module and CSS:


```js
import 'docs-searchbar.js/dist/cdn/docs-searchbar.css'
```


In your React component, use a `useEffect `hook to initialize the search:


```js
useEffect(() => {
  const docsSearchBar = require('docs-searchbar.js').default
  docsSearchBar({
    hostUrl: 'http://localhost:7700',
    apiKey: 'masterKey',
    indexUid: 'your-index',
    inputSelector: '#search-bar-input',
    meilisearchOptions: { limit: 5 },
    enhancedSearchInput: true,
  })
}, [])
```


Finally, add the search input field in your JSX:


```js
<input type="search" id="search-bar-input" placeholder="Search..." className="searchbox" />
```


This setup connects your static frontend to a live search index. Users get results as they type, and search query parsing, autocomplete, and typo tolerance are fully supported.

Next up is customization. You will learn how to modify a search experience to better match your site’s design and structure.


## 5. Customize your search experience

To unlock customization for your Gatsby site, you need a working search component. Once it’s working, you can modify the search experience according to your site’s structure and design. 

To begin, you will modify the transformer function in `gatsby-config.js`. 

This function determines how your data appears in Meilisearch. You can enrich each search index item with metadata like `frontmatter.title`, `description`, `slug`, or any custom fields.


```js
transformer: (data) =>
  data.allMdx.edges.map(({ node }) => ({
    id: node.id,
    title: node.frontmatter.title,
    description: node.frontmatter.description,
    url: node.slug,
  }))
```


Prioritization is a significant part of customization. To prioritize which fields Meilisearch should match first, you will update `searchableAttributes `in the plugin settings:


```js
settings: {
  searchableAttributes: ['title', 'description', 'content']
}
```


Meilisearch brings several other perks to your customization process. For instance, you can easily adjust query behavior, such as typo tolerance and filtering. Plus, you can always tweak the CSS styles of your search input and add a `classname `to match your design system.

Building components manually through React components? You might refer to the [React Search Engine guide](https://www.meilisearch.com/blog/react-search-engine) for increased frontend control. Customization is all about enhancing the user experience, and this is no exception. 

## 6. Build and deploy your Gatsby site with search

With the search functionality in place and customization all done, it’s time for the final step: to build and deploy your Gatsby site. Let’s run the protection build command:


```
gatsby build
```


During build, `gatsby-plugin-meilisearch` runs your GraphQL query, applies the transformer, and pushes data to the search index. This process runs on every deployment if your Gatsby site is hosted on platforms like Netlify.

Once live, test your searchbox, confirm search input behavior, and validate query results. On Meilisearch Cloud, you also get access to built-in analytics.

Use the official [Gatsby plugin documentation](https://www.gatsbyjs.com/plugins/gatsby-plugin-meilisearch/) or this[ Gatsby search tutorial for full setup steps](https://www.meilisearch.com/blog/add-a-search-bar-to-your-gatsby-project-using-meilisearch).


## How is search used in Gatsby?

Search adds speed and usability to static content—Gatsby sites often power blogs, documentation, ecommerce, and marketing pages.

With `gatsby-plugin`, content in Markdown, JSON, or HTML becomes searchable. This improves navigation and makes your site search fast and efficient.

Let’s have a look at some of the key use cases:

* **Site search:** A quick way to help users locate what they are looking for on your Gatsby site.
* **Docs search:** Makes it easier to look up commands in developer documentation built with Markdown and frontmatter.
* **Blog search:** Filtering by tag, category, or title makes it way easier to find the content you care about.
* **e-Commerce search:** Helps shoppers look up products and see suggestions as they type.
* **Static knowledge bases:** It is responsible for fast client-side search across indexed content.

In short, search is responsible for the user experience and engagement across all these formats.


### Does Gatsby support server-side search?

No, it does not. Gatsby is a static site generator, so it builds all your content ahead of time and shows pre-made HTML pages. An outside tool like Meilisearch could be the answer if you want to add live search to your site. It works by handling queries and returning the results through the API. For example, one way to add the desired search on your site is by using the [Meilisearch React integration](https://www.meilisearch.com/blog/react-search-engine).


### Does Gatsby support local search?

Yes. Gatsby supports local search using plugins like `gatsby-plugin-local-search` and `lunr`. These tools index content at build time and provide lightweight, browser-based search without relying on external APIs. While this suits smaller projects, larger sites often use Meilisearch for faster indexing, typo tolerance, and advanced search functionality. For complex content-driven sites, Meilisearch is a more flexible option.


## Building powerful search in Gatsby sites

Search is a must-have on any content-rich Gatsby site. Fast search is invaluable for blogs, docs, and especially online stores. Tools like `gatsby-plugin-meilisearch` bring real-time, typo-tolerant search functionality to your React components.

Meilisearch connects through your `gatsby-config.js `using a GraphQL query, a transformer function, and a defined search index. It supports Markdown, JSON, and nested content structures. With minimal setup, your static Gatsby site can offer dynamic search query handling and a modern user experience.


Meilisearch latest news and company updates