באזור המתפתח במהירות של 2026, "AI-first" הוא כבר לא מילה קדומה - זה דרישה אדריכלית עבור מוסדות פינטק, היכולת לאוטומטית החלטות אשראי תוך שמירה על תאימות קפדנית היא הגראל הקדוש בתהליך זה נוכל לבנות מגוון רחב של מוצרים אנחנו לא רק עוזבים את הארגונים 2 אנו נזרק שכבה קוגניטיבית למכונת המדינה באמצעות ו המערכת שלנו תדרג באופן אוטומטי את בקשות ההלוואה ומעבירה אותן באופן דינמי: בקשות עם ציון גבוה מקבלות אישור מיידי, אלה מסוכנים נדחו ומקרים בגבול מועברים לסוכנים אנושיים. Bank Loan Approval Workflow “Draft” “Approved.” symfony/workflow symfony/ai-bundle האדריכלות אנחנו בונים מכונת מדינה מבוססת תוצאות. תנועות עבודה מסורתיות הן ליניאריות או ממוקדות על-ידי המשתמש. . agentic 
 
 
 
 
 הצגת: המשתמש שולח בקשה להלוואה. ניתוח אינטליגנציה אינטליגנטית: סוכן אינטליגנציה אינטליגנטית מיועד לנתח את הנתונים הבולטים של המועמד (הכנסה, החוב, ההיסטוריה) נגד דרישה "מדיניות סיכון". ציון: ה- AI מחזיר ציון מובנה (0-100) וסיכום סיכום. הדרכה דינמית: ציון > 80: אישור אוטומטי. ציון < 40: אישור אוטומטי.40–80: מעבר ל- manual_review. ה Stack 
 
 
 
 
 PHP 8.4: לשימוש ב- Property Hooks החדשים ו-Native HTML5 Parsing אם יש צורך. סימפוניה 7.4: הליבה של LTS. סימפוניה / זרימת עבודה: ניהול מחזור החיים של המדינה. symfony/ai-bundle: שכבת האינטגרציה עבור LLMs (OpenAI, אנתרופי, או מודלים מקומיים). תכנון פרויקטים ותנאים מוקדמים ראשית, ודא שיש לך את Symfony CLI ו- PHP 8.4 מותקן. symfony new bank_approval --webapp --version=7.4
cd bank_approval
 התקנת תלויות אנחנו צריכים את רכיב זרימת העבודה ואת חבילת AI. שימו לב כי מאז אמצע 2025, זה היה הסטנדרט של אינטגרציה. symfony/ai-bundle composer require symfony/workflow symfony/ai-bundle symfony/http-client
 אנו מניחים שיש לך מפתח OpenAI API או דומה עבור הגדרת פלטפורמת 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
 תגית: Domain Layer אנחנו צריכים ישות שמחזיקה את הנתונים ואת המצב.אנו נשתמש תכונות PHP 8.4 עבור מפות. 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;
    }
}
 שירות AI Scoring זהו הבסיס של שלנו אנו יוצרים שירות שמפורמט את הנתונים של הישות לתוך דחיפה, שולח אותו למסגרת שלנו. הגדרת תשובת 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;
    }
}
 Workflow Automator אוטומטיזציה כעת אנו זקוקים לוגיקה שמחברת את Scorer ל- Workflow.This service triggers the transitions based on the 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',
        };
    }
}
 להדביק אותו באירועים כדי להפוך את זה מושלם, אנחנו רוצים את האוטומציה להפעיל מיד לאחר המשתמש שולח את היישום. כאשר ההלוואה נכנסת למצב processing_score (באמצעות המעבר לשלוח), אנו מפעילים את האוטומציה. Workflow Event Listener באפליקציה בעולם האמיתי בקנה מידה גבוה, היית שולח הודעה כאן כדי להתמודד עם שיחת ה- AI באופן אסינכרוני.לדוגמה זו, נעשה את זה באופן סינכרוני כדי לשמור על הקוד ממוקד על ההיגיון. 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()));
    }
}
 המפקח לבסוף, בואו נבנה מנהל כדי לסמול את ההגשה. 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.'
        ]);
    }
}
 בדיקת 
 
 
 
 הגדרת מפתח ה-API: ודא כי OPENAI_API_KEY מוגדר ב- .env.local. שרת ההתחלה: Symfony Server:start שלח בקשה: השתמש curl או 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%..."
}
 מסקנה אינטגרציה מוצלחת דפוס זה מנצל את הטוב ביותר משני העולמות: Generative AI 
 
 
 זרימת העבודה של סימפוניה: מספקת את האמינות, מסלולי האקדמיה והניהול הקפדני של המדינה הדרושים לבנקאות. סימפוניה AI: מספקת את יכולת קבלת ההחלטות המתוחכמת שהייתה דורשת מעורבות אנושית בעבר. באפשרותך להציג סוכנים חדשים לזיהוי הונאה, ניתוח מסמכים (באמצעות ב ), או בדיקות תאימות רגולטוריות, הכל מתארגן בתוך אותה מערכת זרימת עבודה גלויה. OCR tools symfony/ai-bundle אתה יכול למצוא את היישום המלא ולעקוב אחר התקדמות הפרויקט על GitHub: [ ] Source Code: https://github.com/mattleads/AIBankApproval https://github.com/mattleads/AIBankApproval Let’s Connect! אם מצאתם את זה שימושי או שיש לכם שאלות בנוגע ליישום, אשמח לשמוע מכם. 
 
 
 
 
 LinkedIn: [https://www.linkedin.com/in/matthew-mochalkin/] אתר האינטרנט: [https://x.com/MattLeads] טלגרם: [https://t.me/MattLeads] גטהוב: [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

האודיו הזה מופק בשפת המקור של הסיפור!

כיצד לבנות זרימת עבודה של אישור הלוואות מבוססת AI עם Symfony 7.4 ו- Symfony AI

About Author

הערות

תלו תגים

מאמר זה הוצג ב

Related Stories

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

The TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/20/2024)

The TechBeat: To Focus or Not Focus: How to Find the Right Product-Market Fit (3/10/2024)

ברכות עונות מ-HackerNoon: Boost Stories עם תרגומים, דיבור לטקסט ועוד

10 Reasons Why Publishing on HackerNoon Will Skyrocket Your Reach and Impact

The TechBeat: Investigating Internet Freedom: Unseen Aspects of Our Online Existence (1/20/2024)

The TechBeat: To Focus or Not Focus: How to Find the Right Product-Market Fit (3/10/2024)

ברכות עונות מ-HackerNoon: Boost Stories עם תרגומים, דיבור לטקסט ועוד

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps