THAKURCODER BLOG

As web applications grow in complexity and user expectations soar, delivering fast, accurate, and relevant search results becomes critical. Whether you’re building a content-heavy platform, an e-commerce site, or any data-driven application, your search engine can make or break the user experience.

MySQL’s built-in full-text search serves as a decent starting point for small to mid-sized projects. However, as your application scales, you might notice the limitations: slower query times, less relevant results, and a lack of advanced features. Enter Typesense—a purpose-built, open-source search engine that’s designed to be lightning-fast, highly relevant, and incredibly easy to integrate with Laravel.

In this article, I’ll guide you through the process of migrating from MySQL’s full-text search to Typesense. Whether you’re dealing with thousands of records or millions, Typesense can handle your needs efficiently, offering a significant performance boost while enhancing the quality of your search results.

Why Consider Typesense Over MySQL?

Before diving into the technical implementation, let’s explore why you might want to make the switch from MySQL’s full-text search to Typesense. MySQL is a general-purpose relational database, and while it does offer full-text search capabilities, it wasn’t designed with search as its primary function. This can lead to several challenges as your data grows:

• Performance Bottlenecks: As the volume of data increases, MySQL’s full-text search can become sluggish, impacting user experience.
• Limited Features: MySQL lacks advanced search features such as typo tolerance, faceted search, and relevance tuning, which are essential for a modern search experience.
• Complexity in Scaling: Scaling MySQL for search purposes often requires significant infrastructure and optimization efforts.

Typesense, on the other hand, is a specialized search engine built for speed and relevance. It’s optimized for handling large-scale search queries with sub-millisecond latency, making it ideal for applications where search performance is a priority. Some of the standout features of Typesense include:

• Sub-Millisecond Search Times: Typesense is engineered to deliver results in under 50ms, even with large datasets.
• Typo Tolerance and Relevance Tuning: Out-of-the-box support for handling common spelling errors and fine-tuning result relevance based on custom criteria.
• Faceted and Filtered Search: Easily implement features like faceted search, which allows users to filter search results by categories, tags, or other attributes.
• Developer-Friendly API: Typesense offers a clean, intuitive REST API that integrates seamlessly with Laravel, reducing the overhead of complex search implementations.

Getting Started: Setting Up Typesense in Your Laravel Project

Migrating to Typesense involves setting up the Typesense server, configuring it within your Laravel application, and indexing your data. Let’s walk through these steps in detail.

1. Installing Typesense in Your Laravel Project

Start by adding the official Typesense PHP client to your Laravel project. This client acts as a bridge between your application and the Typesense server, allowing you to perform operations like indexing documents and querying the search index.

composer require typesense/typesense-php

2. Setting Up the Typesense Server

You have several options for running Typesense, including local development setups using Docker, on-premises installations, or leveraging Typesense Cloud for a managed solution. For simplicity, we’ll use Docker to spin up a local instance of Typesense.

docker run -p 8108:8108 -v/tmp/typesense-data:/data typesense/typesense:latest

This command runs the Typesense server on port 8108, storing data in a temporary directory. You can adjust the volume path to persist data across restarts if needed.

3. Configuring Laravel to Communicate with Typesense

Next, create a configuration file in your Laravel project to manage the connection details for your Typesense server. This file will include information such as the server’s host, port, and API key.

// config/typesense.php
return [
    'nodes' => [
        [
            'host' => env('TYPESENSE_HOST', 'localhost'),
            'port' => env('TYPESENSE_PORT', '8108'),
            'protocol' => env('TYPESENSE_PROTOCOL', 'http'),
        ]
    ],
    'api_key' => env('TYPESENSE_API_KEY', 'xyz'),
    'collection_name' => 'your_collection_name',
];

Make sure to add the necessary environment variables in your .env file:

TYPESENSE_HOST=localhost
TYPESENSE_PORT=8108
TYPESENSE_PROTOCOL=http
TYPESENSE_API_KEY=your_api_key

Indexing Your Data in Typesense

Now that your Typesense server is up and running, and Laravel is configured to communicate with it, the next step is to index your existing data. Unlike MySQL, where data is automatically indexed within the database, Typesense requires you to explicitly send data to be indexed.

1. Defining Your Data Schema in Typesense

Before you can index data, you need to define a schema that describes the structure of the documents you’ll be indexing. This includes specifying which fields will be searchable, which fields will be used for filtering, and how the data should be organized.

use Typesense\Client;

