Dans le paysage en évolution rapide de 2026, « AI-first » n’est plus un mot-clé – c’est une exigence architecturale.Pour les institutions de fintech, la capacité d’automatiser les décisions de crédit tout en maintenant une stricte conformité est le Saint Graal Dans cette profonde plongée, nous allons construire un niveau de production Nous ne déplacerons pas seulement des entités de deux Nous injecterons une couche cognitive dans la machine d'état en utilisant et Notre système notera automatiquement les demandes de prêt et les traitera de manière dynamique : les demandes de prêt avec un score élevé obtiennent une approbation instantanée, les demandes risquées sont rejetées et les cas de limite sont dirigés vers des assureurs humains. Bank Loan Approval Workflow “Draft” “Approved.” symfony/workflow symfony/ai-bundle L’architecture Nous construisons une machine d’État basée sur le score. Les flux de travail traditionnels sont linéaires ou axés sur l'utilisateur. . agentic 
 
 
 
 
 Soumission : L’Utilisateur soumet une demande de prêt. Analyse d’IA: Un agent d’IA dédié analyse les données brutes du demandeur (venu, dette, historique) contre une prompt « Politique de risque ». Scoring : L’IA renvoie un score structuré (0 à 100) et un résumé de raisonnement. Routage dynamique:Score > 80:Auto-Approve.Score < 40:Auto-Reject.40–80: Transition vers manual_review. Le Stack 
 
 
 
 
 PHP 8.4 : Pour utiliser les nouveaux Property Hooks et le parsing HTML5 natif si nécessaire. Symfony 7.4 : le noyau LTS. Symphonie / flux de travail: Gérer le cycle de vie de l'état. symphony/ai-bundle: La couche d'intégration pour les LLM (OpenAI, Anthropic, ou modèles locaux). Définition du projet et conditions préalables Tout d'abord, assurez-vous que vous avez le Symfony CLI et PHP 8.4 installé. Nous allons créer un nouveau projet de squelette et installer nos dépendances. symfony new bank_approval --webapp --version=7.4
cd bank_approval
 Installation des dépendances Nous avons besoin de la composante du flux de travail et du bundle d’IA. Notez que depuis la mi-2025, C’est la norme pour l’intégration. symfony/ai-bundle composer require symfony/workflow symfony/ai-bundle symfony/http-client
 Nous supposons que vous avez une clé API OpenAI ou similaire pour la configuration de la plate-forme AI. Configuration **AI Configuration (config/packages/ai.yaml)
\ We will configure a “Risk Agent” specifically designed for financial analysis. We use gpt-4o (or the latest equivalent available in 2026) for its reasoning capabilities. ai:
    platform:
        openai:
            api_key: '%env(OPENAI_API_KEY)%'

    agent:
        risk_officer:
            model: 'gpt-4o'
            prompt:
                file: '%kernel.project_dir%/tools/prompt/riskManager.txt'
 **Workflow Configuration (config/packages/workflow.yaml)
\ We define a workflow named  . loan_approval framework:
    workflows:
        loan_approval:
            type: 'state_machine'
            audit_trail:
                enabled: true
            marking_store:
                type: 'method'
                property: 'status'
            supports:
                - App\Entity\LoanApplication
            initial_marking: draft
            
            places:
                - draft
                - processing_score
                - manual_review
                - approved
                - rejected

            transitions:
                submit:
                    from: draft
                    to: processing_score
                
                auto_approve:
                    from: processing_score
                    to: approved
                
                auto_reject:
                    from: processing_score
                    to: rejected
                
                refer_to_underwriter:
                    from: processing_score
                    to: manual_review
                
                underwriter_approve:
                    from: manual_review
                    to: approved
                
                underwriter_reject:
                    from: manual_review
                    to: rejected
 Le Domain Layer Nous avons besoin d'une entité qui détient les données et l'état. Nous utiliserons les attributs PHP 8.4 pour la cartographie. namespace App\Entity;

use App\Repository\LoanApplicationRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: LoanApplicationRepository::class)]
class LoanApplication
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $applicantName = null;

    #[ORM\Column]
    private ?int $annualIncome = null;

    #[ORM\Column]
    private ?int $requestedAmount = null;

    #[ORM\Column]
    private ?int $totalMonthlyDebt = null;

    // The Workflow Marking
    #[ORM\Column(length: 50)]
    private string $status = 'draft';

    // AI Scoring Results
    #[ORM\Column(type: Types::INTEGER, nullable: true)]
    private ?int $riskScore = null;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
    private ?string $aiReasoning = null;

    public function __construct(string $name, int $income, int $amount, int $monthlyDebt)
    {
        $this->applicantName = $name;
        $this->annualIncome = $income;
        $this->requestedAmount = $amount;
        $this->totalMonthlyDebt = $monthlyDebt;
    }

    // Getters and Setters...

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getApplicantName(): ?string
    {
        return $this->applicantName;
    }

    public function setApplicantName(string $applicantName): static
    {
        $this->applicantName = $applicantName;

        return $this;
    }

    public function getAnnualIncome(): ?int
    {
        return $this->annualIncome;
    }

    public function setAnnualIncome(int $annualIncome): static
    {
        $this->annualIncome = $annualIncome;

        return $this;
    }

    public function getRequestedAmount(): ?int
    {
        return $this->requestedAmount;
    }

    public function setRequestedAmount(int $requestedAmount): static
    {
        $this->requestedAmount = $requestedAmount;

        return $this;
    }

    public function getTotalMonthlyDebt(): ?int
    {
        return $this->totalMonthlyDebt;
    }

    public function setTotalMonthlyDebt(int $totalMonthlyDebt): static
    {
        $this->totalMonthlyDebt = $totalMonthlyDebt;

        return $this;
    }
    
    public function getStatus(): string
    {
        return $this->status;
    }

    public function setStatus(string $status): void
    {
        $this->status = $status;
    }

    public function setAiResult(int $score, string $reasoning): void
    {
        $this->riskScore = $score;
        $this->aiReasoning = $reasoning;
    }
    
    public function getRiskScore(): ?int
    {
        return $this->riskScore;
    }
    
    public function getAiReasoning(): ?string
    {
        return $this->aiReasoning;
    }

    // Calculated fields for the AI context
    public function getDtiRatio(): float
    {
        $monthlyIncome = $this->annualIncome / 12;
        if ($monthlyIncome === 0) return 100.0;
        return ($this->totalMonthlyDebt / $monthlyIncome) * 100;
    }
}
 Le service de scoring C’est le cœur de notre Nous créerons un service qui formatera les données de l'entité en un prompt, l'enverra à notre Définissez la réponse JSON. “Intelligent Workflow.” risk_officer agent namespace App\Service;

use App\Entity\LoanApplication;
use Symfony\AI\Agent\AgentInterface;
use Symfony\AI\Platform\Message\MessageBag;
use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\AI\Platform\Message\UserMessage;
use Symfony\AI\Platform\Message\Content\Text;

readonly class LoanScorer
{
    public function __construct(
        #[Target('risk_officer')]
        private AgentInterface $agent
    ) {}

    /**
     * @return array{score: int, reasoning: string}
     */
    public function scoreApplication(LoanApplication $loan): array
    {
        // 1. Construct the context for the AI
        $context = sprintf(
            "Applicant: %s
Annual Income: $%d
Requested Amount: $%d
Monthly Debt: $%d
Calculated DTI: %.2f%%",
            $loan->getApplicantName(),
            $loan->getAnnualIncome(),
            $loan->getRequestedAmount(),
            $loan->getTotalMonthlyDebt(),
            $loan->getDtiRatio()
        );

        // 2. Create the message
        $message = new UserMessage(new Text($context));

        // 3. Call the AI Agent
        // In Symfony 7.4/AI Bundle, we call the agent which handles the platform communication
        $response = $this->agent->call(
            new MessageBag($message)
        );

        // 4. Parse the output
        // Ideally, we would use Structured Outputs (JSON mode) supported by the bundle
        $content = $response->getContent();

        return $this->parseJson($content);
    }

    private function parseJson(string $content): array
    {
        // The AI might wrap the JSON in a markdown code block. Let's extract it.
        if (preg_match('/```json\s*(\{.*?\})\s*```/s', $content, $matches)) {
            $jsonContent = array_pop($matches);
        } else {
            // If no markdown block is found, assume the content is already a JSON string.
            $jsonContent = $content;
        }

        $data = json_decode($jsonContent, true);

        if (!isset($data['score']) || !is_int($data['score']) || !isset($data['reasoning']) || !is_string($data['reasoning'])) {
            throw new \RuntimeException('AI returned invalid or malformed JSON format: ' . $content);
        }

        return $data;
    }
}
 L’automatisation du workflow Maintenant, nous avons besoin de la logique qui connecte le Scorer au flux de travail. Ce service déclenche les transitions en fonction du score. namespace App\Service;

use App\Entity\LoanApplication;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Workflow\WorkflowInterface;
use Psr\Log\LoggerInterface;

readonly class LoanAutomationService
{
    public function __construct(
        private WorkflowInterface      $loanApprovalStateMachine,
        private LoanScorer             $scorer,
        private EntityManagerInterface $entityManager,
        private LoggerInterface        $logger
    ) {}

    public function processApplication(LoanApplication $loan): void
    {
        // 1. Verify we are in the correct state
        if ($loan->getStatus() !== 'processing_score') {
            return;
        }

        $this->logger->info("Starting AI scoring for Loan #{$loan->getId()}");

        // 2. Get the AI Score
        try {
            $result = $this->scorer->scoreApplication($loan);

            // Update entity with results
            $loan->setAiResult($result['score'], $result['reasoning']);
            $this->entityManager->flush();

            $score = $result['score'];
            $this->logger->info("AI Score generated: {$score}");

            // 3. Determine and Apply Transition
            $transition = $this->determineTransition($score);

            if ($this->loanApprovalStateMachine->can($loan, $transition)) {
                $this->loanApprovalStateMachine->apply($loan, $transition);
                $this->entityManager->flush();
                $this->logger->info("Applied transition: {$transition}");
            } else {
                $this->logger->error("Transition {$transition} blocked for Loan #{$loan->getId()}");
            }

        } catch (\Exception $e) {
            $this->logger->error("AI Scoring failed: " . $e->getMessage());
            // Fallback: Default to manual review on error
            if ($this->loanApprovalStateMachine->can($loan, 'refer_to_underwriter')) {
                $this->loanApprovalStateMachine->apply($loan, 'refer_to_underwriter');
                $this->entityManager->flush();
            }
        }
    }

    private function determineTransition(int $score): string
    {
        return match (true) {
            $score >= 80 => 'auto_approve',
            $score < 40  => 'auto_reject',
            default      => 'refer_to_underwriter',
        };
    }
}
 Lier avec des événements Pour ce faire, nous voulons que l'automatisation se déclenche immédiatement après que l'utilisateur ait soumis l'application. Lorsque le prêt entre dans l'état processing_score (via la transition soumettre), nous déclenchons l'automatisation. Workflow Event Listener Dans une application du monde réel à grande échelle, vous enverriez un message ici pour traiter l'appel AI de manière asynchrone. Pour cet exemple, nous allons le faire de manière synchrone pour garder le code axé sur la logique. Symfony Messenger namespace App\EventListener\Workflow;

use App\Entity\LoanApplication;
use App\Message\ScoreLoanApplication;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Workflow\Event\Event;

readonly class LoanScoringListener
{
    public function __construct(
        private MessageBusInterface $bus
    ) {}

    /**
     * Listen to the 'entered' event for the 'processing_score' place.
     * Event name format: workflow.[workflow_name].entered.[place_name]
     */
    #[AsEventListener('workflow.loan_approval.entered.processing_score')]
    public function onProcessingScore(Event $event): void
    {
        $subject = $event->getSubject();

        if (!$subject instanceof LoanApplication) {
            return;
        }

        // Trigger the AI Automation asynchronously
        $this->bus->dispatch(new ScoreLoanApplication($subject->getId()));
    }
}
 Le contrôleur Enfin, construisons un contrôleur pour simuler la soumission. namespace App\Controller;

use App\DTO\LoanApplicationInput;
use App\Entity\LoanApplication;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpKernel\Attribute\MapRequestPayload;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Workflow\WorkflowInterface;

#[Route('/api/loan')]
class LoanController extends AbstractController
{
    #[Route('/submit', methods: ['POST'])]
    public function submit(
        #[MapRequestPayload] LoanApplicationInput $data,
        WorkflowInterface $loanApprovalStateMachine,
        EntityManagerInterface $em
    ): JsonResponse
    {
        // 1. Create Entity from validated DTO
        $loan = new LoanApplication(
            $data->name,
            $data->income,
            $data->amount,
            $data->debt
        );

        $em->persist($loan);
        $em->flush(); // Save as draft first

        // 2. Apply 'submit' transition
        // This moves state to 'processing_score'
        // Which triggers our Listener -> which dispatches a message
        if ($loanApprovalStateMachine->can($loan, 'submit')) {
            $loanApprovalStateMachine->apply($loan, 'submit');
            $em->flush();
        }

        return $this->json([
            'id' => $loan->getId(),
            'status' => $loan->getStatus(),
            'message' => 'Loan application submitted and is being processed.'
        ]);
    }
}
 vérification 
 
 
 
 Configurez la clé API : Assurez-vous que OPENAI_API_KEY est défini dans .env.local. Démarrer le serveur : symfony server :start. Envoyer une demande: Utilisez curl ou Postman. Request (High Risk): curl -X POST https://127.0.0.1:8000/api/loan/submit \
  -H "Content-Type: application/json" \
  -d '{"name": "Risk Taker", "income": 30000, "amount": 50000, "debt": 2000}'
 Expected Response: {
  "id": 1,
  "status": "rejected",
  "risk_score": 15,
  "ai_reasoning": "The applicant has a Debt-to-Income ratio exceeding 80%..."
}
 Request (Low Risk): curl -X POST https://127.0.0.1:8000/api/loan/submit \
  -H "Content-Type: application/json" \
  -d '{"name": "Safe Saver", "income": 120000, "amount": 10000, "debt": 500}'
 Expected Response: {
  "id": 2,
  "status": "approved",
  "risk_score": 92,
  "ai_reasoning": "The applicant demonstrates excellent financial health with a DTI below 10%..."
}
 Conclusion Nous avons intégré avec succès Dans un processus déterministe d’affaires, ce modèle exploite le meilleur des deux mondes : Generative AI 
 
 
 Symphony Workflow: Fournit la fiabilité, les pistes d'audit et la gestion stricte de l'état requise pour la banque. Symphony AI: fournit la capacité de prise de décision nuancée qui nécessitait auparavant une intervention humaine. Vous pouvez introduire de nouveaux agents pour la détection de la fraude, l'analyse de documents (en utilisant dans ), ou des contrôles de conformité réglementaires, tous orchestrés dans le même système de flux de travail transparent. OCR tools symfony/ai-bundle Vous pouvez trouver la mise en œuvre complète et suivre le progrès du projet sur GitHub: [ ] Source Code: https://github.com/mattleads/AIBankApproval https://github.com/mattleads/AIBankApproval Let’s Connect! Si vous avez trouvé cela utile ou si vous avez des questions sur la mise en œuvre, j'aimerais entendre parler de vous. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Résumé du site : [https://x.com/MattLeads] Télégramme : [https://t.me/MattLeads] GitHub : [https://github.com/mattleads] https://www.linkedin.com/in/matthew-mochalkin/ https://x.com/MattLeads https://t.me/MattLeads https://github.com/mattleads

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Cet audio est produit dans la langue originale de l'histoire !

Comment créer un flux de travail d'approbation de prêts basé sur l'IA avec Symfony 7.4 et Symfony AI

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

Nomades numériques, écoutez : ce que vous devez savoir sur le nouveau visa DTV de la Thaïlande

Le guide complet pour réussir une migration vers le cloud : stratégies et bonnes pratiques

Boostez votre productivité avec ces 18 outils de développement 🚀🔥

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

Nomades numériques, écoutez : ce que vous devez savoir sur le nouveau visa DTV de la Thaïlande

Le guide complet pour réussir une migration vers le cloud : stratégies et bonnes pratiques

Boostez votre productivité avec ces 18 outils de développement 🚀🔥

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps