En el paisaje que evoluciona rápidamente en 2026, “AI-first” ya no es un buzzword, es un requisito arquitectónico.Para las instituciones de fintech, la capacidad de automatizar las decisiones de crédito mientras se mantiene el cumplimiento estricto es el Santo Graal En esta profunda inmersión, construiremos un nivel de producción No solo vamos a mover entidades de Dos Injetaremos una capa cognitiva en la máquina de estado utilizando y Nuestro sistema clasificará automáticamente las solicitudes de préstamos y las dirigirá de forma dinámica: las solicitudes de alta puntuación reciben la aprobación instantánea, las de alto riesgo son rechazadas y los casos de borderline se dirigen a los financiadores humanos. Bank Loan Approval Workflow “Draft” “Approved.” symfony/workflow symfony/ai-bundle La arquitectura Estamos construyendo una máquina de Estado guiada por puntos. Los flujos de trabajo tradicionales son lineales o orientados al usuario. . agentic 
 
 
 
 
 Envío: El usuario presenta una solicitud de préstamo. Análisis de IA: Un agente de IA dedicado analiza los datos brutos del solicitante (ingresos, deuda, historial) contra un prompt de “Política de riesgo”. Scoring: El AI devuelve una puntuación estructurada (0-100) y un resumen de razonamiento. Ruta dinámica:Puntuación > 80:Auto-Approve.Puntuación < 40:Auto-Reject.40–80: Transición a manual_review. El Stack 
 
 
 
 
 PHP 8.4: Para utilizar los nuevos Property Hooks y el análisis nativo de HTML5 si es necesario. Symfony 7.4: El núcleo LTS. Sinfonía / flujo de trabajo: Gestionar el ciclo de vida del estado. Symfony/ai-bundle: La capa de integración para LLMs (OpenAI, Antropic, o modelos locales). Proyecto y Prerequisitos Primero, asegúrese de que tenga instalado el CLI de Symfony y PHP 8.4. Crearemos un nuevo proyecto de esqueleto e instalaremos nuestras dependencias. symfony new bank_approval --webapp --version=7.4
cd bank_approval
 Instalación de dependencias Necesitamos el componente de flujo de trabajo y el paquete de IA. Tenga en cuenta que desde mediados de 2025, Es el estándar para la integración. symfony/ai-bundle composer require symfony/workflow symfony/ai-bundle symfony/http-client
 Suponemos que tiene una clave de API OpenAI o similar para la configuración de la plataforma de IA. Configuración **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
 El nivel de dominio Necesitamos una entidad que mantenga los datos y el estado. Utilizaremos los atributos de PHP 8.4 para mapear. 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;
    }
}
 El servicio de puntuación AI Este es el núcleo de nuestra Crearemos un servicio que formatea los datos de la entidad en un prompt, lo envía a nuestro configurado Descarga la respuesta de 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;
    }
}
 Automatizador de flujo de trabajo Ahora necesitamos la lógica que conecta el Scorer al flujo de trabajo. Este servicio desencadena las transiciones basadas en la puntuación. 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',
        };
    }
}
 Enlazarlo con los eventos Para hacer esto sin problemas, queremos que la automatización se activa inmediatamente después de que el usuario envíe la aplicación. Cuando el préstamo entra en el estado processing_score (a través de la transición de envío), desencadenamos la automatización. Workflow Event Listener En una aplicación de mundo real de gran escala, enviaría un mensaje aquí para manejar la llamada AI de forma asíncrona. Para este ejemplo, lo haremos de forma sincronizada para mantener el código enfocado en la lógica. 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()));
    }
}
 El controlador Finalmente, construamos un controlador para simular la presentación. 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.'
        ]);
    }
}
 Verificación 
 
 
 
 Configurar la clave de la API: Asegúrese de que OPENAI_API_KEY esté configurado en .env.local. Servicio de inicio: Symfony Server:start. Enviar solicitud: Utilice curl o Correos. 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%..."
}
 Conclusión Se ha integrado con éxito Este patrón aprovecha lo mejor de ambos mundos: Generative AI 
 
 
 Flujo de trabajo de la sinfonía: Proporciona la fiabilidad, las pistas de auditoría y la gestión estricta del estado necesaria para la banca. Symfony AI: Proporciona la capacidad de toma de decisiones que anteriormente requería la intervención humana. Puede introducir nuevos agentes para la detección de fraudes, el análisis de documentos (utilizando en ), o controles de cumplimiento regulatorio, todos orquestados dentro del mismo sistema de flujo de trabajo transparente. OCR tools symfony/ai-bundle Puedes encontrar la implementación completa y seguir el progreso del proyecto en GitHub: [ ] Source Code: https://github.com/mattleads/AIBankApproval https://github.com/mattleads/AIBankApproval Let’s Connect! Si ha encontrado esto útil o tiene preguntas sobre la implementación, me encantaría escuchar de usted. 
 
 
 
 
 Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] X (Twitter): [https://x.com/MattLeads] Telegrama: [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

Este audio es producido en el idioma original de la historia!

Cómo construir un flujo de trabajo de aprobación de préstamos impulsado por IA con Symfony 7.4 y Symfony AI

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Cómo mejorar su flujo de trabajo 10 veces: 17 aplicaciones esenciales

Telegram: el puente de Crypto Island hacia el continente

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Cómo mejorar su flujo de trabajo 10 veces: 17 aplicaciones esenciales

Telegram: el puente de Crypto Island hacia el continente

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps