Driver de Amazon Bedrock para Laravel AI SDK

Descripción general

revolution/laravel-amazon-bedrock es un driver para usar Amazon Bedrock con Laravel AI SDK. Permite manejar múltiples modelos de Bedrock a través de la API unificada del Laravel AI SDK.

Función	Utilizable solo con API key de Bedrock	Modelos / servicios compatibles
Generación de texto / streaming	✅	Anthropic Claude, Amazon Nova y casi todos los demás modelos de Bedrock (todos vía Converse API)
Uso de herramientas (Function Calling)	✅
Salida estructurada	✅
Adjuntar archivos	✅	Adjunta imágenes, documentos, audio y vídeo vía Converse API (los formatos admitidos varían según el modelo)
Generación de imágenes	✅	Stability AI (por defecto), Amazon Nova Canvas (obsoleto)
Audio (TTS)	⚠️	Amazon Polly (motores generative / neural / long-form / standard)
Transcripción (STT)	❌	No compatible
Embeddings	✅	Amazon Titan Embeddings V2 (por defecto), Cohere Embed English/Multilingual V3, Cohere Embed V4 (con soporte de lote)
Reranking	⚠️	Cohere Rerank 3.5, Amazon Rerank 1.0
Archivos	✅	Admite adjuntar archivos locales en la generación de texto. No admite subidas al servidor ni `fromId()`

El símbolo ⚠️ en la tabla no significa que la función no esté soportada, sino que no se puede usar únicamente con la API key de Bedrock.

Con Laravel AI SDK v0.6.3 se añadió soporte oficial para Text, Image y Embeddings utilizando la API key de Bedrock. Este paquete sigue publicándose porque además admite funciones como audio (TTS) con Amazon Polly y reranking, que no están disponibles en la integración oficial.

Sus principales características son:

Autenticación: puedes elegir entre API key de Bedrock, credenciales IAM de AWS (SigV4) o la cadena de credenciales por defecto de AWS (roles IAM, perfiles de instancia, etc.).
Failover: compatible con el failover multiproveedor del AI SDK. Los errores de límite de tasa (429), sobrecarga (503, 529) y errores relacionados con créditos se mapean a excepciones aptas para failover.
Control de caché: la caché ephemeral está siempre activada en los prompts de sistema de la Converse API de Bedrock.
API unificada: Anthropic Claude, Amazon Nova, Meta Llama, Mistral y cualquier otro modelo se manejan con una interfaz unificada a través de la Converse API de Bedrock.

Requisitos

PHP >= 8.3
Laravel >= 12.x

Instalación

Instala el paquete

composer require revolution/laravel-amazon-bedrock

Publica la configuración de AI SDK

php artisan vendor:publish --provider="Laravel\Ai\AiServiceProvider"

Configuración

Añade el proveedor amazon-bedrock en config/ai.php. Si es necesario, cambia también el proveedor por defecto a Bedrock.

'default' => 'amazon-bedrock',
'default_for_images' => 'amazon-bedrock',
'default_for_audio' => 'amazon-bedrock',
'default_for_embeddings' => 'amazon-bedrock',
'default_for_reranking' => 'amazon-bedrock',

Opción 1: API key de Bedrock

'providers' => [
    'amazon-bedrock' => [
        'driver' => 'amazon-bedrock',
        'key'    => env('AWS_BEDROCK_API_KEY', ''),
        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    ],
],

AWS_BEDROCK_API_KEY=your_api_key
AWS_DEFAULT_REGION=us-east-1

La API key de Bedrock se obtiene desde la consola de AWS.

La API key de Bedrock es exclusiva de la Bedrock Runtime API. No se puede usar con reranking (bedrock-agent-runtime) ni con Amazon Polly (TTS). Para esos servicios utiliza SigV4 o la cadena de credenciales por defecto de AWS.

Opción 2: credenciales IAM de AWS (SigV4)

Utiliza una access key y una secret key de AWS que se firman con Signature Version 4.

'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'),
    ],
],

AWS_ACCESS_KEY_ID=AKIA...
AWS_SECRET_ACCESS_KEY=wJalr...
AWS_SESSION_TOKEN= # opcional (para credenciales temporales de STS)
AWS_DEFAULT_REGION=us-east-1

