Dalam lanskap yang berkembang pesat pada tahun 2026, "AI-first" tidak lagi menjadi buzzword - itu adalah persyaratan arsitektur. bagi lembaga fintech, kemampuan untuk mengotomatisasi keputusan kredit sambil mempertahankan kepatuhan ketat adalah Grail suci Pada tahap ini, kita akan membangun produksi Kami tidak hanya akan memindahkan entitas dari Dua Kita akan menyuntikkan lapisan kognitif ke dalam mesin negara dengan menggunakan dan Sistem kami akan secara otomatis mencocokkan aplikasi pinjaman dan secara dinamis mengarahkan mereka: aplikasi dengan skor tinggi mendapatkan persetujuan instan, yang berisiko ditolak dan kasus borderline diarahkan ke pengusaha manusia. Bank Loan Approval Workflow “Draft” “Approved.” symfony/workflow symfony/ai-bundle Arsitektur yang Kami sedang membangun mesin negara berbasis skor. Alur kerja tradisional adalah linear atau user-driven. . agentic 
 
 
 
 
 Pengguna mengajukan permohonan pinjaman. Analisis AI: Agen AI yang didedikasikan menganalisis data mentah pemohon (pendapatan, utang, riwayat) terhadap petunjuk “Risiko Kebijakan”. Skor: AI mengembalikan skor terstruktur (0-100) dan ringkasan argumen. Routing Dinamis: Skor > 80:Auto-Approve.Score < 40:Auto-Reject.40–80: Beralih ke manual_review. Untuk Stack 
 
 
 
 
 PHP 8.4: Untuk menggunakan Property Hooks baru dan native HTML5 parsing jika diperlukan. Symfony 7.4 adalah LTS core. simfoni / aliran kerja: Mengelola siklus hidup negara. symfony/ai-bundle: Lapisan integrasi untuk LLM (OpenAI, Anthropic, atau model lokal). Proyek dan prasyarat Pertama, pastikan Anda memiliki Symfony CLI dan PHP 8.4 terinstal. kami akan membuat proyek skeleton baru dan menginstal ketergantungan kami. symfony new bank_approval --webapp --version=7.4
cd bank_approval
 Instalasi Dependensi Kami membutuhkan komponen alur kerja dan bundel AI. Perhatikan bahwa sejak pertengahan 2025, telah menjadi standar untuk integrasi AI. symfony/ai-bundle composer require symfony/workflow symfony/ai-bundle symfony/http-client
 Kami mengasumsikan Anda memiliki kunci API OpenAI atau serupa untuk konfigurasi platform AI. Konfigurasi **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
 Layer Domain Kita membutuhkan entitas yang memegang data dan status. kita akan menggunakan atribut PHP 8.4 untuk mapping. 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;
    }
}
 Layanan Scoring AI Ini adalah inti dari kita Kami akan membuat layanan yang memformat data entitas menjadi prompt, mengirimkannya ke Menggunakan jawaban 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;
    }
}
 Perangkat Workflow Automator Sekarang kita membutuhkan logika yang menghubungkan Scorer ke alur kerja. layanan ini memicu transisi berdasarkan skor. 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',
        };
    }
}
 Menghubungkannya dengan peristiwa Untuk membuat ini lancar, kami ingin otomatisasi untuk memicu segera setelah pengguna mengirimkan aplikasi. Ketika pinjaman memasuki status processing_score (melalui transisi kirim), kami memicu otomatisasi. Workflow Event Listener Dalam sebuah aplikasi dunia nyata skala tinggi, Anda akan mengirimkan pesan di sini untuk menangani panggilan AI secara asynchronous. untuk contoh ini, kita akan melakukannya secara sinkron untuk menjaga kode fokus pada 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()));
    }
}
 Pengendali Akhirnya, mari kita membangun kontroler untuk mensimulasikan pengiriman. 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.'
        ]);
    }
}
 Verifikasi 
 
 
 
 Konfigurasi Kunci API: Pastikan OPENAI_API_KEY diatur ke .env.local. Untuk memulai, simfony server:start. Mengirim permintaan: Gunakan curl atau 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%..."
}
 Kesimpulan Kami berhasil mengintegrasikan Model ini memanfaatkan yang terbaik dari kedua dunia: Generative AI 
 
 
 Symfony Workflow: Menyediakan keandalan, jalur audit dan manajemen negara yang ketat yang diperlukan untuk perbankan. Symfony AI: Menyediakan kemampuan pengambilan keputusan nuansa yang sebelumnya membutuhkan intervensi manusia. Anda dapat memperkenalkan agen baru untuk deteksi penipuan, analisis dokumen (menggunakan dalam ), atau pemeriksaan kepatuhan peraturan, semuanya disusun dalam sistem alur kerja yang transparan. OCR tools symfony/ai-bundle Anda dapat menemukan implementasi lengkap dan melacak kemajuan proyek di GitHub: [ ] Source Code: https://github.com/mattleads/AIBankApproval https://github.com/mattleads/AIBankApproval Let’s Connect! Jika Anda menemukan ini berguna atau memiliki pertanyaan tentang implementasi, saya ingin mendengar dari Anda. mari kita tetap berhubungan dan menjaga percakapan berjalan di seluruh platform ini: 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Anda dapat mengunduh: [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

Audio ini diproduksi dalam bahasa asli cerita!

Cara membangun alur kerja persetujuan pinjaman yang didorong oleh AI dengan Symfony 7.4 dan Symfony AI

About Author

KOMENTAR

HANG TAG

ARTIKEL INI DISAJIKAN PADA

Related Stories

THE CAVERNS OF VENUS

NIGHT (continued)

PROMISES FULFILLED.

The Crypto Trading Writing Contest: Submission Deadline Extended!

THE CAVERNS OF VENUS

NIGHT (continued)

PROMISES FULFILLED.

The Crypto Trading Writing Contest: Submission Deadline Extended!

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps