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

# Suche

> Überblick über die Suchfunktionen in Laravel. Volltextsuche, Vektorsuche, Reranking und Laravel Scout – anwendungsgerecht auswählen.

## Einführung

Es gibt mehrere Wege, in einer Anwendung eine Suche anzubieten. Laravel liefert dafür eingebaute Werkzeuge – von der reinen Stichwortsuche bis zur semantischen KI-Suche – ohne dass ein externer Dienst nötig wäre.

```mermaid theme={null}
flowchart TD
    Q["Suchanforderung"]
    Q --> A{"Reicht Stichwortsuche?"}
    A -->|Ja| B["Volltextsuche<br>whereFullText"]
    A -->|Nein – Bedeutung wichtig| C["Vektorsuche<br>whereVectorSimilarTo"]
    Q --> D{"Automatische Modellsynchronisation?"}
    D -->|Ja| E["Laravel Scout<br>Trait Searchable"]
    Q --> F{"Relevanz per KI umsortieren?"}
    F -->|Ja| G["Reranking<br>AI SDK Reranking"]
```

### Funktionsvergleich

| Funktion               | Externer Dienst                     | Merkmale                                                |
| ---------------------- | ----------------------------------- | ------------------------------------------------------- |
| `whereFullText`        | Nein                                | Eingebaute Volltextindizes in MariaDB/MySQL/PostgreSQL  |
| `whereVectorSimilarTo` | Nein (PostgreSQL + pgvector)        | Ähnlichkeitssuche über Bedeutung; benötigt AI SDK       |
| `Reranking`            | KI-Provider                         | Beliebige Ergebnismengen per KI nach Relevanz sortieren |
| Laravel Scout          | Nein (`database`-Engine) / optional | Automatische Indexsynchronisation von Eloquent-Modellen |

***

## Volltextsuche

`LIKE`-Abfragen sind praktisch für einfache Teilzeichenketten, verstehen aber keine Sprache. Volltextsuche nutzt spezialisierte Indizes, um Worten, Wortgrenzen und Relevanz zu berücksichtigen.

MariaDB, MySQL und PostgreSQL unterstützen Volltextsuche eingebaut – ganz ohne externe Dienste.

<Warning>
  Volltextsuche wird von MariaDB, MySQL und PostgreSQL unterstützt.
</Warning>

### Volltextindex anlegen

Bevor Sie eine Volltextsuche verwenden, legen Sie einen Volltextindex auf den betroffenen Spalten an.

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

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

In PostgreSQL können Sie die Sprache angeben. Für andere Sprachen als Englisch ändert sich die Wortbeugung.

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

Details finden Sie unter [Migrationen](/de/migrations).

<Info>
  **Volltextsuche für Deutsch (bzw. nicht-lateinische Sprachen)**\
  Die Unterstützung von MySQL variiert; auf AWS RDS ist z. B. nur der N-gram-Parser verfügbar, MeCab u. Ä. lässt sich nicht ergänzen. Auch PostgreSQL bietet für manche Sprachen nur eingeschränkte Wortformen. Wenn die Suchqualität kritisch ist, prüfen Sie spezialisierte Engines wie Meilisearch oder Typesense.
</Info>

### Volltextabfragen ausführen

Nach dem Anlegen des Indexes suchen Sie mit `whereFullText`. Laravel erzeugt je nach Datenbank passendes SQL (in MariaDB/MySQL `MATCH(...) AGAINST(...)`, in PostgreSQL `to_tsvector(...) @@ plainto_tsquery(...)`).

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

Für zusammengesetzte Indizes übergeben Sie dasselbe Spalten-Array.

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