AWS_SESSION_TOKEN solo se configura cuando se usan credenciales temporales (STS).

Opción 3: cadena de credenciales por defecto de AWS (roles IAM)

En entornos con rol IAM como EC2 / ECS / Lambda, puedes omitir key y secret y utilizar la cadena de proveedores de credenciales por defecto de AWS.

'providers' => [
    'amazon-bedrock' => [
        'driver' => 'amazon-bedrock',
        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    ],
],

AWS_DEFAULT_REGION=us-east-1

La cadena de credenciales por defecto resuelve automáticamente desde variables de entorno, el archivo de credenciales compartido (~/.aws/credentials), roles de tareas de ECS, perfiles de instancia EC2, etc.

Claves de configuración opcionales

Clave	Descripción	Valor por defecto
`secret`	AWS secret access key (SigV4)	—
`token`	AWS session token (SigV4)	—
`timeout`	Timeout de peticiones HTTP (segundos)	30
`max_tokens`	Max tokens por defecto por petición	8096
`models.text.default`	Modelo de texto por defecto	`global.anthropic.claude-sonnet-4-6`
`models.text.cheapest`	Modelo de texto más económico	`global.anthropic.claude-haiku-4-5-20251001-v1:0`
`models.text.smartest`	Modelo de texto de mayor rendimiento	`global.anthropic.claude-opus-4-7`
`models.embeddings.default`	Modelo de embeddings por defecto	`amazon.titan-embed-text-v2:0`
`models.embeddings.dimensions`	Dimensiones de embeddings por defecto	`1024`
`models.image.default`	Modelo de imagen por defecto	`stability.stable-image-core-v1:1`
`models.audio.default`	Motor de audio (TTS) por defecto	`generative`
`models.reranking.default`	Modelo de reranking por defecto	`cohere.rerank-v3-5:0`

Generación de texto

Clase Agent

Crea una clase Agent con un comando Artisan.

php artisan make:agent BedrockAgent

<?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 'Eres un experto en desarrollo de software.';
    }
}

use App\Ai\Agents\BedrockAgent;

$response = (new BedrockAgent)->prompt('Cuéntame sobre Laravel.');

echo $response->text;

Anonymous Agent

Si quieres usarlo rápidamente sin crear una clase, utiliza el helper agent().

use function Laravel\Ai\agent;

$response = agent(
    instructions: 'Eres un experto en desarrollo de software.',
)->prompt('Cuéntame sobre Laravel.');

echo $response->text;

Streaming

use App\Ai\Agents\BedrockAgent;
use Illuminate\Support\Facades\Route;

Route::get('/stream', function () {
    return (new BedrockAgent)->stream('Cuéntame sobre Laravel.');
});

También puedes manejar los eventos manualmente.

use Laravel\Ai\Streaming\Events\TextDelta;

use function Laravel\Ai\agent;

$stream = agent(
    instructions: 'Eres un experto en desarrollo de software.',
)->stream('Cuéntame sobre Laravel.');

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

Uso de herramientas (Function Calling)

Define las herramientas que se invocarán durante la generación.

use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Ai\Contracts\Tool;
use Laravel\Ai\Tools\Request;

class GetWeather implements Tool
{
    public function description(): string
    {
        return 'Devuelve el tiempo actual de una ciudad.';
    }

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

    public function handle(Request $request): string
    {
        // Llama aquí a la API del tiempo
        return json_encode(['temperature' => 22, 'condition' => 'sunny']);
    }
}

Se usa desde el Agent.

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 'Eres un asistente meteorológico.';
    }
}

$response = (new WeatherAgent)->prompt('¿Qué tiempo hace en Tokio?');
echo $response->text;

También funciona con Anonymous Agent.

use function Laravel\Ai\agent;

$response = agent(
    instructions: 'Eres un asistente meteorológico.',
    tools: [new GetWeather],
    maxSteps: 5,
)->prompt('¿Qué tiempo hace en Tokio?');

