In die vinnig ontwikkelende landskap van 2026 is "AI-first" nie meer 'n buzzword nie - dit is 'n argitektuurse vereiste. In hierdie diep duik, sal ons 'n produksie-graad bou Ons sal nie net entiteite van Twee Ons sal 'n kognitiewe laag in die staatmasjien injecteer met behulp van en Ons stelsel sal outomatiese leningaanvragen score en dinamies roeteer: hoë-score-aanvragen kry onmiddellike goedkeuring, riskante word verwerp en borderline gevalle word na menslike onderhandelaars geruiteer. Bank Loan Approval Workflow “Draft” “Approved.” symfony/workflow symfony/ai-bundle Die architektuur Ons bou 'n Score-Driven State Machine. Tradisionele werkstrome is lineêre of gebruikersgesteunde. . agentic 
 
 
 
 
 Inskrywing: Die gebruiker stuur 'n lening aansoek. AI-analise: 'n toegewyde AI-agent analiseer die aanvrager se ruwe data (inkomste, skuld, geskiedenis) teen 'n "Risikobeleid" oproep. Scoring: Die AI gee 'n gestruktureerde score (0-100) en 'n resuming van die rede. Dynamic Routing:Score > 80:Auto-Approve.Score < 40:Auto-Reject.40–80: oorgang na manual_review. Die Stack 
 
 
 
 
 PHP 8.4: Vir die gebruik van die nuwe Property Hooks en native HTML5 parsing indien nodig. Symfony 7.4: die LTS kern. simfonie / werkstroom: Die beheer van die staat se lewenscyklus. symfony/ai-bundel: Die integrasie laag vir LLMs (OpenAI, Anthropic, of plaaslike modelle). Projek opstel en voorwaardes Eerstens, maak seker dat jy die Symfony CLI en PHP 8.4 geïnstalleer het. symfony new bank_approval --webapp --version=7.4
cd bank_approval
 Afhanklikheid installeer Ons benodig die werkstroomkomponent en die AI-pakket. Let daarop dat sedert die middel van 2025 Dit was die standaard vir integrasie. symfony/ai-bundle composer require symfony/workflow symfony/ai-bundle symfony/http-client
 Ons neem aan dat u 'n OpenAI API sleutel of soortgelyke vir die AI platformkonfigurasie het. Konfigurasie **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
 Die Domain Layer Ons benodig 'n entiteit wat die data en die toestand behou. 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;
    }
}
 Die AI Scoring Service Dit is die kern van ons Ons sal 'n diens skep wat die entiteit data in 'n prompt vorm, stuur dit na ons gekonfigureerde en die JSON reaksie parseer. “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;
    }
}
 Die Workflow Automator Nou benodig ons die logika wat die Scorer met die werkstroom verbind. Hierdie diens veroorsaak die oorgange gebaseer op die 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',
        };
    }
}
 Draai dit met gebeurtenisse Om dit naadloos te maak, wil ons hê dat die outomatisering onmiddellik begin nadat die gebruiker die aansoek ingedien het. Wanneer die lening in die verwerking_score-toestand kom (via die stuur oorgang), trigger ons die outomatisering. Workflow Event Listener In 'n hoë-skale werklike wêreld-app, sal jy 'n boodskap hier om die AI oproep asynchrone te hanteer. Vir hierdie voorbeeld sal ons dit sinchrone doen om die kode gefokus te hou op logika. 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()));
    }
}
 Die beheerder Ten slotte, laat ons 'n beheerder bou om die oordrag te simuleer. 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.'
        ]);
    }
}
 Verifikasie 
 
 
 
 Configure API Key: Maak seker OPENAI_API_KEY is ingestel in .env.local. Start Server: Symfony server: begin. Stuur 'n versoek: gebruik curl of 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%..."
}
 Konklusie Ons het suksesvol geïntegreer Hierdie patroon maak gebruik van die beste van beide wêreld: Generative AI 
 
 
 Symfony Workflow: Bied die betroubaarheid, audit tracks en streng staatsbestuur wat nodig is vir bankwese. Symfony AI: Bied die nuantiewe besluitnemingsvermoë wat voorheen menslike tussenkoms vereis het. Hierdie argitektuur skaal. U kan nuwe agente invoer vir bedrogdeteksie, dokumenteanalise (met behulp van in ), of regulatoriese ooreenstemmingskontrole, almal georkestreer binne dieselfde transparante werkstroomstelsel. OCR tools symfony/ai-bundle Jy kan die volledige implementering vind en die vooruitgang van die projek op GitHub volg: [ ] Source Code: https://github.com/mattleads/AIBankApproval https://github.com/mattleads/AIBankApproval Let’s Connect! As jy dit nuttig gevind het of vrae oor die implementering het, sal ek graag van jou hoor. 
 
 
 
 
 LinkedIn: [https://www.linkedin.com/in/matthew-mochalkin/] Die volgende is die volgende: [https://x.com/MattLeads] Telegram: [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

Hierdie oudio word in die oorspronklike taal van die storie vervaardig!

Hoe om 'n AI-gedrewe lening goedkeuring werkstroom te bou met Symfony 7.4 en Symfony AI

About Author

KOMMENTAAR

HANG TAGS

HIERDIE ARTIKEL IS AANGEBIED IN

Related Stories

$30M Raised in 30 Minutes and the Controversies to Follow: The Story Behind Dexter’s GM.ai Project

Thinking for the 21st century

The #bitcoin Writing Contest by Rootstock and HackerNoon: Final Round Results🎉

The #decentralize-ai Writing Contest by ICP and HackerNoon: Results Announcement 🎉

$30M Raised in 30 Minutes and the Controversies to Follow: The Story Behind Dexter’s GM.ai Project

Thinking for the 21st century

The #bitcoin Writing Contest by Rootstock and HackerNoon: Final Round Results🎉

The #decentralize-ai Writing Contest by ICP and HackerNoon: Results Announcement 🎉

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps