You know what's amazing about search? It's at the heart of how people interact with your application. But let's be honest: building and managing search infrastructure can feel like you're spending more time wrestling with configuration than creating value for your users. That's why we're excited to share something that changes this completely: the Meilisearch MCP server.

## Why MCP? Building bridges between search and AI

Before we dive in, let's talk about what MCP (Model Context Protocol) is and why we're excited about it. [MCP](https://www.anthropic.com/news/model-context-protocol) is an emerging open protocol that standardizes how applications provide context to Large Language Models (LLMs). Think of it as a universal translator between your tools and AI models.

Even though MCP isn't yet fully standardized, we believe it represents the future of how developers will interact with their tools. Here's why:
- It creates a consistent way for AI models to interact with different tools and services
- It puts security and user control at the forefront
- It enables natural language interactions while maintaining precise control
- It's being built in the open, with input from the developer community

## From complex commands to natural conversations

Remember the last time you needed to update your search settings? It probably involved looking up API documentation, crafting the perfect JSON payload, and triple-checking your syntax. We've all been there. But what if you could just tell your search engine what you want, in plain English?

That's exactly what we've built. By implementing MCP, we've enabled natural conversations with Meilisearch through AI assistants like Claude. Here's what this means in practice using [our movies database](https://where2watch.meilisearch.com/) as an example:

### Before:
```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/settings' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer MASTER_KEY' \
  --data-binary '{
    "rankingRules": [
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness"
    ]
  }'
```

### After:
> "Update the ranking rules for the movies index to prioritize word matches and handle typos."

That's it. When paired with advanced LLMs like Claude Sonnet, the AI understands your intent and handles all the technical details behind the scenes. No more context-switching between documentation tabs.

## What can you do with it today?

Thanks to the capabilities of modern LLMs, our MCP integration already enables natural language control over your Meilisearch instance. Here's what you can do right now:

1. **Index management made simple**
```"Create a new index for our product catalog and optimize it for e-commerce search"```
The AI will guide you through setting up your index with appropriate configurations for e-commerce.

2. **Search optimization**
```"Our users are having trouble finding products when they make typos. How can we fix this?"```
Get instant guidance on configuring typo tolerance and seeing real-time results.

3. **Performance insights**
```"How is our search performance looking? Any areas we should optimize?"```
Understand your search analytics and get actionable recommendations.

## How does it work?

Our current MCP implementation exposes Meilisearch's capabilities through a set of carefully designed tools that AI assistants can use to manage your search infrastructure. When paired with advanced LLMs like [Claude Sonnet](https://www.anthropic.com/news/claude-3-5-sonnet), these tools enable natural conversations about complex search operations.

The best part? It works seamlessly with Claude Desktop and other MCP-compatible clients, giving you:
- Natural language control over your search infrastructure
- Instant access to best practices and optimization tips
- Real-time insights and analytics

## Getting started in 2 minutes

1. Install [Claude Desktop](https://claude.ai/download) (it's free!)
2. Add our MCP server to your configuration:

```json
{
  "mcpServers": {
    "meilisearch": {
      "command": "uvx",
      "args": ["-n", "meilisearch-mcp"]
    }
  }
}
```
3. Start managing your search like you're chatting with a colleague!

## Building the future of search

This is just the beginning of our mission to make search infrastructure more accessible. Here's what we're working on next:

### Smart prompts
We're developing pre-built templates for common scenarios like:
- Optimizing index settings for specific use cases (e-commerce, documentation, etc.)
- Debugging search behavior and performance issues
- Understanding and improving search analytics
- Implementing industry-specific best practices

### Enhanced capabilities
- More sophisticated analytics and monitoring tools
- Expanded AI assistant integrations
- Advanced collaborative features for teams
- Deeper integration with Meilisearch Cloud

## Open source and open for contributions

True to our values, the Meilisearch MCP server is completely open source. We believe in building in public and learning from our community. Check out our implementation, contribute, or adapt it for your needs:

[GitHub repository](https://github.com/meilisearch/meilisearch-mcp)

## Join us in simplifying search

- ⭐ Star [our repository](https://github.com/meilisearch/meilisearch)
- 💬 Join our [Discord community](https://discord.meilisearch.com/) & share your use cases (or do it on social media and tag us)
- 🛠️ Contribute to development on [GitHub](https://github.com/meilisearch/meilisearch-mcp)

We're excited to see how you'll use this to build better search experiences. Try it out and let us know what you think!

How we made Meilisearch talk to AI: introducing our MCP server

Building a RAG system with Meilisearch: a comprehensive guide

Imagine this: You're a SaaS product manager who just left a board meeting where the CEO announced, "We need to invest in AI search!" The budget is set, the engineering team is eager, and time is running out. But as you explore **AI-powered search**, the reality strikes hard. The field is filled with buzzwords, big promises, and high costs. You start to question, "Will this really deliver the ROI we need?"

The problem is an unrealistic outlook, wrong metrics, and the "more is better" mentality regarding features. SaaS companies spend millions on AI search, only to deal with rising costs, unhappy users, and doubts about their approach.

But there's good news. With a **pragmatic, business-focused approach**, you can use AI search to achieve real results. This can be done without overspending or losing focus.

This article will cover crucial strategies for **implementing AI-powered search** effectively. Topics include budgeting, feature selection, measuring success, and future-proofing your SaaS. Prepare to move beyond the hype and truly harness AI search.

## Core features of new generation AI-powered search

### Demystifying AI search technologies

AI-powered search represents a significant leap forward from traditional keyword matching. It employs sophisticated algorithms that understand context and user intent.

At its core, this technology combines machine learning and natural language processing to interpret queries as humans naturally express them. For instance, when Bookshop.org implemented AI search, their system understood complex queries about books. It accounted for variations in titles, author names, and even thematic searches that traditional systems would struggle with.

![Differnent Layers Of Ai Powered Search](https://unable-actionable-car.media.strapiapp.com/ai_powered_search_834ac28328.avif)

### Storage layer

#### Vector database

[Vector databases](https://www.meilisearch.com/blog/what-is-a-vector-database) form the foundation of modern AI search systems. They store complex data representations that capture semantic relationships between items. Unlike traditional databases, these specialized systems can efficiently process high-dimensional data. **This enables lightning-fast similarity searches across millions of items.**

#### Multiple DBs for full-text search

The architecture of modern search systems often employs multiple specialized databases features working together. These include prefix databases for instant search suggestions, inverted indexes for rapid full-text search, and specialized stores for handling typos and variations.

### Capabilities layer

#### Full-text search

[Full-text search](https://www.meilisearch.com/blog/how-full-text-search-engines-work) remains a cornerstone of modern search systems. It provides precise lexical matching with advanced features like typo tolerance and prefix searching. This capability is especially valuable in e-commerce scenarios. Users often search for specific product codes or exact phrases.

#### Vector search

[Vector search](https://www.meilisearch.com/blog/introducing-vector-search) enables semantic understanding by converting search queries and content into mathematical representations that capture meaning, not just keywords. **This technology powers the ability to find relevant results even when queries don't exactly match the target content.** It was transformative for Bookshop.org's vast catalog of six million books.

#### Hybrid search

[Hybrid search](https://www.meilisearch.com/blog/introducing-hybrid-search) combines the precision of full-text search with the semantic understanding of vector search. It offers the best of both worlds. This approach allows systems to handle both precise queries and more exploratory searches effectively. It delivers relevant results regardless of how users express their needs.

### Application layer

The application layer transforms raw search capabilities into practical features that drive business value. It includes personalization systems that adapt results based on user behavior, [semantic search that understands natural language queries](https://www.meilisearch.com/blog/choosing-the-best-model-for-semantic-search), and recommendation engines that suggest related items.

Hugging Face leverages this layer to help users discover relevant AI models based on specific use cases and preferences. Similarly, HitPay uses it to enable merchants to prioritize specific products in search results based on business rules.

<Callout intent="note">
	
	**Want to dive deeper?** Check out our [detailed comparison of full-text vs vector search](https://www.meilisearch.com/blog/full-text-search-vs-vector-search) to understand their unique strengths and use cases.
	
	
</Callout>

## Use cases that demonstrate tangible benefits

AI-powered search is transforming how users interact with digital platforms beyond the traditional search bar.

[Bookshop.org's implementation](https://www.meilisearch.com/blog/bookshop-increases-search-based-purchases) demonstrates a compelling impact: **their conversion rate jumped from 14% to 20% after switching to AI-powered search, representing a 43% increase in search-to-purchase conversion**. This improvement came from the system's ability to understand complex book queries and handle their massive six-million-item catalog effectively.

[For Hugging Face](https://www.meilisearch.com/blog/hugging-face-democratizes-ai), **AI search solved the challenge of making 220,000 AI models, 38,000 datasets, and 60,000 demos discoverable to their technical audience**. Their implementation goes beyond simple keyword matching, allowing developers to find relevant models based on use cases, performance characteristics, and technical requirements. The system's ability to understand technical context and relationships between different AI models has made it significantly easier for users to find the right tools for their specific needs.

[HitPay's experience](https://blog.meilisearch.com/hitpay-streamlines-search/) highlights how AI search can bridge the gap between online and offline retail operations. Their point-of-sale system uses AI search to help sales assistants quickly locate specific products across multiple locations, while simultaneously powering their e-commerce storefronts. The system's ability to sync product catalogs across channels and prioritize frequently accessed items has resulted in a 50% increase in search API response speed. **This directly improves the customer experience both in-store and online.**

## Budgeting for AI-powered search

### Determining AI budget allocation

<Callout intent="note">
	
	Enterprises are rapidly adopting generative AI, [dedicating upwards of 10% of their IT budgets by 2025](https://techstrong.ai/articles/generative-ai-consuming-larger-percentage-of-it-budgets/). You can allocate between 5-15% of IT budgets to AI initiatives. the ideal investment varies based on company size, sector, and goals.
	
	
</Callout>

When budgeting for AI-powered search integration, consider these factors:

- The scale of your existing search infrastructure
- The complexity of your data and search requirements
- The size of your user base and expected growth
- Your team's existing AI and machine learning expertise
- The level of customization you require

### Breakdown of costs: R&D, implementation, ongoing optimization

#### The true cost of AI search implementation

Implementing AI-powered search requires careful consideration of both direct and indirect costs. The initial investment covers infrastructure setup, data preparation, and integration costs.

For example, Bookshop.org's transition from Elasticsearch to a more sophisticated AI search solution involved not only technology costs but also resources to properly index and configure their six-million-item catalog. Companies must also factor in ongoing costs for maintenance, updates, and infrastructure scaling as search volume grows.

<Callout intent="note">
	
	[Check out our analysis of Meilisearch vs. Elasticsearch](https://www.meilisearch.com/blog/meilisearch-vs-elasticsearch), for a detailed comparison of the two search solutions.
	
	
</Callout>

**HitPay demonstrates this approach – they began with an open-source solution to validate their use case before transitioning to a managed cloud service.** This allowed them to optimize costs while ensuring reliability for their business-critical search functions.

#### Avoiding budget black holes

The most significant hidden costs often stem from unexpected infrastructure scaling needs and ongoing optimization requirements. Companies frequently underestimate the resources needed to maintain search relevance and manage growing data volumes.

![ai powered search](https://unable-actionable-car.media.strapiapp.com/ai_powered_search_4def6c80b2.avif)

#### Infrastructure costs and scalability considerations

Infrastructure is critical for AI-powered search implementation.** Key considerations include:

- **Computing power:** AI models, especially during training, require substantial computational resources. This may necessitate investment in high-performance hardware or cloud computing services.
- **Storage:** AI systems need to process and store large amounts of data. Ensure your storage solutions can handle this increased load.
- **Network capacity:** If your AI search system processes queries in real-time, upgrade your network infrastructure to handle increased traffic.
- **Scalability:** As your user base grows, your AI search system needs to scale. Cloud-based solutions offer flexibility for scaling but may have higher long-term costs compared to on-premises solutions.

### ROI calculation framework for AI search investments

Measuring return on investment requires tracking both direct and indirect impacts of AI search implementation. Key metrics should include:

- Conversion rate improvements (like Bookshop.org's 43% increase)
- Operational efficiency gains (such as HitPay's 50% faster search response times)
- Customer satisfaction metrics
- Reduced support costs from improved self-service capabilities

For SaaS businesses, significant returns often come from improved user engagement and reduced churn. When calculating ROI, companies should consider both immediate performance improvements and long-term benefits, like increased customer lifetime value and reduced operational costs.

## KPIs for measuring success

### Beyond vanity metrics

Basic metrics like search volume and click-through rates provide some insight, but often mask deeper performance issues. The most telling indicators come from user behavior patterns and business outcomes.

For example, Bookshop.org's success wasn't measured by the number of searches performed, but by the 20% conversion rate from search to purchase. **This metric is directly tied to revenue generation.**

### Decoding search performance that actually matters

Search performance metrics should reflect real user success rates rather than just technical measurements.

Hitpay's 50% improvement in search API response speed impacts in-store customer service and online shopping experiences.

The most telling metrics often combine multiple data points to create a complete picture of search effectiveness. Consider tracking:

- Search-to-conversion ratio: Like Bookshop.org's jump from 14% to 20% in search-driven purchases
- Query refinement rate: How often users need to modify their search terms to find what they need
- Time-to-content: How quickly users find relevant information after initiating a search
- Zero-result rates: The percentage of searches that yield no results, indicating gaps in content or search capability

These metrics should be analyzed in context with your specific business objectives. For a knowledge base, success might mean reduced time-to-answer. For an e-commerce platform, it could mean higher average order values from search-driven purchases.

### Warning signs: KPIs that signal AI search failure

Several indicators can reveal problems with your AI search implementation. Watch for:

- High abandonment rates after search attempts
- Increased support tickets related to finding information
- Growing use of alternative navigation methods
- Declining engagement with search-discovered content

When Hugging Face noticed users bypassing their search functionality in favor of direct repository browsing, it signaled a need to improve their search relevance and feature set. **Monitoring these warning signs helps identify** issues before they impact user satisfaction and business outcomes.

## Selecting the right AI search features for your SaaS business

### What use cases they enable

AI search features should align with specific business objectives and user needs.

Bookshop.org's implementation demonstrates this principle perfectly. Their focus on semantic understanding and typo tolerance addressed the challenge of helping users find books across a vast catalog, even with imperfect queries. **This targeted approach led to their impressive 43% increase in conversion rates.**

### AI search feature mapping

Semantic search capabilities are valuable for content-rich platforms. Hugging Face's implementation helps users navigate their extensive repository of AI models. Users can find relevant models even when search terms don't exactly match model names or descriptions, significantly improving discovery rates.

Similarity search is particularly useful in e-commerce contexts. HitPay uses this feature to help merchants connect customers with related products. This goes beyond category matching to understand product relationships based on multiple attributes, enhancing cross-selling opportunities.

Personalization features are crucial for platforms with diverse user bases. For instance, HitPay's implementation allows merchants to pin frequently accessed products, automatically adapting search results based on business-specific patterns and preferences.

### When more features mean less value

Not every AI search feature delivers equal value for every business case. Hugging Face's experience shows the importance of prioritizing features that align with core user needs. **They focused on making their vast technical documentation and model repository discoverable rather than implementing every available search feature.**

The key to feature selection lies in understanding user behavior patterns and business objectives. For example, while multi-modal search might seem cutting-edge, Bookshop.org achieved significant results by focusing on fundamental features like semantic understanding and typo tolerance. These features directly addressed their users' primary needs.

<Callout intent="tip">
	
	Ready to supercharge your search experience? [Explore Meilisearch Cloud](https://meilisearch.com/cloud) and deliver lightning-fast search results that will keep your users engaged and boost your conversion rates.
	
	
</Callout>

## Best practices for implementing AI-powered search

### The implementation gauntlet

Successful AI search implementation requires a methodical approach that prioritizes user needs over technical complexity. HitPay's implementation journey is instructive.

They started with a simple internal dashboard search before expanding to customer-facing features. This gradual rollout allowed them to refine their approach with minimal risk. **They achieved a 50% improvement in search API response speed while maintaining system stability.**

When Bookshop.org transitioned to their new search system, they started with a test environment. This allowed them to validate their approach before full deployment. This methodical strategy enabled them to **maintain search performance during their busy holiday season** while implementing significant improvements.

### Critical decision points in AI search deployment

Key decisions during implementation should focus on:

- **Initial feature set selection based on immediate user needs**
- Data indexing strategy and update frequency
- Performance monitoring and optimization approaches
- User feedback collection and integration methods

Bookshop.org's team made their ranking rules accessible to non-developers, allowing for quick iterations based on business needs **without requiring engineering intervention**. This approach enabled them to maintain search relevance during peak periods while continuously improving the user experience.

## Future proofing your SaaS with AI-powered search

### Cutting through the AI hype cycle

The future of AI-powered search extends beyond current capabilities. Successful implementation requires distinguishing between genuine innovations and marketing hype.

Hugging Face's approach to testing vector database integration for semantic search demonstrates how companies can practically evaluate emerging technologies.

**Organizations can evaluate search solutions based on actual business needs. This approach helps avoid chasing trendy technologies that fail to deliver meaningful results.**

<Callout intent="tip">
	
	Stay informed about the latest in search technology, product updates, and industry insights. [Subscribe to our newsletter](https://share-eu1.hsforms.com/1LN5N0x_GQgq7ss7tXmSykwfg3aq) and be the first to know about Meilisearch Cloud's exciting developments.
	
	
</Callout>

### Strategic long-term AI search planning

Long-term success requires building flexibility into search implementations. HitPay's evolution from basic search functionality to a sophisticated multi-channel solution shows how search capabilities can grow alongside business needs. Their experience highlights the importance of choosing solutions that can scale and adapt as requirements change, rather than being locked into rigid implementations that limit future options.

The most sustainable approaches focus on creating adaptable search infrastructures that can incorporate new capabilities as they mature. Bookshop.org's implementation demonstrates this principle. **Their search architecture allows them to continuously refine ranking rules and add new features without disrupting core functionality.** This flexibility enabled them to achieve immediate benefits while maintaining the ability to adopt new AI capabilities as they become available.

As AI technologies evolve, AI-powered search has become a critical differentiator for SaaS businesses. Success stories of companies like Bookshop.org, HitPay, and Hugging Face show that thoughtful implementation of AI search capabilities can deliver concrete business results.

These include increased conversion rates and improved user engagement. The key lies in selecting and implementing solutions that align with specific business needs while maintaining the flexibility to adapt as technology and user expectations evolve.

<Callout intent="tip">
	
	Need a custom search solution tailored to your unique requirements? [Schedule a Consultation](https://meet.meilisearch.com/meetings/cloud/presentation?uuid=d7d3d29c-635f-4544-877d-86ecbd29e7b8) with our expert team and transform your search strategy.
	
	
</Callout>

Beyond the hype: practical AI search strategies that deliver ROI


Have you ever noticed how Google suggests exactly what you're looking for before you finish typing? That's predictive search in action. It revolutionizes user interaction with software applications. In this guide, we'll explore implementing predictive search in your applications.

## Introduction to predictive search

### Definition and importance of predictive search

**Predictive search is an intelligent system that anticipates user intent and suggests relevant results in real-time as users type**. Unlike traditional search methods that wait for a complete query, predictive search processes each keystroke to provide immediate, relevant suggestions.

The importance of predictive search in software engineering is significant. It bridges user intent and content discovery, reducing the time and effort users spend searching. Modern applications leverage predictive search to enhance productivity and streamline workflows.

Software engineering teams implementing predictive search can expect improved user engagement metrics. For instance, e-commerce platforms often see a 25-30% increase in conversion rates with predictive search features. Developer tools report significant reductions in time spent searching for code snippets or documentation.

### Predictive search enhancing autocomplete

Traditional autocomplete completes words based on character matching. Predictive search, however, analyzes patterns in user behavior, search history, and contextual data to offer intelligent suggestions.

The personalization aspect of predictive search sets it apart from basic autocomplete. **Predictive search creates a more tailored experience by considering factors like previous searches, user location, and trending queries**.

For example, when a developer searches for "deploy" in a cloud platform's console, the system prioritizes suggestions based on their commonly used services or recent deployments.

<Callout intent="note">
	
	For example, in an e-commerce platform, **autocomplete might suggest "laptop bag"** when a user types "lap", predictive search might also suggest "computer accessories," "mobile workstation," or specific laptop models based on browsing history and market trends.
	
	
</Callout>

## Core concepts and components

### Predictive models in software engineering

Predictive models form the backbone of modern search capabilities. **They utilize complex algorithms to analyze user input patterns and generate relevant suggestions**.

Businesses can leverage large datasets, with the specific type of data varying depending on the industry and business objectives. It is possible to use various data sources like browsing history, user interactions, and market trends to improve predictive search strategies.

![Examples Of Data Predictive Search](https://unable-actionable-car.media.strapiapp.com/predictive_search_b4778b9493.avif)

These models process queries through multiple layers of analysis, including string matching, semantic understanding, and historical pattern recognition.

Predictive models often rely on prefix trees (or radix trees) for efficient string matching and retrieval. This structure enables rapid processing of partial queries, allowing the system to generate suggestions with minimal latency. The models continuously learn from user interactions, refining their prediction accuracy over time.

### Search engines and search queries

Search engines in predictive systems employ sophisticated indexing mechanisms to aid rapid query processing. Key components include query processors, suggestion generators, and ranking algorithms.

These elements work together to produce and prioritize results based on various relevance factors.

![Layers Of Logic Search Engine](https://unable-actionable-car.media.strapiapp.com/predictive_search_2c856b34f6.avif)

Modern search queries go through steps including tokenization, spell checking, and context analysis. **This ensures that even imperfect queries can yield useful suggestions**. Balancing immediate results and accuracy often involves using caching mechanisms to optimize frequently requested queries.

### Machine learning and AI power

Artificial intelligence significantly enhances predictive search through advanced natural language processing and machine learning algorithms.

These technologies help systems understand user intent beyond literal string matching, incorporating semantic understanding and contextual relevance.

AI improves search accuracy by:

- Capturing user intent with natural language understanding
- Adapting ranking algorithms to changing user behavior patterns
- Identifying relationships between different terms through semantic analysis
- Tailoring suggestions based on user profiles and historical interactions

Combining machine learning with traditional search algorithms creates a hybrid approach that delivers both speed and accuracy.

## Capabilities required for predictive search

A robust predictive search implementation requires several key capabilities to deliver a seamless user experience. Fast indexing and efficient query processing are foundational, but there's more to consider.

### Meilisearch's approach to enabling predictive search

Meilisearch combines traditional full-text search with AI-powered capabilities. Its architecture enables fast, relevant results and maintains simplicity in implementation.

**The integration process focuses on three key areas**: data indexing, search configuration, and result optimization. Here's an example of configuring search settings:

```typescript
// config/search.ts
const searchConfig = {
  settings: {
    rankingRules: [
      'words',
      'typo',
      'proximity',
      'attribute',
      'sort',
      'exactness'
    ],
    searchableAttributes: [
      'title',
      'description',
      'category'
    ],
    displayedAttributes: [
      'title',
      'description',
      'category',
      'thumbnail'
    ],
    // Enable AI-powered search with OpenAI
    embedder: {
      type: 'openai',
      documentTemplate: "Product: {{title}}nDescription: {{description}}"
    }
  }
};

await searchClient.index('products').updateSettings(searchConfig);
```

**This configuration enables both traditional search capabilities and AI-powered features**, creating a hybrid search experience that delivers both speed and relevance. The system handles typos, synonyms, and contextual understanding while maintaining sub-50ms response times.

<Callout intent="tip">
	
	Ready to supercharge your search experience? [Explore Meilisearch Cloud](https://meilisearch.com/cloud) and deliver lightning-fast search results that will keep your users engaged and boost your conversion rates.
	
	
</Callout>

## Applications and use cases

Modern software applications leverage predictive search in numerous ways, from e-commerce platforms to content management systems. Understanding these practical applications helps developers implement the right search strategies for their specific use cases.

### App search

**App search is a common implementation of predictive search in software applications**. Mobile apps benefit particularly due to limited screen space and typing constraints.

For instance, food delivery apps use predictive search to help users find restaurants or dishes quickly, considering factors like previous orders and current location.

### Site and media search

**Site and media search capabilities have evolved to handle complex content structures**. Content management systems and documentation platforms use predictive search to help users navigate large information hierarchies.

For example, technical documentation sites can suggest relevant API endpoints or code examples as developers type their queries.

<Callout intent="note">
	
	Check out how Meilisearch powers the discovery of 300,000+ AI models on [Hugging Face](https://www.meilisearch.com/blog/hugging-face-democratizes-ai), demonstrating the power of predictive search in organizing and accessing vast AI resources.
	
	
</Callout>

### Ecommerce search

E-commerce platforms showcase the potential of predictive search through sophisticated product discovery. Online stores suggest not only product names but also categories, brands, and specific features. **This capability extends to handling complex queries like "red summer dress under $50" accurately**.

<Callout intent="note">
	
	For another compelling example of predictive search in action, explore [Meilisearch's case study with Bookshop.org](https://www.meilisearch.com/blog/bookshop-increases-search-based-purchases), where they achieved a remarkable 43% increase in search-based purchases by enhancing their book discovery platform.
	
	
</Callout>

### Enterprise search

[Enterprise search](meilisearch.com/blog/enterprise-search) presents unique challenges because it handles diverse data sources while maintaining security constraints. Predictive search in enterprise environments must consider user permissions, department-specific terminology, and internal document hierarchies.

For instance, a company's internal tools might suggest different results for the same query based on the user's role and access level.

## Techniques and methodologies

### Genetic programming and test models

Genetic programming enhances predictive search capabilities by **evolving and refining search algorithms**. These techniques mimic natural selection to optimize search patterns and improve relevancy.

The system dynamically generates search algorithm variations. It then evaluates these algorithms by analyzing user interactions. Based on performance metrics, the system selects the most effective algorithm combinations to enhance future search experiences.

Test models developed through genetic programming adapt to changing search patterns. For instance, e-commerce search systems can automatically adjust prediction weights based on seasonal trends, user behavior shifts, and new product introductions. **The evolutionary nature of these algorithms ensures relevant search suggestions** as user preferences and patterns evolve.

### Base software and search base

Establishing a robust search base requires careful consideration of data structure and indexing strategies.

<Callout intent="note">
	
	For deeper insights into optimizing search indexing, check our comprehensive guide on [best practices for faster indexing](https://meilisearch.com/blog/best-practices-for-faster-indexing).
	
	
</Callout>

Typically, it consists of an inverted index system enabling quick lookup of terms while maintaining relationships between search elements. **This base structure must support both exact matches and fuzzy searching capabilities**.

Integration of predictive search within software frameworks demands:

- Efficient data storage and retrieval mechanisms to handle large volumes of search queries
- Flexible indexing strategies accommodating both structured and unstructured data
- Scalable architecture maintaining performance under increasing load
- Real-time update capabilities to reflect changes in underlying data

The search base must also handle edge cases and special scenarios. For example, with multilingual search capabilities, the base system must account for different character sets, writing systems, and language-specific patterns. **This ensures reliable and effective predictive search functionality across diverse use cases** and user requirements.

## Capabilities

Low latency is crucial for predictive search systems because users expect instant feedback while typing. Modern search implementations must maintain response times under 100ms to feel instantaneous. This speed requirement becomes even more critical when handling complex queries across large datasets.

Several optimization techniques help achieve these performance goals. **Intelligent caching strategies store frequently accessed results and partial queries**, significantly reducing database load and response times for common searches. Here's how response times typically break down:

| Operation | Target Latency | Optimization Method |
| --- | --- | --- |
| Query Processing | &lt; 20ms | In-memory processing |
| Index Lookup | &lt; 30ms | Cached indices |
| Result Ranking | &lt; 30ms | Pre-computed scores |
| Network Transfer | &lt; 20ms | Edge caching |

Ensuring reliability involves implementing robust error handling and failover mechanisms. **Search systems must gracefully handle scenarios like network issues, invalid queries, or backend service disruptions**. Implementing circuit breakers and fallback options helps maintain service availability.

Performance monitoring is vital for maintaining optimal search functionality. Modern search implementations use real-time metrics tracking to identify bottlenecks and optimization opportunities.

Key performance benchmarks for predictive search systems include:

- **Query response time:** 95th percentile under 200ms
- **Suggestion relevancy:** Minimum 80% accuracy rate for top 5 suggestions
- **System throughput:** Ability to handle 1000+ queries per second per node
- **Cache hit ratio:** At least 85% cache effectiveness

<Callout intent="tip">
	
	Meilisearch Cloud includes [built-in monitoring tools](https://www.meilisearch.com/docs/learn/analytics/monitoring) that enable real-time tracking of search performance metrics.
	
	
</Callout>

The architecture should scale horizontally to handle increasing load while maintaining performance. This typically involves:

1. Distributed index sharding for better resource utilization
2. Load balancing across multiple search nodes
3. Asynchronous index updates to prevent blocking operations
4. Smart query routing based on user location and server load

Reliability also extends to data consistency and accuracy. Search systems must handle index updates and real-time data changes without compromising search quality or availability. **This often requires sophisticated versioning and synchronization mechanisms** to ensure users always see the most relevant and up-to-date results.

## Future directions and innovations

As predictive search technology continues to evolve, several emerging trends and innovations are reshaping the future of search systems.

### Integration with advanced technologies

The future of predictive search is being shaped by **advancements in artificial intelligence and machine learning technologies**. Large language models (LLMs) are transforming how search systems understand and process user queries. These models can interpret natural language with high accuracy, enabling more conversational and context-aware search experiences.

Integration with advanced technologies is already showing promising results. Some systems are experimenting with multimodal search capabilities, processing text, images, and voice inputs simultaneously. This enables more intuitive search interfaces that match how humans naturally communicate.

### Trends in predictive search

LLMs are revolutionizing predictive search capabilities by fundamentally transforming how we interact with search engines. These sophisticated systems can now comprehend complex queries and generate natural, contextually appropriate suggestions that feel remarkably human-like.

Modern search systems now interpret both technical and informal language, moving beyond pattern matching to understand the true meaning behind user queries.

This advancement has enabled several crucial improvements in search functionality:

- More precise interpretation of user queries
- Sophisticated handling of ambiguous searches
- Enhanced recognition of specialized terminology
- Intelligent, context-aware result ranking

**These innovations are already being implemented in various forms**. Some search engines use hybrid approaches that combine traditional search algorithms with [AI-powered semantic understanding](meilisearch.com/blog/ai-powered-search). This allows them to maintain the speed and reliability of conventional search while leveraging advanced AI capabilities.

## Beyond horizons: the transformative potential of predictive search

Predictive search has evolved from a convenient feature to an essential component of modern software applications.

Successful implementation requires careful consideration of architecture, performance optimization, and user experience design.

The integration of advanced AI technologies and mobile-first approaches will continue to push the boundaries of what's possible in predictive search. This makes it an exciting area for continued innovation and development.

<Callout intent="tip">
	
	Unlock advanced search potential with customizable relevancy, typo tolerance, and more. [Enhance Your Search Strategy](https://meilisearch.com/features) with Meilisearch Cloud's powerful search capabilities.
	
	
</Callout>

Software engineering predictive search: a complete guide

In today's interconnected world, many applications need to handle content in multiple languages. Meilisearch offers powerful capabilities for multilingual search, combining intelligent language handling with specialized models for optimal relevance. This guide will walk you through setting up multilingual search with Meilisearch, covering both full-text and semantic search approaches.

Why multilingual search matters
===============================

Before we dive into the technical details, let's consider why multilingual search is crucial:

1.  Global reach: Expand your audience by catering to users in their native languages.
2.  Improved user experience: Provide relevant results regardless of the language used in queries or content.
3.  Increased engagement: Users are more likely to interact with content they can easily find and understand.

Now, let's explore how Meilisearch makes multilingual search a breeze.

Full-text search: intelligent language handling
-----------------------------------------------

At its core, Meilisearch excels at handling diverse languages out of the box. Our [advanced tokenizer](https://www.meilisearch.com/docs/learn/indexing/tokenization?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search) is designed to work with:

*   Languages that use whitespace to separate words (like English, Spanish, and French)
*   Languages with different writing systems (such as Chinese, Japanese, and Thai)

### Automatic language detection

When you add documents to your Meilisearch index, the engine automatically detects the language of each field. This means you don't need to specify languages manually in most cases - Meilisearch will handle it for you.

For example, if your documents contain a mix of English and Spanish content:

```json
[
  {
    "id": 1,
    "title": "The quick brown fox",
    "description": "El zorro marrón rápido salta sobre el perro perezoso"
  },
  {
    "id": 2,
    "title": "La luna y las estrellas",
    "description": "A beautiful night sky filled with twinkling stars"
  }
]
```

Meilisearch will automatically detect and properly handle the different languages in each field, ensuring accurate search results across your multilingual content.

### Specifying languages for specific fields

While automatic detection works well in most cases, you might want more control over language handling for certain fields. Meilisearch allows you to [specify languages](https://www.meilisearch.com/docs/reference/api/settings#localized-attributes?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search) for particular attributes using the `localizedAttributes` setting.

Here's how you can set it up:

```json
{
  "localizedAttributes": [
    {
      "locales": ["eng"],
      "attributePatterns": ["title_en", "*_english"]
    },
    {
      "locales": ["spa"],
      "attributePatterns": ["description_es", "*_spanish"]
    }
  ]
}
```

This configuration tells Meilisearch to treat fields ending with `_en` or `_english` as English, and fields ending with `_es` or `_spanish` as Spanish. This approach is particularly useful when you have a consistent naming convention for your multilingual fields or when you want to ensure specific treatment for certain attributes.

Semantic search: Enhancing multilingual relevance
=================================================

While full-text search works well for many multilingual scenarios, semantic search can provide even better results, especially for complex queries or when dealing with nuanced meanings across languages.

Meilisearch supports various embedding models for semantic search, offering powerful auto-embedding capabilities. This means you can easily set up semantic search without having to manage the embedding process yourself. Meilisearch handles the generation and storage of embeddings automatically, seamlessly integrating them into your search experience.

For multilingual applications, we recommend using specialized multilingual models rather than relying on general-purpose models. These models are designed to understand and represent meaning across multiple languages, leading to more relevant search results in multilingual contexts.

One excellent option for multilingual semantic search is the [Cohere Multilingual embedding model](https://docs.cohere.com/docs/multilingual-language-models). It offers a great balance of speed and relevance across a wide range of languages. Cohere's model is particularly adept at understanding context and nuance in different languages, making it an ideal choice for diverse, multilingual content. Follow [the guide](https://www.meilisearch.com/docs/guides/ai/cohere?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search) if you want to do it now.

To explore different models and their performance, you can use the [Meilisearch playground](https://playground.meilisearch.com). This interactive tool allows you to test various embedding models and see how they perform with your specific multilingual queries and content.

Conclusion
----------

We encourage you to experiment with different settings and models to find the optimal configuration for your specific use case. And remember, the Meilisearch community is always here to help - join us on [Discord](https://discord.meilisearch.com/) or check out our documentation for more detailed information and support.

Ready to get started with multilingual search? Try Meilisearch today [with a 14 day trial](https://cloud.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search)!

Searching across multiple languages

How to add AI-powered search to a React app

  
[Semantic search](/blog/what-is-a-vector-database/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#what-is-similarity-search) is transforming search technology by providing more accurate and relevant results. However, with many embedding models available, choosing the right one can be challenging. This guide will help you understand the key factors to consider when selecting a model to build semantic search.

Overview
--------

In this guide, we will use the open-source search engine [Meilisearch](https://www.meilisearch.com?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) to perform the semantic searches. For the purpose of the tests, we're using the entry tier of [Meilisearch Cloud](https://www.meilisearch.com/cloud?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) (i.e., the [Build plan](https://www.meilisearch.com/pricing?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) .)

This guide will cover the following models:

| Model/Service | Dimensions | Context Length |
| --- | --- | --- |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | 1024 | 512 |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | 384 | 512 |
| [Cohere embed-multilingual-v3.0](https://docs.cohere.com/docs/embeddings) | 1024 | 512 |
| [Cohere embed-multilingual-light-v3.0](https://docs.cohere.com/docs/embeddings) | 384 | 512 |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | 1536 | 8192 |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | 3072 | 8192 |
| [Mistral](https://mistral.ai/product/embeddings/) | 1024 | 8192 |
| [VoyageAI voyage-2](https://voyageai.com/) | 1024 | 4000 |
| [VoyageAI voyage-large-2](https://voyageai.com/) | 1536 | 16000 |
| [VoyageAI voyage-multilingual-2](https://voyageai.com/) | 1024 | 32000 |
| [Jina Colbert v2](https://jina.ai/news/jina-colbert-v2-multilingual-late-interaction-retriever-for-embedding-and-reranking/) | 128, 96, or 64 | 8192 |
| [OSS all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | 384 | 512 |
| [OSS bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 1024 | 512 |
| [OSS bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 1536 | 512 |

Factors to consider
-------------------

### 1\. Results relevancy

[Relevancy](https://www.meilisearch.com/docs/learn/relevancy/relevancy?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) is crucial for effective search, as it ensures that users find the most pertinent results quickly. In the realm of semantic search, achieving a balance between relevancy and speed is essential to provide a seamless user experience. It's important to consider the tradeoffs of [vector search vs full-text search](/blog/full-text-search-vs-vector-search/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison)

When selecting a model, consider your specific use case, such as the need for multilingual support, handling multi-modal data, or addressing domain-specific requirements. If you have a highly specialized use case or need to support a particular language, it may be beneficial to explore models that can be trained on your data or opt for multilingual models.

The performance difference between a very small model and a large model is not always substantial. **Smaller models are generally less expensive and faster**, making them a practical choice in many scenarios. Therefore, it is often worth considering smaller models for their cost-effectiveness and speed.

Additionally, you should always consider the context you're providing to the model. In Meilisearch, this comes in the form of a [document template](https://www.meilisearch.com/docs/reference/api/settings?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#embedders-object). The more accurately the template describes the data, the better the search results will be, leading to a more satisfying user experience.

### 2\. Search performance

You read everywhere now. Time is money. And the web is no different. Nowadays, [search-as-you-type](https://www.meilisearch.com/docs/learn/getting_started/what_is_meilisearch?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#features) is the baseline for customer-facing applications. Saving users time greatly enhances their satisfaction and keeps them engaged with your platform.

To achieve lightning-fast search performance, **consider using a local model** to minimize latency by eliminating the need for round trips to the embedding service. If you need to use a remote model, then hosting your search service (e.g., your Meilisearch database) in close proximity to the embedding service can significantly reduce latency.

The table below showcases latency benchmarks for various local embedding models and embedding APIs. All requests are originated from a Meilisearch instance hosted on AWS (London datacenter.)

| Model/Service | Latency |
| --- | --- |
| [Cloudflare bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | ±800ms |
| [Cloudflare bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | ±500ms |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | ±170ms |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | ±160ms |
| [Local gte-small](https://huggingface.co/sentence-transformers/gte-small) | ±20ms |
| [Local all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | ±10ms |
| [Local bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | ±20ms |
| [Local bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | ±60ms |
| [Mistral](https://mistral.ai/product/embeddings/) | ±200ms |
| [Jina colbert](https://huggingface.co/jinac/cobert-v1) | ±400ms |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | ±460ms |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | ±750ms |
| [VoyageAI voyage-2](https://voyageai.com/) | ±350ms |
| [VoyageAI voyage-large-2](https://voyageai.com/) | ±400ms |

Here you can see that there are some clear winners in terms of latency. Unfortunately, latency is not the same as throughput, so we also need to take a close look at the indexing time.

### 3\. Indexing performance

Indexing performance is another critical aspect when [comparing search solutions](https://www.meilisearch.com/docs/learn/resources/comparison_to_alternatives?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison). The embedding model performance will directly impact the indexing speed of your search solution. And the speed at which your data can be indexed directly impacts the overall efficiency and scalability of your search solution.

Local **models without GPUs may have slower indexing** due to limited processing power. In contrast, third-party services offer varying speeds and limitations based on their infrastructure and service agreements. It is essential to evaluate these factors to ensure that your chosen model and service can meet your requirements effectively.

Several factors come into play when optimizing indexing. Again, the latency plays a big role: reducing the time taken for data to travel between your application and the model is always going to improve your experience. Additionally, the **maximum size of API calls** the API accepts, the provider's **rate limiting**, and the model's supported **number of dimensions** can all influence the efficiency and scalability of the indexing process.

The benchmark below compares the indexing of a 10k e-commerce documents (with [automatic embedding generation](https://www.meilisearch.com/docs/learn/experimental/vector_search?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#generate-auto-embeddings)):

| Model/Service | Indexation Time |
| --- | --- |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | 43s |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | 16s |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | 95s |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | 151s |
| [Cloudflare bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 152s |
| [Cloudflare bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 159s |
| [Jina Colbert V2](https://huggingface.co/jinac/cobert-v1) | 375s |
| [VoyageAI voyage-large-2](https://voyageai.com/) | 409s |
| [Mistral](https://mistral.ai/product/embeddings/) | 409s |
| [Local all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | 880s |
| [Local bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 3379s |
| [Local bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 9132s |

### 4\. Pricing

While local embedders are free, most services charge per million of tokens. Here's a breakdown of the pricing for each platform:

| Provider      | Price                                      |
|---------------|--------------------------------------------|
| Cohere        | $0.10 per million tokens                   |
| OpenAI        | $0.13 per million tokens for text-embedding-3-large  |
|               | $0.02 per million tokens for text-embedding-3-small  |
| Cloudflare    | $0.011 per 1,000 Neurons                   |
| Jina          | $0.18 per million tokens                   |
| Mistral       | $0.10 per million tokens                   |
| VoyageAI      | $0.10 per million tokens for voyage-2      |
|               | $0.12 per million tokens for voyage-large-2 |
|               | $0.12 per million tokens for voyage-multilingual-2 |
| Local model   | Free                                       |


As your search needs grow and scale, it may become more cost-effective to invest in your own GPU machine. By having your own hardware, you can have greater control over the performance and scalability of your search solution and potentially reduce costs in the long run.

It is often best to start with a well-known model from the list provided. They are generally easy to setup and you will easily find community resources to help you.. As the need arises, you can consider migrating the model to a cloud provider like AWS. Many services offer this option, allowing you to leverage their infrastructure for improved performance and scalability.

Alternatively, you can choose an equivalent open-source model to self-host, giving you even more flexibility and control over your search solution in the long term. Please note that optimizing local models for performance or high volume may require to scale your infrastructure accordingly.

* * *

Ready to elevate your search experience?

[Talk to a search expert](https://dub.sh/meili-sales?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison)

* * *

Going further
-------------

While this article provides a comprehensive overview, we did not delve deeply into optimization techniques. There are several additional optimizations that can be explored to further enhance the performance of semantic search.

Here is a list of additional areas to investigate when choosing a model for your search experience:

*   Experiment with different presets (query vs. document) for models that offer this option to potentially improve relevancy
*   Evaluate specialized models for specific applications to assess their performance and suitability for your use case
*   Explore models that provide a reranking function to further refine search results
*   Test higher-tier accounts on each platform to check for improved performance and reduced rate limiting
*   Investigate parameters for receiving quantized data directly from the API to optimize data transfer and processing

Conclusion
----------

| Model/Service | Dimensions | Context Length | Latency | Indexation Time | Pricing (per million tokens) |
| --- | --- | --- | --- | --- | --- |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | 1024 | 512 | ±170ms | 43s | $0.10 |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | 384 | 512 | ±160ms | 16s | $0.10 |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | 1536 | 8192 | ±460ms | 95s | $0.02 |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | 3072 | 8192 | ±750ms | 151s | $0.13 |
| [Mistral](https://mistral.ai/product/embeddings/) | 1024 | 8192 | ±200ms | 409s | $0.10 |
| [VoyageAI voyage-2](https://voyageai.com/) | 1024 | 4000 | ±350ms | 330s | $0.10 |
| [VoyageAI voyage-large-2](https://voyageai.com/) | 1536 | 16000 | ±400ms | 409s | $0.12 |
| [Jina Colbert v2](https://jina.ai/news/jina-colbert-v2-multilingual-late-interaction-retriever-for-embedding-and-reranking/) | 128, 96, or 64 | 8192 | ±400ms | 375s | $0.18 |
| [OSS all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | 384 | 512 | ±10ms | 880s | Free |
| [OSS bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 1024 | 512 | ±20ms | 3379s | Free |
| [OSS bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 1536 | 512 | ±60ms | 9132s | Free |

Choosing the right model and service for semantic search involves carefully balancing several key factors: relevancy, search performance, indexation performance, and cost.

Each option presents its own set of trade-offs:

*   Cloud-based services like Cohere and OpenAI offer excellent relevancy and reasonable latency, with Cohere's embed-english-light-v3.0 standing out for its balance of speed and performance.
*   Local models provide the fastest search latency but may struggle with indexation speed on limited hardware.
*   Emerging services like Mistral and VoyageAI show promise with competitive pricing and performance.
*   Open-source models offer cost-effective solutions for those willing to manage their own infrastructure.

Ultimately, the best choice depends on your specific use case, budget, and performance requirements. For many applications, starting with a cloud-based service like Cohere or OpenAI provides a good balance of ease of use, performance, and cost. As your needs grow, consider exploring local or specialized models, or contact Meilisearch's sales team for tailored solutions.

* * *

[Meilisearch](https://www.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) is an open-source search engine enabling developers to build state-of-the-art experiences while enjoying simple, intuitive DX.

For more things Meilisearch, you can join the community on [Discord](https://discord.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) or subscribe to the [newsletter](https://dub.sh/meili-newsletter?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison). You can learn more about the product by checking out its [roadmap](https://roadmap.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) and participating in [product discussions](https://github.com/orgs/meilisearch/discussions).

Choosing the best model for semantic search

_This is part 4 of a series of blog posts_ [_originally published on Clément Renault's blog_](https://blog.kerollmops.com/how-meilisearch-updates-a-millions-vector-embeddings-database-in-under-a-minute)_. Begin the journey with_ [_part 1_](/blog/spotify-inspired-hybrid-search-and-rust/)_,_ [_part 2_](/blog/refining-ann-performance-with-rust/)_ and_ [_part 3_](/blog/arroy-filtered-disk-ann/)_ This blog post considers that you’ve already read parts 1 and 2._

In this blog post, we’ll talk about how we implemented incremental indexing in [Arroy](https://github.com/meilisearch/arroy). By incremental, we mean that when inserting or deleting items in a tree, we can update only the required parts instead of rebuilding everything.

At Meilisearch, that’s essential because our users usually send updates regularly, and their content constantly changes. Rebuilding everything from scratch is very costly and won’t give a good experience; that’s why we already spent a lot of time on our latest release to make all the [data structures support incremental indexing](https://github.com/meilisearch/meiliSearch/releases/tag/v1.6.0) and arroy being one of them, we _HAD TO_ implement it as well!

The theory
----------

The following schema shows a high-level view of what should happen when adding and deleting documents into an existing tree.

As a reminder, arroy is a vector store based on [LMDB](http://www.lmdb.tech/doc/), an embedded transactional memory-mapped key-value store. It stores your vectors in trees composed of three kinds of nodes:

*   The split nodes - Store information on which item IDs are spread out between its left and right.
*   The descendants' nodes - Store multiple item IDs.
*   The items - A single vector.

For the following examples, we’ll consider the descendants node cannot contain **more** than two items and that the closer the IDs are, the closer the items are in space. For example, the item `1` is close to the item `2` but is farther from the item `10`.

![First step before inserting elements in the tree](https://unable-actionable-car.media.strapiapp.com/tamo_1_9ea29125b9.png)

Here, we’re trying to insert items `2` and `7` and delete items `3` and `11`.

Following what we do on the search, we split the items to insert between the left and right split nodes. But the deleted items are no longer present in the database! We don't have their associated vector, and therefore we'll need to iterate over all the leaves to find and delete them.

Fortunately, since we use roaring bitmaps, this list doesn't consume much memory, and since we never update it, we can share it with every thread without ever copying it 🎉

![Second step inserting element in the tree](https://unable-actionable-car.media.strapiapp.com/tamo_2_e4cd099c77.png)

Notice how the items to insert were balanced between the left and right split nodes. In the next step, we’ll follow the same process and split both lists of items to insert on the split node.

![Third step inserting into elements in the tree](https://unable-actionable-car.media.strapiapp.com/tamo_3_ab539d2465.png)

It’s on this step that all the good stuff happens. From the left to the right:

*   The first descendant node gets its item `3` removed, and item `2` added.
*   The second descendant node gets too big and must be replaced by a new split node.
*   The item `8` becomes a descendant containing both the items `7` and `8`.
*   After deleting item `10` in the last descendant node, we replace it with a direct link to an item to reduce the number of nodes in the tree (and improve search time by reducing the number of lookups).

![Last step inserting elements in the tree](https://unable-actionable-car.media.strapiapp.com/tamo_4_b07ebb4b8f.png)

Now that you’ve seen all the steps of our incremental indexing process, we’re still going to take a few notes on what happened:

*   In the first three steps, we had to read all of the tree nodes, which, by default, is equal to the total number of items in the database.
*   In the last step, we had to write four new tree nodes. Previously we would have rewritten the whole tree. The number of writes, which is the slowest operation in databases, is reduced to the bare minimum.
*   The process works on a single tree which means we can still multi-thread the computation of every tree.
*   The IDs aren’t sequential anymore, which doesn't play well with the ID generation strategy described in [Writing the tree in parallel](https://blog.kerollmops.com/multithreading-and-memory-mapping-refining-ann-performance-with-arroy).

How did we fix the ID generation?
---------------------------------

At the start of the indexing process, we need to gather all the existing tree IDs.  
The information we need to generate new nodes are:

*   The total number of tree nodes used to know when to stop building trees.
*   The « holes » in the used IDs that we want to re-use. This fragmentation is produced when we edit the trees.
*   The highest ID existing in the trees to generate the next new IDs.

![Selecting the next ID in the Roaring Bitmap](https://unable-actionable-car.media.strapiapp.com/tamo_5_1f7bb6a273.png)

The « simple » idea is to have a counter for the total number of tree nodes. A counter that we can increment to generate new fresh IDs. The most challenging part is to pick an available ID shared between threads and without big mutexes.

It took me quite some time to find a solution for this last point; I implemented a whole complex solution (150loc) that I ended up [rewriting entirely from scratch](https://github.com/meilisearch/arroy/pull/56/commits/0bf68e21cfd97ff00c7ef5a0ec116ba34c43c6a5) in one hour for an easy and more efficient solution. We're going to see all the ideas we went through before finding our final solution.

### Sharing an iterator over the available IDs

The first and most straightforward idea that comes to mind is to create and share an iterator over all the available IDs.

```rust
let mut available_ids = available_ids.into_iter();

roots.into_par_iter().for_each(|root| {
    // stuff
    let next_id = available_ids.next();
    // stuff
});
```

If you’re familiar with Rust, you’ll notice immediately that the `for_each` _cannot_ capture a mutable reference over the `available_ids` because we use the `into_par_iter` method from Rayon that execute the next methods on the iterator in a multi-threaded way. Which means we can't call `.next()`.

By using a mutex (short for [mutual exclusion](https://en.wikipedia.org/wiki/Mutual_exclusion)), we can make it compile:

```rust
let mut available_ids = Mutex::new(available_ids.into_iter());

roots.into_par_iter().for_each(|root| {
    // stuff
    let next_id = available_ids.lock().unwrap().next();
    // stuff
});
```

That is safe and will yield the right results, but won’t scale well as all the threads have to wait for each other on the lock.

### Let each thread own its list of IDs

When you need to remove a lock, a common solution is to split the work beforehand so each thread can work to its full capacity without ever having to know what’s happening on the other threads. That’s the solution [I implemented initially](https://github.com/meilisearch/arroy/pull/56/files/dc782ea61ef84f0ad8ad20e092476494d6eacc0c). The idea is to explode the roaring bitmap into as many smaller roaring bitmaps as there are trees to update.

The following function can split a roaring bitmap into `n` sub-bitmaps of equal size:

```rust
pub fn split_ids_in(available: RoaringBitmap, n: usize) -> Vec<RoaringBitmap> {
    // Define the number of elements per sub-bitmap
    let chunk_size = available.len() / n as u64;
    let mut ret = Vec::new();

    let mut iter = available.into_iter();
    for _ in 0..(n - 1) {
        // Create a roaring bitmap of `chunk_size` elements from the iterator without consuming it
        let available: RoaringBitmap = iter.by_ref().take(chunk_size as usize).collect();
        ret.push(available);
    }
    // the last element is going to contain everything remaining
    ret.extend(iter);

    ret
}
```

With this function available, it's then trivial to use one bitmap per tree to update with the [`zip`](https://docs.rs/rayon/latest/rayon/iter/trait.IndexedParallelIterator.html#method.zip) method on the parallel iterators of Rayon:

```rust
let available_ids = split_ids_in(available_ids, roots.len());

roots.into_par_iter().zip(available_ids).for_each(|(root, available_ids)| {
    let mut available_ids = available_ids.into_iter();
    // stuff
    let next_id = available_ids.next();
    // Here, we can use the available_ids without any locks or inter-thread synchronization
    // stuff
});
```

This works well while we're updating the already existing root trees. But later on, we may want to create new trees from scratch, and we can't know in advance how many new trees we’ll need to create. That's an issue because, without this information, we don't know how many sub-bitmaps we need to create.

At this point, I couldn’t see an easy fix to this problem, but I made the assumption that we rarely create a lot of new trees and that all new trees would use a lot of IDs. This means, giving all the IDs to the **first** new tree would _probably work out_ (it’s hard to be 100% sure without monitoring it in prod).

### The final solution

The previous solution was complex and did not even work perfectly. While I was scrolling through the documentation of the Roaring Bitmap, I saw [the `select` method](https://docs.rs/roaring/latest/roaring/bitmap/struct.RoaringBitmap.html#method.select) and immediately understood how I could make the initial approach works.

This method lets you get the values in your bitmap by index in an efficient way.  
For example, with the following values in a bitmap: `13, 14, 15, 98, 99, 100`:

*   `select(0)` returns `13`.
*   `select(3)` returns `98`.
*   `select(5)` returns `100`.
*   `select(6)` returns `None`.

With that in mind, if we share the bitmap with all threads in **read-only** and share the index in the bitmap as an atomic number, we can have multiple threads get available IDs at the same time with lock-free synchronization.

Once the `select` method returns `None`, it means we can stop picking IDs from the bitmap and instead simply generate new IDs from scratch with the old method.  
Even if it's super fast, calling the `select` method still takes some time, so once a thread gets a `None` returned from the method, we're going to update an atomic boolean telling us if there are still values to look at in the bitmap. If not, we can skip calling `select` and directly generate a new ID.

With that in mind, the cool `ConcurrentNodeIds` structure we showed you before in part 2 got a little bit more complex but it still let us generate IDs fairly without any locks!

```rust
/// A concurrent ID generator that will never return the same ID twice.
pub struct ConcurrentNodeIds {
    /// The current tree node ID we should use if no other IDs are available.
    current: AtomicU32,
    /// The total number of tree node IDs used.
    used: AtomicU64,

    /// A list of IDs to exhaust before picking IDs from `current`.
    available: RoaringBitmap,
    /// The current Nth ID to select in the bitmap.
    select_in_bitmap: AtomicU32,
    /// Tells if you should look in the roaring bitmap or if all the IDs are already exhausted.
    look_into_bitmap: AtomicBool,
}

impl ConcurrentNodeIds {
    /// Creates an ID generator returning unique IDs, avoiding the specified used IDs.
    pub fn new(used: RoaringBitmap) -> ConcurrentNodeIds {
        let last_id = used.max().map_or(0, |id| id + 1);
        let used_ids = used.len();
        let available = RoaringBitmap::from_sorted_iter(0..last_id).unwrap() - used;

        ConcurrentNodeIds {
            current: AtomicU32::new(last_id),
            used: AtomicU64::new(used_ids),
            select_in_bitmap: AtomicU32::new(0),
            look_into_bitmap: AtomicBool::new(!available.is_empty()),
            available,
        }
    }

    /// Returns a new unique ID and increases the count of IDs used.
    pub fn next(&self) -> Result<u32> {
        if self.look_into_bitmap.load(Ordering::Relaxed) {
            let current = self.select_in_bitmap.fetch_add(1, Ordering::Relaxed);
            match self.available.select(current) {
                Some(id) => Ok(id),
                None => {
                    self.look_into_bitmap.store(false, Ordering::Relaxed);
                    Ok(self.current.fetch_add(1, Ordering::Relaxed))
                }
            }
        } else {
            Ok(self.current.fetch_add(1, Ordering::Relaxed))
        }
    }
}
```

Performances in practice
------------------------

I haven’t run a lot of benchmarks yet (I would like to, though, and may update this post later), but on my benchmarks with a few hundred thousand items, here are the results I get:

![Performance improvement showed on a graph](https://unable-actionable-car.media.strapiapp.com/tamo_6_8c737d7e95.png)

*   On average, we get more than a 10x speedup after three batches of items indexed.
*   The little bumps we observe afterward that make us go from ~700ms to ~3s are due to the creation of new trees as the number of items increases.
*   I expect this benchmark to represent a worst-case scenario:
    *   All my item IDs are randomly generated, which means there are very few duplicates/updates but always new insertions and more writing.
    *   My vectors are also randomly generated with a uniform distribution, which means there shouldn’t be clusters as we observe in a real-life dataset.

This feature is now being used on production data with millions of documents, and we've seen numbers in the range of 9000 items added on a 2M items database in under a minute.

* * *

[Meilisearch](https://meilisearch.com/?ref=blog.meilisearch.com) is an open-source search engine enabling developers to build state-of-the-art experiences while enjoying simple, intuitive DX. 

For more things Meilisearch, you can join the community on [Discord](https://discord.gg/meilisearch/?ref=blog.meilisearch.com) or subscribe to the [newsletter](https://dub.sh/meili-newsletter). You can learn more about the product by checking out the [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and participating in [product discussions](https://github.com/orgs/meilisearch/discussions?ref=blog.meilisearch.com).

How Meilisearch updates a database with millions of vector embeddings in under a minute

On March 7th, we hosted a live showcase session introducing hybrid search and other Meilisearch product updates. Watch a recording and see the hybrid search demo [here](https://www.youtube.com/watch?v=Lgv8iTdWDQc&t=881s).

* * *

AI's influence on search
------------------------

The rapid advancement of AI technology is undeniably reshaping human-machine interactions. Historically, communication with machines necessitated intermediaries like programming languages and structured scripts.

Now, with the arrival of GPTs and AI-assisted bots, machine-learning models are approaching a deeper comprehension of natural human language. This evolution brings humans and machines closer, changing the way we seek and find information.

From keyword-based searches to discovery-driven inquiries, people’s approach to search evolves: we are moving from searching for known items to exploring unknown territories, searching and finding the concepts instead of focusing solely on words.

Take a streaming media company: the searches across their platform might include the inquiry for a specific movie title, such as "Back to the Future," as well as conceptually-driven searches like "Give me recommendations for a feel-good sci-fi movie from the 80s".

Consider everyday scenarios: spotting an item on the street and using an image to search for it, or conducting voice searches instead of typing in words on keyboards. These are manifestations of our changing search behaviors.

The pinnacle: hybrid search
---------------------------

While traditional search methods excel in keyword-based queries, they falter with complex, nuanced requests. This is where Meilisearch’s new hybrid search approach comes into play, enriching the efficiency and precision of our robust full-text search engine with a depth of semantic understanding, catering to a wide array of use cases driven by customer-generated data.

Integrating models from AI giants like [OpenAI](https://www.meilisearch.com/docs/learn/experimental/vector_search#generate-auto-embeddings-with-openai) (open-source embedders generation feature is set for the next release cycle), Meilisearch enables users to create and fine-tune vector embeddings, tailoring their search engine to specific business needs. Moreover, evolving AI models learn from user interactions, continuously improving search precision.

What‘s included in the new release package?
-------------------------------------------

The AI-enhanced hybrid search from Meilisearch leverages our existing robust search infrastructure, including advanced sorting, filtering, faceting, and geo-sorting capabilities, among others.

New release features
--------------------

*   **Enhanced search relevancy**: The AI-enhanced layers bring a deeper semantic understanding, significantly improving result quality.
*   **AI embedders autogeneration:** Choose between using a third-party solution like OpenAI or your own locally generated embeddings. An open-source embedders generation feature is set for the next release cycle.

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

Add a new AI embedder in Meilisearch Cloud.

*   **Improved prompting:** Enhanced to incorporate key information templates, aiding the system in prompt ingestion and relevant metadata interpretation.
*   **Semantic ratio control:** Customize your search to span anywhere from purely keyword-based to entirely semantic.  
    

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

Choose where you want your results to fall on the spectrum from pure keyword-based to fully semantic search.

*   **Multimodal search capabilities:** Expanding search functionality to include image, sound, and video content.

**Democratizing search**
------------------------

At Meilisearch, our journey has always been anchored in simplicity, performance, and out-of-the-box relevancy. Our core mission remains steadfast: make it easy to find anything anywhere by providing a go-to-search solution for every team.

> “Meilisearch's hybrid search will democratize advanced search technology, focusing on simplicity and open-source customizability”  
> \- **Quentin de Quelen, Meilisearch’s CEO and Co-founder.**

As we evolve, our methods become more sophisticated, adapting to the ever-changing needs of businesses and developers alike. In a world brimming with data, effective content discovery is essential, not just a luxury. Our vision combines innovation with accessibility, aiming to make cutting-edge search technology inclusive for all.

The launch of our hybrid search product marks a significant milestone for Meilisearch and the search technology landscape. We invite you to try the new solution and join us in shaping the future of search.

* * *

Our AI-powered hybrid search is currently in beta. Eager to try it out? Sign up for our waitlist by using the link below, and our team will be in contact soon.

[Sign up now](https://share-eu1.hsforms.com/1RN-rGYhHQPu5BNivfknlwAfg3aq?utm_source=Blog&utm_campaign=HybridSearchRelease)

* * *

Stay in the loop by subscribing to our [newsletter](https://dub.sh/meili-newsletter?&utm_source=blog&utm_campaign=HybridSearchRelease). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_source=Blog&utm_campaign=HybridSearchRelease) and participate in our [Product Discussions](https://github.com/orgs/meilisearch/discussions?utm_source=Blog&utm_campaign=HybridSearchRelease).

For anything else, join our developer community on [Discord](https://discord.com/invite/hTD5hU2yWV?utm_source=Blog&utm_campaign=HybridSearchRelease).

Introducing hybrid search: combining full-text and semantic search for optimal balance

What is a vector?
-----------------

Vectors are mathematical entities that possess both **magnitude** and **direction**. This ability to not only convey how much (magnitude) but also in which direction, makes them powerful tools for representing and manipulating different types of complex data. 

Vectors are often pictured as **arrows** pointing in a certain direction **within a space**, but they can also be translated into numbers. Representing vectors as **numerical values** makes it easier to work with them mathematically. 

Vectors are a broad mathematical concept used for various purposes across multiple fields.

Vector embeddings are a particular application of vectors in the domain of [machine learning](https://en.wikipedia.org/wiki/Machine_learning) and AI.

What is the purpose of vector embeddings?
-----------------------------------------

Machine learning models are designed to uncover patterns and relationships. They **map complex entities**, like text or images, **to points within a** [**vector space**](https://en.wikipedia.org/wiki/Vector_space). We call these vector embeddings. 

Vector embeddings, also called just embeddings, represent non-numeric data in a numerical format while **preserving the semantic meaning and relationships** of these non-numeric entities. Their goal is to allow computational models in machine learning and natural language processing (NLP) to **"understand" similarities and differences** between entities.

What is vector space embedding?
-------------------------------

In a vector space, similar entities are **positioned closely together**, indicating their semantic or contextual similarity. For instance, in the context of word embeddings, words with similar meanings are embedded near each other in the vector space. 

This spatial configuration is what enables embeddings to effectively capture and organize the **semantic relationships** between entities, a concept known as the semantic space.

What is the semantic space?
---------------------------

The semantic space is like a **virtual landscape** that each [large language model](https://en.wikipedia.org/wiki/Large_language_model) (LLM) builds as it trains. During this training phase, the model analyzes huge amounts of data to represent and understand language. The diversity and nature of the information it absorbs play a significant role in **shaping this semantic space**, which in turn influences how the LLM interprets and generates language.

Given the intricate nature of the data to be transformed, vector embeddings require **multidimensional spaces** to encompass the depth of these relationships and nuances. Depending on the **complexity of the features** they are meant to capture and the size of the dataset involved, these spaces can span a wide range, from dozens to thousands of dimensions.

This multi-dimensional space allows algorithms to interpret and process complex data in a way that mirrors human intuition and understanding.

### Illustrating the semantic space

Let’s illustrate the semantic space with a very simple example. Consider a diagram with three axes corresponding to the following semantic properties: `feline`, `juvenile`, and `canine`.

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

*   On the `feline` axis, we have the `cat`
*   On the `juvenile` axis, the `baby`
*   On the `canine` axis, we have the `dog`

By combining these axes, we can find intersections that give us more specific entities:

*   `Feline` and `juvenile` combined give us the `kitten`
*   `Juvenile` and `canine` combined give us the `puppy`

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

By assigning numerical values to these properties, we can construct a simple semantic space:

| word   | canine | feline | juvenile |
|--------|--------|--------|----------|
| dog    | 1      | 0      | 0        |
| cat    | 0      | 1      | 0        |
| baby   | 0      | 0      | 1        |
| kitten | 0      | 1      | 1        |
| puppy  | 1      | 0      | 1        |

### Embedding vectors in the semantic space

In reality, **the semantic space is more complex**, and properties are not always clearly defined. We don’t know if this is actually the `canine` property, but it’s correlated to something `canine`, and the `dog` ranks very high on this property. The numbers are not `1` or `0` but some real numbers. This complexity allows for a nuanced understanding of how words and concepts relate to each other. The actual semantic space could look like the following:

| word   | ??canine?? | ??feline?? | ??juvenile?? |
|--------|------------|------------|--------------|
| dog    | 0.95973    | 0.12       | 0.22         |
| cat    | 0.05       | 0.99954    | 0.08         |
| baby   | 0.001      | 0.002      | 0.8973       |
| kitten | 0.02       | 0.9212     | 0.8647       |
| puppy  | 0.897      | 0.04       | 0.8834       |


From these detailed values, vector embeddings are created, capturing the essence of each word in a multidimensional vector, such as `[0.95973, 0.12, 0.22]` for `dog`. These vectors do more than just position words in a space; they build a **detailed network of meanings**, with each aspect designed to reveal a bit of what the word really means. The specific dimensions and what they represent can **vary from one model to another**, reflecting the complexity of the semantic meanings they encapsulate. 

Conclusion
----------

Vector embeddings are numerical representations of complex, non-numerical data. They are generated by machine learning models using vectors of real numbers. Embedded in a high-dimensional space, these vectors encapsulate the original data’s relationships and characteristics in a format suitable for computation. 

[**Vector databases**](/blog/what-is-a-vector-database/?utm_source=blog&utm_medium=embeddings-content&utm_campaign=vector-search) like Meilisearch, are the go-to for working with embeddings, as they facilitate **similarity searches**, also known as semantic searches, which allow identification of items that are semantically similar based on their vector representations.

AI Search is coming to Meilisearch Cloud, join the waitlist:

[Join now](https://share-eu1.hsforms.com/1RN-rGYhHQPu5BNivfknlwAfg3aq?utm_source=blog&utm_medium=embeddings-content&utm_campaign=vector-search)

* * *

[Meilisearch](https://meilisearch.com/?utm_source=blog&utm_medium=embeddings-content&utm_campaign=vector-search) is an open-source search engine that not only provides state-of-the-art experiences for end users but also a simple and intuitive developer experience. 

A long-time actor in keyword search, Meilisearch enables users to address search use cases by building upon AI-powered solutions, not only supporting vector search as a vector store but also by providing hybrid search. This hybrid approach blends full-text search with semantic search, enhancing both the accuracy and comprehensiveness of search results.

For more things Meilisearch, you can join the community on [Discord](https://discord.meilisearch.com/?ref=blog.meilisearch.com) or subscribe to the [newsletter](https://dub.sh/meili-newsletter?utm_source=blog&utm_medium=embeddings-content&utm_campaign=vector-search). You can learn more about the product by checking out the [roadmap](https://roadmap.meilisearch.com/?utm_source=blog&utm_medium=embeddings-content&utm_campaign=vector-search) and participating in [product discussions](https://github.com/orgs/meilisearch/discussions?utm_source=blog&utm_medium=embeddings-content&utm_campaign=vector-search).

Meilisearch latest news and company updates