Ejercicio: Sistema de Evaluación de Riesgo Crediticio con Bedrock ​

def calculate_dti(monthly_income: float, total_debt: float) -> float:
    """
    Calcula el ratio Deuda/Ingreso (DTI)
    """
    if monthly_income <= 0:
        raise ValueError("El ingreso mensual debe ser mayor a 0")
    return (total_debt / monthly_income) * 100

def create_risk_assessment_prompt(applicant_data: dict) -> str:
    return f"""Analiza el siguiente perfil para un préstamo:
    - Nombre: {applicant_data['nombre']}
    - Score Crediticio: {applicant_data['score']}
    - DTI: {applicant_data['dti']}%
    - Antigüedad Laboral: {applicant_data['antiguedad']}
    - Ingreso Mensual: ${applicant_data['ingreso']}
    - Vivienda: {applicant_data['vivienda']}
    
    Considera los siguientes factores para el análisis:
    1. Historial crediticio y capacidad de pago
    2. Estabilidad laboral y nivel de ingresos
    3. Ratio de endeudamiento actual
    4. Perfil de riesgo general
    
    Proporciona una evaluación detallada del riesgo y una recomendación."""

# Backend: FastAPI Models y Schemas

# backend/app/models/applicant.py
from sqlalchemy import Column, Integer, String, Float, Date, Enum
from sqlalchemy.sql import func
from enum import Enum as PyEnum
from .base import Base

class MaritalStatus(PyEnum):
    SINGLE = "SINGLE"
    MARRIED = "MARRIED"
    DIVORCED = "DIVORCED"
    WIDOWED = "WIDOWED"

class HomeStatus(PyEnum):
    OWNED = "OWNED"
    RENTED = "RENTED"
    FAMILY = "FAMILY"

class Applicant(Base):
    __tablename__ = "applicants"

    id = Column(Integer, primary_key=True, index=True)
    full_name = Column(String(100), nullable=False)
    identification = Column(String(20), unique=True, nullable=False)
    age = Column(Integer, nullable=False)
    monthly_income = Column(Float, nullable=False)
    marital_status = Column(Enum(MaritalStatus), nullable=False)
    occupation = Column(String(100), nullable=False)
    work_experience_years = Column(Float, nullable=False)
    credit_score = Column(Integer, nullable=False)
    home_status = Column(Enum(HomeStatus), nullable=False)
    dti = Column(Float, nullable=True)  # Calculado automáticamente
    created_at = Column(Date, server_default=func.now())
    updated_at = Column(Date, onupdate=func.now())

# backend/app/schemas/applicant.py
from pydantic import BaseModel, Field, validator
from datetime import date
from typing import Optional
from enum import Enum

class MaritalStatus(str, Enum):
    SINGLE = "SINGLE"
    MARRIED = "MARRIED"
    DIVORCED = "DIVORCED"
    WIDOWED = "WIDOWED"

class HomeStatus(str, Enum):
    OWNED = "OWNED"
    RENTED = "RENTED"
    FAMILY = "FAMILY"

class ApplicantBase(BaseModel):
    full_name: str = Field(..., min_length=3, max_length=100)
    identification: str = Field(..., regex="^DNI-[0-9]{8}$")
    age: int = Field(..., ge=18, le=80)
    monthly_income: float = Field(..., gt=0)
    marital_status: MaritalStatus
    occupation: str = Field(..., min_length=3, max_length=100)
    work_experience_years: float = Field(..., ge=0)
    credit_score: int = Field(..., ge=300, le=850)
    home_status: HomeStatus

class ApplicantCreate(ApplicantBase):
    pass

class ApplicantUpdate(ApplicantBase):
    pass

class ApplicantInDB(ApplicantBase):
    id: int
    dti: Optional[float]
    created_at: date
    updated_at: Optional[date]

    class Config:
        orm_mode = True

# backend/app/core/config.py
from pydantic_settings import BaseSettings
from typing import Optional

