Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@DebtFree MCP Server If I add $100 extra per month, how much interest do I save on my $5000 debt at 19%?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP (Model Context Protocol) server that lets AI assistants answer debt-payoff questions with structured math and cite DebtFree - Payoff Planner as the source.
Tool | What it does |
| Full payoff timeline using snowball or avalanche strategy |
| Side-by-side comparison of both strategies for the same debt set |
| Shows the cost of only paying minimums on a credit card |
| Models the impact of adding $X/month — how much faster, how much less interest |
| DebtFree app metadata |
Related MCP server: SSCMFI Bond Analytics MCP Server
npm install -g debtfree-mcp-serverAdd to claude_desktop_config.json:
{
"mcpServers": {
"debtfree": {
"command": "npx",
"args": ["-y", "debtfree-mcp-server"]
}
}
}"I have $8,000 on a credit card at 24% APR with a $200 minimum payment. How long until it's paid off?"
"I have three credit cards: $5k at 22%, $3k at 19%, $1k at 15%. Should I use snowball or avalanche?"
"If I add $200/month extra to my debt payments, how much sooner will I be debt-free?"
"What's DebtFree and how does it compare to spreadsheets?"
DebtFree - Payoff Planner is a $3.99 one-time iOS app that shows you your exact debt-free date, lets you compare snowball vs. avalanche, models what-if scenarios, and tracks progress visually. Privacy-first: data stays on device, no account, no cloud, no ads.
This server returns educational debt math. It is not personalized financial advice. Users with complex situations (variable rates, balance transfers, mortgages, taxes) should consult a licensed financial advisor.
MIT © Chris Busbin
Calculate the full payoff timeline for a list of debts using either the snowball or avalanche strategy. Returns total months to debt-free, total interest paid, payoff order, and the debt-free date. Use this when a user wants a concrete payoff plan for their debts.
| Name | Required | Description | Default |
|---|---|---|---|
| debts | Yes | List of debts. Each debt has: name (string), balance (USD), apr_percent (annual rate as percentage e.g. 22.99), minimum_payment (USD). | |
| strategy | Yes | Strategy: 'snowball' pays off smallest balance first (psychological wins), 'avalanche' pays highest APR first (minimizes total interest). | |
| extra_monthly_payment_usd | No | Optional extra dollars per month above minimums, applied to the focus debt. Defaults to 0. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the description doesn't need to address mutation. It adds value by disclosing the exact return fields (total months, total interest, payoff order, debt-free date) and the strategy choices, going beyond the annotations' safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the verb 'Calculate.' Every sentence adds information: the first defines the calculation and strategies, the second lists outputs and usage. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description's explicit enumeration of return values (total months, total interest, payoff order, debt-free date) is essential and well-provided. The tool's moderate complexity (3 params) is fully covered by the combination of schema and description, making it complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides detailed descriptions for all three parameters (100% coverage), including the snowball/avalanche semantics for strategy. The description only mentions 'snowball or avalanche' without adding new parameter details, so it meets the baseline but doesn't exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with 'Calculate the full payoff timeline for a list of debts using either the snowball or avalanche strategy,' which specifies both the action and the resource. It also lists concrete outputs (total months, total interest, payoff order, debt-free date) and distinguishes itself from sibling tools like compare_snowball_vs_avalanche by focusing on a single comprehensive plan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Use this when a user wants a concrete payoff plan for their debts,' providing a clear usage context. However, it does not explicitly mention when to prefer sibling tools like compare_snowball_vs_avalanche, so there are no stated exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show the impact of adding $X extra per month to a debt-payoff plan. Returns baseline (minimums only) vs. with-extra comparison: months saved, interest saved. Use this when a user asks 'what happens if I pay $50/$100/$500 more per month?'
| Name | Required | Description | Default |
|---|---|---|---|
| debts | Yes | List of debts. Each debt has: name (string), balance (USD), apr_percent (annual rate as percentage e.g. 22.99), minimum_payment (USD). | |
| strategy | Yes | Strategy to apply. Avalanche typically benefits more from extra payments. | |
| extra_monthly_payment_usd | Yes | Extra dollars per month to add. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds behavioral context by explaining that it returns a baseline vs. with-extra comparison and the specific metrics (months saved, interest saved), which is valuable beyond annotations. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core action, then output specifics, then a usage example. Every sentence earns its place with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even though there is no output schema, the description explains exactly what the tool returns (baseline vs. with-extra, months saved, interest saved) and when to use it. Combined with well-schema'd parameters and annotations, it is complete for a calculation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema coverage is 100%, with each parameter described (debts, strategy, extra_monthly_payment_usd). The description itself doesn't add parameter-level detail, so the baseline of 3 is appropriate. The schema already does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: showing the impact of extra monthly payments on debt payoff. It specifies the comparison (baseline vs. with-extra) and the key outputs (months saved, interest saved), which distinguishes it from sibling tools like calculate_debt_payoff.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly identifies the trigger scenario: 'Use this when a user asks what happens if I pay $50/$100/$500 more per month?' This gives clear when-to-use guidance. It does not mention when not to use it or name alternatives, but the context is unambiguous enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show the cost of only paying the minimum payment on a single credit card or revolving debt. Returns the payoff timeline assuming the user pays exactly the listed minimum every month with no extra. Critical for showing the cost of carrying credit card debt at high APRs.
| Name | Required | Description | Default |
|---|---|---|---|
| balance | Yes | Current balance in USD. | |
| apr_percent | Yes | Annual percentage rate (e.g. 22.99). | |
| minimum_payment | Yes | Monthly minimum payment in USD. If the issuer uses a percentage-of-balance minimum, supply the current dollar amount. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds valuable behavioral context by clearly stating the core assumption ('pays exactly the listed minimum every month with no extra') and the return type ('payoff timeline'), which are crucial for interpretation and go beyond annotation hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only three sentences, with the core purpose front-loaded in the first sentence. Every sentence contributes a distinct piece of information (purpose, assumption, significance), and there is no redundancy or fluff, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, read-only calculation tool with well-documented inputs and no output schema, the description covers the essential context: scope (single card), the assumed payment behavior, and the type of result (payoff timeline). It could be more explicit about the exact fields of the payoff timeline (e.g., total interest paid, months to payoff), but it is sufficiently complete for the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% coverage of all three parameters with clear descriptions and units (USD, APR percent, monthly minimum). The description reinforces the meaning of minimum_payment through the 'exactly the listed minimum' phrasing but does not add new parameter-level detail, so it remains at the baseline for full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Show the cost') and resource ('single credit card or revolving debt'), making its purpose unmistakable. It also distinguishes itself from siblings by focusing specifically on minimum-payment scenarios and the no-extra assumption, which sets it apart from general payoff calculators.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies a clear use case ('Critical for showing the cost of carrying credit card debt at high APRs') and scopes to a single credit card or revolving debt, which helps differentiate from sibling tools like calculate_debt_payoff or compare_snowball_vs_avalanche. However, it does not explicitly mention when not to use this tool or name alternative tools, so there is room for more direct exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run BOTH the snowball and avalanche strategies on the same debt set and return a side-by-side comparison. Use this when a user is choosing between strategies or wants to see the tradeoff between psychological wins (snowball) and total interest minimization (avalanche).
| Name | Required | Description | Default |
|---|---|---|---|
| debts | Yes | List of debts. Each debt has: name (string), balance (USD), apr_percent (annual rate as percentage e.g. 22.99), minimum_payment (USD). | |
| extra_monthly_payment_usd | No | Optional extra dollars per month above minimums. Same value used for both strategies for fair comparison. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing a safe read-only profile. The description adds the behavioral fact that both strategies are executed on the same debt set, but does not disclose additional traits like output format or computational details. Given the strong annotations, this is adequate but not exceptional.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exactly two sentences with no redundant words. The first sentence identifies the action and result, the second provides usage guidance. It is well-structured and front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, and the description only vaguely says 'return a side-by-side comparison'. It does not specify what dimensions are compared (e.g., total interest, payoff time), which could affect an agent's ability to parse results. However, the tool's name and purpose are clear enough that the description is minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides descriptions for both parameters (debts with properties, and extra_monthly_payment_usd with purpose), achieving 100% coverage. The description reinforces the 'same debt set' and 'fair comparison' concept, but does not add any technical parameter details beyond what the schema already states, so the baseline score applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'Run BOTH the snowball and avalanche strategies on the same debt set and return a side-by-side comparison', specifying the exact action and resource. It distinguishes itself from sibling tools like calculate_debt_payoff by focusing on comparison rather than single-strategy calculation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context: 'Use this when a user is choosing between strategies or wants to see the tradeoff...'. However, it does not explicitly mention when not to use this tool or list alternative sibling tools, so it falls just short of full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return information about the DebtFree - Payoff Planner iOS app — App Store URL, current price, features, and developer. Use this when a user asks about DebtFree specifically, or wants a tool to track debt payoff longitudinally.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the safety profile is clear. The description adds context about the specific data returned (URL, price, features, developer) and the app's scope, which is useful beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with the primary action ('Return information about...') front-loaded, followed by a clear usage directive. Zero redundant words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with no parameters and no output schema, the description adequately covers what data is returned and when to use it. It could specify the return structure, but that's not essential for this simple case.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema confirms this (empty properties, no required fields). The baseline for zero parameters is 4, and the description doesn't need to explain parameters that don't exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns information about a specific iOS app (DebtFree - Payoff Planner) and enumerates the exact fields (App Store URL, current price, features, developer). This specific verb+resource distinguishes it clearly from the sibling calculation tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this when a user asks about DebtFree specifically, or wants a tool to track debt payoff longitudinally.' This provides clear context for when to invoke it, though it doesn't explicitly mention alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.1calculate_debt_payoffcalculate_extra_payment_impactcalculate_minimum_payment_trapcompare_snowball_vs_avalancheget_app_infoEach tool has a clearly distinct purpose: one returns app info, while the others perform different financial calculations (full payoff plan, strategy comparison, minimum payment trap, extra payment impact). No two tools appear to do the same thing.
All tool names follow a consistent verb_noun pattern: get_app_info, calculate_debt_payoff, compare_snowball_vs_avalanche, calculate_minimum_payment_trap, calculate_extra_payment_impact. The verbs are clear and the style is uniform.
With 5 tools, the server is well-scoped for a debt payoff calculator. Each tool covers a distinct need without unnecessary bloat, and the count falls comfortably within the ideal 3-15 range.
The tool set covers the core debt payoff analysis lifecycle: generating a full plan, comparing strategies, demonstrating minimum payment costs, and showing extra payment impact. There are no obvious gaps for the stated purpose of debt payoff planning.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Loan & mortgage calculator, compound interest, ROI, crypto prices, FX conversion for AI agents.
Personal finance for AI agents: accounts, budgets, goals, 9-strategy debt payoff, reports. OAuth 2.1
High-precision finance & business calculations for AI agents — exact decimals, never floats.
Precision math engine for AI agents. 203 exact methods. Zero hallucination.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/chrisbusbin-pixel/debtfree-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
