Logomark

LARAVEL

Un framework qui rend heureux
Voir cette catégorie
Vers le bas
À la découverte du Laravel AI SDK
Mardi 1 septembre 2026 16:06

Avec la sortie de Laravel 13, l’écosystème fait un bond en avant majeur dans le domaine de l’ingénierie d’agents et de l'intégration de l'intelligence artificielle. Finis les packages tiers hétérogènes ou les appels HTTP manuels avec Http::post() pour interagir avec OpenAI ou Anthropic : le Laravel AI SDK (laravel/ai) est officiellement lancé.

Ce SDK apporte une couche d’abstraction unifiée, expressive et parfaitement intégrée au framework pour gérer les grands modèles de langage (LLM), le streaming, le Function Calling (via les Tools), les embeddings, la génération d’images, le TTS/STT, etc.

Avant Laravel AI, intégrer l’IA dans une application Laravel signifiait :

  • gérer manuellement les appels API vers OpenAI, Anthropic, etc. (avec leurs différences de format de réponse)
  • écrire du code boilerplate pour le streaming, la gestion des erreurs ou le parsing des réponses JSON
  • réinventer la roue pour la mémoire des conversations ou l’orchestration d’outils

Résultat : du temps perdu, des bugs et une maintenance complexe. Avec Laravel/AI, tout cela disparaît.

Découvrons ensemble comment ce package transforme la manière de concevoir des fonctionnalités IA dans nos applications Laravel.

Installation et configuration

L'installation se fait en toute simplicité via Composer :

composer require laravel/ai

Ensuite, publiez les fichiers de configuration et les migrations :

php artisan vendor:publish --provider="Laravel\Ai\AiServiceProvider"
php artisan migrate

Note : les migrations créent les tables agent_conversations et agent_conversation_messages, qui sont indispensables si vous souhaitez déléguer à Laravel la gestion automatique de la mémoire contextuelle des conversations.

Configuration multi-fournisseurs

Dans votre fichier .env, il vous suffit d'indiquer les clés API des services que vous souhaitez utiliser :

OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=...
DEEPSEEK_API_KEY=...
OLLAMA_API_KEY=...

Le SDK prend en charge nativement une immense variété de providers (OpenAI, Anthropic, Gemini, Mistral, Groq, DeepSeek, xAI, Ollama, Bedrock, Azure, etc.).

Support des API compatibles OpenAI (Local LLM / LiteLLM)

Si vous faites tourner des modèles locaux (via Ollama, LM Studio, vLLM) ou des passerelles d'entreprise, vous pouvez déclarer un driver openai-compatible dans config/ai.php :

'providers' => [
    'local' => [
        'driver' => 'openai-compatible',
        'url' => env('LOCAL_AI_URL', 'http://localhost:11434/v1'),
        'key' => env('LOCAL_AI_API_KEY'),
        'models' => [
            'text' => ['default' => 'gemma3:4b'],
            'embeddings' => ['default' => 'nomic-embed-text', 'dimensions' => 768],
        ],
    ],
],

Le concept clé : les Agents

Dans le Laravel AI SDK, l'unité de base est l'Agent. Un agent est une classe PHP dédiée qui encapsule les instructions système, le contexte de conversation, les outils (Tools) disponibles et le schéma de sortie attendu.

Pour créer un agent, Laravel met à disposition une commande Artisan :

php artisan make:agent SalesCoach --structured

Voici à quoi ressemble une classe Agent complète :

namespace App\Ai\Agents;

use App\Ai\Tools\RetrievePreviousTranscripts;
use App\Models\User;
use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\Conversational;
use Laravel\Ai\Contracts\HasStructuredOutput;
use Laravel\Ai\Contracts\HasTools;
use Laravel\Ai\Concerns\RemembersConversations;
use Laravel\Ai\Promptable;

class SalesCoach implements Agent, Conversational, HasTools, HasStructuredOutput
{
    use Promptable, RemembersConversations;

    public function __construct(public User $user) {}

    /**
     * Consignes système pour l'agent.
     */
    public function instructions(): string
    {
        return 'Vous êtes un coach commercial. Analysez les échanges et fournissez un retour constructif ainsi qu'une note globale.';
    }

    /**
     * Outils mis à disposition de l'agent.
     */
    public function tools(): iterable
    {
        return [
            new RetrievePreviousTranscripts($this->user),
        ];
    }

    /**
     * Structure de la réponse JSON attendue (Structured Output).
     */
    public function schema(JsonSchema $schema): array
    {
        return [
            'feedback' => $schema->string()->required(),
            'score'    => $schema->integer()->min(1)->max(10)->required(),
        ];
    }
}

Chaque interface apporte une capacité spécifique :

  • Conversational : gère l’historique des messages
  • HasTools : permet à l’agent d’utiliser des outils externes
  • HasStructuredOutput : force la réponse à suivre un schéma JSON strict (ici, {feedback: string, score: int}).

Solliciter un Agent (Prompting)

L'exécution d'un agent se fait de manière très fluide :

use App\Ai\Agents\SalesCoach;
use Laravel\Ai\Enums\Lab;

// Instanciation via le container (avec injection de dépendances)
$agent = SalesCoach::make(user: $user);

// Envoi du prompt
$response = $agent->prompt(
    'Analyse ce dernier appel client : ...',
    provider: Lab::Anthropic, // ou 'anthropic'
    model: 'claude-3-5-sonnet-20241022'
);

// Récupération des données structurées
$feedback = $response['feedback'];
$score    = $response['score'];

Accès aux réponses HTTP brutes

Pour déboguer ou vérifier le statut du Rate Limiting de l'API sous-jacente, le SDK expose l'objet HTTP raw :

$remaining = $response->raw->header('X-RateLimit-Remaining-Requests');

Outils (Tools) & approbation humaine

Les Tools permettent aux agents d'exécuter des actions ou d'aller chercher du contexte métier dans votre application (ex: requêter la base de données, appeler une API externe).

Exemple d'outil :

class GetUserOrders implements Tool
{
    public function description(): string
    {
        return 'Récupère les 5 dernières commandes de l\'utilisateur.';
    }

    public function handle(array $arguments): array
    {
        return User::find($arguments['user_id'])
            ->orders()
            ->latest()
            ->take(5)
            ->get()
            ->toArray();
    }
}

Human Tool Approval

L'une des fonctionnalités les plus puissantes du SDK est le Human Tool Approval (validation humaine préalable). Si un agent souhaite exécuter un outil sensible (comme effectuer un virement ou supprimer un compte), vous pouvez intercepter l'exécution et demander une confirmation utilisateur avant de laisser l'agent poursuivre sa boucle d'actions.

Fonctionnalités multimodales & Embeddings

Le SDK ne se limite pas aux textes et agents conversationnels :

Embeddings & Vector Stores

Générez facilement des embeddings pour vos recherches vectorielles (RAG) :

use Laravel\Ai\Facades\Embeddings;

// Générer un embedding pour un texte
$vector = Embeddings::generate('Documentation Laravel AI');

// Stocker dans une base vectorielle (ex: Pinecone, Weaviate)
VectorStore::store($vector, ['metadata' => ['source' => 'docs']]);

// Recherche sémantique
$results = VectorStore::search('Comment créer un agent ?', limit: 3);

Le SDK inclut également des abstractions pour le Reranking (Cohere, Jina), la gestion des fichiers (File Storage pour les LLMs) et la mémoire vectorielle.

Image, Speech-to-Text & Text-to-Speech

Génération d'images

use Laravel\Ai\Facades\Image;

$image = Image::generate('Un renard lisant de la philosophie dans une bibliothèque');

Transcription (STT)

use Laravel\Ai\Facades\Transcription;

$text = Transcription::generate(storage_path('audio/meeting.mp3'));

Synthèse Vocale (TTS)

use Laravel\Ai\Facades\Audio;

$audioContent = Audio::generate('Bonjour et bienvenue sur notre application.');

Testing & mocks : la touche Laravel

Fidèle aux standards de Laravel, le SDK offre un support irréprochable pour le testing sans consommer vos crédits d'API :

use Laravel\Ai\Facades\Agent;

Agent::fake([
    SalesCoach::class => Agent::response([
        'feedback' => 'Très bonne écoute active.',
        'score' => 9,
    ]),
]);

// Votre test de contrôleur ou de job
$this->post('/analyze-call')->assertOk();

Agent::assertPrompted(SalesCoach::class);

On peut valider des outils :

Agent::fake([
    SalesCoach::class => Agent::response(['feedback' => 'OK', 'score' => 8])
        ->withToolCalls([RetrievePreviousTranscripts::class]),
]);

// Vérifier que l'outil a été appelé
Agent::assertToolCalled(RetrievePreviousTranscripts::class);

Ou du streaming :

$response = $agent->prompt('...', stream: true);
// Vérifier les chunks reçus

En résumé

Le Laravel AI SDK apporte la rigueur, l'élégance et la simplicité habituelles du framework au domaine des agents IA. Il élimine la nécessité d'écrire du code boilerplate pour gérer le découpage des prompts, l'historique des conversations, le parsing des réponses JSON ou l'intégration des API locales.

Que vous souhaitiez créer un chatbot simple avec Ollama en local ou orchestrer des agents complexes multi-outils avec Claude et GPT-4o, le SDK AI fournit toutes les fonctionnalités nécessaires.

Avec l’évolution rapide des LLM (par exemple GPT-5 ou Claude 4), le SDK Laravel AI est conçu pour s’adapter : les drivers sont modulaires et les mises à jour seront transparentes.

Et demain ? On peut imaginer des agents Laravel qui :

  • automatisent des workflows métiers (ex. : validation de commandes)
  • intègrent des modèles locaux (Ollama) pour des solutions 100 % on-premise
  • utilisent le Function Calling pour interagir avec des API externes (Stripe, Slack, etc.).

À vos terminaux : composer require laravel/ai !


Par bestmomo

Aucun commentaire