class CreateTypesenseSchema
{
    public function handle()
    {
        $client = new Client(config('typesense'));

        $schema = [
            'name' => 'your_collection_name',
            'fields' => [
                ['name' => 'title', 'type' => 'string'],
                ['name' => 'description', 'type' => 'string'],
                ['name' => 'author', 'type' => 'string'],
                ['name' => 'published_at', 'type' => 'int64'],
            ],
        ];

        $client->collections->create($schema);
    }
}

This script defines a collection named your_collection_name with four fields: title, description, author, and published_at. Once the schema is defined, you can start indexing your data.

2. Indexing Existing Data

To index your existing data, create a Laravel job that will fetch records from your database and send them to Typesense. This approach allows you to handle large datasets efficiently by processing the data in the background.

use Typesense\Client;
use App\Models\YourModel;

class IndexDataInTypesenseJob implements ShouldQueue
{
    public function handle()
    {
        $client = new Client(config('typesense'));
        $data = YourModel::all();

        foreach ($data as $item) {
            $document = [
                'id' => (string)$item->id,
                'title' => $item->title,
                'description' => $item->description,
                'author' => $item->author,
                'published_at' => strtotime($item->published_at),
            ];

            $client->collections['your_collection_name']->documents->create($document);
        }
    }
}

This job iterates over all records in your model, formats them according to the defined schema, and sends them to Typesense for indexing.

3. Automating Indexing on Data Changes

To keep your Typesense index in sync with your database, you can set up event listeners to automatically re-index data whenever a record is created, updated, or deleted.

use Typesense\Client;

class YourModelObserver
{
    public function created(YourModel $model)
    {
        $client = new Client(config('typesense'));
        $client->collections['your_collection_name']->documents->create($model->toArray());
    }

    public function updated(YourModel $model)
    {
        $client = new Client(config('typesense'));
        $client->collections['your_collection_name']->documents[$model->id]->update($model->toArray());
    }

    public function deleted(YourModel $model)
    {
        $client = new Client(config('typesense'));
        $client->collections['your_collection_name']->documents[$model->id]->delete();
    }
}

By registering this observer in your AppServiceProvider, you ensure that any changes to your data are immediately reflected in your Typesense index.

Implementing Search Functionality

With your data successfully indexed, the final step is to implement search functionality in your application. This involves creating a controller to handle search queries and a view to display the results.

1. Building a Search Controller

Create a controller that handles incoming search requests, queries Typesense, and returns the search results to the user.

use Typesense\Client;

class SearchController extends Controller
{
    public function search(Request $request)
    {
        $client = new Client(config('typesense'));

        $query = $request->get('q');
        $searchResults = $client->collections['your_collection_name']->documents->search([
            'q' => $query,
            'query_by' => 'title,description,author',
            'filter_by' => 'published_at:>=' . strtotime('-1 year'),
            'sort_by' => 'published_at:desc',
        ]);

        return view('search.results', compact('searchResults'));
    }
}

In this example, we’re searching across the title, description, and author fields, filtering results to only show documents published in the last year, and sorting them by the publication date in descending order

.

2. Creating a Search View

Finally, create a Blade view to display the search results. This view will iterate over the results returned by Typesense and present them in a user-friendly format.

@extends('layouts.app')

@section('content')
    <h1>Search Results</h1>

    @if($searchResults['found'])
        <ul>
            @foreach ($searchResults['hits'] as $result)
                <li>
                    <h2>{{ $result['document']['title'] }}</h2>
                    <p>{{ $result['document']['description'] }}</p>
                    <small>By {{ $result['document']['author'] }} on {{ date('M d, Y', $result['document']['published_at']) }}</small>
                </li>
            @endforeach
        </ul>
    @else
        <p>No results found for your query.</p>
    @endif
@endsection

This template displays each result’s title, description, author, and publication date, providing users with a clean and intuitive interface for interacting with your search results.

Conclusion: Unlocking the Full Potential of Search in Laravel

Migrating from MySQL’s full-text search to Typesense can be a transformative step for your Laravel application. By leveraging Typesense’s powerful search capabilities, you can provide your users with lightning-fast, highly relevant search results that enhance their overall experience.

Typesense not only boosts performance but also simplifies the implementation of advanced search features, making it a valuable addition to any data-driven application. Whether you’re dealing with content management, e-commerce, or any other domain where search is critical, Typesense offers a robust, scalable solution that grows with your application.

So why stick with the limitations of MySQL full-text search when you can supercharge your Laravel app with Typesense? The migration process is straightforward, the performance gains are significant, and your users will thank you for it.

By following this detailed guide, you should now have a solid foundation for integrating Typesense into your Laravel project. As always, the specifics of your implementation may vary depending on your application’s needs, but the principles outlined here will serve as a reliable starting point for most use cases.

🚀 Happy coding!