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

# Amazon Bedrock-driver voor de Laravel AI SDK

> Amazon Bedrock-driver voor de Laravel AI SDK. Ondersteunt tekstgeneratie, streaming, tool-gebruik, gestructureerde output, bestandsbijlagen, gespreksgeschiedenis, embeddings, beeldgeneratie, audio (TTS) en reranking.

## Overzicht

[revolution/laravel-amazon-bedrock](https://github.com/invokable/laravel-amazon-bedrock) is een driver om Amazon Bedrock te gebruiken met de [Laravel AI SDK](https://laravel.com/docs/ai-sdk). Je kunt meerdere Bedrock-modellen aansturen via de uniforme API van de Laravel AI SDK.

| Functie                         | Beschikbaar met alleen een Bedrock API-key | Ondersteunde modellen / services                                                                                         |
| ------------------------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
| Tekstgeneratie / streaming      | ✅                                          | Anthropic Claude, Amazon Nova en de meeste andere Bedrock-modellen (allemaal via de Converse API)                        |
| Tool-gebruik (function calling) | ✅                                          |                                                                                                                          |
| Gestructureerde output          | ✅                                          |                                                                                                                          |
| Bestandsbijlagen                | ✅                                          | Afbeeldingen, documenten, audio en video als bijlage via de Converse API (ondersteunde formaten verschillen per model)   |
| Beeldgeneratie                  | ✅                                          | Stability AI (standaard), Amazon Nova Canvas (deprecated)                                                                |
| Audio (TTS)                     | ⚠️                                         | Amazon Polly (generative / neural / long-form / standard engines)                                                        |
| Transcriptie (STT)              | ❌                                          | Niet ondersteund                                                                                                         |
| Embeddings                      | ✅                                          | Amazon Titan Embeddings V2 (standaard), Cohere Embed English/Multilingual V3, Cohere Embed V4 (met batch-ondersteuning)  |
| Reranking                       | ⚠️                                         | Cohere Rerank 3.5, Amazon Rerank 1.0                                                                                     |
| Bestanden                       | ✅                                          | Lokale bestandsbijlagen worden ondersteund bij tekstgeneratie. Server-side uploads en `fromId()` worden niet ondersteund |

<Info>
  Een `⚠️` in de tabel betekent niet "de functie wordt niet ondersteund", maar "niet bruikbaar met alleen een Bedrock API-key".
</Info>

<Info>
  In Laravel AI SDK v0.6.3 is officiële ondersteuning toegevoegd voor Text, Image en Embeddings met een Bedrock API-key. Dit pakket ondersteunt ook functies die niet beschikbaar zijn in de officiële integratie, zoals audio (TTS) via Amazon Polly en reranking, en blijft daarom gepubliceerd.
</Info>

De belangrijkste kenmerken:

* **Authenticatie**: kies uit een Bedrock API-key, AWS IAM-credentials (SigV4) of de standaard AWS-credentialketen (IAM-rollen, instance profiles, enz.).
* **Failover**: ondersteunt de multi-provider failover van de AI SDK. Rate limits (429), overbelasting (503, 529) en credit-gerelateerde fouten worden gemapt naar failover-geschikte excepties.
* **Cache-controle**: ephemeral caching is altijd ingeschakeld voor de systeemprompt van de [Bedrock Converse API](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html).
* **Uniforme API**: alle modellen zoals Anthropic Claude, Amazon Nova, Meta Llama en Mistral zijn via de Bedrock Converse API met één uniforme interface te gebruiken.

## Vereisten

* PHP >= 8.3
* Laravel >= 12.x

## Installatie

<Steps>
  <Step title="Installeer het pakket">
    ```bash theme={null}
    composer require revolution/laravel-amazon-bedrock
    ```
  </Step>

  <Step title="Publiceer de AI SDK-configuratie">
    ```bash theme={null}
    php artisan vendor:publish --provider="Laravel\Ai\AiServiceProvider"
    ```
  </Step>
</Steps>

## Configuratie

Voeg de provider `amazon-bedrock` toe aan `config/ai.php`. Zet indien nodig ook de standaardproviders om naar Bedrock.

```php theme={null}
'default' => 'amazon-bedrock',
'default_for_images' => 'amazon-bedrock',
'default_for_audio' => 'amazon-bedrock',
'default_for_embeddings' => 'amazon-bedrock',
'default_for_reranking' => 'amazon-bedrock',
```

### Optie 1: Bedrock API-key

```php theme={null}
'providers' => [
    'amazon-bedrock' => [
        'driver' => 'amazon-bedrock',
        'key'    => env('AWS_BEDROCK_API_KEY', ''),
        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    ],
],
```

```dotenv theme={null}
AWS_BEDROCK_API_KEY=your_api_key
AWS_DEFAULT_REGION=us-east-1
```

Je haalt een Bedrock API-key op via de AWS Management Console.

<Warning>
  Een Bedrock API-key werkt uitsluitend met de Bedrock Runtime API. Je kunt hem niet gebruiken voor reranking (dat `bedrock-agent-runtime` gebruikt) of Amazon Polly (TTS). Gebruik daarvoor SigV4 of de standaard AWS-credentialketen.
</Warning>

### Optie 2: AWS IAM-credentials (SigV4)

Gebruik een AWS access key en secret key die worden ondertekend met [Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html).

```php theme={null}
'providers' => [
    'amazon-bedrock' => [
        'driver' => 'amazon-bedrock',
        'key'    => env('AWS_ACCESS_KEY_ID'),
        'secret' => env('AWS_SECRET_ACCESS_KEY'),
        'token'  => env('AWS_SESSION_TOKEN'),
        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    ],
],
```

```dotenv theme={null}
AWS_ACCESS_KEY_ID=AKIA...
AWS_SECRET_ACCESS_KEY=wJalr...
AWS_SESSION_TOKEN= # optioneel (voor tijdelijke STS-credentials)
AWS_DEFAULT_REGION=us-east-1
```

<Info>
  Stel `AWS_SESSION_TOKEN` alleen in als je tijdelijke credentials (STS) gebruikt.
</Info>

### Optie 3: standaard AWS-credentialketen (IAM-rol)

In omgevingen met een IAM-rol, zoals EC2 / ECS / Lambda, kun je `key` en `secret` weglaten en de [standaard AWS-credentialproviderketen](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) gebruiken.

```php theme={null}
'providers' => [
    'amazon-bedrock' => [
        'driver' => 'amazon-bedrock',
        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    ],
],
```

```dotenv theme={null}
AWS_DEFAULT_REGION=us-east-1
```

De standaard credentialketen wordt automatisch opgelost via omgevingsvariabelen, het gedeelde credentialsbestand (`~/.aws/credentials`), ECS-taakrollen, EC2 instance profiles en meer.

### Optionele configuratiesleutels

| Sleutel                        | Beschrijving                           | Standaardwaarde                    |
| ------------------------------ | -------------------------------------- | ---------------------------------- |
| `secret`                       | AWS secret access key (SigV4)          | —                                  |
| `token`                        | AWS session token (SigV4)              | —                                  |
| `timeout`                      | Time-out voor HTTP-requests (seconden) | 30                                 |
| `max_tokens`                   | Standaard max tokens per request       | 8096                               |
| `models.text.default`          | Standaard tekstmodel                   | Claude Sonnet                      |
| `models.text.cheapest`         | Goedkoopste tekstmodel                 | Claude Haiku                       |
| `models.text.smartest`         | Best presterende tekstmodel            | Claude Opus / Fable                |
| `models.embeddings.default`    | Standaard embeddingmodel               | `amazon.titan-embed-text-v2:0`     |
| `models.embeddings.dimensions` | Standaard aantal embedding-dimensies   | `1024`                             |
| `models.image.default`         | Standaard beeldmodel                   | `stability.stable-image-core-v1:1` |
| `models.audio.default`         | Standaard audio-engine (TTS)           | `generative`                       |
| `models.reranking.default`     | Standaard rerankingmodel               | `cohere.rerank-v3-5:0`             |

## Tekstgeneratie

### Agent-klasse

Maak een Agent-klasse met het Artisan-commando.

```bash theme={null}
php artisan make:agent BedrockAgent
```

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

namespace App\Ai\Agents;

use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Promptable;

class BedrockAgent implements Agent
{
    use Promptable;

    public function instructions(): string
    {
        return 'Je bent een expert in softwareontwikkeling.';
    }
}
```

```php theme={null}
use App\Ai\Agents\BedrockAgent;

$response = (new BedrockAgent)->prompt('Vertel me over Laravel.');

echo $response->text;
```

### Anonymous Agent

Wil je snel aan de slag zonder een klasse aan te maken, gebruik dan de `agent()`-helper.

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

$response = agent(
    instructions: 'Je bent een expert in softwareontwikkeling.',
)->prompt('Vertel me over Laravel.');

echo $response->text;
```

### Streaming

```php theme={null}
use App\Ai\Agents\BedrockAgent;
use Illuminate\Support\Facades\Route;

Route::get('/stream', function () {
    return (new BedrockAgent)->stream('Vertel me over Laravel.');
});
```

Je kunt events ook handmatig verwerken.

```php theme={null}
use Laravel\Ai\Streaming\Events\TextDelta;

use function Laravel\Ai\agent;

$stream = agent(
    instructions: 'Je bent een expert in softwareontwikkeling.',
)->stream('Vertel me over Laravel.');

foreach ($stream as $event) {
    if ($event instanceof TextDelta) {
        echo $event->delta;
    }
}
```

### Tool-gebruik (function calling)

Definieer tools die tijdens de generatie worden aangeroepen.

```php theme={null}
use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Ai\Contracts\Tool;
use Laravel\Ai\Tools\Request;

class GetWeather implements Tool
{
    public function description(): string
    {
        return 'Geeft het huidige weer voor een stad terug.';
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'city' => $schema->string()->required()->description('Naam van de stad'),
        ];
    }

    public function handle(Request $request): string
    {
        // Roep hier een weer-API aan
        return json_encode(['temperature' => 22, 'condition' => 'sunny']);
    }
}
```

Gebruik de tool vanuit een Agent.

```php theme={null}
use App\Ai\Tools\GetWeather;
use Laravel\Ai\Attributes\MaxSteps;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\HasTools;
use Laravel\Ai\Promptable;

#[MaxSteps(5)]
class WeatherAgent implements Agent, HasTools
{
    use Promptable;

    public function tools(): array
    {
        return [new GetWeather];
    }

    public function instructions(): string
    {
        return 'Je bent een weerassistent.';
    }
}

$response = (new WeatherAgent)->prompt('Wat is het weer in Tokio?');
echo $response->text;
```

Dit werkt ook met een Anonymous Agent.

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

$response = agent(
    instructions: 'Je bent een weerassistent.',
    tools: [new GetWeather],
    maxSteps: 5,
)->prompt('Wat is het weer in Tokio?');
```

Tool-aanroepen werken ook bij streaming. De SDK voert de tools automatisch uit en zet het gesprek voort totdat er een definitief tekstantwoord is.

### Bestandsbijlagen

Met de parameter `attachments` kun je afbeeldingen, documenten, audio- en videobestanden aan een prompt toevoegen. De Bedrock Converse API verwerkt de bijlageblokken, maar welke formaten daadwerkelijk werken hangt af van het model (Anthropic Claude ondersteunt bijvoorbeeld alleen afbeeldingen en documenten).

```php theme={null}
use Laravel\Ai\Files\Document;
use Laravel\Ai\Files\Image;

use function Laravel\Ai\agent;

// Een afbeelding van een lokaal pad bijvoegen
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
)->prompt('Beschrijf deze afbeelding.', attachments: [
    Image::fromPath('/path/to/photo.jpg'),
]);

