# Legal Fees Apportionment MCP > Legal Fees Apportionment Engine splits judicial awards and attorney fees across multiple parties with exact proportional math. This MCP handles shared condemnations, ensuring every cent is accounted for and ratios are correct. It deterministically calculates complex fee deductions and distributions based on claim weights or percentages. Stop dealing with rounding errors that invalidate agreements; use this to calculate precise settlements. ## Overview - **Category:** data-analytics - **Price:** Free - **Tags:** fee-calculation, proportional-math, litigation-support, financial-auditing, precision-math, settlement-management ## Description When a lawsuit ends and the money needs splitting, it’s rarely simple division. You have judicial awards, co-plaintiff claims, and mandatory attorney fees—all of which need to be accounted for proportionally. This MCP handles those exact calculations. It performs weighted division with high-precision decimal output, guaranteeing that the final distribution reconciles perfectly. Your agent can feed it raw settlement data or complex claim weights, and it returns a clean, auditable breakdown. Instead of relying on general scripting tools that introduce rounding errors, this engine is built specifically for deterministic financial apportionment. You connect this Legal Fees Apportionment Engine through Vinkius to any MCP-compatible client (like Cursor or Claude) and get precise results without the headache. It’s the math you can trust with high stakes. ## Tools ### apportion_legal_fees Splits a total judicial award among several parties while accurately deducting specific attorney fees. ## Prompt Examples **Prompt:** ``` Split a $50,000 judicial award among 3 plaintiffs equally, deducting 15% attorney fees first. ``` **Response:** ``` The award has been apportioned with mathematical precision. Each plaintiff receives exactly $14,166.67 after the $7,500.00 attorney fee deduction. ``` **Prompt:** ``` We have 4 co-plaintiffs with different claim weights: A=3, B=2, C=1, D=1. Split $100,000 with 10% fees. ``` **Response:** ``` Distribution complete. Party A receives $38,571.43 (3/7), Party B receives $25,714.29 (2/7), Parties C and D each receive $12,857.14 (1/7). ``` **Prompt:** ``` Calculate the exact sucumbência for a losing defendant ordered to pay $200,000, with 20% attorney fees split between 2 law firms. ``` **Response:** ``` The computation has been executed with mathematical precision. Attorney fees total $40,000.00, split equally at $20,000.00 per firm. ``` ## Capabilities ### Split Awards Among Parties Determines how a total judicial award must be proportionally split among multiple named parties. ### Deduct Attorney Fees First Calculates and deducts specified attorney fees from the overall award before distributing remaining funds. ### Handle Weighted Claims Applies varying claim weights for co-plaintiffs, ensuring distribution reflects their proportional involvement in the case. ### Calculate Specific Fee Types Computes specialized fee allocations, such as sucumbência (costs paid by a losing defendant). ## Use Cases ### Co-Plaintiff Settlement Four co-plaintiffs file a suit and win $1 million. They contributed with different claim weights (3:2:1:1). The agent uses this MCP to split the award correctly after deducting 10% in fees, providing each party's exact share based on their weight. ### Multiple Law Firm Split A defendant loses a case and owes $200k. The attorney fees (20%) must be split equally between two separate law firms. Running this through the MCP calculates the total fee amount and divides it precisely, preventing misallocation. ### Partial Judgment Distribution A partial judgment of $50k is awarded to three parties, but one party's share must be reduced by a mandatory 15% deduction. The MCP runs the calculation instantly, giving the exact final amount for all three. ### Complex Claim Weighting The agent needs to model a scenario with four parties and uneven claim weights (A=3, B=2, C=1, D=1) on a $100k award. This MCP handles the non-linear proportional distribution effortlessly. ## Benefits - Stops rounding errors. The engine performs high-precision decimal math, guaranteeing the total always reconciles perfectly across all parties and deductions. - Handles complexity in one step. You don't need multiple scripts to manage co-plaintiff weights plus fee splits; this MCP handles it all. - Auditability built in. Every calculation is deterministic, producing a clear breakdown that can stand up to scrutiny from opposing counsel or financial reviewers. - Flexibility for fees. It calculates and deducts various types of attorney fees—from standard retainers to sucumbência—before distributing the remainder. - Speed up modeling. Instead of manually adjusting formulas in Excel, your agent sends the data directly to this MCP for instant, accurate results. ## How It Works The bottom line is you get an auditable settlement math package that accounts for every dollar without rounding errors. 1. Provide the MCP with the total judicial award amount and all relevant claim weights or percentages. 2. Specify any deductions needed, like attorney fees, and how those fees must be split among law firms or parties. 3. The engine performs deterministic weighted division and returns a fully accounted distribution breakdown. ## Frequently Asked Questions **How does the Legal Fees Apportionment Engine handle co-plaintiff weights?** It handles weighted claims by allowing you to specify a ratio (e.g., 3:2:1). It ensures that distribution is proportional, not merely equal. **Can the Legal Fees Apportionment Engine split funds if fees are deducted first?** Yes, it calculates and deducts specified attorney fees before performing the final proportionate split of the remaining award amount. **What kind of math does the Legal Fees Apportionment Engine use?** It uses deterministic weighted division with high-precision decimal output. It avoids the common rounding errors found in standard calculators or basic scripting. **Is the Legal Fees Apportionment Engine useful for general budgeting?** No. This MCP is specialized for legal finance, handling complex claims weights and specific fee types like sucumbência, not general operational budgets. **What data structure does `apportion_legal_fees` require for inputs?** The tool requires three primary structured inputs: the total judicial award amount, the total percentage of fees to deduct, and a list of parties along with their specific claim weights. This required format ensures the calculation is deterministic and accounts for every variable precisely. **How does the Legal Fees Apportionment Engine handle invalid or conflicting data?** If inputs fail validation—for instance, if a party weight is zero or the total award is negative—the engine stops immediately. It returns a structured error message detailing the exact point of failure, preventing any inaccurate results from being generated. **Are there rate limits when calling `apportion_legal_fees`?** Usage adheres to standard Vinkius Marketplace API rate limits. For high-volume tasks or continuous processing across many records, you should check your subscription tier for dedicated throughput guarantees. **What types of AI clients support the Legal Fees Apportionment Engine?** The engine uses the Model Context Protocol (MCP), making it compatible with any MCP-enabled client. You can connect it through your agent, whether that's in VS Code, Claude, or another dedicated workflow tool. **Does it handle unequal weights?** Yes. Each party can have a custom weight. The engine computes exact ratios based on the total sum of all weights, ensuring mathematically perfect proportional distribution. **How precise is the rounding?** The engine calculates ratios to 6 decimal places internally and outputs currency amounts rounded to exactly 2 decimal places, matching court-standard precision. **Can I deduct fees before splitting?** Absolutely. You specify the fee percentage and the engine automatically separates the fee amount from the net award before distributing among parties.