Hybrid AI + business rules

Documents / unstructured input
    |
    v
AI EXTRACTION
(extract structured data from documents)
    |
    v
BUSINESS RULES
(deterministic calculations, formulas)
    |
    v
AI UNDERSTANDING
(fuzzy matching, qualitative filtering)
    |
    v
BUSINESS RULES
(scoring, ranking, normalization)
    |
    v
AI GENERATION
(produce human-readable report)
    |
    v
Final output (structured data + report)

Extract the following financial parameters from the provided bank rule document:

- income_weights: object mapping income source types to their weight factors
- debt_factors: object mapping debt types to their monthly burden factors
- max_ltv: maximum loan-to-value ratio (as decimal)
- min_income_threshold: minimum gross monthly income required
- supported_currencies: array of accepted currency codes
- special_conditions: any additional eligibility conditions described in the document

Return a JSON object with these fields. Use null for any parameter not found in the document.

{
  "type": "object",
  "properties": {
    "income_weights": {
      "type": "object",
      "description": "Income source type to weight factor mapping"
    },
    "debt_factors": {
      "type": "object",
      "description": "Debt type to monthly burden factor mapping"
    },
    "max_ltv": {
      "type": "number"
    },
    "min_income_threshold": {
      "type": "number"
    },
    "supported_currencies": {
      "type": "array",
      "items": { "type": "string" }
    },
    "special_conditions": {
      "type": "array",
      "items": { "type": "string" }
    }
  },
  "required": ["income_weights", "debt_factors", "max_ltv", "min_income_threshold"]
}

// Inputs from AI extraction
const params = input.extractedParams.output;
const client = input.clientData;

// Weighted income calculation
let weightedIncome = 0;
for (const [source, amount] of Object.entries(client.incomeSources)) {
  const weight = params.income_weights[source] || 0;
  weightedIncome += amount * weight;
}

// Monthly debt burden
let monthlyDebt = 0;
for (const [debtType, balance] of Object.entries(client.debts)) {
  const factor = params.debt_factors[debtType] || 0.05;
  monthlyDebt += balance * factor;
}

// PMT calculation (monthly payment for a given loan amount)
function computePMT(principal, annualRate, termMonths) {
  const r = annualRate / 12;
  if (r === 0) return principal / termMonths;
  return principal * (r * Math.pow(1 + r, termMonths)) /
         (Math.pow(1 + r, termMonths) - 1);
}

// Debt-to-income ratio
const dti = (monthlyDebt) / weightedIncome;

// Maximum loan amount (iterative solve for PMT <= allowed DTI share)
const maxDtiShare = 0.43; // Standard threshold
const allowablePayment = (maxDtiShare * weightedIncome) - monthlyDebt;
const maxLoan = allowablePayment > 0
  ? allowablePayment * ((Math.pow(1 + client.rate / 12, client.termMonths) - 1) /
    (client.rate / 12 * Math.pow(1 + client.rate / 12, client.termMonths)))
  : 0;

// Currency conversion (if needed)
const loanInClientCurrency = maxLoan * (client.exchangeRate || 1);

output.calculationResults = {
  weightedIncome,
  monthlyDebt,
  dti: Math.round(dti * 10000) / 10000,
  ltv: Math.round((client.requestedLoan / client.propertyValue) * 10000) / 10000,
  maxLoanAmount: Math.round(loanInClientCurrency),
  meetsIncomeThreshold: weightedIncome >= params.min_income_threshold,
  meetsLtvRequirement: (client.requestedLoan / client.propertyValue) <= params.max_ltv
};

You are a mortgage product filter. Given the client's preferences and a list of available
products, evaluate each product against the qualitative criteria.

Client preferences:
- Loan type preference: {{input.clientData.loanTypePreference}}
- Values sustainability features: {{input.clientData.sustainabilityPreference}}
- Risk tolerance: {{input.clientData.riskTolerance}}

For each product, return:
- product_id: the product identifier
- qualitative_match_score: a number between 0 and 1
- match_reasons: brief explanation of why it matches or does not match
- disqualified: boolean, true if the product is fundamentally incompatible

Only return products where disqualified is false.

{
  "type": "object",
  "properties": {
    "filtered_products": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "product_id": { "type": "string" },
          "qualitative_match_score": { "type": "number" },
          "match_reasons": { "type": "string" },
          "disqualified": { "type": "boolean" }
        },
        "required": ["product_id", "qualitative_match_score", "disqualified"]
      }
    }
  },
  "required": ["filtered_products"]
}

const calcResults = input.calculationResults;
const aiFiltered = input.filteredProducts.output.filtered_products;

// Scoring weights
const WEIGHT_RATE = 0.35;
const WEIGHT_QUALITATIVE = 0.25;
const WEIGHT_LTV = 0.20;
const WEIGHT_FLEXIBILITY = 0.20;

const scored = aiFiltered.map(product => {
  const details = input.productCatalog.find(p => p.id === product.product_id);
  if (!details) return null;

  // Normalize rate score (lower rate = higher score)
  const rateScore = 1 - (details.rate / 0.10); // Normalize against 10% max

  // LTV score (how close to max allowed)
  const ltvScore = details.maxLtv >= calcResults.ltv ? 1.0 : details.maxLtv / calcResults.ltv;

  // Flexibility score (prepayment, term options)
  const flexScore = (details.allowsPrepayment ? 0.5 : 0) +
                    (details.flexibleTerm ? 0.5 : 0);

  const totalScore = (rateScore * WEIGHT_RATE) +
                     (product.qualitative_match_score * WEIGHT_QUALITATIVE) +
                     (ltvScore * WEIGHT_LTV) +
                     (flexScore * WEIGHT_FLEXIBILITY);

  return {
    productId: product.product_id,
    bankName: details.bankName,
    totalScore: Math.round(totalScore * 1000) / 1000,
    breakdown: { rateScore, qualitativeScore: product.qualitative_match_score, ltvScore, flexScore },
    matchReasons: product.match_reasons
  };
}).filter(Boolean);

// Sort descending by total score
scored.sort((a, b) => b.totalScore - a.totalScore);

output.rankedProducts = scored.slice(0, 5); // Top 5
output.topRecommendation = scored[0] || null;

You are a professional mortgage consultant. Generate a concise recommendation report
for the client based on the following analysis results.

Client profile:
- Weighted monthly income: {{input.calculationResults.weightedIncome}}
- Debt-to-income ratio: {{input.calculationResults.dti}}
- Maximum eligible loan: {{input.calculationResults.maxLoanAmount}}

Top recommended products (ranked):
{{input.rankedProducts}}

Structure the report as:
1. Executive summary (2-3 sentences)
2. Eligibility assessment (income qualification, DTI status)
3. Top 3 product recommendations with key differentiators
4. Next steps for the client

Use professional financial language. Do not include disclaimers about being an AI.

AI EXTRACTION --> [Human review gate] --> BUSINESS RULES --> AI UNDERSTANDING --> [Human review gate] --> BUSINESS RULES --> AI GENERATION

// Adjust DTI threshold based on extraction confidence
const extractionConfidence = input.extractedParams.confidence || 1.0;
const baseMaxDti = 0.43;

// Lower confidence = stricter threshold (more conservative)
const adjustedMaxDti = baseMaxDti * extractionConfidence;

output.meetsAdjustedDti = calcResults.dti <= adjustedMaxDti;
output.confidenceAdjustment = {
  original: baseMaxDti,
  adjusted: adjustedMaxDti,
  confidence: extractionConfidence
};