Création d’un Projet Symfony avec IA : Utilisation de DTO, Flow et RapidAPI

le 19 janvier 2025

Le développement d’applications modernes s’appuie de plus en plus sur l’intelligence artificielle pour optimiser les processus de création. Cet article explique comment créer une application Symfony pour scraper des pages web, obtenir un résumé et des tags pertinents, en s’appuyant sur des technologies telles que Flow, OpenAI, et RapidAPI. Ce projet a été conçu à l’aide de prompts personnalisés sur Cursor, tels que : "Mets en place une API avec Flow et OpenAI".

L'idée principale derrière ce projet est de démontrer comment mettre en place rapidement un SaaS (Software as a Service) performant. Dans cet exemple, nous avons créé un service qui permet de scraper n'importe quelle URL et d'en extraire automatiquement les informations pertinentes grâce à l'intelligence artificielle.

Cette approche présente plusieurs avantages :

• Rapidité de mise en place : En utilisant des outils modernes comme Symfony, ApiPlatform, Flow et l'API OpenAI, nous pouvons développer rapidement un service fonctionnel
• Scalabilité : L'architecture choisie permet de gérer facilement une montée en charge
• Valeur ajoutée : L'utilisation de l'IA pour l'analyse du contenu apporte une réelle plus-value au service

Le service peut être utilisé dans de nombreux contextes : veille concurrentielle, agrégation de contenu, analyse de tendances, etc.

Initialisation du Projet Symfony

Commencez par créer un projet Symfony :

composer create-project symfony/skeleton my_project
cd my_project
composer require webapp

Ajoutez les dépendances de base :

composer require doctrine annotations
composer require api
composer require maker http-client symfony/serializer
composer require openai-php/client

Vérifiez que le serveur fonctionne :

symfony serve

Votre projet de base est prêt !

Implémentation du Contrôleur pour le Scraping et l’Analyse

Voici un contrôleur basé sur le code source de l’application :

<?php

namespace App\Controller;

use App\Dto\UrlDto;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Serializer\SerializerInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;
use OpenAI;
use Flow\Flow\Flow;
use Flow\FlowFactory;
use Flow\Ip;

class UrlController extends AbstractController
{
    public function __construct(
        private HttpClientInterface $httpClient,
        private string $openaiApiKey
    ) {}

    public function __invoke(Request $request, SerializerInterface $serializer): JsonResponse
    {
        try {
            // Decode JSON request body
            $data = json_decode($request->getContent(), true);

            // Deserialize into UrlDto
            $urlDto = $serializer->denormalize($data, UrlDto::class);

            // Integrate Flow
            $flow = (new FlowFactory())->create(function() use (&$data) {
                yield function ($url) use (&$data) {
                    // Fetch URL content
                    $response = $this->httpClient->request('GET', $url);
                    $content = $response->getContent();

                    // Initialize OpenAI client
                    $client = OpenAI::client($this->openaiApiKey);

                    // Get summary and tags from ChatGPT
                    $result = $client->chat()->create([
                        'model' => 'gpt-4o-mini',
                        'messages' => [
                            ['role' => 'system', 'content' => 'First provide a concise summary of the webpage content. Then on a new line after "TAGS:", list up to 10 relevant single-word or short-phrase tags, separated by commas.'],
                            ['role' => 'user', 'content' => $content],
                        ],
                        'max_tokens' => 400
                    ]);

                    // Split the response into summary and tags
                    $data = $result->choices[0]->message->content;
                };
            });

            $ip = new Ip($urlDto->url);
            $flow($ip);
            $flow->await();

            $parts = explode('TAGS:', $data);
            $summary = trim($parts[0]);
            $tags = isset($parts[1]) ? array_map('trim', explode(',', trim($parts[1]))) : [];

            return new JsonResponse([
                'url' => $urlDto->url,
                'summary' => $summary,
                'tags' => $tags,
            ]);

        } catch (\Exception $e) {
            return new JsonResponse([
                'error' => $e->getMessage()
            ], 500);
        }
    }
}

Intégration de Flow pour Orchestrer les Données

Flow est utilisé pour orchestrer les étapes du pipeline de scraping et d’analyse. Dans le code ci-dessus :

• Récupération du contenu : Le contenu de l’URL est récupéré via HttpClientInterface.
• Analyse via OpenAI : Le contenu est envoyé à OpenAI pour générer un résumé et des tags.
• Traitement des résultats : Les réponses sont traitées et renvoyées sous forme de JSON.

Mise en Place du SaaS avec RapidAPI

Pour transformer ce projet en SaaS accessible via RapidAPI :

• Créez un Compte RapidAPI : Inscrivez-vous sur RapidAPI.

• Publiez vos Endpoints :

  • Créez des endpoints RESTful comme présenté ci-dessus.
  • Configurez les routes et les paramètres requis sur RapidAPI.

• Testez et Partagez : Testez votre API directement sur la plateforme et partagez-la avec vos utilisateurs.

Conlusion

Ce projet montre comment utiliser Symfony, ApiPlatform, Flow et OpenAI pour créer une API performante capable de scraper des pages web et d’analyser leur contenu. En publiant cette API sur RapidAPI, vous pouvez transformer cette solution en un SaaS accessible à tous.

Essayez d’intégrer ces concepts dans vos propres projets et adaptez-les en fonction des besoins de vos utilisateurs. Pour des détails supplémentaires, référez-vous à la source sur UrlScrapingApi.

• Poster un commentaire