// Een document van een URL bijvoegen
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
)->prompt('Vat dit document samen.', attachments: [
    Document::fromUrl('https://example.com/report.pdf'),
]);

// Bijvoegen vanuit een string (met expliciet formaat)
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
)->prompt('Analyseer deze tekst.', attachments: [
    Document::fromString($csvContent, 'text/csv')->as('data.csv'),
]);
```

De ondersteunde bijlagetypen zijn `Image`, `Document` en `Audio` uit `Laravel\Ai\Files\*`. Video's kun je bijvoegen via `Illuminate\Http\UploadedFile`.

<Info>
  Server-side bestandsuploads (`Document::fromPath()->put()`) en hergebruik via ID (`Document::fromId()`) worden niet ondersteund op Bedrock.
</Info>

### Gespreksgeschiedenis

Om een gesprek over meerdere beurten vast te houden, implementeer je de `Conversational`-interface in je Agent-klasse. Als je in `messages()` de eerdere gespreksberichten teruggeeft, worden die automatisch bij elke prompt meegestuurd.

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

namespace App\Ai\Agents;

use App\Models\ChatHistory;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\Conversational;
use Laravel\Ai\Messages\Message;
use Laravel\Ai\Promptable;

class ChatAgent implements Agent, Conversational
{
    use Promptable;

    public function __construct(public int $userId) {}

    public function instructions(): string
    {
        return 'Je bent een behulpzame assistent.';
    }

    public function messages(): iterable
    {
        return ChatHistory::where('user_id', $this->userId)
            ->latest()
            ->limit(20)
            ->get()
            ->reverse()
            ->map(fn ($m) => new Message($m->role, $m->content))
            ->all();
    }
}
```

```php theme={null}
$response = (new ChatAgent(auth()->id()))->prompt('Waar hadden we het vorige keer over?');
```

#### Automatisch opslaan met `RemembersConversations`

Wil je `messages()` niet zelf implementeren, dan kun je met de trait `RemembersConversations` gesprekken volledig automatisch laten opslaan. Hiervoor zijn de databasetabellen van de AI SDK nodig, dus voer eerst `php artisan vendor:publish --provider="Laravel\Ai\AiServiceProvider" && php artisan migrate` uit.

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

namespace App\Ai\Agents;

use Laravel\Ai\Concerns\RemembersConversations;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\Conversational;
use Laravel\Ai\Promptable;

class ChatAgent implements Agent, Conversational
{
    use Promptable, RemembersConversations;

    public function instructions(): string
    {
        return 'Je bent een behulpzame assistent.';
    }
}
```

Start een nieuw gesprek.

```php theme={null}
$response = (new ChatAgent)->forUser($user)->prompt('Hallo!');

$conversationId = $response->conversationId;
```

Zet een bestaand gesprek voort.

```php theme={null}
$response = (new ChatAgent)
    ->continue($conversationId, as: $user)
    ->prompt('Vertel me daar meer over.');
```

De Bedrock-driver voegt de gespreksgeschiedenis automatisch toe aan Bedrock Converse API-requests, zodat alle ondersteunde modellen context hebben in multi-turn gesprekken.

### Gestructureerde output

Implementeer de `HasStructuredOutput`-interface om getypeerde antwoorden te krijgen.

```php theme={null}
use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\HasStructuredOutput;
use Laravel\Ai\Promptable;

class ExtractPerson implements Agent, HasStructuredOutput
{
    use Promptable;

    public function instructions(): string
    {
        return 'Haal persoonsinformatie uit de gegeven tekst.';
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'name' => $schema->string()->description('Volledige naam van de persoon'),
            'age' => $schema->integer()->description('Leeftijd'),
            'occupation' => $schema->string()->description('Beroep'),
        ];
    }
}

$response = (new ExtractPerson)->prompt('John is een 30-jarige software-engineer.');

echo $response['name'];       // "John"
echo $response['age'];        // 30
echo $response['occupation']; // "software engineer"
```

Gestructureerde output werkt ook met een Anonymous Agent.

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

$response = agent(
    instructions: 'Haal persoonsinformatie uit de gegeven tekst.',
    schema: fn (JsonSchema $schema) => [
        'name' => $schema->string()->description('Volledige naam van de persoon'),
        'age' => $schema->integer()->description('Leeftijd'),
    ],
)->prompt('Alice is 25 years old.');

echo $response['name']; // "Alice"
echo $response['age'];  // 25
```

Intern wordt een synthetische tool (`output_structured_data`) aangemaakt die waarden volgens het schema laat teruggeven. Deze aanpak is via de Converse API compatibel met alle modellen op Bedrock.

### Converse API (alle modellen)

Alle tekstgeneratie en streaming loopt via de [Bedrock Converse API](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html). Dit is uniform, inclusief Anthropic Claude, zodat je diverse modellen op Bedrock — Amazon Nova, Meta Llama, Mistral, Cohere, DeepSeek en meer — met dezelfde interface kunt gebruiken.

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

// Anthropic Claude (via de Converse API)
$response = agent(
    instructions: 'Je bent een expert in softwareontwikkeling.',
    model: 'global.anthropic.claude-sonnet-4-6',
)->prompt('Vertel me over Laravel.');

// Amazon Nova
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
    model: 'amazon.nova-pro-v1:0',
)->prompt('Vertel me over AWS.');

// Meta Llama
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
    model: 'meta.llama3-1-70b-instruct-v1:0',
)->prompt('Leg quantumcomputing uit.');

// Mistral
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
    model: 'mistral.mistral-large-2402-v1:0',
)->prompt('Schrijf een haiku over programmeren.');

// Cohere Command R+
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
    model: 'cohere.command-r-plus-v1:0',
)->prompt('Vat deze tekst samen.');

// DeepSeek R1
$response = agent(
    instructions: 'Je bent een behulpzame assistent.',
    model: 'deepseek.r1-v1:0',
)->prompt('Los dit wiskundeprobleem op.');
```

Streaming, tool-gebruik, gestructureerde output en bestandsbijlagen werken op modellen die deze functies ondersteunen. Zie het [overzicht van ondersteunde Bedrock-modellen](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-supported-models-features.html) voor details.

### Provider Options

Implementeer `HasProviderOptions` om Bedrock-specifieke opties zoals `anthropic_version` door te geven.

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

namespace App\Ai\Agents;

use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\HasProviderOptions;
use Laravel\Ai\Enums\Lab;
use Laravel\Ai\Promptable;

class BedrockAgent implements Agent, HasProviderOptions
{
    use Promptable;

    public function instructions(): string
    {
        return 'Je bent een expert in softwareontwikkeling.';
    }

    public function providerOptions(Lab|string $provider): array
    {
        return [
            'top_p' => 0.9,
        ];
    }
}
```

Ondersteunde Provider Options:

| Optie                          | Beschrijving                                          | Standaardwaarde |
| ------------------------------ | ----------------------------------------------------- | --------------- |
| `top_k`                        | Top-K sampling-parameter                              | —               |
| `top_p`                        | Top-P (nucleus) sampling-parameter                    | —               |
| `additionalModelRequestFields` | Modelspecifieke extra parameters voor de Converse API | —               |

### Configuratie-attributen voor Agents

Je kunt opties voor tekstgeneratie instellen met PHP-attributen.

```php theme={null}
use Laravel\Ai\Attributes\MaxTokens;
use Laravel\Ai\Attributes\Temperature;
use Laravel\Ai\Attributes\Timeout;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Promptable;

#[MaxTokens(4096)]
#[Temperature(0.7)]
#[Timeout(120)]
class BedrockAgent implements Agent
{
    use Promptable;

    // ...
}
```

## Beeldgeneratie

Genereer afbeeldingen met Stability AI-modellen (standaard) of Amazon Nova Canvas.

```php theme={null}
use Laravel\Ai\Image;
use Revolution\Amazon\Bedrock\Bedrock;

// Standaard wordt Stability AI Stable Image Core gebruikt
$response = Image::of('een schattige steampunkrobot')->generate(provider: Bedrock::KEY);

// De eerste afbeelding ophalen
$image = $response->firstImage();

// Opslaan op schijf
$response->store('images', 's3');

// Uitvoeren als HTML <img>-tag
echo $response->toHtml('steampunkrobot');
```

Beschikbare Stability AI-modellen (allemaal vereisen ze de regio `us-west-2`):

```php theme={null}
// Stable Image Core — snel en goedkoop (standaard)
$response = Image::of('landschap')
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-core-v1:1');

// Stable Diffusion 3.5 Large — hoge kwaliteit, grootschalige generatie
$response = Image::of('portret')
    ->generate(provider: Bedrock::KEY, model: 'stability.sd3-5-large-v1:0');

// Stable Image Ultra — ultrarealistisch, hoogste kwaliteit
$response = Image::of('luxueus product')
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-ultra-v1:1');
```

<Info>
  De beeldmodellen van Stability AI zijn alleen beschikbaar in `us-west-2`. Stel `AWS_DEFAULT_REGION=us-west-2` in wanneer je deze modellen gebruikt.
</Info>

### Beeldbewerking met Stability AI

De bewerkingsmodellen van Stability AI Image Services zijn ook beschikbaar via de `attachments()`-methode. Je geeft een invoerafbeelding door en transformeert die met een bewerkingsmodel.

```php theme={null}
use Laravel\Ai\Files\Image as ImageFile;
use Laravel\Ai\Image;
use Revolution\Amazon\Bedrock\Bedrock;

$inputImage = ImageFile::fromPath('/path/to/photo.jpg');

// Inpaint — gebieden herschilderen met een masker of alfakanaal
$response = Image::of('vervang de achtergrond door een bos')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-inpaint-v1:0');

// Erase — ongewenste elementen verwijderen
$response = Image::of('')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-erase-object-v1:0');

// Achtergrond verwijderen en alleen het onderwerp uitsnijden
$response = Image::of('')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-remove-background-v1:0');

// Search and Replace — een via de prompt aangegeven object vervangen
$response = Image::of('kat')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-search-replace-v1:0');

// Style Transfer — de stijl uit de prompt toepassen
$response = Image::of('in olieverfstijl')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-style-transfer-v1:0');
```

Beschikbare Stability AI-bewerkingsmodellen (allemaal beschikbaar in `us-east-1`, `us-east-2` en `us-west-2`):

| Model ID                                        | Beschrijving                                               |
| ----------------------------------------------- | ---------------------------------------------------------- |
| `stability.stable-image-inpaint-v1:0`           | Inpaint — geselecteerde gebieden herschilderen             |
| `stability.stable-outpaint-v1:0`                | Outpaint — afbeelding uitbreiden buiten de randen          |
| `stability.stable-image-erase-object-v1:0`      | Erase — objecten verwijderen                               |
| `stability.stable-image-remove-background-v1:0` | Achtergrond verwijderen                                    |
| `stability.stable-image-search-replace-v1:0`    | Search and Replace — objecten vervangen                    |
| `stability.stable-image-search-recolor-v1:0`    | Search and Recolor — kleur van objecten aanpassen          |
| `stability.stable-image-style-guide-v1:0`       | Style Guide — stijl toepassen met een referentieafbeelding |
| `stability.stable-style-transfer-v1:0`          | Style Transfer — beeldstijl overzetten                     |
| `stability.stable-image-control-sketch-v1:0`    | Control Sketch — genereren vanuit een schets               |
| `stability.stable-image-control-structure-v1:0` | Control Structure — genereren volgens de structuur         |
| `stability.stable-creative-upscale-v1:0`        | Creative Upscale — opschalen met aanvulling                |
| `stability.stable-conservative-upscale-v1:0`    | Conservative Upscale — details behouden                    |
| `stability.stable-fast-upscale-v1:0`            | Fast Upscale — lichte 4x-opschaling                        |

Amazon Nova Canvas wordt ook ondersteund, maar wordt door AWS uitgefaseerd.

```php theme={null}
// Nova Canvas (deprecated; beschikbaar in us-east-1, ap-northeast-1 en eu-west-1)
$response = Image::of('zonsondergang')
    ->size('3:2')           // '1:1', '3:2', '2:3'
    ->quality('high')       // 'low', 'medium', 'high' (alleen Nova Canvas)
    ->generate(provider: Bedrock::KEY, model: 'amazon.nova-canvas-v1:0');
```

## Audio (TTS)

Genereer spraak uit tekst met [Amazon Polly](https://docs.aws.amazon.com/polly/latest/dg/what-is.html).

```php theme={null}
use Laravel\Ai\Audio;
use Revolution\Amazon\Bedrock\Bedrock;

$response = Audio::of('Ik hou van programmeren met Laravel.')->generate(provider: Bedrock::KEY);

$rawContent = (string) $response;
```

Je kunt een mannen- of vrouwenstem kiezen.

```php theme={null}
$response = Audio::of('Ik hou van programmeren met Laravel.')
    ->female()
    ->generate(provider: 'bedrock');

$response = Audio::of('Ik hou van programmeren met Laravel.')
    ->male()
    ->generate(provider: Bedrock::KEY);
```

Geef een specifieke [Polly-stem](https://docs.aws.amazon.com/polly/latest/dg/voicelist.html) op.

```php theme={null}
$response = Audio::of('Ik hou van programmeren met Laravel.')
    ->voice('Joanna')
    ->generate(provider: Bedrock::KEY);
```

Sla de gegenereerde audio op.

```php theme={null}
$response = Audio::of('Ik hou van programmeren met Laravel.')->generate(provider: Bedrock::KEY);

$path = $response->store();
$path = $response->storeAs('audio.mp3');
```

Je kunt ook een engine (model) opgeven.

```php theme={null}
// generative (standaard), neural, long-form, standard
$response = Audio::of('Ik hou van programmeren met Laravel.')
    ->generate(provider: Bedrock::KEY, model: 'neural');
```

**Standaardstemmen:** `default-female` → Ruth, `default-male` → Matthew (beide ondersteunen de generative engine).

<Warning>
  Amazon Polly is een aparte AWS-service, los van Bedrock. Een Bedrock API-key (bearer token) werkt niet met Polly. Gebruik AWS IAM-credentials (SigV4) of de standaard AWS-credentialketen.
</Warning>

## Embeddings

Genereer vectorembeddings met Amazon Titan Embeddings V2.

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

$response = Embeddings::for(['Hello world', 'Foo bar'])->generate(provider: Bedrock::KEY);

// De eerste embeddingvector
$vector = $response->first();

// Over alle embeddings itereren
foreach ($response as $embedding) {
    // $embedding is een array van floats
}

echo $response->tokens; // Totaal aantal tokens
```

Je kunt het aantal dimensies opgeven (Titan Embeddings V2: 256, 512 of 1024).

```php theme={null}
$response = Embeddings::for(['Hello world'])->dimensions(512)->generate(provider: Bedrock::KEY);
```

Een voorbeeld met een aangepast model.

```php theme={null}
$response = Embeddings::for(['Hello world'])
    ->dimensions(1024)
    ->generate(provider: Bedrock::KEY, model: 'amazon.titan-embed-text-v2:0');
```

### Cohere Embed-modellen

Cohere Embed-modellen worden automatisch gedetecteerd en gebruiken de batch-API. Waar Titan per invoer een HTTP-request stuurt, bundelt Cohere alle invoer in één request, wat efficiënter is bij het verwerken van meerdere teksten.

```php theme={null}
// Cohere Embed English V3
$response = Embeddings::for(['Hello world', 'Foo bar'])
    ->dimensions(1024)
    ->generate(provider: Bedrock::KEY, model: 'cohere.embed-english-v3');

// Cohere Embed Multilingual V3
$response = Embeddings::for(['Hello', 'こんにちは'])
    ->dimensions(1024)
    ->generate(provider: Bedrock::KEY, model: 'cohere.embed-multilingual-v3');

// Cohere Embed V4 (uitvoerdimensies instelbaar van 256 tot 1536)
$response = Embeddings::for(['Hello world'])
    ->dimensions(512)
    ->generate(provider: Bedrock::KEY, model: 'cohere.embed-v4');
```

<Info>
  Cohere Embed-modellen geven geen tokenaantal terug, dus `$response->tokens` is altijd `0`.
</Info>

## Reranking

Sorteer documenten op relevantie voor een query met Cohere Rerank 3.5 of Amazon Rerank 1.0.

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

$response = Reranking::of([
    'Laravel is een webframework voor PHP.',
    'Python is een programmeertaal.',
    'Laravel biedt een elegante syntaxis voor webontwikkeling.',
])->rerank(query: 'Wat is Laravel?', provider: Bedrock::KEY);

// Het meest relevante document
echo $response->first()->document;
echo $response->first()->score;

// Alles ophalen in gesorteerde volgorde
foreach ($response as $result) {
    echo "{$result->index}: {$result->document} ({$result->score})\n";
}

// Het aantal resultaten beperken
$response = Reranking::of([...])
    ->limit(2)
    ->rerank(query: 'Wat is Laravel?', provider: Bedrock::KEY);
```

Een voorbeeld met een aangepast model.

```php theme={null}
$response = Reranking::of([...])
    ->rerank(query: 'zoekopdracht', provider: Bedrock::KEY, model: 'amazon.rerank-v1:0');
```

<Info>
  De reranking-API gebruikt het endpoint `bedrock-agent-runtime` (niet `bedrock-runtime`). Amazon Rerank 1.0 is niet beschikbaar in `us-east-1`; gebruik in die regio Cohere Rerank 3.5.
</Info>

## Testen

Je kunt de standaard testfuncties van de AI SDK gewoon gebruiken.

Het staat niet in de officiële documentatie, maar een Anonymous Agent die je met de `agent()`-helper maakt kun je mocken met `AnonymousAgent::fake()`, en de variant met gestructureerde output met `StructuredAnonymousAgent::fake()`.

```php theme={null}
use Laravel\Ai\AnonymousAgent;
use Laravel\Ai\Prompts\AgentPrompt;

use function Laravel\Ai\agent;

it('can generate text', function () {
    AnonymousAgent::fake();

    $response = agent(
        instructions: 'Je bent een expert in softwareontwikkeling.',
    )->prompt('Vertel me over Laravel.');

    AnonymousAgent::assertPrompted(function (AgentPrompt $prompt) {
        return $prompt->contains('Laravel');
    });
});
```

<Info>
  Raadpleeg de [GitHub-repository](https://github.com/invokable/laravel-amazon-bedrock) voor de meest recente informatie.
</Info>


## Related topics

- [Bottutorial - Laravel Bluesky](/nl/packages/laravel-bluesky/bot-tutorial.md)
- [Een custom provider voor de AI SDK maken](/nl/advanced/ai-sdk-custom-provider.md)
- [Laravel AI SDK](/nl/ai-sdk.md)
- [Bestandsopslag](/nl/filesystem.md)
- [我的包](/zh-CN/packages/index.md)