Las llamadas a herramientas también funcionan en streaming. El SDK ejecuta las herramientas automáticamente y continúa la conversación hasta obtener la respuesta de texto final.

Adjuntar archivos

Con el parámetro attachments puedes adjuntar imágenes, documentos, audio y vídeo al prompt. La Converse API de Bedrock procesa los bloques adjuntos, aunque los formatos realmente utilizables dependen del modelo (por ejemplo, Anthropic Claude solo admite imágenes y documentos).

use Laravel\Ai\Files\Document;
use Laravel\Ai\Files\Image;

use function Laravel\Ai\agent;

// Adjuntar una imagen de una ruta local
$response = agent(
    instructions: 'Eres un asistente útil.',
)->prompt('Describe esta imagen.', attachments: [
    Image::fromPath('/path/to/photo.jpg'),
]);

// Adjuntar un documento desde una URL
$response = agent(
    instructions: 'Eres un asistente útil.',
)->prompt('Resume este documento.', attachments: [
    Document::fromUrl('https://example.com/report.pdf'),
]);

// Adjuntar desde una cadena (especificando el formato explícitamente)
$response = agent(
    instructions: 'Eres un asistente útil.',
)->prompt('Analiza este texto.', attachments: [
    Document::fromString($csvContent, 'text/csv')->as('data.csv'),
]);

Los tipos de adjunto compatibles son Image, Document y Audio dentro de Laravel\Ai\Files\*. El vídeo puede adjuntarse mediante Illuminate\Http\UploadedFile.

La subida de archivos al servidor (Document::fromPath()->put()) y la reutilización mediante ID (Document::fromId()) no son compatibles con Bedrock.

Historial de conversaciones

Para mantener una conversación de varios turnos, implementa la interfaz Conversational en la clase Agent. Los mensajes que devuelve messages() se incluirán automáticamente en cada prompt.

<?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 'Eres un asistente útil.';
    }

    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();
    }
}

$response = (new ChatAgent(auth()->id()))->prompt('¿De qué estábamos hablando la última vez?');

Guardado automático con `RemembersConversations`

Si no quieres implementar messages() por tu cuenta, puedes utilizar el trait RemembersConversations para guardar automáticamente la conversación. Necesitas las tablas de base de datos del AI SDK, así que ejecuta antes php artisan vendor:publish --provider="Laravel\Ai\AiServiceProvider" && php artisan migrate.

<?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 'Eres un asistente útil.';
    }
}

Inicia una nueva conversación.

$response = (new ChatAgent)->forUser($user)->prompt('¡Hola!');

$conversationId = $response->conversationId;

Continúa una conversación existente.

$response = (new ChatAgent)
    ->continue($conversationId, as: $user)
    ->prompt('Cuéntame más detalles.');

El driver de Bedrock incluye automáticamente el historial de conversaciones en las peticiones a la Converse API, por lo que puedes usar el contexto de conversaciones multiturno en todos los modelos compatibles.

Salida estructurada

Si implementas la interfaz HasStructuredOutput, obtendrás respuestas tipadas.

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 'Extrae información de la persona del texto proporcionado.';
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'name' => $schema->string()->description('Nombre completo de la persona'),
            'age' => $schema->integer()->description('Edad'),
            'occupation' => $schema->string()->description('Ocupación'),
        ];
    }
}

$response = (new ExtractPerson)->prompt('John tiene 30 años y es ingeniero de software.');

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

La salida estructurada también funciona con Anonymous Agent.

use function Laravel\Ai\agent;

$response = agent(
    instructions: 'Extrae información de la persona del texto proporcionado.',
    schema: fn (JsonSchema $schema) => [
        'name' => $schema->string()->description('Nombre completo de la persona'),
        'age' => $schema->integer()->description('Edad'),
    ],
)->prompt('Alice is 25 years old.');

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

Internamente se crea una herramienta sintética (output_structured_data) que obliga a devolver un valor que se ajuste al esquema. Este mecanismo es compatible con todos los modelos de Bedrock a través de la Converse API.

Converse API (todos los modelos)

