feature #583 [AI Bundle] Add memory provider configuration support (OskarStark)

This PR was squashed before being merged into the main branch.

Discussion
----------

[AI Bundle] Add memory provider configuration support

| Q             | A
| ------------- | ---
| Bug fix?      | no
| New feature?  | yes
| Docs?         | yes
| Issues        | Follows #117
| License       | MIT

This PR introduces comprehensive memory provider configuration capabilities for AI agents, enabling both simple static memory and advanced dynamic memory scenarios.

## 🚀 Key Features

### Smart Detection Logic
The system automatically detects the intent:
- If the value matches an existing service/alias → uses that service directly
- If no matching service exists → creates `StaticMemoryProvider` with the string as static content

### Memory as System Prompt
- When only `memory` is provided (no `prompt`), memory serves as the system prompt
- When both `memory` and `prompt` are provided, memory is prepended to the prompt

### Configuration Examples

**Static Memory (Most Common):**
```yaml
ai:
  agent:
    my_agent:
      model:
        class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
        name: !php/const Symfony\AI\Platform\Bridge\OpenAi\Gpt::GPT_4O_MINI
      memory: 'You have access to user preferences and conversation history'
      prompt:
        text: 'You are a helpful assistant.'
```

**Dynamic Memory (Advanced):**
```yaml
ai:
  agent:
    my_agent:
      model:
        class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
        name: !php/const Symfony\AI\Platform\Bridge\OpenAi\Gpt::GPT_4O_MINI
      memory: 'my_custom_memory_service'  # References existing service
      prompt:
        text: 'You are a helpful assistant.'
```

**Memory as System Prompt:**
```yaml
ai:
  agent:
    my_agent:
      model:
        class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
        name: !php/const Symfony\AI\Platform\Bridge\OpenAi\Gpt::GPT_4O_MINI
      memory: 'You are a helpful assistant with access to user context.'
      # No prompt needed - memory serves as system prompt
```

This enhancement significantly improves the developer experience while maintaining full backward compatibility and adding powerful new memory capabilities for AI agents.

cc `@DZunke`

Commits
-------

f4ac5b6 [AI Bundle] Add memory provider configuration support

Author: OskarStark

src/ai-bundle/CHANGELOG.md

@@ -5,6 +5,7 @@ CHANGELOG
 ---
 
  * Add Symfony bundle for integrating Platform, Agent, and Store components
+ * Add memory provider configuration support for agents. Symfony AI was bootstrapped by Christopher Hertel and Oskar Stark
  * Add Perplexity platform support with API key configuration
  * Add service configuration:
    - Agent services with configurable platforms and system prompts

src/ai-bundle/config/options.php

@@ -130,6 +130,14 @@
                             ->end()
                         ->end()
                         ->booleanNode('structured_output')->defaultTrue()->end()
+                        ->scalarNode('memory')
+                            ->info('Plain string or service name of the memory provider implementing MemoryProviderInterface')
+                            ->defaultNull()
+                            ->validate()
+                                ->ifTrue(function ($v) { return \is_string($v) && '' === $v; })
+                                ->thenInvalid('Memory cannot be empty.')
+                            ->end()
+                        ->end()
                         ->arrayNode('prompt')
                             ->info('The system prompt configuration')
                             ->beforeNormalization()

src/ai-bundle/doc/index.rst

@@ -71,6 +71,7 @@ Configuration
                 model:
                     class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
                     name: !php/const Symfony\AI\Platform\Bridge\OpenAi\Gpt::GPT_4O_MINI
+                memory: 'You have access to conversation history and user preferences' # Optional: static memory or service reference
                 prompt: # The system prompt configuration
                     text: 'You are a helpful assistant that can answer questions.' # The prompt text
                     include_tools: true # Include tool definitions at the end of the system prompt
@@ -181,6 +182,108 @@ The array format supports these options:
 * ``text`` (string, required): The system prompt text that will be sent to the AI model
 * ``include_tools`` (boolean, optional): When set to ``true``, tool definitions will be appended to the system prompt
 
