Symfony AI - Agent Component

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\Toolbox\Attribute\AsTool;

#[AsTool(
    name: 'weather_current',
    description: 'get current weather for a location',
    method: 'current',
)]
#[AsTool(
    name: 'weather_forecast',
    description: 'get weather forecast for a location',
    method: 'forecast',
)]
final readonly class OpenMeteo
{
    public function current(float $latitude, float $longitude): array
    {
        // ...
    }

    public function forecast(float $latitude, float $longitude): array
    {
        // ...
    }
}

1
2
3
4
5
6
7
8
9
10

use Symfony\AI\Agent\Toolbox\Tool\Agent;
use Symfony\AI\Agent\Toolbox\Toolbox;
use Symfony\AI\Agent\Toolbox\ToolFactory\MemoryToolFactory;

// agent was initialized before

$agentTool = new Agent($agent);
$metadataFactory = (new MemoryToolFactory())
    ->addTool($agentTool, 'research_agent', 'Meaningful description for sub-agent');
$toolbox = new Toolbox($metadataFactory, [$agentTool]);

1
2
3
4
5
6
7
8
9
10

use Symfony\AI\Agent\Agent;
use Symfony\AI\Agent\Toolbox\AgentProcessor;
use Symfony\AI\Agent\Toolbox\FaultTolerantToolbox;

// Platform, LLM & Toolbox instantiation

$toolbox = new FaultTolerantToolbox($innerToolbox);
$toolProcessor = new AgentProcessor($toolbox);

$agent = new Agent($platform, $model, inputProcessor: [$toolProcessor], outputProcessor: [$toolProcessor]);

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
30
31
32
33
34
35

use Symfony\AI\Agent\Toolbox\Exception\ToolExecutionExceptionInterface;

class EntityNotFoundException extends \RuntimeException implements ToolExecutionExceptionInterface
{
    public function __construct(
        private string $entityName,
        private int $id,
    ){
    }

    public function getToolCallResult(): string
    {
        return \sprintf('No %s found with id %d', $this->entityName, $this->id);
    }
}

#[AsTool('get_user_age', 'Get age by user id')]
class GetUserAge
{
    public function __construct(
        private UserRepository $userRepository,
    ){
    }

    public function __invoke(int $id): int
    {
        $user = $this->userRepository->find($id)

        if (null === $user) {
            throw new EntityNotFoundException('user', $id);
        }

        return $user->getAge();
    }
}

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

use Symfony\AI\Agent\Toolbox\Source\HasSourcesInterface;
use Symfony\AI\Agent\Toolbox\Source\HasSourcesTrait;

#[AsTool('my_tool', 'Example tool with sources.')]
final class MyTool implements HasSourcesInterface
{
    use HasSourcesTrait;

    public function __invoke(string $query): string
    {
        // Add sources relevant for the result

        $this->addSource(
            new Source('Example Source 1', 'https://example.com/source1', 'Relevant content from source 1'),
        );

        // return result
    }
}

1
2
3
4
5
6
7
8
9
10
11

$eventDispatcher->addListener(ToolCallArgumentsResolved::class, function (ToolCallArgumentsResolved $event): void {
    // Let the client know, that the tool $event->toolCall->name was executed
});

$eventDispatcher->addListener(ToolCallSucceeded::class, function (ToolCallSucceeded $event): void {
    // Let the client know, that the tool $event->toolCall->name successfully returned the result $event->result
});

$eventDispatcher->addListener(ToolCallFailed::class, function (ToolCallFailed $event): void {
    // Let the client know, that the tool $event->toolCall->name failed with the exception: $event->exception
});

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

use Symfony\AI\Agent\Toolbox\AgentProcessor;
use Symfony\AI\Agent\Toolbox\Toolbox;

// Platform instantiation

$messages = new MessageBag(
    Message::forSystem(<<<PROMPT
        Please answer all user questions only using the my-tool tool.
        Do not add information and if you cannot find an answer, say so.
        PROMPT),
    Message::ofUser('...') // The user's question.
);

$tool = new MyTool();

$toolbox = new Toolbox([$tool]);
$toolProcessor = new AgentProcessor($toolbox, keepToolMessages: true);

$agent = new Agent($platform, $model, inputProcessor: [$toolProcessor], outputProcessor: [$toolProcessor]);
$result = $agent->call($messages);
// $messages will now include the tool messages

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

use Symfony\AI\Agent\Input;
use Symfony\AI\Agent\InputProcessorInterface;
use Symfony\AI\Platform\Message\AssistantMessage;

final class MyProcessor implements InputProcessorInterface
{
    public function processInput(Input $input): void
    {
        // mutate options
        $options = $input->getOptions();
        $options['foo'] = 'bar';
        $input->setOptions($options);

        // mutate MessageBag
        $input->messages->append(new AssistantMessage(sprintf('Please answer using the locale %s', $this->locale)));
    }
}

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

use Symfony\AI\Agent\Output;
use Symfony\AI\Agent\OutputProcessorInterface;

final class MyProcessor implements OutputProcessorInterface
{
    public function processOutput(Output $output): void
    {
        // mutate result
        if (str_contains($output->result->getContent(), self::STOP_WORD)) {
            $output->result = new TextResult('Sorry, we were unable to find relevant information.')
        }
    }
}

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

use Symfony\AI\Agent\AgentAwareInterface;
use Symfony\AI\Agent\AgentAwareTrait;
use Symfony\AI\Agent\Output;
use Symfony\AI\Agent\OutputProcessorInterface;

final class MyProcessor implements OutputProcessorInterface, AgentAwareInterface
{
    use AgentAwareTrait;

    public function processOutput(Output $out): void
    {
        // additional agent interaction
        $result = $this->agent->call(...);
    }
}

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

use Symfony\AI\Agent\Agent;
use Symfony\AI\Agent\Memory\MemoryInputProcessor;
use Symfony\AI\Agent\Memory\StaticMemoryProvider;
use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;

// Platform instantiation

$personalFacts = new StaticMemoryProvider(
    'My name is Wilhelm Tell',
    'I wish to be a swiss national hero',
    'I am struggling with hitting apples but want to be professional with the bow and arrow',
);
$memoryProcessor = new MemoryInputProcessor($personalFacts);

$agent = new Agent($platform, $model, [$memoryProcessor]);
$messages = new MessageBag(Message::ofUser('What do we do today?'));
$result = $agent->call($messages);

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

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

$agent = new MockAgent([
    'What is Symfony?' => 'Symfony is a PHP web framework',
    'Tell me about caching' => 'Symfony provides powerful caching',
]);

$messages = new MessageBag(Message::ofUser('What is Symfony?'));
$result = $agent->call($messages);

echo $result->getContent(); // "Symfony is a PHP web framework"

1
2
3
4
5
6
7
8
9
10

// Verify agent interactions
$agent->assertCallCount(1);
$agent->assertCalledWith('What is Symfony?');

// Get detailed call information
$calls = $agent->getCalls();
$lastCall = $agent->getLastCall();

// Reset call tracking
$agent->reset();

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

$agent = new MockAgent();

// Dynamic response based on input and context
$agent->addResponse('weather', function ($messages, $options, $input) {
    $messageCount = count($messages->getMessages());
    return "Weather info (context: {$messageCount} messages)";
});

// Callable can return string or MockResponse
$agent->addResponse('complex', function ($messages, $options, $input) {
    return new MockResponse("Complex response for: {$input}");
});

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

class ChatServiceTest extends TestCase
{
    public function testChatResponse(): void
    {
        $agent = new MockAgent([
            'Hello' => 'Hi there! How can I help?',
        ]);

        $chatService = new ChatService($agent);
        $response = $chatService->processMessage('Hello');

        $this->assertSame('Hi there! How can I help?', $response);
        $agent->assertCallCount(1);
        $agent->assertCalledWith('Hello');
    }
}