-

Author: OskarStark

docs/bundles/ai-bundle.rst

@@ -699,7 +699,7 @@ Usage
 Agent Service
 ~~~~~~~~~~~~~
 
-Use the `Agent` service to leverage models and tools::
+Use the :class:`Symfony\\AI\\Agent\\Agent` service to leverage models and tools::
 
     use Symfony\AI\Agent\AgentInterface;
     use Symfony\AI\Platform\Message\Message;
@@ -726,11 +726,11 @@ Use the `Agent` service to leverage models and tools::
 Register Processors
 ~~~~~~~~~~~~~~~~~~~
 
-By default, all services implementing the ``InputProcessorInterface`` or the
-``OutputProcessorInterface`` interfaces are automatically applied to every ``Agent``.
+By default, all services implementing the :class:`Symfony\\AI\\Agent\\InputProcessorInterface` or the
+:class:`Symfony\\AI\\Agent\\OutputProcessorInterface` interfaces are automatically applied to every :class:`Symfony\\AI\\Agent\\Agent`.
 
-This behavior can be overridden/configured with the ``#[AsInputProcessor]`` and
-the ``#[AsOutputProcessor]`` attributes::
+This behavior can be overridden/configured with the :class:`Symfony\\AI\\AiBundle\\Attribute\\AsInputProcessor` and
+the :class:`Symfony\\AI\\AiBundle\\Attribute\\AsOutputProcessor` attributes::
 
     use Symfony\AI\Agent\Input;
     use Symfony\AI\Agent\InputProcessorInterface;
@@ -779,7 +779,7 @@ To use existing tools, you can register them as a service:
         Symfony\AI\Agent\Toolbox\Tool\Brave:
           $apiKey: '%env(BRAVE_API_KEY)%'
 
-Custom tools can be registered by using the ``#[AsTool]`` attribute::
+Custom tools can be registered by using the :class:`Symfony\\AI\\Agent\\Toolbox\\Attribute\\AsTool` attribute::
 
     use Symfony\AI\Agent\Toolbox\Attribute\AsTool;
 
@@ -813,8 +813,8 @@ To inject only specific tools, list them in the configuration:
                 tools:
                     - 'Symfony\AI\Agent\Toolbox\Tool\SimilaritySearch'
 
-To restrict the access to a tool, you can use the ``IsGrantedTool`` attribute, which
-works similar to ``IsGranted`` attribute in `symfony/security-http`. For this to work,
+To restrict the access to a tool, you can use the :class:`Symfony\\AI\\Agent\\Attribute\\IsGrantedTool` attribute, which
+works similar to :class:`Symfony\\Component\\Security\\Http\\Attribute\\IsGranted` attribute in `symfony/security-http`. For this to work,
 make sure you have `symfony/security-core` installed in your project.
 
 ::
@@ -831,7 +831,7 @@ make sure you have `symfony/security-core` installed in your project.
         }
     }
 
-The attribute ``IsGrantedTool`` can be added on class- or method-level - even multiple
+The attribute :class:`Symfony\\AI\\Agent\\Attribute\\IsGrantedTool` can be added on class- or method-level - even multiple
 times. If multiple attributes apply to one tool call, a logical AND is used and all access
 decisions have to grant access.
 

docs/components/agent.rst

@@ -1,8 +1,9 @@
 Symfony AI - Agent Component
 ============================
 
-The Agent component provides a framework for building AI agents that, sits on top of the Platform and Store components,
-allowing you to create agents that can interact with users, perform tasks, and manage workflows.
+The Agent component provides a framework for building AI agents that,
+sits on top of the Platform and Store components, allowing you to create
+agents that can interact with users, perform tasks, and manage workflows.
 
 Installation
 ------------
@@ -14,8 +15,8 @@ Installation
 Basic Usage
 -----------
 
-To instantiate an agent, you need to pass a ``Symfony\AI\Platform\PlatformInterface`` and a
-``Symfony\AI\Platform\Model`` instance to the ``Symfony\AI\Agent\Agent`` class::
+To instantiate an agent, you need to pass a :class:`Symfony\\AI\\Platform\\PlatformInterface` and a
+:class:`Symfony\\AI\\Platform\\Model` instance to the :class:`Symfony\\AI\\Agent\\Agent` class::
 
     use Symfony\AI\Agent\Agent;
     use Symfony\AI\Platform\Bridge\OpenAi\Gpt;
@@ -26,7 +27,7 @@ To instantiate an agent, you need to pass a ``Symfony\AI\Platform\PlatformInterf
 
     $agent = new Agent($platform, $model);
 
-You can then run the agent with a ``Symfony\AI\Platform\Message\MessageBagInterface`` instance as input and an optional
+You can then run the agent with a :class:`Symfony\\AI\\Platform\\Message\\MessageBagInterface` instance as input and an optional
 array of options::
 
     use Symfony\AI\Agent\Agent;
@@ -74,7 +75,7 @@ Tool calling can be enabled by registering the processors in the agent::
 
     $agent = new Agent($platform, $model, inputProcessors: [$toolProcessor], outputProcessors: [$toolProcessor]);
 
-Custom tools can basically be any class, but must configure by the ``#[AsTool]`` attribute::
+Custom tools can basically be any class, but must configure by the :class:`Symfony\\AI\\Agent\\Toolbox\\Attribute\\AsTool` attribute::
 
     use Symfony\AI\Toolbox\Attribute\AsTool;
 
@@ -96,7 +97,7 @@ JsonSerializable interface, to JSON strings for you. So you can return arrays or
 Tool Methods
 ~~~~~~~~~~~~
 
-You can configure the method to be called by the LLM with the ``#[AsTool]`` attribute and have multiple tools per class::
+You can configure the method to be called by the LLM with the :class:`Symfony\\AI\\Agent\\Toolbox\\Attribute\\AsTool` attribute and have multiple tools per class::
 
     use Symfony\AI\Toolbox\Attribute\AsTool;
 
@@ -126,14 +127,14 @@ You can configure the method to be called by the LLM with the ``#[AsTool]`` attr
 Tool Parameters
 ~~~~~~~~~~~~~~~
 
-Symfony AI generates a JSON Schema representation for all tools in the Toolbox based on the ``#[AsTool]`` attribute and
+Symfony AI generates a JSON Schema representation for all tools in the :class:`Symfony\\AI\\Agent\\Toolbox\\Toolbox` based on the :class:`Symfony\\AI\\Agent\\Toolbox\\Attribute\\AsTool` attribute and
 method arguments and param comments in the doc block. Additionally, JSON Schema support validation rules, which are
 partially supported by LLMs like GPT.
 
 Parameter Validation with ``#[With]`` Attribute
 ...............................................
 
-To leverage JSON Schema validation rules, configure the ``#[With]`` attribute on the method arguments of your tool::
+To leverage JSON Schema validation rules, configure the :class:`Symfony\\AI\\Platform\\Contract\\JsonSchema\\Attribute\\With` attribute on the method arguments of your tool::
 
     use Symfony\AI\Agent\Toolbox\Attribute\AsTool;
     use Symfony\AI\Platform\Contract\JsonSchema\Attribute\With;
@@ -158,12 +159,12 @@ To leverage JSON Schema validation rules, configure the ``#[With]`` attribute on
         }
     }
 
-See attribute class ``Symfony\AI\Platform\Contract\JsonSchema\Attribute\With`` for all available options.
+See attribute class :class:`Symfony\\AI\\Platform\\Contract\\JsonSchema\\Attribute\\With` for all available options.
 
 Automatic Enum Validation
 .........................
 
-For PHP backed enums, automatic validation without requiring any ``#[With]`` attribute is supported::
+For PHP backed enums, automatic validation without requiring any :class:`Symfony\\AI\\Platform\\Contract\\JsonSchema\\Attribute\\With` attribute is supported::
 
     enum Priority: int
     {
@@ -208,8 +209,8 @@ This eliminates the need for manual ``#[With(enum: [...])]`` attributes when usi
 Third-Party Tools
 ~~~~~~~~~~~~~~~~~
 
-In some cases you might want to use third-party tools, which are not part of your application. Adding the ``#[AsTool]``
-attribute to the class is not possible in those cases, but you can explicitly register the tool in the MemoryFactory::
+In some cases you might want to use third-party tools, which are not part of your application. Adding the :class:`Symfony\\AI\\Agent\\Toolbox\\Attribute\\AsTool`
+attribute to the class is not possible in those cases, but you can explicitly register the tool in the :class:`Symfony\\AI\\Agent\\Toolbox\\ToolFactory\\MemoryToolFactory`::
 
     use Symfony\AI\Agent\Toolbox\Toolbox;
     use Symfony\AI\Agent\Toolbox\ToolFactory\MemoryToolFactory;
@@ -223,7 +224,7 @@ attribute to the class is not possible in those cases, but you can explicitly re
 
     Please be aware that not all return types are supported by the toolbox, so a decorator might still be needed.
 
-This can be combined with the ``ChainFactory`` which enables you to use explicitly registered tools and ``#[AsTool]`` tagged
+This can be combined with the :class:`Symfony\\AI\\Agent\\Toolbox\\ToolFactory\\ChainFactory` which enables you to use explicitly registered tools and :class:`Symfony\\AI\\Agent\\Toolbox\\Attribute\\AsTool` tagged
 tools in the same chain - which even enables you to overwrite the pre-existing configuration of a tool::
 
     use Symfony\AI\Agent\Toolbox\Toolbox;
@@ -261,7 +262,7 @@ Fault Tolerance
 ~~~~~~~~~~~~~~~
 
 To gracefully handle errors that occur during tool calling, e.g. wrong tool names or runtime errors, you can use the
-``FaultTolerantToolbox`` as a decorator for the Toolbox. It will catch the exceptions and return readable error messages
+:class:`Symfony\\AI\\Agent\\Toolbox\\FaultTolerantToolbox` as a decorator for the :class:`Symfony\\AI\\Agent\\Toolbox\\Toolbox`. It will catch the exceptions and return readable error messages
 to the LLM::
 
     use Symfony\AI\Agent\Agent;
@@ -275,7 +276,7 @@ to the LLM::
 
     $agent = new Agent($platform, $model, inputProcessor: [$toolProcessor], outputProcessor: [$toolProcessor]);
 
-If you want to expose the underlying error to the LLM, you can throw a custom exception that implements `ToolExecutionExceptionInterface`::
+If you want to expose the underlying error to the LLM, you can throw a custom exception that implements :class:`Symfony\\AI\\Agent\\Toolbox\\Exception\\ToolExecutionExceptionInterface`::
 
     use Symfony\AI\Agent\Toolbox\Exception\ToolExecutionExceptionInterface;
 
@@ -325,7 +326,7 @@ Tool Result Interception
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 To react to the result of a tool, you can implement an EventListener, that listens to the
-``ToolCallsExecuted`` event. This event is dispatched after the Toolbox executed all current
+:class:`Symfony\\AI\\Agent\\Toolbox\\Event\\ToolCallsExecuted` event. This event is dispatched after the :class:`Symfony\\AI\\Agent\\Toolbox\\Toolbox` executed all current
 tool calls and enables you to skip the next LLM call by setting a result yourself::
 
     $eventDispatcher->addListener(ToolCallsExecuted::class, function (ToolCallsExecuted $event): void {
@@ -525,8 +526,8 @@ They are provided while instantiating the agent instance::
 InputProcessor
 ~~~~~~~~~~~~~~
 
-InputProcessor instances are called in the agent before handing over the MessageBag and the $options array to the LLM
-and are able to mutate both on top of the Input instance provided::
+:class:`Symfony\\AI\\Agent\\InputProcessorInterface` instances are called in the agent before handing over the :class:`Symfony\\AI\\Platform\\Message\\MessageBag` and the $options array to the LLM
+and are able to mutate both on top of the :class:`Symfony\\AI\\Agent\\Input` instance provided::
 
     use Symfony\AI\Agent\Input;
     use Symfony\AI\Agent\InputProcessorInterface;
@@ -549,7 +550,7 @@ and are able to mutate both on top of the Input instance provided::
 OutputProcessor
 ~~~~~~~~~~~~~~~
 
-OutputProcessor instances are called after the model provided a result and can - on top of options and messages - mutate
+:class:`Symfony\\AI\\Agent\\OutputProcessorInterface` instances are called after the model provided a result and can - on top of options and messages - mutate
 or replace the given result::
 
     use Symfony\AI\Agent\Output;
@@ -569,9 +570,9 @@ or replace the given result::
 Agent Awareness
 ~~~~~~~~~~~~~~~
 
-Both, Input and Output instances, provide access to the LLM used by the agent, but the agent itself is only provided,
-in case the processor implemented the AgentAwareInterface interface, which can be combined with using the
-AgentAwareTrait::
+Both, :class:`Symfony\\AI\\Agent\\Input` and :class:`Symfony\\AI\\Agent\\Output` instances, provide access to the LLM used by the agent, but the agent itself is only provided,
+in case the processor implemented the :class:`Symfony\\AI\\Agent\\AgentAwareInterface` interface, which can be combined with using the
+:class:`Symfony\\AI\\Agent\\AgentAwareTrait`::
 
     use Symfony\AI\Agent\AgentAwareInterface;
     use Symfony\AI\Agent\AgentAwareTrait;
@@ -599,7 +600,7 @@ model with context without changing your application logic.
 Using Memory
 ^^^^^^^^^^^^
 
-Memory integration is handled through the ``MemoryInputProcessor`` and one or more ``MemoryProviderInterface`` implementations::
+Memory integration is handled through the :class:`Symfony\\AI\\Agent\\Memory\\MemoryInputProcessor` and one or more :class:`Symfony\\AI\\Agent\\Memory\\MemoryProviderInterface` implementations::
 
     use Symfony\AI\Agent\Agent;
     use Symfony\AI\Agent\Memory\MemoryInputProcessor;
@@ -669,7 +670,7 @@ Testing
 MockAgent
 ^^^^^^^^^
 
-For testing purposes, the Agent component provides a ``MockAgent`` class that behaves like Symfony's ``MockHttpClient``.
+For testing purposes, the Agent component provides a :class:`Symfony\\AI\\Agent\\MockAgent` class that behaves like Symfony's :class:`Symfony\\Component\\HttpClient\\MockHttpClient`.
 It provides predictable responses without making external API calls and includes assertion methods for verifying interactions::
 
     use Symfony\AI\Agent\MockAgent;
@@ -702,7 +703,7 @@ Call Tracking and Assertions::
 MockResponse Objects
 ^^^^^^^^^^^^^^^^^^^^
 
-Similar to ``MockHttpClient``, you can use ``MockResponse`` objects for more complex scenarios::
+Similar to :class:`Symfony\\Component\\HttpClient\\MockHttpClient`, you can use :class:`Symfony\\AI\\Agent\\MockResponse` objects for more complex scenarios::
 
     use Symfony\AI\Agent\MockResponse;
 
@@ -715,7 +716,7 @@ Similar to ``MockHttpClient``, you can use ``MockResponse`` objects for more com
 Callable Responses
 ^^^^^^^^^^^^^^^^^^
 
-Like ``MockHttpClient``, ``MockAgent`` supports callable responses for dynamic behavior::
+Like :class:`Symfony\\Component\\HttpClient\\MockHttpClient`, :class:`Symfony\\AI\\Agent\\MockAgent` supports callable responses for dynamic behavior::
 
     $agent = new MockAgent();
 

docs/components/platform.rst

@@ -126,8 +126,8 @@ One central feature of the Platform component is the support for language
 models and easing the interaction with them. This is supported by providing
 an extensive set of data classes around the concept of messages and their content.
 
-Messages can be of different types, most importantly ``UserMessage``, ``SystemMessage``, or ``AssistantMessage``, can
-have different content types, like ``Text``, ``Image`` or ``Audio``, and can be grouped into a ``MessageBag``::
+Messages can be of different types, most importantly :class:`Symfony\\AI\\Platform\\Message\\UserMessage`, :class:`Symfony\\AI\\Platform\\Message\\SystemMessage`, or :class:`Symfony\\AI\\Platform\\Message\\AssistantMessage`, can
+have different content types, like :class:`Symfony\\AI\\Platform\\Message\\Content\\Text`, :class:`Symfony\\AI\\Platform\\Message\\Content\\Image` or :class:`Symfony\\AI\\Platform\\Message\\Content\\Audio`, and can be grouped into a :class:`Symfony\\AI\\Platform\\Message\\MessageBag`::
 
     use Symfony\AI\Platform\Message\Content\Image;
     use Symfony\AI\Platform\Message\Message;
@@ -170,7 +170,7 @@ Result Streaming
 ----------------
 
 Since LLMs usually generate a result word by word, most of them also support streaming the result using Server Side
-Events. Symfony AI supports that by abstracting the conversion and returning a ``Generator`` as content of the result::
+Events. Symfony AI supports that by abstracting the conversion and returning a :class:`Generator` as content of the result::
 
     use Symfony\AI\Agent\Agent;
     use Symfony\AI\Message\Message;
@@ -206,7 +206,7 @@ Code Examples
 Image Processing
 ----------------
 
-Some LLMs also support images as input, which Symfony AI supports as content type within the ``UserMessage``::
+Some LLMs also support images as input, which Symfony AI supports as content type within the :class:`Symfony\\AI\\Platform\\Message\\UserMessage`::
 
     use Symfony\AI\Platform\Message\Content\Image;
     use Symfony\AI\Platform\Message\Message;
@@ -235,7 +235,7 @@ Audio Processing
 ----------------
 
 Similar to images, some LLMs also support audio as input, which is just another content type within the
-``UserMessage``::
+:class:`Symfony\\AI\\Platform\\Message\\UserMessage`::
 
     use Symfony\AI\Platform\Message\Content\Audio;
     use Symfony\AI\Platform\Message\Message;
@@ -261,7 +261,7 @@ Embeddings
 
 Creating embeddings of word, sentences, or paragraphs is a typical use case around the interaction with LLMs.
 
-The standalone usage results in an ``Vector`` instance::
+The standalone usage results in a :class:`Symfony\\AI\\Store\\Vector` instance::
 
     use Symfony\AI\Platform\Bridge\OpenAi\Embeddings;
 
@@ -307,13 +307,13 @@ which can be useful to speed up the processing::
 Testing Tools
 -------------
 
-For unit or integration testing, you can use the `InMemoryPlatform`,
-which implements `PlatformInterface` without calling external APIs.
+For unit or integration testing, you can use the :class:`Symfony\\AI\\Platform\\InMemoryPlatform`,
+which implements :class:`Symfony\\AI\\Platform\\PlatformInterface` without calling external APIs.
 
 It supports returning either:
 
 - A fixed string result
-- A callable that dynamically returns a simple string or any ``ResultInterface`` based on the model, input, and options::
+- A callable that dynamically returns a simple string or any :class:`Symfony\\AI\\Platform\\Result\\ResultInterface` based on the model, input, and options::
 
     use Symfony\AI\Platform\InMemoryPlatform;
     use Symfony\AI\Platform\Model;

docs/components/store.rst

@@ -22,8 +22,8 @@ for documents.
 Indexing
 --------
 
-One higher level feature is the ``Symfony\AI\Store\Indexer``. The purpose of this service is to populate a store with documents.
-Therefore it accepts one or multiple ``Symfony\AI\Store\Document\TextDocument`` objects, converts them into embeddings and stores them in the
+One higher level feature is the :class:`Symfony\\AI\\Store\\Indexer`. The purpose of this service is to populate a store with documents.
+Therefore it accepts one or multiple :class:`Symfony\\AI\\Store\\Document\\TextDocument` objects, converts them into embeddings and stores them in the
 used vector store::
 
     use Symfony\AI\Store\Document\TextDocument;
@@ -101,7 +101,7 @@ you can use the ``bin/console ai:store:setup`` command to initialize the store a
 Implementing a Bridge
 ---------------------
 
-The main extension points of the Store component is the ``Symfony\AI\Store\StoreInterface``, that defines the methods
+The main extension points of the Store component is the :class:`Symfony\\AI\\Store\\StoreInterface`, that defines the methods
 for adding vectorized documents to the store, and querying the store for documents with a vector.
 
 This leads to a store implementing two methods::