Laravel AI SDK용 Amazon Bedrock 드라이버

'default' => 'amazon-bedrock',
'default_for_images' => 'amazon-bedrock',
'default_for_audio' => 'amazon-bedrock',
'default_for_embeddings' => 'amazon-bedrock',
'default_for_reranking' => 'amazon-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

'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= # 선택(STS 임시 자격 증명용)
AWS_DEFAULT_REGION=us-east-1

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

AWS_DEFAULT_REGION=us-east-1

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 '당신은 소프트웨어 개발 전문가입니다.';
    }
}

use App\Ai\Agents\BedrockAgent;

$response = (new BedrockAgent)->prompt('Laravel에 대해 알려주세요.');

echo $response->text;

use function Laravel\Ai\agent;

$response = agent(
    instructions: '당신은 소프트웨어 개발 전문가입니다.',
)->prompt('Laravel에 대해 알려주세요.');

echo $response->text;

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

Route::get('/stream', function () {
    return (new BedrockAgent)->stream('Laravel에 대해 알려주세요.');
});

use Laravel\Ai\Streaming\Events\TextDelta;

use function Laravel\Ai\agent;

$stream = agent(
    instructions: '당신은 소프트웨어 개발 전문가입니다.',
)->stream('Laravel에 대해 알려주세요.');

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

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

class GetWeather implements Tool
{
    public function description(): string
    {
        return '도시의 현재 날씨를 반환합니다.';
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'city' => $schema->string()->required()->description('도시명'),
        ];
    }

    public function handle(Request $request): string
    {
        // 여기서 날씨 API를 호출합니다
        return json_encode(['temperature' => 22, 'condition' => 'sunny']);
    }
}

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 '당신은 날씨 어시스턴트입니다.';
    }
}

$response = (new WeatherAgent)->prompt('도쿄의 날씨는?');
echo $response->text;

use function Laravel\Ai\agent;

$response = agent(
    instructions: '당신은 날씨 어시스턴트입니다.',
    tools: [new GetWeather],
    maxSteps: 5,
)->prompt('도쿄의 날씨는?');

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

use function Laravel\Ai\agent;

// 로컬 경로의 이미지를 첨부
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
)->prompt('이 이미지를 설명해 주세요.', attachments: [
    Image::fromPath('/path/to/photo.jpg'),
]);

// URL의 문서를 첨부
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
)->prompt('이 문서를 요약해 주세요.', attachments: [
    Document::fromUrl('https://example.com/report.pdf'),
]);

// 문자열에서 첨부(포맷을 명시적으로 지정)
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
)->prompt('이 텍스트를 분석해 주세요.', attachments: [
    Document::fromString($csvContent, 'text/csv')->as('data.csv'),
]);

<?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 '당신은 유용한 어시스턴트입니다.';
    }

    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('지난번에 무슨 이야기를 하고 있었죠?');

<?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 '당신은 유용한 어시스턴트입니다.';
    }
}

$response = (new ChatAgent)->forUser($user)->prompt('안녕하세요!');

$conversationId = $response->conversationId;

$response = (new ChatAgent)
    ->continue($conversationId, as: $user)
    ->prompt('좀 더 자세히 알려주세요.');

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 '주어진 문장에서 인물 정보를 추출해 주세요.';
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'name' => $schema->string()->description('인물의 풀네임'),
            'age' => $schema->integer()->description('나이'),
            'occupation' => $schema->string()->description('직업'),
        ];
    }
}

$response = (new ExtractPerson)->prompt('John은 30세의 소프트웨어 엔지니어입니다.');

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

use function Laravel\Ai\agent;

$response = agent(
    instructions: '주어진 문장에서 인물 정보를 추출해 주세요.',
    schema: fn (JsonSchema $schema) => [
        'name' => $schema->string()->description('인물의 풀네임'),
        'age' => $schema->integer()->description('나이'),
    ],
)->prompt('Alice is 25 years old.');

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

use function Laravel\Ai\agent;

// Anthropic Claude(Converse API 경유)
$response = agent(
    instructions: '당신은 소프트웨어 개발 전문가입니다.',
    model: 'global.anthropic.claude-sonnet-4-6',
)->prompt('Laravel에 대해 알려주세요.');

// Amazon Nova
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
    model: 'amazon.nova-pro-v1:0',
)->prompt('AWS에 대해 알려주세요.');

// Meta Llama
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
    model: 'meta.llama3-1-70b-instruct-v1:0',
)->prompt('양자 컴퓨팅을 설명해 주세요.');

// Mistral
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
    model: 'mistral.mistral-large-2402-v1:0',
)->prompt('코딩에 대한 하이쿠를 써 주세요.');

// Cohere Command R+
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
    model: 'cohere.command-r-plus-v1:0',
)->prompt('이 텍스트를 요약해 주세요.');

// DeepSeek R1
$response = agent(
    instructions: '당신은 유용한 어시스턴트입니다.',
    model: 'deepseek.r1-v1:0',
)->prompt('이 수학 문제를 풀어 주세요.');

<?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 '당신은 소프트웨어 개발 전문가입니다.';
    }

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

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;

    // ...
}

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

// 기본값으로 Stability AI Stable Image Core를 사용
$response = Image::of('귀여운 스팀펑크 로봇')->generate(provider: Bedrock::KEY);

// 첫 번째 이미지를 가져옴
$image = $response->firstImage();

// 디스크에 저장
$response->store('images', 's3');

// HTML의 <img> 태그로 출력
echo $response->toHtml('스팀펑크 로봇');

// Stable Image Core — 고속·저비용(기본값)
$response = Image::of('풍경')
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-core-v1:1');

// Stable Diffusion 3.5 Large — 고품질·대량 생성
$response = Image::of('포트레이트')
    ->generate(provider: Bedrock::KEY, model: 'stability.sd3-5-large-v1:0');

// Stable Image Ultra — 초현실적·최고 품질
$response = Image::of('고급스러운 제품')
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-ultra-v1:1');

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

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

// Inpaint — 마스크나 알파 채널로 영역을 다시 그림
$response = Image::of('배경을 숲으로 바꿔 주세요')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-inpaint-v1:0');

// Erase — 불필요한 요소를 제거
$response = Image::of('')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-erase-object-v1:0');

// 배경을 제거하여 피사체만 잘라내기
$response = Image::of('')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-remove-background-v1:0');

// Search and Replace — 프롬프트로 지정한 오브젝트를 교체
$response = Image::of('고양이')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-image-search-replace-v1:0');

// Style Transfer — 프롬프트의 스타일을 적용
$response = Image::of('유화 스타일')
    ->attachments([$inputImage])
    ->generate(provider: Bedrock::KEY, model: 'stability.stable-style-transfer-v1:0');

// Nova Canvas(권장하지 않음. us-east-1, ap-northeast-1, eu-west-1에서 이용 가능)
$response = Image::of('노을')
    ->size('3:2')           // '1:1', '3:2', '2:3'
    ->quality('high')       // 'low', 'medium', 'high'(Nova Canvas 전용)
    ->generate(provider: Bedrock::KEY, model: 'amazon.nova-canvas-v1:0');

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

$response = Audio::of('Laravel로 코딩하는 것을 정말 좋아합니다.')->generate(provider: Bedrock::KEY);

$rawContent = (string) $response;

$response = Audio::of('Laravel로 코딩하는 것을 정말 좋아합니다.')
    ->female()
    ->generate(provider: 'bedrock');

$response = Audio::of('Laravel로 코딩하는 것을 정말 좋아합니다.')
    ->male()
    ->generate(provider: Bedrock::KEY);

$response = Audio::of('Laravel로 코딩하는 것을 정말 좋아합니다.')
    ->voice('Joanna')
    ->generate(provider: Bedrock::KEY);

$response = Audio::of('Laravel로 코딩하는 것을 정말 좋아합니다.')->generate(provider: Bedrock::KEY);

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

// generative(기본값), neural, long-form, standard
$response = Audio::of('Laravel로 코딩하는 것을 정말 좋아합니다.')
    ->generate(provider: Bedrock::KEY, model: 'neural');

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

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

// 첫 번째 임베딩 벡터
$vector = $response->first();

// 모든 임베딩 순회
foreach ($response as $embedding) {
    // $embedding은 float 배열
}

echo $response->tokens; // 총 토큰 수

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

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

// 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(출력 차원 256~1536 설정 가능)
$response = Embeddings::for(['Hello world'])
    ->dimensions(512)
    ->generate(provider: Bedrock::KEY, model: 'cohere.embed-v4');

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

$response = Reranking::of([
    'Laravel은 PHP의 웹 프레임워크입니다.',
    'Python은 프로그래밍 언어입니다.',
    'Laravel은 웹 개발을 위한 우아한 문법을 제공합니다.',
])->rerank(query: 'Laravel이란 무엇입니까?', provider: Bedrock::KEY);

// 가장 관련도가 높은 문서
echo $response->first()->document;
echo $response->first()->score;

// 모두 정렬 순으로 취득
foreach ($response as $result) {
    echo "{$result->index}: {$result->document} ({$result->score})\n";
}

// 건수 제한
$response = Reranking::of([...])
    ->limit(2)
    ->rerank(query: 'Laravel이란?', provider: Bedrock::KEY);

$response = Reranking::of([...])
    ->rerank(query: '검색 쿼리', provider: Bedrock::KEY, model: 'amazon.rerank-v1:0');

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

use function Laravel\Ai\agent;

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

    $response = agent(
        instructions: '당신은 소프트웨어 개발 전문가입니다.',
    )->prompt('Laravel에 대해 알려주세요.');

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