# Security Deposit Deductor MCP for AI Agents AI Agent Connect

> Security Deposit Deductor helps landlords calculate exact refund amounts by itemizing repair costs. It checks if damages are valid, summarizes totals, and ensures you don't over-deduct from a tenant's deposit. Use it to stay compliant and avoid disputes during move-outs by generating a clear audit trail of every deduction.

## Overview
- **Category:** finance
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_s4wp7XWgxfucQE7ck20gOEDGseqZwejxWLYXuURV/ai-agent-connect
- **Tags:** landlord, tenant, security-deposit, rental-agreement, deductions

## Description

The Security Deposit Deductor MCP helps landlords calculate the remaining balance of a security deposit after deducting verified repair costs. Managing a move-out is usually a headache of spreadsheets and arguing over who's responsible for what. You need to know exactly what to take out of a security deposit without overstepping or making a math error that could lead to a legal mess. This Connector takes that weight off your shoulders. Instead of squinting at a pile of repair invoices, you can have your AI client walk through the damage list with you. It checks if each repair entry actually has the info you need to justify the cost, summarizes the total damage, and then does the math to see what's left for the tenant. It's like having a property management clerk who never misses a decimal point. By using this through the Vinkius catalog, you turn a messy manual process into a clear, itemized audit trail. You get a final number that's backed by logic, making it much easier to send that final statement and move on to the next unit.

## Tools

### calculate_final_refund
Calculates the exact amount to return to a tenant after all valid deductions are subtracted. This ensures you stay within the original deposit limit.

### get_damage_summary
Lists all identified damages and flags if the total cost goes over the deposit limit. This provides a clear overview of the move-out costs.

### verify_damage_validity
Checks if a specific repair entry contains all the necessary details to be considered actionable. This helps prevent disputes over vague damage claims.

## Prompt Examples

**Prompt:** 
```
I have a $1,500 deposit. The damages are a broken door ($400), a stained rug ($200), and a cracked window ($300). How much is the refund?
```

**Response:** 
```
Here is the refund breakdown for the $1,500 deposit:

* **Total Damages:** $900
* **Items:**
    * Broken door: $400
    * Stained rug: $200
    * Cracked window: $300
* **Final Refund:** **$600**
```

**Prompt:** 
```
Can I deduct $600 for 'general cleaning' from a $1,000 deposit?
```

**Response:** 
```
You should verify if 'general cleaning' is a valid, actionable repair entry. Using the verification step, we can check if you have specific photos or a quote. If it's just a general charge without specific evidence, it might be harder to justify if the tenant disputes it.
```

**Prompt:** 
```
The total repair costs for Unit 4B are $1,100, but the deposit was only $1,000. What happens?
```

**Response:** 
```
Since the repair costs exceed the deposit:

* **Deposit Amount:** $1,000
* **Total Damage Costs:** $1,100
* **Amount to Deduct:** $1,000 (Capped at deposit limit)
* **Final Refund:** **$0**
```

## Capabilities

### Check repair detail validity
The agent confirms if a damage entry has enough specific info to be actionable.

### Summarize total damage costs
It compiles all identified repairs into a single clear list for the unit.

### Flag deposit overages
The agent identifies if the total repair costs exceed the initial deposit amount.

### Calculate final refund amounts
It determines the exact dollar amount to return to the tenant after deductions.

### Prevent negative cost errors
It ensures repair costs are non-negative numbers before they hit the final total.

## Use Cases

### Handling damages that exceed the deposit
A landlord has a $1,200 deposit and $1,300 in damages. The agent uses get_damage_summary to show the overage and then calculate_final_refund to cap the deduction at the deposit limit.

### Verifying vague repair claims
A tenant claims a carpet stain was pre-existing. The landlord uses verify_damage_validity to see if the repair entry has enough photos or notes to hold up in a dispute.

### Processing high-volume turnovers
A property manager is processing 10 move-outs in one day. They feed the damage lists to the agent to get a batch of final refund totals quickly.

### Catching data entry errors
A repair bill comes in with a negative number by mistake. The agent catches this using verify_damage_validity before it messes up the final math.

## Benefits

- Avoid over-deducting from deposits by using get_damage_summary to see if costs exceed the initial amount.
- Keep your records clean by using verify_damage_validity to ensure every repair entry is actually usable.
- Cut down on move-out paperwork by having your agent calculate the final refund automatically.
- Reduce tenant disputes by providing a clear, itemized list of damages instead of a single lump sum.
- Prevent math errors during high-volume turnovers by letting the Connector handle the final balance calculation.

## How It Works

The bottom line is you get a precise, itemized refund amount that protects you from over-deducting.

1. Provide the damage list and the total deposit amount to your agent.
2. Ask the agent to verify the validity of each repair entry.
3. Request the final refund calculation and an itemized summary.

## Frequently Asked Questions

**Can the Security Deposit Deductor help me avoid legal issues with tenants?**
Yes, it helps by creating an itemized audit trail. By verifying each repair entry and capping deductions at the deposit limit, you have a clear record to show tenants if a dispute arises.

**How does the Security Deposit Deductor handle damages that cost more than the deposit?**
It automatically identifies when costs exceed the deposit. It then calculates the maximum allowable deduction so you don't accidentally try to charge a tenant more than they paid.

**Can I use the Security Deposit Deductor to verify if my repair notes are detailed enough?**
Yes, you can use it to check each repair entry. It ensures you have the necessary information to justify the cost before you include it in the final refund calculation.

**Does the Security Deposit Deductor do the math for me automatically?**
It does. Once you provide the damage list and the deposit amount, it performs all the subtractions and provides the final refund number in one step.

**Can the Security Deposit Deductor help me with high-volume property management?**
It's designed for that. It allows you to quickly process multiple move-out lists, ensuring each one is calculated accurately and consistently without manual math errors.

**How does the Security Deposit Deductor create an itemized refund list?**
It takes your raw damage data and organizes it into a clear summary. This summary shows each individual repair cost, the total, and the final refund amount for the tenant.

**How does the tool calculate deductions?**
It sums all repair costs and subtracts them from the deposit, ensuring the deduction doesn't exceed the original amount.

**Can I verify a single damage entry?**
Yes, use `verify_damage_validity` to check if a description and cost are valid.

**What happens if damages exceed the deposit?**
The tool identifies that costs are over the deposit and calculates a refund of zero.