Toda la generación de texto y el streaming se ejecutan a través de la Converse API de Bedrock. El acceso está unificado incluso para Anthropic Claude, y puedes utilizar los distintos modelos disponibles en Bedrock como Amazon Nova, Meta Llama, Mistral, Cohere o DeepSeek con la misma interfaz.

use function Laravel\Ai\agent;

// Anthropic Claude (vía Converse API)
$response = agent(
    instructions: 'Eres un experto en desarrollo de software.',
    model: 'global.anthropic.claude-sonnet-4-6',
)->prompt('Cuéntame sobre Laravel.');

// Amazon Nova
$response = agent(
    instructions: 'Eres un asistente útil.',
    model: 'amazon.nova-pro-v1:0',
)->prompt('Cuéntame sobre AWS.');

// Meta Llama
$response = agent(
    instructions: 'Eres un asistente útil.',
    model: 'meta.llama3-1-70b-instruct-v1:0',
)->prompt('Explica la computación cuántica.');

// Mistral
$response = agent(
    instructions: 'Eres un asistente útil.',
    model: 'mistral.mistral-large-2402-v1:0',
)->prompt('Escribe un haiku sobre programar.');

// Cohere Command R+
$response = agent(
    instructions: 'Eres un asistente útil.',
    model: 'cohere.command-r-plus-v1:0',
)->prompt('Resume este texto.');

// DeepSeek R1
$response = agent(
    instructions: 'Eres un asistente útil.',
    model: 'deepseek.r1-v1:0',
)->prompt('Resuelve este problema matemático.');

El streaming, el uso de herramientas, la salida estructurada y los adjuntos de archivos funcionan con los modelos que los admitan. Consulta el detalle en la lista de modelos compatibles de Bedrock.

Provider Options

Para pasar opciones específicas de Bedrock como anthropic_version, implementa HasProviderOptions.

<?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 'Eres un experto en desarrollo de software.';
    }

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

Provider Options admitidas:

Opción	Descripción	Valor por defecto
`top_k`	Parámetro de sampling Top-K	—
`top_p`	Parámetro de sampling Top-P (nucleus)	—
`additionalModelRequestFields`	Parámetros adicionales por modelo de Converse API	—

Atributos de configuración del Agent

Puedes configurar las opciones de generación de texto mediante atributos de PHP.

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;

    // ...
}

Generación de imágenes

Genera imágenes con modelos de Stability AI (por defecto) o con Amazon Nova Canvas.

use Laravel\Ai\Image;
use Revolution\Amazon\Bedrock\Bedrock;

// Por defecto usa Stability AI Stable Image Core
$response = Image::of('un lindo robot steampunk')->generate(provider: Bedrock::KEY);

// Obtén la primera imagen
$image = $response->firstImage();

// Guarda en disco
$response->store('images', 's3');

// Genera una etiqueta HTML <img>
echo $response->toHtml('robot steampunk');

Modelos de Stability AI disponibles (todos requieren la región us-west-2):

// Stable Image Core — rápido y económico (por defecto)
$response = Image::of('paisaje')
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-core-v1:1');

// Stable Diffusion 3.5 Large — alta calidad, generación en volumen
$response = Image::of('retrato')
    ->generate(provider: Bedrock::KEY, model: 'stability.sd3-5-large-v1:0');

// Stable Image Ultra — ultrarrealista, máxima calidad
$response = Image::of('producto de lujo')
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-ultra-v1:1');

Los modelos de imagen de Stability AI solo están disponibles en us-west-2. Configura AWS_DEFAULT_REGION=us-west-2 cuando los uses.

Edición de imágenes con Stability AI

También puedes usar los modelos de edición de Stability AI Image Services mediante el método attachments(). Se pasa una imagen de entrada y el modelo de edición la transforma.

use Laravel\Ai\Files\Image as ImageFile;
use Laravel\Ai\Image;
use Revolution\Amazon\Bedrock\Bedrock;

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

// Inpaint — sustituye una zona con máscara o canal alfa
$response = Image::of('Sustituye el fondo por un bosque')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-inpaint-v1:0');

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

// Quita el fondo y recorta solo el sujeto
$response = Image::of('')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-remove-background-v1:0');