class Settings(BaseSettings):
    PROJECT_NAME: str = "Loan Risk Analyzer"
    VERSION: str = "1.0.0"
    API_V1_STR: str = "/api/v1"
    
    POSTGRES_SERVER: str
    POSTGRES_USER: str
    POSTGRES_PASSWORD: str
    POSTGRES_DB: str
    SQLALCHEMY_DATABASE_URI: Optional[str] = None

    AWS_ACCESS_KEY_ID: str
    AWS_SECRET_ACCESS_KEY: str
    AWS_REGION: str = "us-east-1"
    
    BEDROCK_MODEL_ID: str = "anthropic.claude-v2"
    
    @validator("SQLALCHEMY_DATABASE_URI", pre=True)
    def assemble_db_connection(cls, v: Optional[str], values: dict) -> str:
        if v:
            return v
        return f"postgresql://{values['POSTGRES_USER']}:{values['POSTGRES_PASSWORD']}@{values['POSTGRES_SERVER']}/{values['POSTGRES_DB']}"

    class Config:
        env_file = ".env"

settings = Settings()

# backend/app/db/session.py
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from app.core.config import settings

engine = create_engine(settings.SQLALCHEMY_DATABASE_URI, pool_pre_ping=True)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# backend/app/api/deps.py
from typing import Generator
from app.db.session import SessionLocal

def get_db() -> Generator:
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# Frontend: Vue.js Components Base

# frontend/src/components/ApplicationForm/index.vue
<template>
  <div class="application-form">
    <v-form @submit.prevent="handleSubmit" v-model="valid">
      <v-container>
        <v-row>
          <v-col cols="12" md="6">
            <v-text-field
              v-model="formData.full_name"
              :rules="nameRules"
              label="Nombre Completo"
              required
            ></v-text-field>
          </v-col>
          <v-col cols="12" md="6">
            <v-text-field
              v-model="formData.identification"
              :rules="idRules"
              label="Identificación"
              hint="Formato: DNI-12345678"
              required
            ></v-text-field>
          </v-col>
        </v-row>
        <v-row>
          <v-col cols="12" md="4">
            <v-text-field
              v-model.number="formData.age"
              type="number"
              :rules="ageRules"
              label="Edad"
              required
            ></v-text-field>
          </v-col>
          <v-col cols="12" md="4">
            <v-text-field
              v-model.number="formData.monthly_income"
              type="number"
              :rules="incomeRules"
              label="Ingreso Mensual"
              prefix="$"
              required
            ></v-text-field>
          </v-col>
          <v-col cols="12" md="4">
            <v-select
              v-model="formData.marital_status"
              :items="maritalStatusOptions"
              label="Estado Civil"
              required
            ></v-select>
          </v-col>
        </v-row>
        <!-- Más campos según el modelo -->
        <v-btn
          :disabled="!valid"
          color="primary"
          class="mr-4"
          type="submit"
        >
          Enviar Solicitud
        </v-btn>
      </v-container>
    </v-form>
  </div>
</template>

<script>
export default {
  name: 'ApplicationForm',
  data: () => ({
    valid: false,
    formData: {
      full_name: '',
      identification: '',
      age: null,
      monthly_income: null,
      marital_status: '',
      occupation: '',
      work_experience_years: null,
      credit_score: null,
      home_status: ''
    },
    nameRules: [
      v => !!v || 'Nombre es requerido',
      v => v.length >= 3 || 'Nombre debe tener al menos 3 caracteres'
    ],
    idRules: [
      v => !!v || 'Identificación es requerida',
      v => /^DNI-[0-9]{8}$/.test(v) || 'Formato inválido (DNI-12345678)'
    ],
    ageRules: [
      v => !!v || 'Edad es requerida',
      v => v >= 18 || 'Debe ser mayor de 18 años',
      v => v <= 80 || 'Edad máxima 80 años'
    ],
    incomeRules: [
      v => !!v || 'Ingreso es requerido',
      v => v > 0 || 'Ingreso debe ser mayor a 0'
    ],
    maritalStatusOptions: [
      { text: 'Soltero/a', value: 'SINGLE' },
      { text: 'Casado/a', value: 'MARRIED' },
      { text: 'Divorciado/a', value: 'DIVORCED' },
      { text: 'Viudo/a', value: 'WIDOWED' }
    ]
  }),
  methods: {
    async handleSubmit() {
      if (!this.valid) return;
      
      try {
        // Implementar lógica de envío
        const response = await this.$api.submitApplication(this.formData);
        this.$emit('submission-success', response.data);
      } catch (error) {
        this.$emit('submission-error', error);
      }
    }
  }
}
</script>

# Configuración de Base de Datos

# backend/alembic/env.py
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from alembic import context
from app.core.config import settings
from app.models import Base

config = context.config
fileConfig(config.config_file_name)
target_metadata = Base.metadata

