Symfony AI - Platform Component

1
2
3
4
5
6
7
8
9
10
11
12

use Symfony\AI\Platform\Bridge\OpenAi\Gpt;
use Symfony\AI\Platform\Capability;
use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;

$model = new Gpt('gpt-newest', [
    Capability::INPUT_MESSAGES,
    Capability::OUTPUT_TEXT,
    Capability::TOOL_CALLING,
], ['temperature' => 0.5]);

$result = $platform->invoke($model, new MessageBag(Message::ofUser(...)));

1
2
3
4
5
6
7
8
9
10
11
12
13

use Symfony\AI\Platform\Bridge\Generic\Factory;
use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;

$platform = Factory::createPlatform('https://api.example.com', 'sk-xxxxxx', $httpClient, $modelCatalog);

$messages = new MessageBag(
    Message::forSystem('You are a pirate and you write funny.'),
    Message::ofUser('What is the Symfony framework?'),
);
$result = $platform->invoke('model-name', $messages);

echo $result->asText();

1
2
3
4
5
6
7
8
9
10

use Symfony\AI\Platform\Event\ResultConvertedEvent;
use Symfony\AI\Platform\Event\ResultErrorEvent;

$eventDispatcher->addListener(ResultConvertedEvent::class, function (ResultConvertedEvent $event) {
    // $event->getResult() is the resolved result; a listener may replace it via setResult()
});

$eventDispatcher->addListener(ResultErrorEvent::class, function (ResultErrorEvent $event) {
    // $event->getError() carries the conversion exception (still rethrown to the caller)
});

1
2
3
4
5
6
7
8
9
10
11
12
13

use Symfony\AI\Platform\Message\Message;

$message = Message::ofUser('Hello, AI!');

// Access the unique ID
$id = $message->getId(); // Returns Symfony\Component\Uid\Uuid instance

// Extract creation timestamp
$createdAt = $id->getDateTime(); // Returns \DateTimeImmutable
echo $createdAt->format('Y-m-d H:i:s.u'); // e.g., "2025-06-29 15:30:45.123456"

// Get string representation
echo $id->toRfc4122(); // e.g., "01928d1f-6f2e-7123-a456-123456789abc"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;
use Symfony\AI\Platform\PlatformInterface;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Symfony\Component\Routing\Attribute\Route;

final class ChatController
{
    #[Route('/chat/stream', name: 'chat_stream')]
    public function stream(PlatformInterface $platform): StreamedResponse
    {
        $messages = new MessageBag(
            Message::ofUser('Tell me about Symfony.'),
        );

        $result = $platform->invoke('gpt-5-mini', $messages, [
            'stream' => true,
        ]);

        return new StreamedResponse(function () use ($result) {
            foreach ($result->asTextStream() as $text) {
                echo $text;
                flush();
            }
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;

// Initialize Anthropic Platform

$messages = new MessageBag(
    Message::forSystem('You are a helpful math tutor.'),
    Message::ofUser('What is the sum of the first 100 prime numbers?'),
);

$result = $platform->invoke('claude-sonnet-4-5', $messages, [
    'stream' => true,
    'thinking' => [
        'type' => 'enabled',
        'budget_tokens' => 10000,
    ],
]);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

use Symfony\AI\Platform\Result\Stream\Delta\TextDelta;
use Symfony\AI\Platform\Result\Stream\Delta\ThinkingComplete;
use Symfony\AI\Platform\Result\Stream\Delta\ThinkingDelta;

foreach ($result->asStream() as $delta) {
    if ($delta instanceof ThinkingDelta) {
        // Incremental reasoning chunk (not shown to the user in most UIs)
        echo '[thinking] ' . $delta->getThinking();

        continue;
    }

    if ($delta instanceof ThinkingComplete) {
        // The full thinking block is complete
        echo '[thinking done] ' . $delta->getThinking() . "\n";

        // Anthropic includes a cryptographic signature for verification
        if (null !== $delta->getSignature()) {
            // Store signature if you need to echo the thinking block
            // back in subsequent requests
        }

        continue;
    }

    if ($delta instanceof TextDelta) {
        echo $delta;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

use Symfony\AI\Platform\Message\AssistantMessage;
use Symfony\AI\Platform\Message\Content\Text;
use Symfony\AI\Platform\Message\Content\Thinking;

// Include the model's thinking from a previous turn
$assistant = new AssistantMessage(
    new Thinking('Let me work through this step by step...', 'sig_abc123...'),
    new Text('The answer is 42.'),
);

$messages = new MessageBag(
    Message::ofUser('What is the meaning of life?'),
    $assistant,
    Message::ofUser('Can you elaborate?'),
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

use Symfony\AI\Platform\Bridge\Mistral\Factory;
use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;
use Symfony\AI\Platform\StructuredOutput\PlatformSubscriber;
use Symfony\AI\Platform\Tests\Fixtures\StructuredOutput\MathReasoning;
use Symfony\Component\EventDispatcher\EventDispatcher;

$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new PlatformSubscriber());

$platform = Factory::createPlatform($apiKey, eventDispatcher: $dispatcher);
$messages = new MessageBag(
    Message::forSystem('You are a helpful math tutor. Guide the user through the solution step by step.'),
    Message::ofUser('how can I solve 8x + 7 = -23'),
);
$result = $platform->invoke('mistral-small-latest', $messages, ['response_format' => MathReasoning::class]);

dump($result->asObject()); // returns an instance of `MathReasoning` class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;

// Initialize Platform, LLM and agent with processors and Clock tool

$messages = new MessageBag(Message::ofUser('What date and time is it?'));
$result = $agent->call($messages, ['response_format' => [
    'type' => 'json_schema',
    'json_schema' => [
        'name' => 'clock',
        'strict' => true,
        'schema' => [
            'type' => 'object',
            'properties' => [
                'date' => ['type' => 'string', 'description' => 'The current date in the format YYYY-MM-DD.'],
                'time' => ['type' => 'string', 'description' => 'The current time in the format HH:MM:SS.'],
            ],
            'required' => ['date', 'time'],
            'additionalProperties' => false,
        ],
    ],
]]);

dump($result->getContent()); // returns an array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

use Symfony\AI\Platform\EventListener\TemplateRendererListener;
use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;
use Symfony\AI\Platform\Message\Template;
use Symfony\AI\Platform\Message\TemplateRenderer\StringTemplateRenderer;
use Symfony\AI\Platform\Message\TemplateRenderer\TemplateRendererRegistry;
use Symfony\AI\Platform\StructuredOutput\PlatformSubscriber;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;

$registry = new TemplateRendererRegistry([new StringTemplateRenderer()]);
$dispatcher->addSubscriber(new TemplateRendererListener($registry, new ObjectNormalizer()));
$dispatcher->addSubscriber(new PlatformSubscriber());

$city = new City(name: 'Berlin');

$messages = new MessageBag(
    Message::ofUser(Template::string('Research missing data for: {city.name}')),
);

$result = $platform->invoke($model, $messages, [
    'template_vars' => ['city' => $city],
    'response_format' => $city,
]);

// The same instance is returned with its missing fields filled in
assert($city === $result->asObject());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

use Symfony\Component\Serializer\Attribute\Groups;

final class Product
{
    #[Groups(['read', 'write'])]
    public string $name = '';

    #[Groups(['write'])]
    public ?int $price = null;

    #[Groups(['read'])]
    public string $slug = '';

    public string $internalNote = '';
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

use Symfony\AI\Platform\Exception\ValidationException;
use Symfony\AI\Platform\StructuredOutput\PlatformSubscriber;
use Symfony\AI\Platform\StructuredOutput\Validator\ValidatorSubscriber;
use Symfony\Component\EventDispatcher\EventDispatcher;

$dispatcher = new EventDispatcher();
$dispatcher->addSubscriber(new PlatformSubscriber());
$dispatcher->addSubscriber(new ValidatorSubscriber());

$platform = Factory::createPlatform($apiKey, eventDispatcher: $dispatcher);

try {
    $result = $platform->invoke('gpt-4o', $messages, ['response_format' => MathReasoning::class]);
} catch (ValidationException $e) {
    $violations = $e->getViolations();
    // handle violations
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;
use Symfony\AI\Platform\StructuredOutput\PlatformSubscriber;

// Initialize platform with PlatformSubscriber registered on the event dispatcher.

$messages = new MessageBag(Message::ofUser('Give me a recipe for a Margherita pizza.'));
$result = $platform->invoke('gpt-4o-mini', $messages, [
    'stream' => true,
    'response_format' => Recipe::class,
]);

foreach ($result->asStreamedObject() as $recipe) {
    render($recipe); // progressively populated Recipe instance (name, then ingredients, then steps)
}

$final = $result->asObject(); // fully materialized Recipe; runs ValidatorSubscriber if registered

1
2
3
4
5
6
7
8
9
10
11
12
13

use Symfony\AI\Platform\StructuredOutput\Streaming\PartialJsonParser;

$buffer = '';

foreach ($chunks as $chunk) {
    $buffer .= $chunk;

    $partial = PartialJsonParser::parse($buffer, $errorMessage);

    if (null !== $partial) {
        // render the partial structure (array/object/scalar)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

use Symfony\AI\Platform\Test\MockPlatformFactory;

// 1. Fixed string - every call returns a TextResult
$platform = MockPlatformFactory::createPlatform('Mock result');
echo $platform->invoke('gpt-4o-mini', 'What is the capital of France?')->asText(); // "Mock result"

// 2. Map keyed by model name - per-model response
$platform = MockPlatformFactory::createPlatform([
    'gpt-4o-mini' => 'cheap answer',
    'gpt-4o' => 'expensive answer',
]);

// 3. Closure - full control, branch on the payload or options
$platform = MockPlatformFactory::createPlatform(
    fn ($model, $payload, $options) => "Echo: {$payload}"
);

1
2
3
4
5
6
7
8
9
10

use Symfony\AI\Platform\Result\ObjectResult;
use Symfony\AI\Platform\Result\VectorResult;
use Symfony\AI\Platform\Test\MockPlatformFactory;
use Symfony\AI\Platform\Vector\Vector;

$platform = MockPlatformFactory::createPlatform(fn () => new ObjectResult((object) ['city' => 'Paris']));
echo $platform->invoke('gpt-4o-mini', 'extract the city')->asObject()->city; // "Paris"

$platform = MockPlatformFactory::createPlatform(fn () => new VectorResult([new Vector([0.1, 0.2, 0.3])]));
$vectors = $platform->invoke('text-embedding-3-small', 'vectorize')->asVectors();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

use Symfony\AI\Platform\ModelCatalog\FallbackModelCatalog;
use Symfony\AI\Platform\Platform;
use Symfony\AI\Platform\Provider;
use Symfony\AI\Platform\Test\MockModelClient;
use Symfony\AI\Platform\Test\MockResultConverter;

$client = new MockModelClient('ok');
$provider = new Provider('mock', [$client], [new MockResultConverter()], new FallbackModelCatalog());
$platform = new Platform([$provider]);

$platform->invoke('gpt-4o-mini', 'Hello', ['temperature' => 0.5]);

$calls = $client->getCalls();
// $calls[0]['model']->getName() === 'gpt-4o-mini'
// $calls[0]['options'] === ['temperature' => 0.5]

1
2
3
4
5
6
7
8
9
10

use Symfony\AI\Platform\Capability;
use Symfony\AI\Platform\Model;
use Symfony\AI\Platform\Test\MockModelCatalog;
use Symfony\AI\Platform\Test\MockPlatformFactory;

$provider = MockPlatformFactory::createProvider('mock answer', new MockModelCatalog([
    'mock-model' => ['class' => Model::class, 'capabilities' => [Capability::INPUT_MESSAGES]],
]));
// $provider->supports('mock-model') === true
// $provider->supports('gpt-4o') === false