# Amortization Engine MCP > Interest Amortization Engine calculates precise financial schedules needed for real estate litigation. It generates institutional-grade amortization tables, supporting both Price (French) and SAC (Constant Amortization) methods. This tool isolates the exact principal and interest breakdown for every period, allowing you to mathematically challenge loan charges. ## Overview - **Category:** data-analytics - **Price:** Free - **Tags:** amortization, loan-calculation, real-estate, financial-modeling, math-engine ## Description If you're challenging a bank's reported interest rates in court, your math has to be flawless. Standard language models fail when they hit complex financial modeling; generating accurate Price or SAC schedules is too difficult for them to handle reliably. This MCP runs the calculations locally, providing mathematically precise loan amortization tables that legal teams need. It breaks down every payment into its exact principal and interest components, letting your agent pinpoint where overcharging occurred. By connecting this Interest Amortization Engine via Vinkius, you get a verifiable financial counter-schedule to build unassailable litigation arguments. ## Tools ### calculate_amortization Generates exact PRICE or SAC payment schedules given the principal, months, and annual rate. ## Prompt Examples **Prompt:** ``` The client financed a $200,000 vehicle over 60 months at 15% annual interest. Generate the exact PRICE amortization schedule. ``` **Response:** ``` The computation has been executed with mathematical precision. All results are exact and ready for review. ``` **Prompt:** ``` Produce a SAC (Constant Amortization) schedule for a $500,000 mortgage over 120 months with a 10% annual rate to verify the bank's charges. ``` **Response:** ``` The computation has been executed with mathematical precision. All results are exact and ready for review. ``` **Prompt:** ``` Run a 36-month Price schedule on a $50,000 principal at 12% annual. Tell me exactly how much of the first payment goes to pure interest. ``` **Response:** ``` The computation has been executed with mathematical precision. All results are exact and ready for review. ``` ## Capabilities ### Generate amortization schedules Creates mathematically exact payment tables (Price or SAC) based on loan principal, term length, and annual rate. ### Isolate interest components Separates the total monthly payment into its distinct principal repayment portion and pure interest charge for every period. ### Support multiple calculation types Handles both Price (French) constant installment methods and SAC (Constant Amortization) schedules. ## Use Cases ### Challenging an old mortgage contract A paralegal receives a bank statement showing inconsistent monthly payments over 120 months. Instead of manually checking every entry, they run the principal amount and rates through `calculate_amortization`. The resulting schedule highlights that the actual interest component was systematically inflated by $X per month. ### Comparing two loan products A financial analyst needs to advise a client on whether Loan A (using Price method) or Loan B (using SAC method) is better. They input the same principal and rate into `calculate_amortization` twice, instantly generating both schedules to prove which option saves more money over time. ### Verifying a vehicle financing deal A consumer suspects their dealership used an incorrect annual interest rate. They feed the loan details into `calculate_amortization` and compare the generated schedule against the contract. If the schedules don't match, they have immediate proof of error. ## Benefits - Legal Confidence: Generate a mathematically unassailable counter-schedule. Instead of arguing theory, you present precise data showing exactly where the bank's calculations fail. - Compare Methods: Easily run both Price (French) and SAC schedules with one function. This lets you compare different interest calculation methods side by side for maximum legal leverage. - Pinpoint Discrepancies: The engine isolates principal vs. interest for every month, allowing your agent to immediately spot if the charges are systematically incorrect or abusive. - Local Precision: Calculations happen locally within your client environment. You don't rely on external servers that might compromise data integrity—it’s institution-grade math you can trust. - Speed in Litigation: Stop spending days building spreadsheets. Input parameters and get a complete, ready-to-review schedule instantly. ## How It Works The bottom line is you get an auditable, mathematically verifiable ledger to compare against existing loan statements. 1. Provide the principal loan amount, the total number of months, and the annual interest rate. 2. The MCP runs the calculation, generating a complete schedule that details payments for every period. 3. You receive a precise breakdown showing exactly how much of each payment goes toward interest versus principal. ## Frequently Asked Questions **What is the difference between PRICE and SAC?** PRICE features fixed total monthly payments (interest decreases, amortization increases). SAC features constant amortization, meaning the total monthly payment starts high and decreases over time. **Can it generate 360-month mortgages?** Yes. It can instantly generate the complete, period-by-period JSON schedule for a 30-year (360-month) mortgage without timeout or token limit issues on the Vinkius Edge. **Are the outputs legally viable?** Yes, the formulas applied are the exact universal mathematical standards required by courts and central banks worldwide. **If I use calculate_amortization with conflicting loan variables, how does it handle errors?** It immediately validates inputs and returns a specific error code. The tool tells you exactly which variable is causing the issue, allowing you to fix your data without guessing. **Is the financial data processed by calculate_amortization secure, or does it upload my loan details?** No, the computation runs entirely locally within your environment. Your detailed financial numbers never leave your machine, keeping all calculations private and secure. **After connecting the Interest Amortization Engine MCP via Vinkius, how do I begin with calculate_amortization?** You invoke the tool name and provide three arguments: the principal amount, total months, and annual rate. Your AI agent handles sending these values for accurate execution. **Are there maximum limits on the number of payments I can calculate using calculate_amortization?** The engine is built to handle long-term schedules, supporting up to 360 periods. You won't hit a ceiling unless you are working with an unusually massive principal. **What data format does the calculate_amortization tool accept for inputs?** It accepts standard numerical formats for all three required parameters: principal, total months, and annual rate. You just need to feed it clean numbers.