// Search and Replace — reemplaza el objeto indicado en el prompt
$response = Image::of('gato')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-search-replace-v1:0');

// Style Transfer — aplica el estilo indicado en el prompt
$response = Image::of('estilo pintura al óleo')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-style-transfer-v1:0');

Modelos de edición de Stability AI disponibles (todos en us-east-1, us-east-2 y us-west-2):

Model ID	Descripción
`stability.stable-image-inpaint-v1:0`	Inpaint — sustitución del área seleccionada
`stability.stable-outpaint-v1:0`	Outpaint — amplía la imagen más allá de los bordes
`stability.stable-image-erase-object-v1:0`	Erase — elimina objetos
`stability.stable-image-remove-background-v1:0`	Elimina el fondo
`stability.stable-image-search-replace-v1:0`	Search and Replace — sustitución de objetos
`stability.stable-image-search-recolor-v1:0`	Search and Recolor — cambio de color de objetos
`stability.stable-image-style-guide-v1:0`	Style Guide — aplica el estilo de una referencia
`stability.stable-style-transfer-v1:0`	Style Transfer — transferencia de estilo
`stability.stable-image-control-sketch-v1:0`	Control Sketch — genera a partir de un boceto
`stability.stable-image-control-structure-v1:0`	Control Structure — genera siguiendo una estructura
`stability.stable-creative-upscale-v1:0`	Creative Upscale — reescala rellenando detalles
`stability.stable-conservative-upscale-v1:0`	Conservative Upscale — conserva los detalles
`stability.stable-fast-upscale-v1:0`	Fast Upscale — reescalado ligero 4x

También se admite Amazon Nova Canvas, aunque AWS está avanzando en su desaprobación.

// Nova Canvas (obsoleto. Disponible en us-east-1, ap-northeast-1, eu-west-1)
$response = Image::of('atardecer')
    ->size('3:2')           // '1:1', '3:2', '2:3'
    ->quality('high')       // 'low', 'medium', 'high' (solo Nova Canvas)
    ->generate(provider: Bedrock::KEY, model: 'amazon.nova-canvas-v1:0');

Audio (TTS)

Genera audio a partir de texto usando Amazon Polly.

use Laravel\Ai\Audio;
use Revolution\Amazon\Bedrock\Bedrock;

$response = Audio::of('Me encanta programar con Laravel.')->generate(provider: Bedrock::KEY);

$rawContent = (string) $response;

Puedes indicar voz masculina o femenina.

$response = Audio::of('Me encanta programar con Laravel.')
    ->female()
    ->generate(provider: 'bedrock');

$response = Audio::of('Me encanta programar con Laravel.')
    ->male()
    ->generate(provider: Bedrock::KEY);

Especifica una voz de Polly concreta.

$response = Audio::of('Me encanta programar con Laravel.')
    ->voice('Joanna')
    ->generate(provider: Bedrock::KEY);

Guarda el audio generado.

$response = Audio::of('Me encanta programar con Laravel.')->generate(provider: Bedrock::KEY);

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

También puedes indicar el motor (modelo).

// generative (por defecto), neural, long-form, standard
$response = Audio::of('Me encanta programar con Laravel.')
    ->generate(provider: Bedrock::KEY, model: 'neural');

Voces por defecto: default-female → Ruth, default-male → Matthew (ambas compatibles con el motor generative).

Amazon Polly es un servicio de AWS distinto de Bedrock. La API key de Bedrock (bearer token) no es válida para Polly. Utiliza credenciales IAM de AWS (SigV4) o la cadena de credenciales por defecto de AWS.

Embeddings

Genera embeddings vectoriales con Amazon Titan Embeddings V2.

use Laravel\Ai\Embeddings;
use Revolution\Amazon\Bedrock\Bedrock;

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

// Primer vector de embedding
$vector = $response->first();

// Itera todos los embeddings
foreach ($response as $embedding) {
    // $embedding es un array de floats
}

echo $response->tokens; // Número total de tokens

Puedes indicar las dimensiones (Titan Embeddings V2 admite 256, 512 y 1024).

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

Ejemplo indicando un modelo personalizado.

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

Modelos Cohere Embed

Los modelos Cohere Embed se detectan automáticamente y utilizan la API de lote. Mientras que Titan envía una petición HTTP por cada entrada, Cohere agrupa todas las entradas en una única petición, por lo que resulta más eficiente cuando procesas varios textos.

// 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 (permite configurar dimensiones de salida entre 256 y 1536)
$response = Embeddings::for(['Hello world'])
    ->dimensions(512)
    ->generate(provider: Bedrock::KEY, model: 'cohere.embed-v4');

Los modelos Cohere Embed no devuelven el número de tokens, por lo que $response->tokens siempre es 0.

Reranking

Reordena los documentos por relevancia respecto a la consulta usando Cohere Rerank 3.5 o Amazon Rerank 1.0.

use Laravel\Ai\Reranking;
use Revolution\Amazon\Bedrock\Bedrock;

$response = Reranking::of([
    'Laravel es un framework web de PHP.',
    'Python es un lenguaje de programación.',
    'Laravel ofrece una sintaxis elegante para el desarrollo web.',
])->rerank(query: '¿Qué es Laravel?', provider: Bedrock::KEY);

// Documento con mayor relevancia
echo $response->first()->document;
echo $response->first()->score;

// Obtén todos los resultados en orden
foreach ($response as $result) {
    echo "{$result->index}: {$result->document} ({$result->score})\n";
}

// Limita el número de resultados
$response = Reranking::of([...])
    ->limit(2)
    ->rerank(query: '¿Qué es Laravel?', provider: Bedrock::KEY);

Ejemplo indicando un modelo personalizado.

$response = Reranking::of([...])
    ->rerank(query: 'consulta de búsqueda', provider: Bedrock::KEY, model: 'amazon.rerank-v1:0');

La API de reranking utiliza el endpoint bedrock-agent-runtime (no bedrock-runtime). Amazon Rerank 1.0 no está disponible en us-east-1, así que en esa región usa Cohere Rerank 3.5.

Pruebas

Puedes usar directamente las funciones de testing estándar del AI SDK. Aunque no está documentado oficialmente, los Anonymous Agent creados con el helper agent() se pueden mockear con AnonymousAgent::fake(), y la versión de salida estructurada con StructuredAnonymousAgent::fake().

use Laravel\Ai\AnonymousAgent;
use Laravel\Ai\Prompts\AgentPrompt;

use function Laravel\Ai\agent;

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

    $response = agent(
        instructions: 'Eres un experto en desarrollo de software.',
    )->prompt('Cuéntame sobre Laravel.');

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

Consulta la información más actualizada en el repositorio de GitHub.

​Descripción general

​Requisitos

​Instalación

​Configuración

​Opción 1: API key de Bedrock

​Opción 2: credenciales IAM de AWS (SigV4)

​Opción 3: cadena de credenciales por defecto de AWS (roles IAM)

​Claves de configuración opcionales

​Generación de texto

​Clase Agent

​Anonymous Agent

​Streaming

​Uso de herramientas (Function Calling)

​Adjuntar archivos

​Historial de conversaciones

​Guardado automático con RemembersConversations

​Salida estructurada

​Converse API (todos los modelos)

​Provider Options

​Atributos de configuración del Agent

​Generación de imágenes

​Edición de imágenes con Stability AI

​Audio (TTS)

​Embeddings

​Modelos Cohere Embed

​Reranking

​Pruebas

Descripción general

Requisitos

Instalación

Configuración

Opción 1: API key de Bedrock

Opción 2: credenciales IAM de AWS (SigV4)

Opción 3: cadena de credenciales por defecto de AWS (roles IAM)

Claves de configuración opcionales

Generación de texto

Clase Agent

Anonymous Agent

Streaming

Uso de herramientas (Function Calling)

Adjuntar archivos

Historial de conversaciones

Guardado automático con `RemembersConversations`

Salida estructurada

Converse API (todos los modelos)

Provider Options

Atributos de configuración del Agent

Generación de imágenes

Edición de imágenes con Stability AI

Audio (TTS)

Embeddings

Modelos Cohere Embed

Reranking

Pruebas