De chatbot à agent autonome : construire des apps PHP qui agissent vraiment

Vous avez intégré un LLM à votre application web. Il répond aux questions, résume des documents, génère du texte. Bien. Mais vos utilisateurs, eux, voudraient que l'outil fasse des choses : consulter une base de données, appeler une API tierce, enchaîner plusieurs actions sans intervention humaine. C'est exactement là que la notion d'agent autonome entre en jeu — et c'est ce que cet article explore, dans le contexte PHP/Symfony et Laravel.

Source originale : Building Agentic Laravel Apps with Prism PHP par Dewald Hugo.

Un chatbot, ça répond. Un agent, ça agit.

La différence est fondamentale. Un chatbot classique fonctionne en mode requête/réponse : vous envoyez un message, le modèle génère du texte, c'est terminé. Un agent, lui, dispose d'un boucle de raisonnement : il peut appeler des outils, analyser les résultats, décider de l'étape suivante, et recommencer — jusqu'à accomplir une tâche complexe.

Concrètement pour une PME, cela ouvre des cas d'usage réels :

• Un assistant qui consulte votre CRM, rédige un email personnalisé et l'envoie sans que vous touchiez quoi que ce soit.
• Un outil de support qui recherche dans votre documentation, trouve la procédure adaptée, et guide l'utilisateur étape par étape.
• Un agent d'analyse qui interroge votre base de données, croise les résultats, et produit un rapport structuré.

Ces scénarios nécessitent une architecture différente du simple appel API à OpenAI.

Laravel/AI vs Prism PHP : choisir le bon outil

Laravel 13 embarque désormais un SDK first-party (laravel/ai) qui couvre les besoins courants : génération de texte, embeddings, completions basiques via OpenAI, Gemini et Anthropic. Pour la majorité des intégrations simples, c'est le point de départ recommandé.

Prism PHP est la couche complémentaire que vous atteignez quand vos besoins dépassent ce socle :

Ces deux librairies ne sont pas en concurrence — elles sont complémentaires. laravel/ai pour les workflows simples, Prism PHP dès que vous entrez dans la logique agentique.

Note pour les équipes Symfony : bien que les exemples ci-dessous soient en contexte Laravel, les concepts (tool calling, boucle agentique, RAG avec pgvector) sont transposables. Chez MulerTech, nous intégrons ces patterns dans des architectures Symfony avec des adaptateurs dédiés.

Construire la boucle agentique avec Prism PHP

Le cœur d'un agent réside dans sa capacité à appeler des tools (outils) et à itérer. Avec Prism PHP, cela se traduit par une configuration explicite de la boucle :

use EchoLabs\Prism\Prism;
use EchoLabs\Prism\Enums\Provider;

$response = Prism::text()
    ->using(Provider::Anthropic, 'claude-sonnet-4-5')
    ->withPrompt('Trouve les 3 dernières commandes du client #42 et résume-les.')
    ->withTools([
        new FetchOrdersTool(),
        new SummarizeTextTool(),
    ])
    ->withMaxSteps(5) // Limite la boucle à 5 itérations
    ->generate();

Le paramètre withMaxSteps est crucial : il évite qu'un agent parte en boucle infinie si la logique de décision du modèle déraille. C'est votre filet de sécurité en production.

Chaque tool est une classe PHP qui expose une description lisible par le LLM et une méthode d'exécution :

class FetchOrdersTool extends Tool
{
    public function name(): string
    {
        return 'fetch_orders';
    }

    public function description(): string
    {
        return 'Récupère les commandes récentes d\'un client depuis la base de données.';
    }

    public function parameters(): array
    {
        return [
            'client_id' => ['type' => 'integer', 'description' => 'Identifiant du client'],
            'limit'     => ['type' => 'integer', 'description' => 'Nombre de commandes à retourner'],
        ];
    }

    public function execute(int $client_id, int $limit = 3): string
    {
        $orders = Order::where('client_id', $client_id)
            ->latest()
            ->limit($limit)
            ->get();

        return $orders->toJson();
    }
}

Le LLM décide lui-même quand appeler cet outil, avec quels paramètres, et comment utiliser le résultat pour progresser vers l'objectif. C'est ça, l'autonomie agentique.

RAG avec pgvector : donner de la mémoire à votre agent

Un agent qui ne connaît que ses données d'entraînement est limité. Pour lui donner accès à votre connaissance métier (documentation interne, historique client, base de connaissances), la technique RAG (Retrieval-Augmented Generation) est incontournable.

L'architecture repose sur pgvector, l'extension PostgreSQL qui stocke et interroge des vecteurs sémantiques :

1. Vos documents sont découpés en chunks et transformés en embeddings via Prism PHP.
2. Ces vecteurs sont stockés dans PostgreSQL avec pgvector.
3. À chaque requête utilisateur, les chunks les plus pertinents sont récupérés par similarité cosinus.
4. Ces chunks sont injectés dans le contexte du LLM avant génération.

// Recherche sémantique des documents pertinents
$queryEmbedding = Prism::embeddings()
    ->using(Provider::OpenAI, 'text-embedding-3-small')
    ->fromInput($userQuery)
    ->generate();

$relevantChunks = DocumentChunk::query()
    ->orderByRaw('embedding <-> ?', [$queryEmbedding->embeddings[0]->embedding])
    ->limit(5)
    ->get();

// Injection dans le contexte
$context = $relevantChunks->pluck('content')->implode("\n\n");

$response = Prism::text()
    ->using(Provider::Anthropic, 'claude-sonnet-4-5')
    ->withSystemPrompt("Contexte documentaire :\n{$context}")
    ->withPrompt($userQuery)
    ->generate();

Cette approche permet de construire des agents qui répondent avec précision sur votre domaine, sans fine-tuning coûteux.

Ce que cela change concrètement pour votre PME

Passer du chatbot à l'agent autonome n'est pas qu'une évolution technique — c'est un changement de paradigme dans la valeur que vous offrez à vos utilisateurs.

Un chatbot fait gagner du temps en répondant vite. Un agent fait gagner du temps en agissant. La différence se mesure en heures de travail évitées, en processus automatisés, en erreurs humaines supprimées.

Les briques existent aujourd'hui en PHP : Prism PHP pour l'orchestration agentique, pgvector pour la mémoire sémantique, Laravel ou Symfony pour l'infrastructure applicative. La question n'est plus de savoir si c'est faisable — c'est de définir quel processus métier mérite d'être automatisé en premier.

Chez MulerTech, nous accompagnons les équipes PHP dans la conception et l'intégration de ces architectures. Si vous souhaitez évaluer la faisabilité d'un agent autonome sur votre stack existante, contactez-nous.