> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Zoeken

> Het totaalbeeld van de zoekfunctionaliteit in Laravel. Uitleg over wanneer je full-text zoeken, vectorzoeken, reranking en Laravel Scout inzet.

## Inleiding

Er zijn meerdere manieren om zoekfunctionaliteit aan je applicatie toe te voegen, afhankelijk van je use case. Laravel biedt ingebouwde tools — van keyword-matching tot semantisch zoeken met AI — zonder dat externe diensten nodig zijn.

```mermaid theme={null}
flowchart TD
    Q["Zoekvereisten"]
    Q --> A{"Volstaat keyword-matching?"}
    A -->|Yes| B["Full-text zoeken<br>whereFullText"]
    A -->|No - matchen op betekenis| C["Vectorzoeken<br>whereVectorSimilarTo"]
    Q --> D{"Automatische modelsynchronisatie nodig?"}
    D -->|Yes| E["Laravel Scout<br>Searchable-trait"]
    Q --> F{"Resultaten opnieuw rangschikken op relevantie met AI?"}
    F -->|Yes| G["Reranking<br>AI SDK Reranking"]
```

### Functievergelijking

| Functie                | Externe dienst                                     | Kenmerken                                                     |
| ---------------------- | -------------------------------------------------- | ------------------------------------------------------------- |
| `whereFullText`        | Niet nodig                                         | Ingebouwde full-text indexen van MariaDB / MySQL / PostgreSQL |
| `whereVectorSimilarTo` | Niet nodig (PostgreSQL + pgvector / MariaDB 11.7+) | Zoeken op semantische gelijkenis. Vereist de AI SDK           |
| `Reranking`            | AI-provider                                        | Willekeurige resultaatsets met AI sorteren op relevantie      |
| Laravel Scout          | Niet nodig (database-engine) / optioneel           | Automatische indexsynchronisatie van Eloquent-modellen        |

***

## Full-text zoeken

`LIKE`-query's zijn handig voor eenvoudige gedeeltelijke matches, maar begrijpen geen taal. Full-text zoeken gebruikt een speciale index en houdt rekening met woordgrenzen, woordvormen en relevantiescores.

MariaDB, MySQL en PostgreSQL ondersteunen full-text zoeken standaard; externe diensten zijn niet nodig.

<Warning>
  Full-text zoeken wordt ondersteund door MariaDB, MySQL en PostgreSQL.
</Warning>

### Een full-text index toevoegen

Om full-text zoeken te gebruiken voeg je eerst een full-text index toe aan de betreffende kolommen.

```php theme={null}
Schema::create('articles', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('body');
    $table->timestamps();

    $table->fullText(['title', 'body']); // Samengestelde index
});
```

Bij PostgreSQL kun je een taalinstelling opgeven voor de index. Bij andere talen dan Engels verandert de verwerking van woordvormen.

```php theme={null}
$table->fullText('body')->language('english');
```

Zie [Migrations](/nl/migrations) voor meer details over indexen.

<Info>
  **Aandachtspunten bij Japans full-text zoeken**\
  Japans full-text zoeken in MySQL is wat lastig in gebruik. Op AWS RDS is alleen de N-gram-parser beschikbaar en kun je geen morfologische-analyseplugin (MeCab) toevoegen, wat beperkingen oplevert. Voor MySQL op Laravel Cloud geldt vermoedelijk hetzelfde. Ook in PostgreSQL is de ondersteuning voor Japanse woordvormen beperkt. Is de precisie van Japans zoeken belangrijk, overweeg dan een gespecialiseerde engine zoals Meilisearch of Typesense.
</Info>

### Full-text query's uitvoeren

Zodra de index is toegevoegd, zoek je met de methode `whereFullText`. Laravel genereert de juiste SQL voor de gebruikte databasedriver (`MATCH(...) AGAINST(...)` bij MariaDB / MySQL, `to_tsvector(...) @@ plainto_tsquery(...)` bij PostgreSQL).

```php theme={null}
$articles = Article::whereFullText('body', 'web developer')->get();
```

Heb je een samengestelde index aangemaakt, geef dan dezelfde kolomarray door.

```php theme={null}
$articles = Article::whereFullText(
    ['title', 'body'], 'web developer'
)->get();
```

