Symfony AI : pipeline RAG complet avec PgVector et Claude Sonnet 4

# config/packages/ai.yaml
ai_platform:
    providers:
        anthropic:
            api_key: '%env(ANTHROPIC_API_KEY)%'
        voyage:
            api_key: '%env(VOYAGE_API_KEY)%'
    default_provider: anthropic

ai_store:
    stores:
        pgvector:
            type: pgvector
            dsn: '%env(DATABASE_URL)%'
            table: document_embeddings
            dimensions: 1024      # Dimension des vecteurs voyage-3

ai_agent:
    default_model: claude-sonnet-4-5
    max_tokens: 2048

<?php
// src/Command/IndexDocumentsCommand.php

namespace App\Command;

use App\Repository\DocumentRepository;
use Symfony\AI\Platform\Bridge\Voyage\VoyageEmbeddingsProvider;
use Symfony\AI\Store\Document\TextDocument;
use Symfony\AI\Store\VectorStoreInterface;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;

#[AsCommand(
    name: 'app:index-documents',
    description: 'Indexe les documents dans le vector store PgVector',
)]
final class IndexDocumentsCommand extends Command
{
    public function __construct(
        private readonly DocumentRepository $repository,
        private readonly VoyageEmbeddingsProvider $embeddings,
        private readonly VectorStoreInterface $store,
    ) {
        parent::__construct();
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $io = new SymfonyStyle($input, $output);
        $documents = $this->repository->findAll();
        $io->progressStart(count($documents));

        foreach ($documents as $document) {
            // ~500 tokens par chunk, overlap 200 caractères pour conserver le contexte aux frontières
            foreach ($this->chunk($document->getContent(), chunkSize: 2000, overlap: 200) as $i => $chunk) {
                // Génère le vecteur dense 1024D via Voyage AI
                $vector = $this->embeddings->embed($chunk, model: 'voyage-3');

                $this->store->add(new TextDocument(
                    id: sprintf('%s_chunk_%d', $document->getId(), $i),
                    content: $chunk,
                    metadata: [
                        'source_id' => $document->getId(),
                        'title'     => $document->getTitle(),
                        'chunk'     => $i,
                    ],
                    vector: $vector,
                ));
            }

            $io->progressAdvance();
        }

        $io->progressFinish();
        $io->success(sprintf('%d documents indexés avec succès.', count($documents)));

        return Command::SUCCESS;
    }

    /** @return string[] */
    private function chunk(string $text, int $chunkSize, int $overlap): array
    {
        $chunks = [];
        $offset = 0;
        $length = strlen($text);

        while ($offset < $length) {
            $chunks[] = substr($text, $offset, $chunkSize);
            $offset += $chunkSize - $overlap;  // avance avec chevauchement
        }

        return array_filter($chunks);
    }
}

<?php
// src/Service/RagService.php — partie retrieval

namespace App\Service;

use Symfony\AI\Platform\Bridge\Voyage\VoyageEmbeddingsProvider;
use Symfony\AI\Store\Retriever\SimilarityRetriever;

final class RagService
{
    public function __construct(
        private readonly VoyageEmbeddingsProvider $embeddings,
        private readonly SimilarityRetriever $retriever,
        // ... Agent injecté dans la section suivante
    ) {}

    /** @return string[] Les contenus des chunks les plus pertinents */
    public function findContext(string $question): array
    {
        // Même modèle qu'à l'indexation — indispensable pour que les espaces vectoriels coïncident
        $queryVector = $this->embeddings->embed($question, model: 'voyage-3');

        $documents = $this->retriever->retrieve(
            vector: $queryVector,
            maxResults: 5,     // top-5 chunks les plus proches
            minScore: 0.75,   // seuil de pertinence à calibrer sur ton corpus
        );

        return array_map(fn($doc) => $doc->content, $documents);
    }
}

<?php
// src/Service/RagService.php — pipeline RAG complet

namespace App\Service;

use Symfony\AI\AgentBundle\Agent\Agent;
use Symfony\AI\AgentBundle\Message\Message;
use Symfony\AI\AgentBundle\Message\MessageBag;
use Symfony\AI\Platform\Bridge\Voyage\VoyageEmbeddingsProvider;
use Symfony\AI\Store\Retriever\SimilarityRetriever;

final class RagService
{
    private const SYSTEM_PROMPT = <<<'PROMPT'
    Tu es un assistant expert. Tu réponds uniquement en te basant sur le contexte documentaire fourni.
    Si la réponse n'est pas dans le contexte, indique-le explicitement — ne fabrique jamais d'information.
    Réponds de façon concise et structurée, en français.
    PROMPT;

    public function __construct(
        private readonly Agent $agent,
        private readonly VoyageEmbeddingsProvider $embeddings,
        private readonly SimilarityRetriever $retriever,
    ) {}

    public function query(string $question): string
    {
        // 1. Embedding de la question avec le même modèle qu'à l'indexation
        $queryVector = $this->embeddings->embed($question, model: 'voyage-3');

        // 2. Top-5 chunks au-dessus du seuil de pertinence
        $documents = $this->retriever->retrieve(
            vector: $queryVector,
            maxResults: 5,
            minScore: 0.75,
        );

        // 3. Assemblage du contexte — séparateur explicite entre les extraits
        $context = implode("\n\n---\n\n", array_map(
            fn($doc) => $doc->content,
            $documents,
        ));

        // 4. Construction du MessageBag
        $messages = new MessageBag(
            Message::system(self::SYSTEM_PROMPT),
            Message::user("Contexte documentaire :\n\n" . $context),
            Message::user($question),
        );

        // 5. Appel Claude Sonnet 4 — temperature basse pour coller au contexte
        $response = $this->agent->call(
            messages: $messages,
            options: [
                'model'       => 'claude-sonnet-4-5',
                'max_tokens'  => 1024,
                'temperature' => 0.2,
            ],
        );

        return $response->getContent();
    }
}

<?php
// src/Service/RagService.php — ajout du prompt caching

// System prompt stable → marqué en cache en priorité
$messages = new MessageBag(
    Message::system(self::SYSTEM_PROMPT, cache: true),
    // Contexte documentaire semi-stable → mis en cache également
    Message::user("Contexte documentaire :\n\n" . $context, cache: true),
    // Question de l'utilisateur → toujours dynamique, jamais en cache
    Message::user($question),
);

// À partir de la 2e requête dans la fenêtre de 5 min,
// le system prompt + contexte sont facturés 10× moins cher
$response = $this->agent->call(
    messages: $messages,
    options: [
        'model'       => 'claude-sonnet-4-5',
        'max_tokens'  => 1024,
        'temperature' => 0.2,
    ],
);

return $response->getContent();