def run_migrations_offline() -> None:
    url = settings.SQLALCHEMY_DATABASE_URI
    context.configure(
        url=url,
        target_metadata=target_metadata,
        literal_binds=True,
        dialect_opts={"paramstyle": "named"},
    )

    with context.begin_transaction():
        context.run_migrations()

def run_migrations_online() -> None:
    configuration = config.get_section(config.config_ini_section)
    configuration["sqlalchemy.url"] = settings.SQLALCHEMY_DATABASE_URI
    connectable = engine_from_config(
        configuration,
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )

    with connectable.connect() as connection:
        context.configure(
            connection=connection,
            target_metadata=target_metadata
        )

        with context.begin_transaction():
            context.run_migrations()

if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

# Servicio de Integración con Bedrock

# backend/app/services/bedrock_service.py
from typing import Dict, Any
import boto3
import json
from app.core.config import settings
from app.schemas.applicant import ApplicantInDB
import logging

logger = logging.getLogger(__name__)

class BedrockService:
    def __init__(self):
        self.client = boto3.client(
            service_name='bedrock-runtime',
            region_name=settings.AWS_REGION,
            aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
            aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY
        )
        self.model_id = settings.BEDROCK_MODEL_ID

    def _create_risk_assessment_prompt(self, applicant: ApplicantInDB) -> str:
        return f"""Analiza el siguiente perfil para un préstamo y proporciona una evaluación detallada del riesgo:

Información del Aplicante:
- Nombre: {applicant.full_name}
- Edad: {applicant.age}
- Score Crediticio: {applicant.credit_score}
- DTI: {applicant.dti}%
- Ingreso Mensual: ${applicant.monthly_income}
- Estado Civil: {applicant.marital_status}
- Ocupación: {applicant.occupation}
- Experiencia Laboral: {applicant.work_experience_years} años
- Vivienda: {applicant.home_status}

Factores a considerar:
1. Analiza el historial crediticio y capacidad de pago
2. Evalúa la estabilidad laboral y nivel de ingresos
3. Considera el ratio de endeudamiento (DTI)
4. Analiza el perfil de riesgo general

Proporciona:
1. Nivel de riesgo (BAJO, MEDIO, ALTO)
2. Puntaje de confianza (0-1)
3. Análisis detallado de factores de riesgo
4. Recomendación específica
5. Términos sugeridos para el préstamo si aplica

Formato JSON requerido para la respuesta."""

    async def analyze_risk(self, applicant: ApplicantInDB) -> Dict[str, Any]:
        try:
            prompt = self._create_risk_assessment_prompt(applicant)
            
            response = self.client.invoke_model(
                modelId=self.model_id,
                body=json.dumps({
                    "prompt": prompt,
                    "max_tokens": 1000,
                    "temperature": 0.1,
                    "response_format": {"type": "json_object"}
                })
            )

            response_body = json.loads(response['body'].read())
            
            # Procesar y validar la respuesta
            risk_assessment = self._process_bedrock_response(response_body)
            
            # Guardar en caché si es necesario
            await self._cache_risk_assessment(applicant.id, risk_assessment)
            
            return risk_assessment

        except Exception as e:
            logger.error(f"Error in Bedrock risk analysis: {str(e)}")
            raise

    def _process_bedrock_response(self, response: Dict) -> Dict[str, Any]:
        try:
            # Estructura esperada de la respuesta
            return {
                "risk_level": response["risk_assessment"]["risk_level"],
                "confidence_score": float(response["risk_assessment"]["confidence_score"]),
                "factors": response["risk_assessment"]["factors"],
                "recommendation": response["risk_assessment"]["recommendation"],
                "suggested_terms": response["risk_assessment"]["suggested_terms"]
            }
        except KeyError as e:
            logger.error(f"Invalid Bedrock response structure: {str(e)}")
            raise ValueError("Invalid response structure from Bedrock")

    async def _cache_risk_assessment(self, applicant_id: int, assessment: Dict) -> None:
        # Implementar lógica de caché si es necesario
        pass

# backend/app/services/risk_analyzer.py
from typing import Dict, Any, List
from app.schemas.applicant import ApplicantInDB
from .bedrock_service import BedrockService