<Info>
  In MariaDB/MySQL werden Treffer automatisch nach Relevanz sortiert. In PostgreSQL filtert `whereFullText` nur; für automatische Relevanzsortierung eignet sich die [Datenbank-Engine von Scout](#laravel-scout).
</Info>

Mit `orWhereFullText` fügen Sie eine Volltextsuche als OR-Bedingung an. Details im [Query-Builder](/de/query-builder).

***

## Semantische bzw. Vektorsuche

Volltextsuche basiert auf Wortgleichheit. Die Vektorsuche wählt einen grundlegend anderen Ansatz: KI erzeugt Vektor-Embeddings, mit denen die *Bedeutung* eines Textes als Zahlenarray repräsentiert wird – so lassen sich semantisch nahe Ergebnisse finden.

Beispiel: Eine Suche nach „best wineries in Napa Valley“ findet einen Artikel „Top Vineyards to Visit“, obwohl kein Wort exakt übereinstimmt.

<Note>
  Für die Vektorsuche wird das [Laravel AI SDK](/de/ai-sdk) benötigt. Unterstützt werden PostgreSQL (mit `pgvector`) und MongoDB (mit dem Paket Laravel MongoDB). In allen Postgres-Datenbanken von [Laravel Cloud](https://laravel.com/cloud) ist `pgvector` vorinstalliert.
</Note>

### Embeddings erzeugen

Ein Embedding ist ein hochdimensionales Zahlenarray, das die Bedeutung eines Textes darstellt (oft mehrere hundert bis mehrere tausend Dimensionen). Sie erzeugen es mit der Methode `toEmbeddings` der Klasse `Stringable`.

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

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

Für mehrere Texte ist die Klasse `Embeddings` effizient – ein API-Aufruf für alles.

```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, ...]]
```

Konfiguration des Embedding-Providers und Dimensionen siehe [AI-SDK-Dokumentation](/de/ai-sdk).

### Vektoren speichern und indexieren

In der Migration definieren Sie eine `vector`-Spalte. `dimensions` muss zur Ausgabe des Providers passen (z. B. `text-embedding-3-small` von OpenAI: 1536). Mit `index()` legen Sie einen HNSW-Index an, der Ähnlichkeitssuchen bei großen Datenmengen erheblich beschleunigt.

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

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

Casten Sie im Eloquent-Modell die Spalte `embedding` als `array`; PHP-Array und Datenbank-Vektorformat werden automatisch konvertiert.

```php theme={null}
protected function casts(): array
{
    return [
        'embedding' => 'array',
    ];
}
```

Details zu Vektorspalten und Indizes siehe [Migrationen](/de/migrations).

### Nach Ähnlichkeit suchen

Nach dem Speichern der Embeddings finden Sie ähnliche Datensätze mit `whereVectorSimilarTo`. Verglichen wird per Kosinus-Ähnlichkeit; Ergebnisse unterhalb von `minSimilarity` werden verworfen und die verbleibenden nach Ähnlichkeit sortiert. Der Schwellenwert liegt zwischen `0.0` und `1.0`; `1.0` bedeutet exakte Übereinstimmung.

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

Statt einem Embedding-Array können Sie auch einen String übergeben – Laravel erzeugt das Embedding automatisch. Sehr praktisch, um Benutzeranfragen direkt zu verwenden.

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

Für feinere Kontrolle stehen `whereVectorDistanceLessThan`, `selectVectorDistance` und `orderByVectorDistance` bereit. Details siehe [Query Builder](/de/query-builder) und [AI SDK](/de/ai-sdk).

***

## Reranking

Beim Reranking bringt ein KI-Modell eine bestehende Ergebnismenge in eine an der Query orientierte Reihenfolge. Anders als bei Vektorsuche müssen Sie keine Embeddings vorab berechnen und speichern; es lässt sich auf beliebige Textmengen anwenden.

Sehr effektiv ist das Muster „**Suchen → Reranken**“: Zuerst grenzen Sie mit einer Volltextsuche viele Datensätze schnell ein und lassen sie anschließend per KI umsortieren. So kombinieren Sie die Geschwindigkeit der Datenbank mit der Präzision einer KI.

```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-Collections bieten das Makro `rerank`; damit rerankieren Sie Eloquent-Ergebnisse mit Feldname (oder Closure) und Query.

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

Konfiguration und Optionen des Reranking-Providers siehe [AI SDK](/de/ai-sdk).

***

## Laravel Scout

Die bisher gezeigten Ansätze rufen Query-Builder-Methoden direkt auf. [Laravel Scout](/de/scout) geht einen anderen Weg: Ergänzen Sie am Eloquent-Modell das Trait `Searchable`, synchronisiert Scout Neuanlagen, Aktualisierungen und Löschungen automatisch mit einem Suchindex.

### Datenbank-Engine

Die eingebaute Datenbank-Engine sucht in der vorhandenen DB per Volltextsuche und `LIKE` – ohne zusätzliche Infrastruktur.

In `toSearchableArray` definieren Sie die durchsuchbaren Spalten. Über PHP-Attribute legen Sie pro Spalte die Suchstrategie fest.

```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,
        ];
    }
}
```

| Attribut              | Suchstrategie                                     |
| --------------------- | ------------------------------------------------- |
| `SearchUsingFullText` | Volltextindex (`MATCH...AGAINST` / `to_tsvector`) |
| `SearchUsingPrefix`   | Präfix-Suche (`example%`)                         |
| ohne                  | Wildcards davor und dahinter (`%example%`)        |

<Warning>
  Spalten mit `SearchUsingFullText` benötigen im Vorfeld einen [Volltextindex](/de/migrations).
</Warning>

Sobald das Trait gesetzt ist, verwenden Sie `search`. Die Datenbank-Engine von Scout liefert die Ergebnisse auch in PostgreSQL automatisch nach Relevanz sortiert.

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

### Externe Engines

Scout unterstützt auch [Algolia](https://www.algolia.com/), [Meilisearch](https://www.meilisearch.com) und [Typesense](https://typesense.org). Diese bieten fortgeschrittene Features wie Tippfehler-Toleranz, Facetten-, Geo-Suche und individuelle Ranking-Regeln.

Da Scout eine einheitliche API bereitstellt, ist der Umstieg von der Datenbank-Engine auf eine externe Engine mit minimalen Codeänderungen möglich.

<Note>
  Die meisten Anwendungen benötigen keine externe Such-Engine. Die hier vorgestellten integrierten Methoden decken die überwiegende Zahl der Anwendungsfälle ab.
</Note>

Details finden Sie im [Leitfaden zu Laravel Scout](/de/scout).

***

## Techniken kombinieren

Die gezeigten Ansätze schließen sich nicht aus. Kombinationen liefern häufig die besten Resultate.

### Volltextsuche + Reranking

Volltextsuche filtert Kandidaten schnell heraus, Reranking sortiert danach semantisch. Das kombiniert Datenbank-Geschwindigkeit mit KI-Präzision.

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

### Vektorsuche + reguläre Filter

Kombinieren Sie Vektorsuche mit gewöhnlichen `where`-Klauseln, um semantische Suche auf einer bestimmten Teilmenge auszuführen. Praktisch, wenn Sie z. B. innerhalb eines Teams oder einer Kategorie semantisch suchen wollen.

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

***

## Verwandte Seiten

<Card title="Laravel Scout" icon="magnifying-glass" href="/de/scout">
  Vollständige Anleitung, wie das Trait Searchable Modelle automatisch indiziert.
</Card>

<Card title="Laravel AI SDK" icon="sparkles" href="/de/ai-sdk">
  Konfiguration des AI SDK für Embeddings und Reranking.
</Card>

<Card title="Query Builder" icon="database" href="/de/query-builder">
  Details zu whereFullText, whereVectorSimilarTo und mehr.
</Card>

<Card title="Migrationen" icon="table" href="/de/migrations">
  Anlegen von Volltextindizes und Vektorspalten.
</Card>


## Related topics

- [Laravel Scout](/de/scout.md)
- [Basic client - Laravel Bluesky](/de/packages/laravel-bluesky/basic-client.md)
- [Laravel-Updates März 2026](/de/blog/changelog/202603.md)
- [Übersicht der neuen Features in Laravel 13](/de/blog/laravel-13-new-features.md)
- [Laravel Prompts](/de/prompts.md)