diff --git a/.env b/.env
index b4cb8cbf..d180a0ff 100644
--- a/.env
+++ b/.env
@@ -56,3 +56,10 @@ RUN_EXPENSIVE_EXAMPLES=false
 
 # For using Gemini
 GOOGLE_API_KEY=
+
+# For using Aws BedRock
+
+AWS_ACCESS_KEY=
+AWS_ACCESS_SECRET=
+AWS_REGION=
+AWS_INFERENCE_PROFILE_REGION=
\ No newline at end of file
diff --git a/composer.json b/composer.json
index 4bf61815..c4ff1455 100644
--- a/composer.json
+++ b/composer.json
@@ -56,7 +56,8 @@
         "symfony/event-dispatcher": "^6.4 || ^7.1",
         "symfony/finder": "^6.4 || ^7.1",
         "symfony/process": "^6.4 || ^7.1",
-        "symfony/var-dumper": "^6.4 || ^7.1"
+        "symfony/var-dumper": "^6.4 || ^7.1",
+        "aws/aws-sdk-php": "^3"
     },
     "suggest": {
         "codewithkyrian/chromadb-php": "For using the ChromaDB as retrieval vector store.",
@@ -64,7 +65,8 @@
         "mongodb/mongodb": "For using MongoDB Atlas as retrieval vector store.",
         "probots-io/pinecone-php": "For using the Pinecone as retrieval vector store.",
         "symfony/css-selector": "For using the YouTube transcription tool.",
-        "symfony/dom-crawler": "For using the YouTube transcription tool."
+        "symfony/dom-crawler": "For using the YouTube transcription tool.",
+        "aws/aws-sdk-php": "For using AWS Bedrock"
     },
     "config": {
         "allow-plugins": {
diff --git a/examples/awsbedrock/embeddings.php b/examples/awsbedrock/embeddings.php
new file mode 100644
index 00000000..4cf23a4f
--- /dev/null
+++ b/examples/awsbedrock/embeddings.php
@@ -0,0 +1,34 @@
+<?php
+
+use PhpLlm\LlmChain\Bridge\AwsBedrock\Embeddings;
+use PhpLlm\LlmChain\Bridge\AwsBedrock\PlatformFactory;
+use PhpLlm\LlmChain\Document\Vector;
+use Symfony\Component\Dotenv\Dotenv;
+
+require_once dirname(__DIR__, 2).'/vendor/autoload.php';
+(new Dotenv())->loadEnv(dirname(__DIR__, 2).'/.env');
+
+if (empty($_ENV['AWS_ACCESS_KEY']) || empty($_ENV['AWS_ACCESS_SECRET']) || empty($_ENV['AWS_REGION'])) {
+    echo 'Please set the AWS_ACCESS_KEY, AWS_ACCESS_SECRET, AWS_REGION environment variables.'.PHP_EOL;
+    exit(1);
+}
+
+$platform = PlatformFactory::create(
+    [
+        'key' => $_ENV['AWS_ACCESS_KEY'],
+        'secret' => $_ENV['AWS_ACCESS_SECRET'],
+    ],
+    $_ENV['AWS_REGION'],
+);
+
+$embeddings = new Embeddings();
+
+$response = $platform->request($embeddings, <<<TEXT
+    Once upon a time, there was a country called Japan. It was a beautiful country with a lot of mountains and rivers.
+    The people of Japan were very kind and hardworking. They loved their country very much and took care of it. The
+    country was very peaceful and prosperous. The people lived happily ever after.
+    TEXT);
+
+assert($response->getContent()[0] instanceof Vector);
+
+echo 'Dimensions: '.$response->getContent()[0]->getDimensions().PHP_EOL;
diff --git a/examples/google/toolcall.php b/examples/google/toolcall.php
new file mode 100644
index 00000000..cfdd7708
--- /dev/null
+++ b/examples/google/toolcall.php
@@ -0,0 +1,33 @@
+<?php
+
+use PhpLlm\LlmChain\Bridge\Google\Gemini;
+use PhpLlm\LlmChain\Bridge\Google\PlatformFactory;
+use PhpLlm\LlmChain\Chain;
+use PhpLlm\LlmChain\Chain\Toolbox\ChainProcessor;
+use PhpLlm\LlmChain\Chain\Toolbox\Tool\YouTubeTranscriber;
+use PhpLlm\LlmChain\Chain\Toolbox\Toolbox;
+use PhpLlm\LlmChain\Model\Message\Message;
+use PhpLlm\LlmChain\Model\Message\MessageBag;
+use Symfony\Component\Dotenv\Dotenv;
+use Symfony\Component\HttpClient\HttpClient;
+
+require_once dirname(__DIR__, 2).'/vendor/autoload.php';
+(new Dotenv())->loadEnv(dirname(__DIR__, 2).'/.env');
+
+if (empty($_ENV['GOOGLE_API_KEY'])) {
+    echo 'Please set the GOOGLE_API_KEY environment variable.'.PHP_EOL;
+    exit(1);
+}
+
+$platform = PlatformFactory::create($_ENV['GOOGLE_API_KEY']);
+$llm = new Gemini(Gemini::GEMINI_2_FLASH);
+
+$transcriber = new YouTubeTranscriber(HttpClient::create());
+$toolbox = Toolbox::create($transcriber);
+$processor = new ChainProcessor($toolbox);
+$chain = new Chain($platform, $llm, [$processor], [$processor]);
+
+$messages = new MessageBag(Message::ofUser('Please summarize this video for me https://www.youtube.com/watch?v=6uXW-ulpj0s with the video ID as 6uXW-ulpj0s'));
+$response = $chain->call($messages);
+
+echo $response->getContent().PHP_EOL;
diff --git a/src/Bridge/AwsBedrock/AmazonNova.php b/src/Bridge/AwsBedrock/AmazonNova.php
new file mode 100644
index 00000000..84728ee8
--- /dev/null
+++ b/src/Bridge/AwsBedrock/AmazonNova.php
@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock;
+
+final readonly class AmazonNova implements BedrockLanguageModel
+{
+    public const NOVA_MICRO_V1 = 'amazon.nova-micro-v1:0';
+
+    public const NOVA_LITE_V1 = 'amazon.nova-lite-v1:0';
+
+    public const NOVA_PRO_V1 = 'amazon.nova-pro-v1:0';
+
+    /**
+     * @param array<string, mixed> $options
+     * @param string|null          $inferenceProfileRegion if you need to use an inference profile just add the region here
+     */
+    public function __construct(
+        private string $name = self::NOVA_LITE_V1,
+        private array $options = [],
+        private ?string $inferenceProfileRegion = null,
+    ) {
+    }
+
+    public function getName(): string
+    {
+        if ($this->inferenceProfileRegion) {
+            return $this->inferenceProfileRegion.'.'.$this->name;
+        }
+
+        return $this->name;
+    }
+
+    public function getOptions(): array
+    {
+        return $this->options;
+    }
+
+    public function supportsAudioInput(): bool
+    {
+        return false; // Only videos (!?)
+    }
+
+    public function supportsImageInput(): bool
+    {
+        return true;
+    }
+
+    public function supportsStreaming(): bool
+    {
+        return false; // It does, but it's not implemented yet.
+    }
+
+    public function supportsToolCalling(): bool
+    {
+        return true;
+    }
+
+    public function supportsStructuredOutput(): bool
+    {
+        return false;
+    }
+}
diff --git a/src/Bridge/AwsBedrock/BedrockLanguageModel.php b/src/Bridge/AwsBedrock/BedrockLanguageModel.php
new file mode 100644
index 00000000..5c265c5e
--- /dev/null
+++ b/src/Bridge/AwsBedrock/BedrockLanguageModel.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock;
+
+use PhpLlm\LlmChain\Model\LanguageModel;
+
+interface BedrockLanguageModel extends LanguageModel
+{
+}
diff --git a/src/Bridge/AwsBedrock/BedrockRequestSigner.php b/src/Bridge/AwsBedrock/BedrockRequestSigner.php
new file mode 100644
index 00000000..1f342789
--- /dev/null
+++ b/src/Bridge/AwsBedrock/BedrockRequestSigner.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock;
+
+use Aws\Credentials\Credentials;
+use Aws\Signature\SignatureV4;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Uri;
+
+final class BedrockRequestSigner
+{
+    public function __construct(#[\SensitiveParameter] private Credentials $credentials, private string $region)
+    {
+    }
+
+    public function signRequest(string $method, string $endpoint, array $jsonBody, array $extraHeaders = [])
+    {
+        $signature = new SignatureV4('bedrock', $this->region);
+
+        $uri = new Uri($endpoint);
+
+        $finalHeaders = array_merge([
+            'Host' => $uri->getHost(),
+            'Content-Type' => 'application/json',
+        ], $extraHeaders);
+
+        $request = new Request(
+            $method,
+            $uri,
+            $finalHeaders,
+            $encodedBody = json_encode($jsonBody)
+        );
+
+        $signedRequest = $signature->signRequest($request, $this->credentials);
+
+        $signedHeaders = [];
+        foreach ($signedRequest->getHeaders() as $name => $values) {
+            $signedHeaders[$name] = $signedRequest->getHeaderLine($name);
+        }
+
+        unset($request, $finalHeaders, $uri, $signature);
+
+        return [
+            'headers' => $signedHeaders,
+            'body' => $encodedBody,
+        ];
+    }
+}
diff --git a/src/Bridge/AwsBedrock/Embeddings.php b/src/Bridge/AwsBedrock/Embeddings.php
new file mode 100644
index 00000000..19797239
--- /dev/null
+++ b/src/Bridge/AwsBedrock/Embeddings.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock;
+
+use PhpLlm\LlmChain\Model\EmbeddingsModel;
+
+final readonly class Embeddings implements EmbeddingsModel
+{
+    public const TITAN_EMBED_TEXT_V2 = 'amazon.titan-embed-text-v2:0';
+    public const TITAN_MULTIMODAL_G1 = 'amazon.titan-embed-image-v1';
+
+    public function __construct(
+        private string $name = self::TITAN_EMBED_TEXT_V2,
+        private array $options = [],
+        private ?string $inferenceProfileRegion = null,
+    ) {
+    }
+
+    public function supportsMultipleInputs(): bool
+    {
+        return false;
+    }
+
+    public function getName(): string
+    {
+        if ($this->inferenceProfileRegion) {
+            return $this->inferenceProfileRegion.'.'.$this->name;
+        }
+
+        return $this->name;
+    }
+
+    public function getOptions(): array
+    {
+        return $this->options;
+    }
+}
diff --git a/src/Bridge/AwsBedrock/Embeddings/ModelClient.php b/src/Bridge/AwsBedrock/Embeddings/ModelClient.php
new file mode 100644
index 00000000..a4d1ef85
--- /dev/null
+++ b/src/Bridge/AwsBedrock/Embeddings/ModelClient.php
@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock\Embeddings;
+
+use PhpLlm\LlmChain\Bridge\AwsBedrock\BedrockRequestSigner;
+use PhpLlm\LlmChain\Bridge\AwsBedrock\Embeddings;
+use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Platform\ModelClient as PlatformResponseFactory;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Webmozart\Assert\Assert;
+
+final readonly class ModelClient implements PlatformResponseFactory
+{
+    public function __construct(
+        private HttpClientInterface $httpClient,
+        #[\SensitiveParameter] private BedrockRequestSigner $requestSigner,
+        private string $region,
+    ) {
+        Assert::stringNotEmpty($region, 'The region must not be empty.');
+    }
+
+    public function supports(Model $model, array|string|object $input): bool
+    {
+        return $model instanceof Embeddings;
+    }
+
+    public function request(Model $model, object|array|string $input, array $options = []): ResponseInterface
+    {
+        $signedParameters = $this->requestSigner->signRequest(
+            method: 'POST',
+            endpoint: $bedrockEndpoint = sprintf(
+                'https://bedrock-runtime.%s.amazonaws.com/model/%s/invoke',
+                $this->region,
+                $model->getName(),
+            ),
+            jsonBody: is_string($input) ? array_merge(
+                $model->getOptions(), [
+                    'inputText' => $input,
+                ]
+            ) : (
+                is_array($input) ?
+                    array_merge($model->getOptions(), $options, $input) : $input
+            )
+        );
+
+        return $this->httpClient->request('POST', $bedrockEndpoint, $signedParameters);
+    }
+}
diff --git a/src/Bridge/AwsBedrock/Embeddings/ResponseConverter.php b/src/Bridge/AwsBedrock/Embeddings/ResponseConverter.php
new file mode 100644
index 00000000..a232d8a6
--- /dev/null
+++ b/src/Bridge/AwsBedrock/Embeddings/ResponseConverter.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock\Embeddings;
+
+use PhpLlm\LlmChain\Bridge\AwsBedrock\Embeddings;
+use PhpLlm\LlmChain\Document\Vector;
+use PhpLlm\LlmChain\Exception\RuntimeException;
+use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Model\Response\VectorResponse;
+use PhpLlm\LlmChain\Platform\ResponseConverter as PlatformResponseConverter;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+
+final class ResponseConverter implements PlatformResponseConverter
+{
+    public function supports(Model $model, array|string|object $input): bool
+    {
+        return $model instanceof Embeddings;
+    }
+
+    public function convert(ResponseInterface $response, array $options = []): VectorResponse
+    {
+        $data = $response->toArray();
+
+        if (!isset($data['embedding'])) {
+            throw new RuntimeException('Response does not contain data');
+        }
+
+        return new VectorResponse(
+            new Vector($data['embedding'])
+        );
+    }
+}
diff --git a/src/Bridge/AwsBedrock/Language/ModelClient.php b/src/Bridge/AwsBedrock/Language/ModelClient.php
new file mode 100644
index 00000000..2944059a
--- /dev/null
+++ b/src/Bridge/AwsBedrock/Language/ModelClient.php
@@ -0,0 +1,226 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock\Language;
+
+use PhpLlm\LlmChain\Bridge\AwsBedrock\BedrockLanguageModel;
+use PhpLlm\LlmChain\Bridge\AwsBedrock\BedrockRequestSigner;
+use PhpLlm\LlmChain\Chain\Toolbox\Metadata;
+use PhpLlm\LlmChain\Model\Message\AssistantMessage;
+use PhpLlm\LlmChain\Model\Message\Content\Content;
+use PhpLlm\LlmChain\Model\Message\Content\Image;
+use PhpLlm\LlmChain\Model\Message\Content\Text;
+use PhpLlm\LlmChain\Model\Message\MessageBag;
+use PhpLlm\LlmChain\Model\Message\MessageInterface;
+use PhpLlm\LlmChain\Model\Message\ToolCallMessage;
+use PhpLlm\LlmChain\Model\Message\UserMessage;
+use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Platform\ModelClient as PlatformResponseFactory;
+use Symfony\Component\HttpClient\EventSourceHttpClient;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Webmozart\Assert\Assert;
+
+final readonly class ModelClient implements PlatformResponseFactory
+{
+    private EventSourceHttpClient $httpClient;
+
+    public function __construct(
+        HttpClientInterface $httpClient,
+        #[\SensitiveParameter] private BedrockRequestSigner $requestSigner,
+        private string $region,
+    ) {
+        $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
+
+        Assert::stringNotEmpty($region, 'The region must not be empty.');
+    }
+
+    public function supports(Model $model, array|string|object $input): bool
+    {
+        return $input instanceof MessageBag && $model instanceof BedrockLanguageModel;
+    }
+
+    public function request(Model $model, object|array|string $input, array $options = []): ResponseInterface
+    {
+        $options = array_merge($model->getOptions(), $options);
+
+        if ($input instanceof MessageBag) {
+            $systemMessagesMap = null;
+
+            if ($systemMessage = $input->getSystemMessage()) {
+                $systemMessagesMap = [
+                    [
+                        'text' => $systemMessage->content,
+                    ],
+                ];
+            }
+
+            $messagesMap = array_map(
+                function (MessageInterface $inputEntry) {
+                    if ($inputEntry instanceof ToolCallMessage) {
+                        return [
+                            'role' => 'user',
+                            'content' => [
+                                [
+                                    'toolResult' => [
+                                        'toolUseId' => $inputEntry->toolCall->id,
+                                        'content' => [
+                                            [
+                                                'text' => $inputEntry->content,
+                                            ],
+                                        ],
+                                    ],
+                                ],
+                            ],
+                        ];
+                    } elseif ($inputEntry instanceof AssistantMessage) {
+                        return [
+                            'role' => 'assistant',
+                            'content' => [
+                                array_filter([
+                                    'text' => $inputEntry->content,
+                                    'toolUse' => ($inputEntry->toolCalls[0] ?? null) ? [
+                                        'toolUseId' => $inputEntry->toolCalls[0]->id,
+                                        'name' => $inputEntry->toolCalls[0]->name,
+                                        'input' => $inputEntry->toolCalls[0]->arguments,
+                                    ] : null,
+                                ], fn ($content) => !is_null($content)
+                                ),
+                            ],
+                        ];
+                    } elseif ($inputEntry instanceof UserMessage) {
+                        return [
+                            'role' => 'user',
+                            'content' => array_map(
+                                function (Content $inputContent) {
+                                    if ($inputContent instanceof Text) {
+                                        return [
+                                            'text' => $inputContent->text,
+                                        ];
+                                    } elseif ($inputContent instanceof Image) {
+                                        return [
+                                            'image' => [
+                                                'format' => match ($inputContent->getFormat()) {
+                                                    'image/png' => 'png',
+                                                    'image/jpg', 'image/jpeg' => 'jpeg',
+                                                    'image/gif' => 'gif',
+                                                    'image/webp' => 'webp',
+                                                    default => throw new \Exception('Invalid Image type'),
+                                                },
+                                                'source' => [
+                                                    'bytes' => $inputContent->asBase64(),
+                                                ],
+                                            ],
+                                        ];
+                                    }
+                                }, $inputEntry->content
+                            ),
+                        ];
+                    }
+                },
+                $input->withoutSystemMessage()->getMessages()
+            );
+
+            $toolConfig = null;
+            if (isset($options['tools'])) {
+                $toolConfig = [
+                    'tools' => array_map(
+                        fn (Metadata $toolConfig) => [
+                            'toolSpec' => [
+                                'description' => $toolConfig->description,
+                                'name' => $toolConfig->name,
+                                'inputSchema' => [
+                                    'json' => $toolConfig->parameters,
+                                ],
+                            ],
+                        ], $options['tools']
+                    ),
+                ];
+
+                unset($options['tools']);
+            }
+
+            $inferenceConfig = array_reduce(
+                array_keys(
+                    $filteredAttributes = array_filter(
+                        $options,
+                        fn ($value, $optionKey) => in_array($optionKey, ['max_tokens', 'stop_sequences', 'temperature', 'top_p']),
+                        ARRAY_FILTER_USE_BOTH
+                    )
+                ),
+                function (array $inferenceConfigAcc, string $optionKey) use (&$options, &$filteredAttributes) {
+                    unset($options[$optionKey]);
+
+                    $newKey = mb_lcfirst(
+                        implode(
+                            '',
+                            array_map(
+                                fn ($part) => mb_ucfirst($part),
+                                explode('_', $optionKey)
+                            )
+                        )
+                    );
+
+                    $inferenceConfigAcc[$newKey] = $filteredAttributes[$optionKey];
+
+                    return $inferenceConfigAcc;
+                },
+                []
+            );
+
+            $additionalModelRequestFields = array_reduce(
+                array_keys(
+                    $filteredAttributes = array_filter(
+                        $options,
+                        fn ($value, $optionKey) => in_array($optionKey, ['top_k']),
+                        ARRAY_FILTER_USE_BOTH
+                    )
+                ),
+                function (array $additionalModelRequestFieldsAcc, string $optionKey) use (&$options, &$filteredAttributes) {
+                    unset($options[$optionKey]);
+
+                    $newKey = mb_lcfirst(
+                        implode(
+                            '',
+                            array_map(
+                                fn ($part) => mb_ucfirst($part),
+                                explode('_', $optionKey)
+                            )
+                        )
+                    );
+
+                    $additionalModelRequestFieldsAcc[$newKey] = $filteredAttributes[$optionKey];
+
+                    return $additionalModelRequestFieldsAcc;
+                },
+                []
+            );
+
+            $signedParameters = $this->requestSigner->signRequest(
+                method: 'POST',
+                endpoint: $bedrockEndpoint = sprintf(
+                    'https://bedrock-runtime.%s.amazonaws.com/model/%s/%s',
+                    $this->region,
+                    $model->getName(),
+                    ($options['stream'] ?? false) ? 'converse-stream' : 'converse'
+                ),
+                jsonBody: array_filter(
+                    array_merge($options, [
+                        'messages' => $messagesMap,
+                        'system' => $systemMessagesMap,
+                        'toolConfig' => $toolConfig,
+                        'inferenceConfig' => count($inferenceConfig) > 0 ? $inferenceConfig : null,
+                        'additionalModelRequestFields' => count($additionalModelRequestFields) > 0 ? [
+                            'inferenceConfig' => $additionalModelRequestFields,
+                        ] : null,
+                    ]), fn ($cValue) => !is_null($cValue)
+                )
+            );
+
+            return $this->httpClient->request('POST', $bedrockEndpoint, $signedParameters);
+        } else {
+            throw new \Exception('Invalid input, input must be a MessageBag');
+        }
+    }
+}
diff --git a/src/Bridge/AwsBedrock/Language/ResponseConverter.php b/src/Bridge/AwsBedrock/Language/ResponseConverter.php
new file mode 100644
index 00000000..f4019bc3
--- /dev/null
+++ b/src/Bridge/AwsBedrock/Language/ResponseConverter.php
@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock\Language;
+
+use PhpLlm\LlmChain\Bridge\AwsBedrock\BedrockLanguageModel;
+use PhpLlm\LlmChain\Exception\ContentFilterException;
+use PhpLlm\LlmChain\Exception\RuntimeException;
+use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Model\Response\Choice;
+use PhpLlm\LlmChain\Model\Response\ChoiceResponse;
+use PhpLlm\LlmChain\Model\Response\ResponseInterface as LlmResponse;
+use PhpLlm\LlmChain\Model\Response\TextResponse;
+use PhpLlm\LlmChain\Model\Response\ToolCall;
+use PhpLlm\LlmChain\Model\Response\ToolCallResponse;
+use PhpLlm\LlmChain\Platform\ResponseConverter as PlatformResponseConverter;
+use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface as HttpResponse;
+
+final class ResponseConverter implements PlatformResponseConverter
+{
+    public function supports(Model $model, array|string|object $input): bool
+    {
+        return $model instanceof BedrockLanguageModel;
+    }
+
+    public function convert(HttpResponse $response, array $options = []): LlmResponse
+    {
+        try {
+            $data = $response->toArray();
+        } catch (ClientExceptionInterface $e) {
+            if (400 === $response->getStatusCode()) {
+                throw new ContentFilterException(message: 'Validation error', previous: $e);
+            }
+
+            throw $e;
+        }
+
+        if (!isset($data['output']['message']['content'])) {
+            throw new RuntimeException('Response does not contain choices');
+        }
+
+        $stopReason = $data['stopReason'];
+
+        /** @var Choice[] $choices */
+        $choices = array_values(
+            array_filter(
+                array_map(
+                    fn ($content) => $this->convertChoice(
+                        $content, $stopReason
+                    ),
+                    $data['output']['message']['content']
+                ),
+                function (Choice $choiceEntry) use (&$stopReason) {
+                    if ('tool_use' === $stopReason) {
+                        return $choiceEntry->hasToolCall();
+                    }
+
+                    return true;
+                }
+            )
+        );
+
+        if (1 !== count($choices)) {
+            return new ChoiceResponse(...$choices);
+        }
+
+        if ($choices[0]->hasToolCall()) {
+            return new ToolCallResponse(...$choices[0]->getToolCalls());
+        }
+
+        return new TextResponse($choices[0]->getContent());
+    }
+
+    private function convertChoice(array $choice, string $stopReason): Choice
+    {
+        if (isset($choice['toolUse'])) {
+            return new Choice(
+                toolCalls: [
+                    $this->convertToolCall($choice['toolUse']),
+                ]
+            );
+        }
+
+        if (isset($choice['text'])) {
+            return new Choice(
+                $choice['text']
+            );
+        }
+
+        throw new RuntimeException(sprintf('Unsupported finish reason "%s".', $stopReason));
+    }
+
+    private function convertToolCall(array $toolCall): ToolCall
+    {
+        return new ToolCall($toolCall['toolUseId'], $toolCall['name'], $toolCall['input']);
+    }
+}
diff --git a/src/Bridge/AwsBedrock/PlatformFactory.php b/src/Bridge/AwsBedrock/PlatformFactory.php
new file mode 100644
index 00000000..975f492e
--- /dev/null
+++ b/src/Bridge/AwsBedrock/PlatformFactory.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock;
+
+use Aws\Credentials\Credentials;
+use PhpLlm\LlmChain\Bridge\AwsBedrock\Embeddings\ModelClient as EmbeddingsModelClient;
+use PhpLlm\LlmChain\Bridge\AwsBedrock\Embeddings\ResponseConverter as EmbeddingsResponseConverter;
+use PhpLlm\LlmChain\Bridge\AwsBedrock\Language\ModelClient as LanguageModelClient;
+use PhpLlm\LlmChain\Bridge\AwsBedrock\Language\ResponseConverter as LanguageResponseConverter;
+use PhpLlm\LlmChain\Platform;
+use Symfony\Component\HttpClient\EventSourceHttpClient;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+final class PlatformFactory
+{
+    public static function create(
+        #[\SensitiveParameter]
+        array $credentials,
+        string $region,
+        ?HttpClientInterface $httpClient = null,
+    ): Platform {
+        $httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
+
+        $requesterSigner = new BedrockRequestSigner(
+            new Credentials(
+                key: $credentials['key'] ?? null,
+                secret: $credentials['secret'] ?? null,
+                token: $credentials['token'] ?? null,
+            ),
+            $region
+        );
+
+        return new Platform([
+            new LanguageModelClient($httpClient, $requesterSigner, $region),
+            new EmbeddingsModelClient($httpClient, $requesterSigner, $region),
+        ], [
+            new LanguageResponseConverter(),
+            new EmbeddingsResponseConverter(),
+        ]);
+    }
+}
diff --git a/src/Bridge/AwsBedrock/TokenOutputProcessor.php b/src/Bridge/AwsBedrock/TokenOutputProcessor.php
new file mode 100644
index 00000000..789bfac0
--- /dev/null
+++ b/src/Bridge/AwsBedrock/TokenOutputProcessor.php
@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\AwsBedrock;
+
+use PhpLlm\LlmChain\Chain\Output;
+use PhpLlm\LlmChain\Chain\OutputProcessor;
+use PhpLlm\LlmChain\Model\Response\StreamResponse;
+
+final class TokenOutputProcessor implements OutputProcessor
+{
+    public function processOutput(Output $output): void
+    {
+        if ($output->response instanceof StreamResponse) {
+            // Streams have to be handled manually as the tokens are part of the streamed chunks
+            return;
+        }
+
+        $rawResponse = $output->response->getRawResponse();
+        if (null === $rawResponse) {
+            return;
+        }
+
+        $metadata = $output->response->getMetadata();
+
+        $content = $rawResponse->toArray(false);
+
+        if (!\array_key_exists('usage', $content)) {
+            return;
+        }
+
+        $metadata->add('prompt_tokens', $content['usage']['inputTokens'] ?? null);
+        $metadata->add('completion_tokens', $content['usage']['outputTokens'] ?? null);
+        $metadata->add('total_tokens', $content['usage']['totalTokens'] ?? null);
+    }
+}
diff --git a/src/Bridge/CerebrasAI/CerebrasAI.php b/src/Bridge/CerebrasAI/CerebrasAI.php
new file mode 100644
index 00000000..4af8b8d2
--- /dev/null
+++ b/src/Bridge/CerebrasAI/CerebrasAI.php
@@ -0,0 +1,60 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\CerebrasAI;
+
+use PhpLlm\LlmChain\Model\OpenAiCompatibleLanguageModel;
+
+final readonly class CerebrasAI implements OpenAiCompatibleLanguageModel
+{
+    public const LLAMA_4_SCOUT_17B = 'llama-4-scout-17b-16e-instruct';
+    public const LLAMA_31_8 = 'llama3.1-8b';
+    public const LLAMA_33_70 = 'llama-3.3-70b';
+    public const QWEN_3_32 = 'qwen-3-32b';
+    public const DEEPSEEK_R1 = 'deepseek-r1-distill-llama-70b';
+
+    /**
+     * @param array<string, mixed> $options
+     */
+    public function __construct(
+        private string $name = self::LLAMA_31_8,
+        private array $options = [],
+    ) {
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function getOptions(): array
+    {
+        return $this->options;
+    }
+
+    public function supportsAudioInput(): bool
+    {
+        return false;
+    }
+
+    public function supportsImageInput(): bool
+    {
+        return false;
+    }
+
+    public function supportsStreaming(): bool
+    {
+        return true;
+    }
+
+    public function supportsToolCalling(): bool
+    {
+        return true;
+    }
+
+    public function supportsStructuredOutput(): bool
+    {
+        return true;
+    }
+}
diff --git a/src/Bridge/CerebrasAI/Client.php b/src/Bridge/CerebrasAI/Client.php
new file mode 100644
index 00000000..2108cb1e
--- /dev/null
+++ b/src/Bridge/CerebrasAI/Client.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\CerebrasAI;
+
+use PhpLlm\LlmChain\Model\Message\MessageBagInterface;
+use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Platform\ModelClient;
+use Symfony\Component\HttpClient\EventSourceHttpClient;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Webmozart\Assert\Assert;
+
+final readonly class Client implements ModelClient
+{
+    private EventSourceHttpClient $httpClient;
+
+    public function __construct(
+        HttpClientInterface $httpClient,
+        #[\SensitiveParameter] private string $apiKey,
+    ) {
+        $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
+
+        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
+        Assert::startsWith($apiKey, 'csk-', 'The API key must start with "csk-".');
+    }
+
+    public function supports(Model $model, array|string|object $input): bool
+    {
+        return $input instanceof MessageBagInterface && $model instanceof CerebrasAI;
+    }
+
+    public function request(Model $model, object|array|string $input, array $options = []): ResponseInterface
+    {
+        return $this->httpClient->request('POST', 'https://api.cerebras.ai/v1/chat/completions', [
+            'auth_bearer' => $this->apiKey,
+            'json' => array_merge($options, [
+                'model' => $model->getName(),
+                'messages' => $input,
+            ]),
+        ]);
+    }
+}
diff --git a/src/Bridge/CerebrasAI/PlatformFactory.php b/src/Bridge/CerebrasAI/PlatformFactory.php
new file mode 100644
index 00000000..98a85626
--- /dev/null
+++ b/src/Bridge/CerebrasAI/PlatformFactory.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\CerebrasAI;
+
+use PhpLlm\LlmChain\Bridge\OpenAI\GPT\ResponseConverter as OpenAIGPTResponseConverter;
+use PhpLlm\LlmChain\Platform;
+use Symfony\Component\HttpClient\EventSourceHttpClient;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+final class PlatformFactory
+{
+    public static function create(
+        #[\SensitiveParameter]
+        string $apiKey,
+        ?HttpClientInterface $httpClient = null,
+    ): Platform {
+        $httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
+
+        return new Platform([
+            new Client($httpClient, $apiKey),
+        ], [
+            new OpenAIGPTResponseConverter(),
+        ]);
+    }
+}
diff --git a/src/Bridge/Google/Gemini.php b/src/Bridge/Google/Gemini.php
index e8a82d5b..c428fe79 100644
--- a/src/Bridge/Google/Gemini.php
+++ b/src/Bridge/Google/Gemini.php
@@ -35,7 +35,7 @@ public function getOptions(): array
 
     public function supportsAudioInput(): bool
     {
-        return false; // it does, but implementation here is still open
+        return true;
     }
 
     public function supportsImageInput(): bool
@@ -55,6 +55,6 @@ public function supportsStructuredOutput(): bool
 
     public function supportsToolCalling(): bool
     {
-        return false; // it does, but implementation here is still open
+        return true;
     }
 }
diff --git a/src/Bridge/Google/GooglePromptConverter.php b/src/Bridge/Google/GooglePromptConverter.php
index 8951a3a3..1995e818 100644
--- a/src/Bridge/Google/GooglePromptConverter.php
+++ b/src/Bridge/Google/GooglePromptConverter.php
@@ -5,11 +5,14 @@
 namespace PhpLlm\LlmChain\Bridge\Google;
 
 use PhpLlm\LlmChain\Model\Message\AssistantMessage;
+use PhpLlm\LlmChain\Model\Message\Content\Audio;
+use PhpLlm\LlmChain\Model\Message\Content\File;
 use PhpLlm\LlmChain\Model\Message\Content\Image;
 use PhpLlm\LlmChain\Model\Message\Content\Text;
 use PhpLlm\LlmChain\Model\Message\MessageBagInterface;
 use PhpLlm\LlmChain\Model\Message\MessageInterface;
 use PhpLlm\LlmChain\Model\Message\Role;
+use PhpLlm\LlmChain\Model\Message\ToolCallMessage;
 use PhpLlm\LlmChain\Model\Message\UserMessage;
 
 final class GooglePromptConverter
@@ -50,7 +53,38 @@ public function convertToPrompt(MessageBagInterface $bag): array
     private function convertMessage(MessageInterface $message): array
     {
         if ($message instanceof AssistantMessage) {
-            return [['text' => $message->content]];
+            return [
+                array_filter(
+                    [
+                        'text' => $message->content,
+                        'functionCall' => ($message->toolCalls[0] ?? null) ? [
+                            'id' => $message->toolCalls[0]->id,
+                            'name' => $message->toolCalls[0]->name,
+                            'args' => $message->toolCalls[0]->arguments,
+                        ] : null,
+                    ],
+                    fn ($content) => !is_null($content)
+                ),
+            ];
+        }
+
+        if ($message instanceof ToolCallMessage) {
+            $responseContent = json_validate($message->content) ?
+                json_decode($message->content, true) : $message->content;
+
+            return [
+                [
+                    'functionResponse' => array_filter(
+                        [
+                            'id' => $message->toolCall->id,
+                            'name' => $message->toolCall->name,
+                            'response' => is_array($responseContent) ? $responseContent : [
+                                'rawResponse' => $responseContent, // Gemini expects the response to be an object, but not everyone uses objects as their responses.
+                            ],
+                        ], fn ($value) => $value
+                    ),
+                ],
+            ];
         }
 
         if ($message instanceof UserMessage) {
@@ -59,7 +93,7 @@ private function convertMessage(MessageInterface $message): array
                 if ($content instanceof Text) {
                     $parts[] = ['text' => $content->text];
                 }
-                if ($content instanceof Image) {
+                if ($content instanceof Image || $content instanceof Audio || $content instanceof File) {
                     $parts[] = ['inline_data' => [
                         'mime_type' => $content->getFormat(),
                         'data' => $content->asBase64(),
diff --git a/src/Bridge/Google/ModelHandler.php b/src/Bridge/Google/ModelHandler.php
index f3875c25..30d53034 100644
--- a/src/Bridge/Google/ModelHandler.php
+++ b/src/Bridge/Google/ModelHandler.php
@@ -4,12 +4,17 @@
 
 namespace PhpLlm\LlmChain\Bridge\Google;
 
+use PhpLlm\LlmChain\Chain\Toolbox\Metadata;
 use PhpLlm\LlmChain\Exception\RuntimeException;
 use PhpLlm\LlmChain\Model\Message\MessageBagInterface;
 use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Model\Response\Choice;
+use PhpLlm\LlmChain\Model\Response\ChoiceResponse;
 use PhpLlm\LlmChain\Model\Response\ResponseInterface as LlmResponse;
 use PhpLlm\LlmChain\Model\Response\StreamResponse;
 use PhpLlm\LlmChain\Model\Response\TextResponse;
+use PhpLlm\LlmChain\Model\Response\ToolCall;
+use PhpLlm\LlmChain\Model\Response\ToolCallResponse;
 use PhpLlm\LlmChain\Platform\ModelClient;
 use PhpLlm\LlmChain\Platform\ResponseConverter;
 use Symfony\Component\HttpClient\EventSourceHttpClient;
@@ -54,6 +59,29 @@ public function request(Model $model, object|array|string $input, array $options
 
         $generationConfig = ['generationConfig' => $options];
         unset($generationConfig['generationConfig']['stream']);
+        unset($generationConfig['generationConfig']['tools']);
+
+        if (isset($options['tools'])) {
+            $toolConfig = array_map(
+                function (Metadata $toolConfig) {
+                    $parameters = $toolConfig->parameters;
+                    unset($parameters['additionalProperties']);
+
+                    return [
+                        'functionDeclarations' => [
+                            [
+                                'description' => $toolConfig->description,
+                                'name' => $toolConfig->name,
+                                'parameters' => $parameters,
+                            ],
+                        ],
+                    ];
+                }, $options['tools']
+            );
+
+            unset($options['tools']);
+            $generationConfig['tools'] = $toolConfig;
+        }
 
         return $this->httpClient->request('POST', $url, [
             'headers' => [
@@ -78,11 +106,27 @@ public function convert(ResponseInterface $response, array $options = []): LlmRe
 
         $data = $response->toArray();
 
-        if (!isset($data['candidates'][0]['content']['parts'][0]['text'])) {
+        if (!isset($data['candidates'][0]['content']['parts'][0])) {
             throw new RuntimeException('Response does not contain any content');
         }
 
-        return new TextResponse($data['candidates'][0]['content']['parts'][0]['text']);
+        /** @var Choice[] $choices */
+        $choices = array_map(
+            fn ($content) => $this->convertChoice(
+                $content
+            ),
+            $data['candidates']
+        );
+
+        if (1 !== count($choices)) {
+            return new ChoiceResponse(...$choices);
+        }
+
+        if ($choices[0]->hasToolCall()) {
+            return new ToolCallResponse(...$choices[0]->getToolCalls());
+        }
+
+        return new TextResponse($choices[0]->getContent());
     }
 
     private function convertStream(ResponseInterface $response): \Generator
@@ -125,4 +169,32 @@ private function convertStream(ResponseInterface $response): \Generator
             }
         }
     }
+
+    private function convertChoice(array $choice): Choice
+    {
+        $stopReason = $choice['finishReason'];
+
+        $contentPart = $choice['content']['parts'][0] ?? [];
+
+        if (isset($contentPart['functionCall'])) {
+            return new Choice(
+                toolCalls: [
+                    $this->convertToolCall($contentPart['functionCall']),
+                ]
+            );
+        }
+
+        if (isset($contentPart['text'])) {
+            return new Choice(
+                $contentPart['text']
+            );
+        }
+
+        throw new RuntimeException(sprintf('Unsupported finish reason "%s".', $stopReason));
+    }
+
+    private function convertToolCall(array $toolCall): ToolCall
+    {
+        return new ToolCall($toolCall['id'] ?? '', $toolCall['name'], $toolCall['args']);
+    }
 }
diff --git a/src/Bridge/OpenAI/GPT.php b/src/Bridge/OpenAI/GPT.php
index e2ed6316..321aa03e 100644
--- a/src/Bridge/OpenAI/GPT.php
+++ b/src/Bridge/OpenAI/GPT.php
@@ -4,9 +4,9 @@
 
 namespace PhpLlm\LlmChain\Bridge\OpenAI;
 
-use PhpLlm\LlmChain\Model\LanguageModel;
+use PhpLlm\LlmChain\Model\OpenAiCompatibleLanguageModel;
 
-final class GPT implements LanguageModel
+final class GPT implements OpenAiCompatibleLanguageModel
 {
     public const GPT_35_TURBO = 'gpt-3.5-turbo';
     public const GPT_35_TURBO_INSTRUCT = 'gpt-3.5-turbo-instruct';
diff --git a/src/Bridge/OpenAI/GPT/ResponseConverter.php b/src/Bridge/OpenAI/GPT/ResponseConverter.php
index 247003e5..3f024d99 100644
--- a/src/Bridge/OpenAI/GPT/ResponseConverter.php
+++ b/src/Bridge/OpenAI/GPT/ResponseConverter.php
@@ -4,10 +4,10 @@
 
 namespace PhpLlm\LlmChain\Bridge\OpenAI\GPT;
 
-use PhpLlm\LlmChain\Bridge\OpenAI\GPT;
 use PhpLlm\LlmChain\Exception\ContentFilterException;
 use PhpLlm\LlmChain\Exception\RuntimeException;
 use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Model\OpenAiCompatibleLanguageModel;
 use PhpLlm\LlmChain\Model\Response\Choice;
 use PhpLlm\LlmChain\Model\Response\ChoiceResponse;
 use PhpLlm\LlmChain\Model\Response\ResponseInterface as LlmResponse;
@@ -26,7 +26,7 @@ final class ResponseConverter implements PlatformResponseConverter
 {
     public function supports(Model $model, array|string|object $input): bool
     {
-        return $model instanceof GPT;
+        return $model instanceof OpenAiCompatibleLanguageModel;
     }
 
     public function convert(HttpResponse $response, array $options = []): LlmResponse
diff --git a/src/Bridge/OpenAICompatible/Client.php b/src/Bridge/OpenAICompatible/Client.php
new file mode 100644
index 00000000..199b373f
--- /dev/null
+++ b/src/Bridge/OpenAICompatible/Client.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\OpenAICompatible;
+
+use PhpLlm\LlmChain\Model\Message\MessageBagInterface;
+use PhpLlm\LlmChain\Model\Model;
+use PhpLlm\LlmChain\Platform\ModelClient;
+use Symfony\Component\HttpClient\EventSourceHttpClient;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+use Symfony\Contracts\HttpClient\ResponseInterface;
+use Webmozart\Assert\Assert;
+
+final readonly class Client implements ModelClient
+{
+    private EventSourceHttpClient $httpClient;
+
+    public function __construct(
+        HttpClientInterface $httpClient,
+        #[\SensitiveParameter] private string $apiKey,
+        private string $baseUrl,
+    ) {
+        $this->httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
+
+        Assert::stringNotEmpty($apiKey, 'The API key must not be empty.');
+
+        Assert::stringNotEmpty($baseUrl, 'Base URL must not be empty.');
+        Assert::startsWith($baseUrl, 'http', 'Base URL must have a valid protocol.');
+    }
+
+    public function supports(Model $model, array|string|object $input): bool
+    {
+        return $input instanceof MessageBagInterface && $model instanceof GenericModel;
+    }
+
+    public function request(Model $model, object|array|string $input, array $options = []): ResponseInterface
+    {
+        return $this->httpClient->request('POST', sprintf('%s/chat/completions', $this->baseUrl), [
+            'auth_bearer' => $this->apiKey,
+            'json' => array_merge($options, [
+                'model' => $model->getName(),
+                'messages' => $input,
+            ]),
+        ]);
+    }
+}
diff --git a/src/Bridge/OpenAICompatible/GenericModel.php b/src/Bridge/OpenAICompatible/GenericModel.php
new file mode 100644
index 00000000..afbea997
--- /dev/null
+++ b/src/Bridge/OpenAICompatible/GenericModel.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\OpenAICompatible;
+
+use PhpLlm\LlmChain\Model\OpenAiCompatibleLanguageModel;
+
+final readonly class GenericModel implements OpenAiCompatibleLanguageModel
+{
+    /**
+     * @param array<string, mixed> $options
+     */
+    public function __construct(
+        private string $name,
+        private array $options = [],
+        private bool $supportsAudioInput = false,
+        private bool $supportsImageInput = false,
+        private bool $supportsToolCalling = false,
+        private bool $supportsStructuredOutput = false,
+    ) {
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function getOptions(): array
+    {
+        return $this->options;
+    }
+
+    public function supportsAudioInput(): bool
+    {
+        return $this->supportsAudioInput;
+    }
+
+    public function supportsImageInput(): bool
+    {
+        return $this->supportsImageInput;
+    }
+
+    public function supportsStreaming(): bool
+    {
+        return true;
+    }
+
+    public function supportsToolCalling(): bool
+    {
+        return $this->supportsToolCalling;
+    }
+
+    public function supportsStructuredOutput(): bool
+    {
+        return $this->supportsStructuredOutput;
+    }
+}
diff --git a/src/Bridge/OpenAICompatible/PlatformFactory.php b/src/Bridge/OpenAICompatible/PlatformFactory.php
new file mode 100644
index 00000000..bb3e679a
--- /dev/null
+++ b/src/Bridge/OpenAICompatible/PlatformFactory.php
@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Bridge\OpenAICompatible;
+
+use PhpLlm\LlmChain\Bridge\OpenAI\GPT\ResponseConverter as OpenAIGPTResponseConverter;
+use PhpLlm\LlmChain\Platform;
+use Symfony\Component\HttpClient\EventSourceHttpClient;
+use Symfony\Contracts\HttpClient\HttpClientInterface;
+
+final class PlatformFactory
+{
+    public static function create(
+        #[\SensitiveParameter]
+        string $apiKey,
+        string $baseUrl,
+        ?HttpClientInterface $httpClient = null,
+    ): Platform {
+        $httpClient = $httpClient instanceof EventSourceHttpClient ? $httpClient : new EventSourceHttpClient($httpClient);
+
+        return new Platform([
+            new Client($httpClient, $apiKey, $baseUrl),
+        ], [
+            new OpenAIGPTResponseConverter(),
+        ]);
+    }
+}
diff --git a/src/Chain/Toolbox/ChainProcessor.php b/src/Chain/Toolbox/ChainProcessor.php
index 2e58c113..aceae8ac 100644
--- a/src/Chain/Toolbox/ChainProcessor.php
+++ b/src/Chain/Toolbox/ChainProcessor.php
@@ -10,6 +10,7 @@
 use PhpLlm\LlmChain\Chain\InputProcessor;
 use PhpLlm\LlmChain\Chain\Output;
 use PhpLlm\LlmChain\Chain\OutputProcessor;
+use PhpLlm\LlmChain\Chain\Toolbox\Event\ChainIteractionsFinished;
 use PhpLlm\LlmChain\Chain\Toolbox\Event\ToolCallsExecuted;
 use PhpLlm\LlmChain\Chain\Toolbox\StreamResponse as ToolboxStreamResponse;
 use PhpLlm\LlmChain\Exception\MissingModelSupport;
@@ -104,6 +105,10 @@ private function handleToolCallsCallback(Output $output): \Closure
                 $response = $event->hasResponse() ? $event->response : $this->chain->call($messages, $output->options);
             } while ($response instanceof ToolCallResponse);
 
+            $this->eventDispatcher?->dispatch(
+                new ChainIteractionsFinished($messages)
+            );
+
             return $response;
         };
     }
diff --git a/src/Chain/Toolbox/Event/ChainIteractionsFinished.php b/src/Chain/Toolbox/Event/ChainIteractionsFinished.php
new file mode 100644
index 00000000..f1ca6f4c
--- /dev/null
+++ b/src/Chain/Toolbox/Event/ChainIteractionsFinished.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpLlm\LlmChain\Chain\Toolbox\Event;
+
+use PhpLlm\LlmChain\Model\Message\MessageBag;
+
+final class ChainIteractionsFinished
+{
+    public function __construct(public MessageBag $messageBag)
+    {
+    }
+}
diff --git a/src/Model/OpenAiCompatibleLanguageModel.php b/src/Model/OpenAiCompatibleLanguageModel.php
new file mode 100644
index 00000000..e83731c4
--- /dev/null
+++ b/src/Model/OpenAiCompatibleLanguageModel.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace PhpLlm\LlmChain\Model;
+
+interface OpenAiCompatibleLanguageModel extends LanguageModel
+{
+}