<Info>
  Bij MariaDB en MySQL worden de resultaten automatisch gesorteerd op relevantiescore. Bij PostgreSQL filtert `whereFullText` alleen de matchende records en wordt er niet op relevantie gesorteerd. Heb je op PostgreSQL automatische relevantiesortering nodig, dan is de [database-engine van Scout](#laravel-scout) een goede optie.
</Info>

Met de methode `orWhereFullText` kun je full-text zoeken ook als OR-conditie toevoegen. Zie de [querybuilder-documentatie](/nl/query-builder) voor meer details.

***

## Semantisch / vectorzoeken

Full-text zoeken leunt op keyword-matches. Vectorzoeken hanteert een fundamenteel andere aanpak: met door AI gegenereerde vector-embeddings wordt de *betekenis* van tekst als numerieke array weergegeven en wordt gezocht naar semantisch nabije resultaten.

Zo levert een zoekopdracht naar "best wineries in Napa Valley" een artikel op met de titel "Top Vineyards to Visit". De woorden komen niet overeen, maar de betekenis wel.

<Note>
  Voor vectorzoeken is de [Laravel AI SDK](/nl/ai-sdk) nodig; ondersteund worden PostgreSQL (vereist de `pgvector`-extensie), MariaDB 11.7 en hoger, en MongoDB (vereist het Laravel MongoDB-pakket). Op alle Postgres-databases van [Laravel Cloud](https://laravel.com/cloud) is `pgvector` vooraf geïnstalleerd.
</Note>

### Embeddings genereren

Een embedding is een hoogdimensionale numerieke array (meestal honderden tot duizenden dimensies) die de betekenis van tekst weergeeft. Je genereert er een met de methode `toEmbeddings` van Laravels `Stringable`-klasse.

```php theme={null}
use Illuminate\Support\Str;

$embedding = Str::of('Napa Valley has great wine.')->toEmbeddings();
```

Wil je meerdere teksten in één keer verwerken, dan is de klasse `Embeddings` efficiënter (er is maar één API-aanroep nodig).

```php theme={null}
use Laravel\Ai\Embeddings;

$response = Embeddings::for([
    'Napa Valley has great wine.',
    'Laravel is a PHP framework.',
])->generate();

$response->embeddings; // [[0.123, 0.456, ...], [0.789, 0.012, ...]]
```

Zie de [AI SDK-documentatie](/nl/ai-sdk) voor de configuratie van embedding-providers en het aanpassen van het aantal dimensies.

### Vectoren opslaan en indexeren

Om vector-embeddings op te slaan definieer je in een migratie een `vector`-kolom. Stem `dimensions` af op het aantal outputdimensies van je embedding-provider (bijvoorbeeld: `text-embedding-3-small` van OpenAI heeft 1536 dimensies). Roep `index()` aan om een HNSW-index te maken; dat versnelt gelijkenisonderzoek op grote datasets aanzienlijk.

```php theme={null}
Schema::ensureVectorExtensionExists(); // pgvector-extensie inschakelen

Schema::create('documents', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->vector('embedding', dimensions: 1536)->index();
    $table->timestamps();
});
```

Op Eloquent-modellen gebruik je de `AsVector`-cast om de conversie tussen PHP-arrays en het vectorformaat van de database te automatiseren.

```php theme={null}
use Illuminate\Database\Eloquent\Casts\AsVector;

protected function casts(): array
{
    return [
        'embedding' => AsVector::class,
    ];
}
```

Zie [Migrations](/nl/migrations) voor meer details over vectorkolommen en -indexen.

### Zoeken op gelijkenis

Zodra de embeddings zijn opgeslagen, zoek je vergelijkbare records met de methode `whereVectorSimilarTo`. Deze vergelijkt vectoren op cosinusgelijkenis, filtert resultaten onder de `minSimilarity`-drempel weg en sorteert automatisch op relevantie. De drempel is een waarde tussen `0.0` en `1.0`, waarbij `1.0` een exacte match betekent.

```php theme={null}
$documents = Document::query()
    ->whereVectorSimilarTo('embedding', $queryEmbedding, minSimilarity: 0.4)
    ->limit(10)
    ->get();
```

Geef je een string door in plaats van een embedding-array, dan genereert Laravel automatisch de embedding. Erg handig, want zo kun je de zoekquery van de gebruiker rechtstreeks doorgeven.

```php theme={null}
$documents = Document::query()
    ->whereVectorSimilarTo('embedding', 'best wineries in Napa Valley')
    ->limit(10)
    ->get();
```

Heb je fijnmazigere controle nodig, dan zijn ook `whereVectorDistanceLessThan`, `selectVectorDistance` en `orderByVectorDistance` beschikbaar. Zie de [querybuilder-documentatie](/nl/query-builder) en de [AI SDK-documentatie](/nl/ai-sdk) voor meer details.

***

## Reranking

Reranking is een techniek waarbij een AI-model een resultaatset opnieuw sorteert op relevantie voor de query. Anders dan bij vectorzoeken hoef je geen embeddings vooraf te berekenen en op te slaan; je kunt het toepassen op elke willekeurige tekstcollectie.

Vooral het patroon "**zoeken → reranken**" is effectief: eerst snel een grote hoeveelheid records inperken met full-text zoeken en daarna reranking toepassen. Zo combineer je de snelheid van de database met de precisie van AI.

```php theme={null}
use Laravel\Ai\Reranking;

$response = Reranking::of([
    'Django is a Python web framework.',
    'Laravel is a PHP web application framework.',
    'React is a JavaScript library for building user interfaces.',
])->rerank('PHP frameworks');

$response->first()->document; // "Laravel is a PHP web application framework."
```

Laravel-collecties hebben een `rerank`-macro: je geeft alleen een veldnaam (of closure) en een query door om Eloquent-resultaten te reranken.

```php theme={null}
$articles = Article::all()
    ->rerank('body', 'Laravel tutorials');
```

Zie de [AI SDK-documentatie](/nl/ai-sdk) voor de configuratie van reranking-providers en de beschikbare opties.

***

## Laravel Scout

Alle zoektechnieken tot nu toe riepen rechtstreeks querybuilder-methoden aan. [Laravel Scout](/nl/scout) hanteert een andere aanpak: voeg de `Searchable`-trait toe aan een Eloquent-model en Scout synchroniseert de zoekindex automatisch bij het aanmaken, bijwerken en verwijderen van records.

### Database-engine

De ingebouwde database-engine van Scout voert full-text en `LIKE`-zoekopdrachten uit op je bestaande database. Er is geen externe dienst of extra infrastructuur nodig.

Met de methode `toSearchableArray` definieer je de doorzoekbare kolommen. Via PHP-attributen geef je per kolom een zoekstrategie op.

```php theme={null}
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Attributes\SearchUsingFullText;
use Laravel\Scout\Attributes\SearchUsingPrefix;
use Laravel\Scout\Searchable;

class Article extends Model
{
    use Searchable;

    #[SearchUsingPrefix(['id'])]
    #[SearchUsingFullText(['title', 'body'])]
    public function toSearchableArray(): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'body' => $this->body,
        ];
    }
}
```

| Attribuut             | Zoekstrategie                                                 |
| --------------------- | ------------------------------------------------------------- |
| `SearchUsingFullText` | Full-text index gebruiken (`MATCH...AGAINST` / `to_tsvector`) |
| `SearchUsingPrefix`   | Prefix-match (`example%`)                                     |
| Geen                  | Wildcards aan beide zijden (`%example%`)                      |

<Warning>
  Kolommen waarop je `SearchUsingFullText` toepast, hebben vooraf een [full-text index](/nl/migrations) nodig.
</Warning>

Na het toevoegen van de trait kun je het model doorzoeken met de `search`-methode. De database-engine van Scout geeft ook op PostgreSQL de resultaten automatisch terug op relevantievolgorde.

```php theme={null}
$articles = Article::search('Laravel')->get();
```

### Third-party engines

Scout ondersteunt ook third-party zoekengines zoals [Algolia](https://www.algolia.com/), [Meilisearch](https://www.meilisearch.com) en [Typesense](https://typesense.org). Deze bieden geavanceerde functies als typo-tolerantie, facetzoeken, geo-zoeken en custom ranking.

Omdat Scout een uniforme API biedt, zijn er slechts minimale codewijzigingen nodig als je later van de database-engine naar een third-party engine migreert.

<Note>
  De meeste applicaties hebben geen externe zoekengine nodig. De ingebouwde technieken op deze pagina dekken de overgrote meerderheid van de use cases.
</Note>

Zie de [Laravel Scout-gids](/nl/scout) voor meer details over Scout.

***

## Technieken combineren

De zoektechnieken op deze pagina sluiten elkaar niet uit. Door ze te combineren behaal je de beste resultaten.

### Full-text zoeken + reranking

Beperk snel de kandidaten met full-text zoeken en sorteer ze daarna met reranking op semantische relevantie. Een patroon dat databasesnelheid en AI-precisie combineert.

```php theme={null}
$articles = Article::query()
    ->whereFullText('body', $request->input('query'))
    ->limit(50)
    ->get()
    ->rerank('body', $request->input('query'), limit: 10);
```

### Vectorzoeken + gewone filters

Combineer vectorgelijkenisonderzoek met gewone `where`-clausules voor semantisch zoeken binnen een specifieke subset. Handig als je semantisch wilt zoeken terwijl je filtert op team of categorie.

```php theme={null}
$documents = Document::query()
    ->where('team_id', $user->team_id)
    ->whereVectorSimilarTo('embedding', $request->input('query'))
    ->limit(10)
    ->get();
```

***

## Gerelateerde pagina's

<Card title="Laravel Scout" icon="magnifying-glass" href="/nl/scout">
  De complete gids voor automatische indexsynchronisatie van modellen met de Searchable-trait.
</Card>

<Card title="Laravel AI SDK" icon="sparkles" href="/nl/ai-sdk">
  De configuratie van de AI SDK die nodig is voor vector-embeddings en reranking.
</Card>

<Card title="Querybuilder" icon="database" href="/nl/query-builder">
  Details over querybuilder-methoden zoals whereFullText en whereVectorSimilarTo.
</Card>

<Card title="Migrations" icon="table" href="/nl/migrations">
  Hoe je full-text indexen en vectorkolommen aanmaakt.
</Card>


## Related topics

- [Laravel Scout](/nl/scout.md)
- [Basic client - Laravel Bluesky](/nl/packages/laravel-bluesky/basic-client.md)
- [Laravel-updates van augustus 2026](/nl/blog/changelog/202608.md)
- [Laravel Prompts](/nl/prompts.md)
- [Laravel AI SDK](/nl/ai-sdk.md)