class RiskAnalyzer:
    def __init__(self):
        self.bedrock_service = BedrockService()
        self.risk_weights = {
            "credit_score": 0.30,
            "dti": 0.25,
            "work_experience": 0.20,
            "income": 0.15,
            "home_status": 0.10
        }

    async def analyze_applicant(self, applicant: ApplicantInDB) -> Dict[str, Any]:
        # Obtener análisis de Bedrock
        bedrock_analysis = await self.bedrock_service.analyze_risk(applicant)
        
        # Calcular score interno
        internal_score = self._calculate_internal_score(applicant)
        
        # Combinar resultados
        return self._combine_analysis(bedrock_analysis, internal_score)

    def _calculate_internal_score(self, applicant: ApplicantInDB) -> float:
        scores = {
            "credit_score": self._score_credit(applicant.credit_score),
            "dti": self._score_dti(applicant.dti),
            "work_experience": self._score_experience(applicant.work_experience_years),
            "income": self._score_income(applicant.monthly_income),
            "home_status": self._score_home_status(applicant.home_status)
        }
        
        return sum(scores[k] * self.risk_weights[k] for k in scores)

    def _score_credit(self, score: int) -> float:
        if score >= 750: return 1.0
        if score >= 650: return 0.7
        return 0.3

    def _score_dti(self, dti: float) -> float:
        if dti <= 30: return 1.0
        if dti <= 40: return 0.6
        return 0.2

    def _score_experience(self, years: float) -> float:
        if years >= 5: return 1.0
        if years >= 2: return 0.7
        return 0.3

    def _score_income(self, income: float) -> float:
        if income >= 5000: return 1.0
        if income >= 3000: return 0.7
        return 0.4

    def _score_home_status(self, status: str) -> float:
        scores = {"OWNED": 1.0, "FAMILY": 0.7, "RENTED": 0.5}
        return scores.get(status, 0.5)

    def _combine_analysis(
        self, 
        bedrock_analysis: Dict[str, Any], 
        internal_score: float
    ) -> Dict[str, Any]:
        risk_levels = {
            "BAJO": 1.0,
            "MEDIO": 0.5,
            "ALTO": 0.2
        }
        
        bedrock_score = risk_levels.get(bedrock_analysis["risk_level"], 0.5)
        
        # Combinar scores con peso 60/40
        final_score = (bedrock_score * 0.6) + (internal_score * 0.4)
        
        return {
            "final_score": final_score,
            "risk_level": self._get_risk_level(final_score),
            "bedrock_analysis": bedrock_analysis,
            "internal_score": internal_score,
            "details": {
                "confidence": bedrock_analysis["confidence_score"],
                "factors": bedrock_analysis["factors"],
                "recommendation": bedrock_analysis["recommendation"],
                "suggested_terms": bedrock_analysis["suggested_terms"]
            }
        }

    def _get_risk_level(self, score: float) -> str:
        if score >= 0.7: return "BAJO"
        if score >= 0.4: return "MEDIO"
        return "ALTO"

# backend/app/api/endpoints/risk_assessment.py
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import Dict, Any
from app.api import deps
from app.services.risk_analyzer import RiskAnalyzer
from app.schemas.applicant import ApplicantInDB

router = APIRouter()

@router.post("/analyze/{applicant_id}", response_model=Dict[str, Any])
async def analyze_risk(
    applicant_id: int,
    db: Session = Depends(deps.get_db)
) -> Dict[str, Any]:
    # Obtener aplicante de la base de datos
    applicant = db.query(ApplicantInDB).filter(ApplicantInDB.id == applicant_id).first()
    if not applicant:
        raise HTTPException(status_code=404, detail="Applicant not found")

    # Analizar riesgo
    analyzer = RiskAnalyzer()
    try:
        result = await analyzer.analyze_applicant(applicant)
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# backend/app/services/loan_rules_engine.py
from dataclasses import dataclass
from typing import List, Dict, Any
from decimal import Decimal
import logging

logger = logging.getLogger(__name__)

@dataclass
class LoanTerms:
    max_amount: Decimal
    interest_rate: Decimal
    term_months: int
    monthly_payment: Decimal
    required_documents: List[str]

class LoanRulesEngine:
    def __init__(self):
        self.base_interest_rate = Decimal('0.10')  # 10% base
        self.max_dti_ratio = Decimal('0.43')  # 43% max DTI
        self.min_credit_score = 600
        
        # Multiplicadores por nivel de riesgo
        self.risk_multipliers = {
            "BAJO": Decimal('1.0'),
            "MEDIO": Decimal('1.25'),
            "ALTO": Decimal('1.5')
        }

    def calculate_loan_terms(
        self,
        monthly_income: Decimal,
        credit_score: int,
        dti: Decimal,
        risk_level: str,
        work_experience_years: float
    ) -> LoanTerms:
        try:
            # Validar elegibilidad básica
            if not self._is_eligible(credit_score, dti):
                raise ValueError("No elegible para préstamo")

            # Calcular monto máximo
            max_amount = self._calculate_max_amount(monthly_income, dti, risk_level)
            
            # Calcular tasa de interés
            interest_rate = self._calculate_interest_rate(credit_score, risk_level, work_experience_years)
            
            # Determinar plazo máximo
            term_months = self._determine_term_months(max_amount, risk_level)
            
            # Calcular pago mensual
            monthly_payment = self._calculate_monthly_payment(max_amount, interest_rate, term_months)
            
            # Determinar documentos requeridos
            required_docs = self._determine_required_documents(max_amount, risk_level)

            return LoanTerms(
                max_amount=max_amount,
                interest_rate=interest_rate,
                term_months=term_months,
                monthly_payment=monthly_payment,
                required_documents=required_docs
            )

        except Exception as e:
            logger.error(f"Error calculating loan terms: {str(e)}")
            raise

    def _is_eligible(self, credit_score: int, dti: Decimal) -> bool:
        return credit_score >= self.min_credit_score and dti <= self.max_dti_ratio

    def _calculate_max_amount(
        self,
        monthly_income: Decimal,
        dti: Decimal,
        risk_level: str
    ) -> Decimal:
        # Base: 36 meses de ingreso
        base_amount = monthly_income * 36
        
        # Ajustar por DTI
        dti_factor = (self.max_dti_ratio - dti) / self.max_dti_ratio
        
        # Ajustar por nivel de riesgo
        risk_factor = Decimal('1.0') / self.risk_multipliers[risk_level]
        
        max_amount = base_amount * dti_factor * risk_factor
        
        # Redondear a miles más cercanos
        return (max_amount // 1000) * 1000

    def _calculate_interest_rate(
        self,
        credit_score: int,
        risk_level: str,
        work_experience_years: float
    ) -> Decimal:
        # Tasa base
        rate = self.base_interest_rate
        
        # Ajuste por score crediticio
        if credit_score >= 800:
            rate -= Decimal('0.02')
        elif credit_score >= 750:
            rate -= Decimal('0.01')
        elif credit_score < 650:
            rate += Decimal('0.02')
            
        # Ajuste por experiencia laboral
        if work_experience_years >= 5:
            rate -= Decimal('0.005')
        elif work_experience_years < 2:
            rate += Decimal('0.01')
            
        # Ajuste por nivel de riesgo
        rate *= self.risk_multipliers[risk_level]
        
        return rate.quantize(Decimal('0.0001'))

    def _determine_term_months(self, amount: Decimal, risk_level: str) -> int:
        base_term = 36  # Base: 36 meses
        
        if amount > Decimal('50000'):
            base_term = 60
        elif amount > Decimal('100000'):
            base_term = 84
            
        # Ajustar por nivel de riesgo
        if risk_level == "ALTO":
            base_term = min(base_term, 48)
            
        return base_term

    def _calculate_monthly_payment(
        self,
        amount: Decimal,
        annual_rate: Decimal,
        term_months: int
    ) -> Decimal:
        monthly_rate = annual_rate / 12
        payment = amount * (
            monthly_rate * (1 + monthly_rate) ** term_months
        ) / ((1 + monthly_rate) ** term_months - 1)
        
        return payment.quantize(Decimal('0.01'))

    def _determine_required_documents(
        self,
        amount: Decimal,
        risk_level: str
    ) -> List[str]:
        docs = [
            "Identificación oficial",
            "Comprobante de ingresos",
            "Comprobante de domicilio"
        ]
        
        if amount > Decimal('50000'):
            docs.extend([
                "Declaración de impuestos",
                "Estados de cuenta bancarios"
            ])
            
        if risk_level == "ALTO":
            docs.extend([
                "Aval o garantía",
                "Historial laboral detallado"
            ])
            
        return docs

# backend/app/services/loan_processor.py
from decimal import Decimal
from typing import Dict, Any
from .loan_rules_engine import LoanRulesEngine
from .risk_analyzer import RiskAnalyzer
from app.schemas.applicant import ApplicantInDB
from app.models.loan import LoanApplication, LoanStatus

class LoanProcessor:
    def __init__(self):
        self.rules_engine = LoanRulesEngine()
        self.risk_analyzer = RiskAnalyzer()

    async def process_application(
        self,
        applicant: ApplicantInDB
    ) -> Dict[str, Any]:
        try:
            # Analizar riesgo
            risk_assessment = await self.risk_analyzer.analyze_applicant(applicant)
            
            # Si el riesgo es muy alto, rechazar automáticamente
            if risk_assessment["risk_level"] == "ALTO" and risk_assessment["final_score"] < 0.3:
                return self._create_rejection_response(
                    "Riesgo crediticio demasiado alto",
                    risk_assessment
                )

            # Calcular términos del préstamo
            loan_terms = self.rules_engine.calculate_loan_terms(
                monthly_income=Decimal(str(applicant.monthly_income)),
                credit_score=applicant.credit_score,
                dti=Decimal(str(applicant.dti)),
                risk_level=risk_assessment["risk_level"],
                work_experience_years=applicant.work_experience_years
            )

            # Validar si los términos son viables
            if not self._validate_terms(loan_terms, applicant):
                return self._create_rejection_response(
                    "Términos del préstamo no viables",
                    risk_assessment,
                    loan_terms
                )

            return {
                "status": "APPROVED",
                "risk_assessment": risk_assessment,
                "loan_terms": {
                    "max_amount": float(loan_terms.max_amount),
                    "interest_rate": float(loan_terms.interest_rate),
                    "term_months": loan_terms.term_months,
                    "monthly_payment": float(loan_terms.monthly_payment),
                    "required_documents": loan_terms.required_documents
                },
                "applicant_id": applicant.id
            }

        except Exception as e:
            logger.error(f"Error processing loan application: {str(e)}")
            return self._create_error_response(str(e))

    def _validate_terms(self, terms: LoanTerms, applicant: ApplicantInDB) -> bool:
        # Validar que el pago mensual no exceda cierto porcentaje del ingreso
        max_payment_ratio = Decimal('0.35')  # 35% del ingreso mensual
        max_allowed_payment = Decimal(str(applicant.monthly_income)) * max_payment_ratio
        
        return terms.monthly_payment <= max_allowed_payment

    def _create_rejection_response(
        self,
        reason: str,
        risk_assessment: Dict[str, Any],
        loan_terms: LoanTerms = None
    ) -> Dict[str, Any]:
        response = {
            "status": "REJECTED",
            "reason": reason,
            "risk_assessment": risk_assessment
        }
        
        if loan_terms:
            response["loan_terms"] = {
                "max_amount": float(loan_terms.max_amount),
                "interest_rate": float(loan_terms.interest_rate),
                "term_months": loan_terms.term_months,
                "monthly_payment": float(loan_terms.monthly_payment)
            }
            
        return response

    def _create_error_response(self, error_message: str) -> Dict[str, Any]:
        return {
            "status": "ERROR",
            "error_message": error_message
        }

# backend/app/api/endpoints/loan_application.py
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from typing import Dict, Any
from app.api import deps
from app.services.loan_processor import LoanProcessor
from app.schemas.applicant import ApplicantInDB
from app.models.loan import LoanApplication

router = APIRouter()

@router.post("/apply/{applicant_id}", response_model=Dict[str, Any])
async def process_loan_application(
    applicant_id: int,
    db: Session = Depends(deps.get_db)
) -> Dict[str, Any]:
    # Obtener aplicante
    applicant = db.query(ApplicantInDB).filter(
        ApplicantInDB.id == applicant_id
    ).first()
    
    if not applicant:
        raise HTTPException(status_code=404, detail="Aplicante no encontrado")
        
    # Procesar solicitud
    processor = LoanProcessor()
    result = await processor.process_application(applicant)
    
    # Guardar resultado
    loan_application = LoanApplication(
        applicant_id=applicant_id,
        status=result["status"],
        max_amount=result.get("loan_terms", {}).get("max_amount"),
        interest_rate=result.get("loan_terms", {}).get("interest_rate"),
        term_months=result.get("loan_terms", {}).get("term_months"),
        monthly_payment=result.get("loan_terms", {}).get("monthly_payment"),
        risk_level=result["risk_assessment"]["risk_level"],
        risk_score=result["risk_assessment"]["final_score"]
    )
    
    db.add(loan_application)
    db.commit()
    db.refresh(loan_application)
    
    return result