Vuoden 2026 nopeasti muuttuvassa maisemassa ”AI-first” ei ole enää puhekieli – se on arkkitehtoninen vaatimus. Tässä syvässä sukelluksessa rakennamme tuotantotason Emme aio vain siirtää yksiköitä Kaksi Injektoimme kognitiivisen kerroksen valtion koneeseen käyttämällä ja Järjestelmämme arvioi automaattisesti lainahakemukset ja reitittää ne dynaamisesti: korkeatasoiset hakemukset saavat välittömän hyväksynnän, riskialttiit hakemukset hylätään ja rajatapaukset reititetään ihmisavunantajille. Bank Loan Approval Workflow “Draft” “Approved.” symfony/workflow symfony/ai-bundle Arkkitehtuurin Olemme rakentamassa Score-Driven State Machine -järjestelmää. Perinteiset työnkulut ovat lineaarisia tai käyttäjälähtöisiä. . agentic 
 
 
 
 
 Käyttäjä lähettää lainahakemuksen. AI-analyysi: Omistettu AI-agentti analysoi hakijan raaka-aineistoa (tulot, velat, historia) vasten ”Risk Policy” -pyyntöä. Arviointi: AI palauttaa jäsennellyn arvosanan (0–100) ja yhteenvedon. Dynaaminen reititys:Pistemäärä > 80:Automaattinen hyväksyntä.Pistemäärä < 40:Automaattinen hylkääminen.40–80: Siirtyminen manuaaliseen tarkasteluun. Stack on 
 
 
 
 
 PHP 8.4: Uuden Property Hooksin ja tarvittaessa alkuperäisen HTML5-parsingin käyttämiseen. Symfony 7.4: LTS ydin Symfonia / työnkulku: Valtion elinkaaren hallinta. symfony/ai-bundle: LLM: n integrointikerros (OpenAI, Anthropic tai paikalliset mallit). Hankkeen suunnittelu ja edellytykset Ensinnäkin varmista, että sinulla on Symfony CLI ja PHP 8.4 asennettu. Luomme uuden luurankohankkeen ja asennamme riippuvuutemme. symfony new bank_approval --webapp --version=7.4
cd bank_approval
 Riippuvuuksien asentaminen Tarvitsemme työnkulun osan ja AI-paketin. Huomaa, että vuoden 2025 puolivälistä lähtien Kyseessä on integraation standardi. symfony/ai-bundle composer require symfony/workflow symfony/ai-bundle symfony/http-client
 Oletamme, että sinulla on OpenAI-API-avain tai vastaava AI-alustan kokoonpanoon. Konfigurointi **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 Käyttö Tarvitsemme entiteetin, joka pitää tiedot ja tilan. Käytämme PHP 8.4 attribuutteja kartoittamiseen. 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 -palvelu Tämä on meidän ytimemme Luomme palvelun, joka muotoilee entiteettitiedot kyselyyn, lähettää sen konfiguroidulle Tällöin JSON vastaus. “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;
    }
}
 Työnkulun automatisointi Tarvitsemme nyt logiikan, joka yhdistää pistemiehen työnkulkuun.Tämä palvelu laukaisee siirtymät pistemäärän perusteella. 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',
        };
    }
}
 Sekoita se tapahtumiin Jotta tämä olisi sujuvaa, haluamme automaation käynnistyvän välittömästi sen jälkeen, kun käyttäjä lähettää hakemuksen. Kun laina tulee prosessointi_pisteet tilaan (lähetä siirtymä), käynnistämme automaation. Workflow Event Listener Suuren mittakaavan reaalimaailman sovelluksessa lähettäisit Tässä viestissä käsitellään AI-puhelua epäsynkronisesti.Tässä esimerkissä teemme sen synkronisesti pitääksemme koodin keskittyneenä logiikkaan. 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()));
    }
}
 Ohjaajan Lopuksi rakennetaan ohjain simuloimaan lähetystä. 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.'
        ]);
    }
}
 Tarkistaminen 
 
 
 
 Konfiguroi API-avain: Varmista, että OPENAI_API_KEY on asetettu .env.local. Käynnistä palvelin: symfony server:start. Lähetä pyyntö: Käytä curl tai 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%..."
}
 Johtopäätös Olemme onnistuneesti integroineet Tämä malli hyödyntää molempien maailmojen parasta: Generative AI 
 
 
 Symfony Workflow: Tarjoaa luotettavuuden, tarkastusreitit ja tiukan valtionhallinnan, jota tarvitaan pankkitoiminnassa. Symfony AI: Tarjoaa vivahteellisen päätöksentekokyvyn, joka edellytti aiemmin ihmisen väliintuloa. Voit ottaa käyttöön uusia agentteja petosten havaitsemiseksi, asiakirjan analysoimiseksi (käyttämällä Sisällä ), tai sääntelyyn liittyviä vaatimustenmukaisuustarkastuksia, jotka kaikki on järjestetty saman läpinäkyvän työnkulkujärjestelmän puitteissa. OCR tools symfony/ai-bundle Täydellistä toteutusta ja projektin etenemistä voi seurata Githubissa: [ ] Source Code: https://github.com/mattleads/AIBankApproval https://github.com/mattleads/AIBankApproval Let’s Connect! Jos olet löytänyt tämän hyödylliseksi tai sinulla on kysymyksiä toteutuksesta, haluaisin kuulla sinulta. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Yhteystiedot: [https://x.com/MattLeads] Sähköpostiosoite: [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

Tämä ääni on tuotettu tarinan alkuperäisellä kielellä!

Miten rakentaa AI-ohjattu lainan hyväksymisen työnkulku Symfony 7.4: n ja Symfony AI: n kanssa

About Author

KOMMENTIT

RIPUTA TAGSIA

TÄMÄ ARTIKKELI ESITETTIIN

Related Stories

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

Why The "Missing Middle" Is The Biggest Untapped Opportunity in 2026

The Spacecoin Writing Contest by Spacecoin and HackerNoon: Final Round Results 🎉

Win Up to $2000 in the #blockchain Writing Contest by Aleph Cloud and HackerNoon

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

Why The "Missing Middle" Is The Biggest Untapped Opportunity in 2026

The Spacecoin Writing Contest by Spacecoin and HackerNoon: Final Round Results 🎉

Win Up to $2000 in the #blockchain Writing Contest by Aleph Cloud and HackerNoon

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps