Si estás buscando implementar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch, este artículo te mostrará cómo hacerlo de manera sencilla, efectiva y escalable. Descubre cómo aprovechar todo el potencial de Meilisearch en tus aplicaciones KumbiaPHP, ofreciendo a tus usuarios búsquedas rápidas y resultados altamente relevantes.

¿Por qué utilizar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch?

Implementar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch permite llevar las capacidades de búsqueda de tus aplicaciones a otro nivel. Meilisearch es un motor de búsqueda rápido, potente y de fácil configuración, ideal para aplicaciones modernas que requieren búsquedas en tiempo real, autocompletado y manejo de grandes volúmenes de datos.
Además, gracias a sus capacidades de búsqueda semántica impulsada por inteligencia artificial, se pueden obtener resultados mucho más precisos incluso cuando las palabras de búsqueda no coinciden exactamente con los términos indexados.

Requisitos

Antes de comenzar a integrar un buscador avanzado de texto completo para KumbiaPHP con Meilisearch, verifica que tu entorno cumpla con los siguientes requisitos básicos:

• Tener una aplicación funcionando con KumbiaPHP 1.2 o superior.

• Tener PHP 8.0 o superior.

• Tener acceso al servidor o contenedor donde correrá Meilisearch.

• Instalar el cliente de Meilisearch para PHP con Composer:

composer require meilisearch/meilisearch-php \
guzzlehttp/guzzle \
http-interop/http-factory-guzzle:^1.0

• Instalar el nuevo ActiveRecord de KumbiaPHP si aún no lo tienes:

composer require kumbia/activerecord

Este nuevo ActiveRecord es un componente externo que puedes usar en cualquier proyecto PHP, y es requerido para que los modelos soporten los callbacks usados por el trait MeilisearchSearchable.

Configuración del Cliente Meilisearch

Crea el archivo default/app/config/meilisearch.php con la siguiente estructura:

<?php
/**
 * MeiliSearch configuration file.
 *
 * This file contains the configuration settings for connecting to MeiliSearch.
 */
return [
    'host' => 'http://127.0.0.1:7700', // Change the host
    'api_key' => '', // Change the key
];

Trait MeilisearchSearchableTrait

Crea el archivo default/app/libs/meilisearch_searchable_trait.php con el siguiente código:

<?php

use Meilisearch\Client;

/**
 * Trait MeilisearchSearchableTrait
 */
trait MeilisearchSearchableTrait
{
    /**
     * MeiliSearch client instance.
     */
    protected static ?Client $_meiliClient = null;

    /**
     * Retrieves the MeiliSearch client instance.
     */
    protected static function getMeiliClient(): Client
    {
        if (null !== self::$_meiliClient) {
            return self::$_meiliClient;
        }

        $config = \Config::read('meilisearch');
        if (!$config || !is_array($config)) {
            throw new \RuntimeException('MeiliSearch configuration not found in config file.');
        }
        $host   = $config['host'] ?? 'http://localhost:7700';
        $apiKey = $config['api_key'] ?? '';

        return self::$_meiliClient = new Client($host, $apiKey);
    }

    /**
     * Returns the index name. By default it returns the table name provided by the model.
     */
    protected static function searchableAs(): string
    {
        return static::getTable();
    }

    /**
     * Converts the model instance to an array for indexing.
     */
    abstract protected function toSearchArray(): array;

    /**
     * Callback executed after a model is created.
     * The new record is automatically added to the MeiliSearch index.
     */
    protected function _afterCreate(): void
    {
        self::getMeiliClient()
            ->index(static::searchableAs())
            ->addDocuments([$this->toSearchArray()]);
    }

    /**
     * Callback executed after a model is updated.
     * The updated record is synchronized in the MeiliSearch index.
     */
    protected function _afterUpdate(): void
    {
        self::getMeiliClient()
            ->index(static::searchableAs())
            ->updateDocuments([$this->toSearchArray()]);
    }

    /**
     * Deletes a record and synchronizes the deletion with the MeiliSearch index.
     */
    public static function delete($pk): bool
    {
        $deleted = parent::delete($pk);

        if ($deleted) {
            self::getMeiliClient()
                ->index(static::searchableAs())
                ->deleteDocument($pk);
        }

        return $deleted;
    }

    /**
     * Performs a search query on the MeiliSearch index.
     */
    public static function search(string $query, array $options = []): array
    {
        $results = self::getMeiliClient()
            ->index(static::searchableAs())
            ->search($query, $options);

        return $results->getHits();
    }

    /**
     * Bulk-imports existing records into the MeiliSearch index.
     */
    public static function importToMeilisearch(int $chunkSize = 500): void
    {
        $offset = 0;

        do {
            $records = static::filter("LIMIT $chunkSize OFFSET $offset");
            $data    = [];

            foreach ($records as $record) {
                $data[] = $record->toSearchArray();
            }

            if (!empty($data)) {
                self::getMeiliClient()
                    ->index(static::searchableAs())
                    ->addDocuments($data);
            }

            $offset += $chunkSize;
        } while (count($records) === $chunkSize);
    }
}

Ventajas del Trait MeilisearchSearchable

• Integración simple: Reutiliza fácilmente la funcionalidad en múltiples modelos.

• Automatización: Mantiene sincronizados automáticamente tus modelos con el índice de búsqueda.

• Flexibilidad: Puedes personalizar fácilmente el comportamiento de búsqueda por cada modelo.

• Inteligencia Artificial: Soporte para búsqueda semántica mediante integración con IA (OpenAI u otros proveedores).

Cómo utilizar en la práctica un buscador avanzado de texto completo para KumbiaPHP con Meilisearch

Paso 1: Implementación en Modelos

A continuación, integra el trait en tus modelos que extiendan de LiteRecord:

Ejemplo con Modelo Product

<?php

use Kumbia\ActiveRecord\LiteRecord;

class Product extends LiteRecord
{
    use MeilisearchSearchableTrait;

    protected static $table = 'products';

    protected function toSearchArray(): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'description' => $this->description,
            'price' => $this->price,
        ];
    }
}

Ejemplo con Modelo Article

<?php

use Kumbia\ActiveRecord\LiteRecord;

class Article extends LiteRecord
{
    use MeilisearchSearchableTrait;

    protected static $table = 'articles';

    protected function toSearchArray(): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'content' => $this->content,
            'author' => $this->author,
        ];
    }
}

Una vez implementado el trait en tus modelos, realizar búsquedas será simple y eficaz. Estos ejemplos prácticos ilustran claramente cómo aprovechar tu nuevo buscador avanzado de texto completo para KumbiaPHP con Meilisearch.

Paso 2: Realizar búsquedas fácilmente

Ahora puedes realizar búsquedas en tus modelos:

// Buscar productos
$products = Product::search('zapatos deportivos', ['limit' => 10]);

// Buscar artículos
$articles = Article::search('tecnología', ['limit' => 5]);

Paso 3: Importar datos existentes

Si ya tienes datos almacenados en tu base de datos, puedes importarlos fácilmente:

Product::importToMeilisearch();
Article::importToMeilisearch();

Ejemplo de Mielisearch con Controlador y Vista en KumbiaPHP

Paso 1: Crea el controlador

Controlador: app/controllers/products_controller.php

class ProductsController extends AppController
{
    public function search()
    {
        if (Input::hasPost('query')) {
            $this->results = Product::search(Input::post('query'));
        }
    }
}

Paso 2: Crea la vista

Vista: app/views/products/search.phtml

<h1>Buscar productos</h1>

<?php View::content(); ?>

<?= Form::open(); ?>
    <?= Form::text('query', 'placeholder="Buscar..."') ?>
    <?= Form::submit('Buscar') ?>
<?= Form::close(); ?>

<?php if (empty($results) && Input::post('query')): ?>
    <p>No se encontraron resultados.</p>
    <?php return 1 ?>
<?php endif; ?>

<h2>Resultados</h2>
<ul>
    <?php foreach ($results as $product): ?>
        <li>
            <strong><?= h($product['name']) ?></strong><br>
            <?= h($product['description']) ?><br>
            Precio: $<?= h($product['price']) ?>
        </li>
    <?php endforeach; ?>
</ul>

La combinación de KumbiaPHP con Meilisearch a través del trait MeilisearchSearchable te permite ofrecer una experiencia superior en búsquedas a tus usuarios. Con la posibilidad de usar IA para búsquedas semánticas, la calidad de los resultados se eleva aún más. La integración es simple, escalable y potente, haciendo que valga la pena el esfuerzo inicial.

¡Prueba esta integración y lleva tus búsquedas al siguiente nivel con KumbiaPHP y Meilisearch!

La entrada Buscador avanzado de texto completo para KumbiaPHP con Meilisearch se publicó primero en KumbiaPHP Framework PHP en español.