+Memory Provider Configuration
+-----------------------------
+
+Memory providers allow agents to access and utilize conversation history and context from previous interactions. 
+This enables agents to maintain context across conversations and provide more personalized responses.
+
+**Static Memory (Simple)**
+
+The simplest way to add memory is to provide a string that will be used as static context:
+
+.. code-block:: yaml
+
+    ai:
+        agent:
+            my_agent:
+                model:
+                    class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
+                    name: !php/const Symfony\AI\Platform\Bridge\OpenAi\Gpt::GPT_4O_MINI
+                memory: 'You have access to user preferences and conversation history'
+                prompt:
+                    text: 'You are a helpful assistant.'
+
+This static memory content is consistently available to the agent across all conversations.
+
+**Dynamic Memory (Advanced)**
+
+For more sophisticated scenarios, you can reference an existing service that implements dynamic memory:
+
+.. code-block:: yaml
+
+    ai:
+        agent:
+            my_agent:
+                model:
+                    class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
+                    name: !php/const Symfony\AI\Platform\Bridge\OpenAi\Gpt::GPT_4O_MINI
+                memory: 'my_memory_service'  # References an existing service
+                prompt:
+                    text: 'You are a helpful assistant.'
+
+**Memory as System Prompt**
+
+Memory can work independently or alongside the system prompt:
+
+- **Memory only**: If no prompt is provided, memory becomes the system prompt
+- **Memory + Prompt**: If both are provided, memory is prepended to the prompt
+
+.. code-block:: yaml
+
+    ai:
+        agent:
+            # Agent with memory only (memory becomes system prompt)
+            memory_only_agent:
+                model:
+                    class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
+                memory: 'You are a helpful assistant with conversation history'
+            
+            # Agent with both memory and prompt (memory prepended to prompt)
+            memory_and_prompt_agent:
+                model:
+                    class: 'Symfony\AI\Platform\Bridge\OpenAi\Gpt'
+                memory: 'Previous conversation context...'
+                prompt:
+                    text: 'You are a helpful assistant.'
+
+**Custom Memory Provider Requirements**
+
+When using a service reference, the memory service must implement the ``Symfony\AI\Agent\Memory\MemoryProviderInterface``::
+
+    use Symfony\AI\Agent\Input;
+    use Symfony\AI\Agent\Memory\Memory;
+    use Symfony\AI\Agent\Memory\MemoryProviderInterface;
+
+    final class MyMemoryProvider implements MemoryProviderInterface
+    {
+        public function loadMemory(Input $input): array
+        {
+            // Return an array of Memory objects containing relevant conversation history
+            return [
+                new Memory('Previous conversation context...'),
+                new Memory('User preferences: prefers concise answers'),
+            ];
+        }
+    }
+
+**How Memory Works**
+
+The system automatically detects whether to use static or dynamic memory:
+
+**Static Memory Processing:**
+1. When you provide a string that doesn't match any service name
+2. The system creates a ``StaticMemoryProvider`` automatically
+3. Content is formatted as "## Static Memory" with the provided text
+4. This memory is consistently available across all conversations
+
+**Dynamic Memory Processing:**
+1. When the string matches an existing service in the container
+2. The ``MemoryInputProcessor`` uses that service directly
+3. The service's ``loadMemory()`` method is called before processing user input
+4. Dynamic memory content is injected based on the current context
+
+In both cases, memory content is prepended to the system message, allowing the agent to utilize the context effectively.
 
 Usage
 -----

src/ai-bundle/src/AiBundle.php

@@ -19,6 +19,8 @@
 use Symfony\AI\Agent\Attribute\AsOutputProcessor;
 use Symfony\AI\Agent\InputProcessor\SystemPromptInputProcessor;
 use Symfony\AI\Agent\InputProcessorInterface;
+use Symfony\AI\Agent\Memory\MemoryInputProcessor;
+use Symfony\AI\Agent\Memory\StaticMemoryProvider;
 use Symfony\AI\Agent\OutputProcessorInterface;
 use Symfony\AI\Agent\Toolbox\Attribute\AsTool;
 use Symfony\AI\Agent\Toolbox\FaultTolerantToolbox;
@@ -618,6 +620,31 @@ private function processAgentConfig(string $name, array $config, ContainerBuilde
             $container->setDefinition('ai.agent.'.$name.'.system_prompt_processor', $systemPromptInputProcessorDefinition);
         }
 
+        // MEMORY PROVIDER
+        if (isset($config['memory'])) {
+            $memoryValue = $config['memory'];
+
+            // Check if the value refers to an existing service
+            if ($container->hasDefinition($memoryValue) || $container->hasAlias($memoryValue)) {
+                // Use existing service as memory provider
+                $memoryProviderReference = new Reference($memoryValue);
+            } else {
+                // Create StaticMemoryProvider with the string as static content
+                $staticMemoryProviderDefinition = (new Definition(StaticMemoryProvider::class))
+                    ->setArguments([$memoryValue]);
+
+                $staticMemoryServiceId = 'ai.agent.'.$name.'.static_memory_provider';
+                $container->setDefinition($staticMemoryServiceId, $staticMemoryProviderDefinition);
+                $memoryProviderReference = new Reference($staticMemoryServiceId);
+            }
+
+            $memoryInputProcessorDefinition = (new Definition(MemoryInputProcessor::class))
+                ->setArguments([$memoryProviderReference])
+                ->addTag('ai.agent.input_processor', ['agent' => $agentId, 'priority' => -40]);
+
+            $container->setDefinition('ai.agent.'.$name.'.memory_input_processor', $memoryInputProcessorDefinition);
+        }
+
         $agentDefinition
             ->setArgument(2, []) // placeholder until ProcessorCompilerPass process.
             ->setArgument(3, []) // placeholder until ProcessorCompilerPass process.