Skip to main content
Glama
Personal Finance MCP

Personal Finance MCP

๐Ÿ’ฐ Personal Finance MCP

Deterministic personal-finance toolkit exposed over the Model Context Protocol โ€” 77 calculators, a meta-advisor, and live market data, with a polished web UI. Grounded in established financial mathematics.

Python 3.10+ MCP Tests License: MIT Live on Hugging Face

Live demo: https://sarveshtalele-personal-finance-mcp.hf.space Connector URL: https://sarveshtalele-personal-finance-mcp.hf.space/mcp

Demo

Watch the demo

โ–ถ๏ธ Watch the 2-minute demo โ€” plain-language question โ†’ chained tools โ†’ a prioritized plan.

Public demo note: the hosted Space is a shared, best-effort instance (rate-limited, may cold-start after idle). For heavy or private use, run it locally or self-host (see docs/HOW_IT_WORKS.md).


Related MCP server: Financial Modeling Prep MCP Server

Overview

Most finance "assistants" guess at numbers. This one doesn't. It ships 77 deterministic calculators โ€” same inputs, same answer, every time โ€” and lets an LLM route a plain-language question to the right tools. Describe your situation ("I'm 30, earn โ‚น1L/month, want to retire at 60") and the create_financial_plan orchestrator chains the relevant calculators into a single prioritised plan.

It runs three ways from one codebase:

  • As an MCP server โ€” connect it to Claude Desktop, Claude Code, Cursor, or any MCP client.

  • As a website โ€” a Next.js UI with a live calculator, a market dashboard, and a tool catalog.

  • As a hosted connector โ€” deployed to a Hugging Face Docker Space; one URL does all three.

Highlights

  • ๐Ÿ”ข Deterministic โ€” pure math, no model inference for the numbers.

  • ๐Ÿค– Story โ†’ tools โ€” the model maps intent to tools; users never name them.

  • ๐Ÿ‡ฎ๐Ÿ‡ณ Theory-grounded โ€” TVM, debt, PPF/SSY/NSC/EPF, bonds, derivatives, MPT, and more.

  • ๐Ÿ›ฐ๏ธ Live market data โ€” mutual-fund NAVs (AMFI), FX (ECB), equity quotes (Yahoo) โ€” no API keys.

  • ๐Ÿ”’ Hardened โ€” stateless, rate-limited, input-bounded APIs with security headers/CSP.


Tool catalog โ€” 77 tools, 13 categories

Category

Tools

Examples

Time Value of Money

10

future/present value, annuity, perpetuity, EAR, real return

Portfolio Analytics

11

CAPM, Sharpe, Sortino, Treynor, alpha, allocation, rebalancing

Financial Planning

9

net worth, ratios, emergency fund, retirement, education, insurance

Small Savings (India)

9

PPF, SSY, NSC, KVP, SCSS, RD, FD, EPF

Mutual Funds

7

SIP, SWP, lumpsum-vs-SIP, CAGR, NAV, expense-ratio impact

Debt & Loans

6

EMI, amortization, prepayment, consolidation, invest-vs-prepay

Fixed Income

6

bond price, YTM, current yield, duration, convexity, zero-coupon

Derivatives

5

futures fair value, option payoff, put-call parity, Black-Scholes, beta hedge

Equity Valuation

5

DDM, two-stage DDM, P/E, DCF, dividend yield

Live Market Data

4

MF search, live NAV, FX rate, stock/index quote

Cash Flow & Budgeting

3

household cash flow, debt-to-income, contingency fund

Risk Profiling

1

suitability score โ†’ suggested equity/debt split

Advisor

1

create_financial_plan โ€” the story โ†’ plan orchestrator

Browse them all (with live descriptions) at /tools.


Quick start

Use the hosted connector (no install)

Claude Desktop โ€” Settings โ†’ Connectors โ†’ Add custom connector โ†’ paste:

https://sarveshtalele-personal-finance-mcp.hf.space/mcp

Claude Code

claude mcp add --transport http personal-finance https://sarveshtalele-personal-finance-mcp.hf.space/mcp

Cursor / VS Code โ€” add to mcp.json:

{
  "mcpServers": {
    "personal-finance": {
      "url": "https://sarveshtalele-personal-finance-mcp.hf.space/mcp",
      "transport": "http"
    }
  }
}

Install from PyPI (stdio server)

pip install personal-finance-mcp     # or: uvx personal-finance-mcp

Then point Claude Desktop at it:

{
  "mcpServers": {
    "personal-finance": { "command": "uvx", "args": ["personal-finance-mcp"] }
  }
}

Run locally from source

git clone https://github.com/sarveshtalele/personal-finance-mcp.git
cd personal-finance-mcp
pip install -e .

# Option A โ€” classic stdio MCP server (offline, no web)
python -m src

# Option B โ€” unified server: website + /mcp connector + /api  (http://localhost:7860)
cd web && npm install && npm run build && cd ..
python -m src.web

For stdio, point Claude Desktop at the local process:

{
  "mcpServers": {
    "personal-finance": { "command": "python", "args": ["-m", "src"] }
  }
}

The website

python -m src.web serves everything on one port:

Path

What

/

Next.js site โ€” home, tool catalog, live calculator, market dashboard, setup guide

/mcp

MCP server over streamable-HTTP โ€” the connector URL

/api/*

JSON endpoints (tool catalog, calculators, live market data)


Architecture

src/
โ”œโ”€โ”€ server.py            # FastMCP server โ€” registers all tool modules
โ”œโ”€โ”€ __main__.py          # `python -m src`  (stdio transport)
โ”œโ”€โ”€ tools/               # pure math fns + per-module register(mcp)
โ”‚   โ”œโ”€โ”€ tvm.py  debt.py  planning.py  bonds.py  stocks.py  mutual_funds.py
โ”‚   โ”œโ”€โ”€ portfolio.py  derivatives.py  india_savings.py  cashflow.py
โ”‚   โ”œโ”€โ”€ risk_profile.py  advisor.py   # advisor = story โ†’ plan orchestrator
โ”‚   โ””โ”€โ”€ marketdata.py    # live AMFI / Frankfurter / Yahoo (keyless)
โ”œโ”€โ”€ models/              # Pydantic schemas + enums
โ”œโ”€โ”€ utils/               # output formatters
โ””โ”€โ”€ web/                 # unified Starlette server (MCP + /api + static site)
    โ”œโ”€โ”€ server.py        # routes, security middleware, calculator registry
    โ””โ”€โ”€ __main__.py      # `python -m src.web`  (uvicorn, port 7860)

web/                     # Next.js front-end (static export โ†’ web/out)
โ””โ”€โ”€ app/                 # home, tools, calculator, dashboard, connect

Each tool file keeps deterministic pure functions separate from the thin @mcp.tool wrappers, so the same functions power the MCP server, the web calculators, and the tests.


Security

  • Stateless โ€” no database, no sessions; every call is independent and reproducible.

  • Hardened API โ€” per-IP rate limiting, request-body cap, and input validation that bounds loop-driving parameters (years/months/age) to prevent denial-of-service.

  • Security headers โ€” CSP (with frame-ancestors for the Hugging Face embed), X-Content-Type-Options, Referrer-Policy, Permissions-Policy; CORS limited to GET/POST without credentials. The header middleware is implemented at the ASGI layer so it never buffers the streaming /mcp (SSE) responses.

  • No secrets in the app โ€” live-data sources are public and keyless.

See SECURITY.md to report a vulnerability.


Development

pip install -e ".[dev]"
pytest -q                       # 119 tests
ruff check .                    # lint
python -m src.web               # run the full stack locally

Deployment

Deployed as a Hugging Face Docker Space, auto-synced from GitHub on every push to main (see .github/workflows/hf-sync.yml). Full instructions โ€” local, Docker, and Hugging Face โ€” are in docs/deployment.md.


Documentation

Contributing

Contributions are welcome โ€” see CONTRIBUTING.md and the Code of Conduct. Good first issues: add a calculator (a pure function + a register wrapper + a test), improve descriptions for better tool routing, or extend the web UI.


Disclaimer

Educational tool for illustrating standard financial formulas. Not investment advice. Figures are illustrative; verify before making financial decisions.

License

MIT โ€” free to use, modify, and distribute.

Available Tools

77 tools
analyze_budgetC

Analyze household budget using the 50/30/20 rule. 50% Needs | 30% Wants | 20% Savings. expenses_json: {"rent": 20000, "food": 10000, "entertainment": 5000}

Inputs: expenses_json (required), monthly_income (required), existing_emis, existing_sips. Returns: result

analyze_cash_flowA

Household cash-flow analysis: monthly surplus, savings rate, expense ratio. Use when a user describes their income and spending and asks 'how am I doing', 'how much can I save/invest', or wants a budget health check.

Inputs: fixed_expenses (required), monthly_income (required), variable_expenses (required), emi. Returns: result

analyze_debt_consolidationB

Analyze if consolidating multiple debts into one loan makes sense. Input debts_json: [{"name": "Credit Card", "balance": 100000, "rate": 36, "emi": 5000}]

Inputs: debts_json (required), consolidated_rate (required), consolidated_tenure_years (required). Returns: result

analyze_expense_ratio_impactB

Show how expense ratio eats into your mutual fund returns over time. Optionally compare two funds with different expense ratios.

Inputs: years (required), annual_return (required), expense_ratio (required), investment_amount (required), +1 more. Returns: result

analyze_financial_ratiosC

Calculate all key financial health ratios: Savings ratio, Debt-to-Income, Liquidity ratio, Solvency ratio, Expense ratio. Includes assessments and benchmarks.

Inputs: monthly_emis (required), total_assets (required), liquid_assets (required), monthly_income (required), +3 more. Returns: result

analyze_two_asset_portfolioC

Analyze a two-asset portfolio โ€” return, risk, and minimum variance weights. Also finds the optimal minimum variance portfolio allocation.

Inputs: correlation (required), risk_asset1 (required), risk_asset2 (required), return_asset1 (required), +2 more. Returns: result

assess_risk_profileA

Determine an investor's risk profile (conservativeโ†’aggressive) and a suggested equity/debt split from age, horizon, income stability, knowledge, and reaction to losses. Use when a user asks 'what kind of investor am I', 'how much risk should I take', or before recommending an asset allocation. Scales 1-5 for income_stability, investment_knowledge, loss_reaction.

Inputs: age (required), horizon_years (required), dependents, loss_reaction, +2 more. Returns: result

calculate_annuity_fvB

Calculate Future Value of regular periodic payments (annuity/SIP). Ordinary annuity: payments at end of period. Due: at beginning.

Inputs: years (required), payment (required), annual_rate (required), frequency, +1 more. Returns: result

calculate_annuity_pvB

Calculate Present Value of regular periodic payments. Useful for valuing loan payments, pension, lease payments.

Inputs: years (required), payment (required), annual_rate (required), frequency, +1 more. Returns: result

calculate_black_scholesA

Theoretical European option price (Black-Scholes) and delta. Use for 'what is a fair option premium', option valuation, implied pricing. volatility is annualised in percent (e.g. 20 for 20%).

Inputs: spot (required), years (required), strike (required), volatility (required), +2 more. Returns: result

calculate_bond_convexityB

Calculate bond convexity โ€” second-order measure of interest rate risk. Higher convexity = less price sensitivity to large yield changes.

Inputs: ytm (required), face_value (required), coupon_rate (required), years_to_maturity (required), +1 more. Returns: result

calculate_bond_durationB

Calculate Macaulay Duration and Modified Duration. Duration measures interest rate sensitivity of a bond. Modified Duration shows % price change per 1% yield change.

Inputs: ytm (required), face_value (required), coupon_rate (required), years_to_maturity (required), +1 more. Returns: result

calculate_bond_priceA

Calculate bond price using DCF of coupon payments and face value. Price = ฮฃ[C/(1+r)^t] + FV/(1+r)^n. coupon_frequency: 1=annual, 2=semi-annual, 4=quarterly.

Inputs: ytm (required), face_value (required), coupon_rate (required), years_to_maturity (required), +1 more. Returns: result

calculate_cagrB

Calculate CAGR (Compound Annual Growth Rate). CAGR = (End/Start)^(1/n) - 1. Standard measure for investment returns.

Inputs: years (required), end_value (required), start_value (required). Returns: result

calculate_capm_returnA

Calculate expected return using CAPM. E(R) = Rf + ฮฒ ร— (Rm - Rf). Beta < 1: defensive, Beta > 1: aggressive.

Inputs: beta (required), market_return (required), risk_free_rate (required). Returns: result

calculate_contingency_fundA

Contingency / emergency fund target and shortfall. Use for 'how big should my emergency fund be', 'am I covered if I lose my job'. Recommend 3-6 months of expenses (12 if income is irregular).

Inputs: monthly_expenses (required), existing_fund, months_target. Returns: result

calculate_current_yieldA

Calculate Current Yield = Annual Coupon / Market Price ร— 100.

Inputs: market_price (required), annual_coupon (required). Returns: result

calculate_debt_to_incomeB

Debt-to-income (debt servicing) ratio and how much more EMI is prudent. Use for 'can I afford another loan', 'am I over-leveraged', loan eligibility.

Inputs: monthly_income (required), monthly_emi_total (required). Returns: result

calculate_dividend_yieldA

Calculate dividend yield = Annual Dividend / Market Price ร— 100.

Inputs: market_price (required), dividend_per_share (required). Returns: result

calculate_effective_rateB

Calculate Effective Annual Rate from nominal rate. EAR = (1 + r/n)^n - 1. Compare rates with different compounding.

Inputs: nominal_rate (required), compounding. Returns: result

calculate_emergency_fundB

Calculate recommended emergency fund size (3-6 months of expenses). Adjusts for dependents and job stability. job_stability: stable, moderate, unstable.

Inputs: monthly_expenses (required), dependents, monthly_emis, job_stability, +1 more. Returns: result

calculate_emiA

Calculate EMI (Equated Monthly Instalment) for a loan. EMI = P ร— r ร— (1+r)^n / ((1+r)^n - 1). Also shows total interest paid and interest-to-principal ratio.

Inputs: principal (required), annual_rate (required), tenure_years (required). Returns: result

calculate_epfA

EPF (Employees' Provident Fund) retirement corpus with salary growth. Use for 'how big will my EPF/PF be at retirement', employer+employee contributions compounding monthly.

Inputs: monthly_basic (required), years, annual_rate, employee_pct, +2 more. Returns: result

calculate_fixed_depositB

Fixed Deposit (FD) maturity and effective yield. compounding: annually | half_yearly | quarterly | monthly. Use for bank/NBFC FD maturity.

Inputs: years (required), principal (required), annual_rate (required), compounding. Returns: result

calculate_futures_hedgeA

Number of index-futures contracts needed to hedge an equity portfolio. Use for 'how do I protect/hedge my portfolio against a market fall', beta hedging, downside protection. N = (ฮฒ ร— Value) / (Index ร— Lot Size).

Inputs: lot_size (required), index_level (required), portfolio_beta (required), portfolio_value (required). Returns: result

calculate_futures_priceA

Fair value of a futures/forward contract using cost-of-carry. Use when a user asks 'what should the futures/forward price be', about carry, contango/backwardation, or arbitrage-free pricing of index/stock futures. F = Spot ร— e^((r-q)ร—t). Set dividend_yield for stocks/indices.

Inputs: years (required), spot_price (required), annual_rate (required), compounding, +1 more. Returns: result

calculate_future_valueA

Calculate Future Value of a lump sum investment with compounding. FV = PV ร— (1 + r/n)^(nร—t). Use compounding: annually, semi_annually, quarterly, monthly, daily, continuous.

Inputs: years (required), annual_rate (required), present_value (required), compounding. Returns: result

calculate_gratuityA

Calculate gratuity under India's Payment of Gratuity Act, 1972. Use when a user asks about gratuity eligibility or payout at retirement/resignation. Applies to employees with 5+ years of continuous service. Tax-exempt up to โ‚น20,00,000. Formula: Gratuity = (Last Salary ร— 15 ร— Years) / 26

Inputs: tenure_years (required), last_monthly_salary (required). Returns: result

calculate_inflation_impactC

Calculate future cost of something after inflation. Shows how much more you'll need in the future for the same expense.

Inputs: years (required), current_amount (required), inflation_rate (required). Returns: result

calculate_information_ratioB

Calculate Information Ratio = Active Return / Tracking Error. Measures consistency of outperformance vs benchmark.

Inputs: tracking_error (required), benchmark_return (required), portfolio_return (required). Returns: result

calculate_insurance_needA

Calculate life insurance need using Human Life Value (HLV) method. HLV = PV of future earnings + Outstanding loans + Future goals - Existing cover.

Inputs: annual_income (required), years_of_income_to_replace (required), outstanding_loans, existing_insurance, +2 more. Returns: result

calculate_jensens_alphaA

Calculate Jensen's Alpha = Rp - [Rf + ฮฒ(Rm - Rf)]. Measures portfolio manager's skill โ€” excess return over CAPM expectation.

Inputs: beta (required), market_return (required), risk_free_rate (required), portfolio_return (required). Returns: result

calculate_kvpA

KVP (Kisan Vikas Patra) โ€” doubles your money; returns the tenure required at the given interest rate. Use for 'how long to double my money in KVP'.

Inputs: principal (required), annual_rate. Returns: result

calculate_navA

Calculate Mutual Fund NAV (Net Asset Value). NAV = (Total Assets - Total Liabilities) / Units Outstanding.

Inputs: total_assets (required), total_liabilities (required), units_outstanding (required). Returns: result

calculate_net_worthA

Calculate net worth from assets and liabilities. Input JSON maps of name:value pairs. Example assets: {"house": 5000000, "stocks": 200000, "fd": 300000} Example liabilities: {"home_loan": 3000000, "car_loan": 500000}

Inputs: assets_json (required), liabilities_json (required). Returns: result

calculate_nscA

NSC (National Savings Certificate) maturity. Lump-sum, interest reinvested, annual compounding (typically 5-year tenure).

Inputs: principal (required), years, annual_rate. Returns: result

calculate_option_payoffA

Payoff, profit/loss and breakeven of an option leg at expiry. Use for 'if I buy/sell a call/put at strike X for premium Y, what is my P&L if the stock ends at Z', options breakeven, max profit/loss questions. option_type: call|put. position: long|short.

Inputs: strike (required), premium (required), position (required), option_type (required), +1 more. Returns: result

calculate_perpetuityA

Calculate Present Value of perpetuity (infinite periodic payments). Simple: PV = PMT/r. Growing: PV = PMT/(r-g).

Inputs: payment (required), annual_rate (required), growth_rate. Returns: result

calculate_portfolio_returnA

Calculate expected portfolio return. E(Rp) = ฮฃ w_i ร— E(R_i). weights: [0.6, 0.4], returns: [15, 8] (percentages).

Inputs: returns_json (required), weights_json (required). Returns: result

calculate_portfolio_riskC

Calculate portfolio risk (variance and standard deviation). Shows diversification benefit. correlations: NxN matrix, e.g., [[1, 0.3], [0.3, 1]].

Inputs: weights_json (required), std_devs_json (required), correlations_json (required). Returns: result

calculate_ppfA

PPF (Public Provident Fund) maturity value for a fixed yearly deposit. Use for 'how much will my PPF grow to', PPF maturity/corpus, tax-free long-term government savings. Annual compounding over (default) 15 years.

Inputs: annual_deposit (required), years, annual_rate. Returns: result

calculate_prepayment_savingsA

Calculate how much you save by prepaying a loan (extra EMI or lump sum). Shows interest saved and tenure reduction.

Inputs: principal (required), annual_rate (required), tenure_years (required), lump_sum_month, +2 more. Returns: result

calculate_present_valueB

Calculate Present Value โ€” what a future sum is worth today. PV = FV / (1 + r/n)^(nร—t).

Inputs: years (required), annual_rate (required), future_value (required), compounding. Returns: result

calculate_put_call_parityA

Put-call parity: derive the fair call or put price, or detect arbitrage. Provide whichever option price you know; leave the other at -1 to solve it. C - P = S - Kร—e^(-rร—t).

Inputs: spot (required), years (required), strike (required), annual_rate (required), +2 more. Returns: result

calculate_real_returnB

Calculate real (inflation-adjusted) rate of return using Fisher equation. (1 + real) = (1 + nominal) / (1 + inflation).

Inputs: nominal_rate (required), inflation_rate (required). Returns: result

calculate_recurring_depositA

Recurring Deposit (RD) maturity for a fixed monthly deposit, quarterly compounding. Use for 'monthly bank RD maturity / interest'.

Inputs: months (required), annual_rate (required), monthly_deposit (required). Returns: result

calculate_rule_of_72A

Rule of 72: Approximate how many years to double your money. Years โ‰ˆ 72 / annual_rate.

Inputs: annual_rate (required). Returns: result

calculate_savings_neededB

Calculate monthly savings required to reach a financial target. Accounts for existing savings and expected returns.

Inputs: years (required), annual_rate (required), target_amount (required), current_savings. Returns: result

calculate_scssA

SCSS (Senior Citizens Savings Scheme) โ€” quarterly interest income and the principal returned at maturity. Use for retiree regular-income planning.

Inputs: principal (required), years, annual_rate. Returns: result

calculate_sharpe_ratioA

Calculate Sharpe Ratio = (Rp - Rf) / ฯƒp. Measures risk-adjusted return per unit of total risk.

Inputs: risk_free_rate (required), portfolio_return (required), portfolio_std_dev (required). Returns: result

calculate_sip_neededA

Calculate monthly SIP needed to reach a target corpus. Inverse SIP calculation โ€” find the monthly amount for a given goal.

Inputs: years (required), annual_return (required), target_amount (required). Returns: result

calculate_sip_returnsA

Calculate SIP (Systematic Investment Plan) returns. Shows future value, total invested, and wealth gained. Optional step_up_percentage: annual increase in SIP amount (e.g., 10 for 10%).

Inputs: years (required), annual_return (required), monthly_investment (required), step_up_percentage. Returns: result

calculate_sortino_ratioA

Calculate Sortino Ratio = (Rp - Rf) / Downside Deviation. Like Sharpe but only penalizes downside volatility, not upside.

Inputs: risk_free_rate (required), portfolio_return (required), downside_deviation (required). Returns: result

calculate_sukanya_samriddhiA

Sukanya Samriddhi Yojana (SSY) maturity for a girl child. Use for daughter education/marriage savings, SSY corpus. Deposits for 15 years, matures in 21 years, annual compounding.

Inputs: annual_deposit (required), annual_rate, deposit_years, maturity_years. Returns: result

calculate_swpA

Systematic Withdrawal Plan โ€” how long will your corpus last? Calculate sustainability of regular withdrawals from an investment corpus.

Inputs: corpus (required), annual_return (required), monthly_withdrawal (required). Returns: result

calculate_treynor_ratioB

Calculate Treynor Ratio = (Rp - Rf) / ฮฒ. Measures excess return per unit of systematic risk (beta).

Inputs: beta (required), risk_free_rate (required), portfolio_return (required). Returns: result

calculate_ytmC

Calculate Yield to Maturity โ€” the internal rate of return of a bond. Uses Newton-Raphson iteration for precision.

Inputs: face_value (required), coupon_rate (required), market_price (required), years_to_maturity (required), +1 more. Returns: result

calculate_zero_coupon_bondB

Price a zero-coupon bond. Price = FV / (1+r)^n. Zero-coupon bonds pay no periodic interest, sold at discount.

Inputs: ytm (required), face_value (required), years_to_maturity (required). Returns: result

compare_loansA

Compare multiple loan options to find the best deal. Input: JSON array of loans, each with: principal, annual_rate, tenure_years, name. Example: [{"principal": 5000000, "annual_rate": 8.5, "tenure_years": 20, "name": "Bank A"}]

Inputs: loans_json (required). Returns: result

compare_lumpsum_vs_sipA

Compare lump sum investment vs SIP for the same total amount. Lump sum: invest everything today. SIP: spread equally over the period.

Inputs: years (required), total_amount (required), annual_return (required). Returns: result

create_financial_planA

Holistic financial plan from a user's life situation โ€” the best first tool when someone describes their finances in plain language ('I'm 30, earn X, spend Y, have a home loan, want to retire at 60'). It chains net worth, cash flow, emergency fund, debt-to-income, risk profiling and a retirement gap into ONE prioritised action plan, in the canonical financial-planning order (evaluate โ†’ protect โ†’ reduce debt โ†’ profile risk โ†’ invest for goals). Call this to bridge a free-form story to concrete numbers, then drill into specific calculators (SIP, retirement, loans) for detail.

Inputs: age (required), monthly_income (required), monthly_expenses (required), inflation, +7 more. Returns: result

financial_health_checkB

Comprehensive financial health score (0-100) with rating and recommendations. Evaluates: savings ratio, debt levels, emergency fund, net worth, insurance, liquidity, expense ratio, age-appropriate wealth.

Inputs: age (required), monthly_emis (required), total_assets (required), liquid_assets (required), +6 more. Returns: result

get_fx_rateA

Live currency exchange rates (ECB reference, via Frankfurter). Use for 'what's the USD/INR rate', converting amounts, or FX-impact questions. symbols can be comma-separated, e.g. 'INR,EUR,GBP'.

Inputs: base, symbols. Returns: result

get_mutual_fund_navA

Latest live NAV for an AMFI mutual-fund scheme code. Use for 'what's the current NAV of fund X' (first find the code with search_mutual_funds).

Inputs: scheme_code (required). Returns: result

get_stock_quoteA

Live equity/index quote (Yahoo Finance). Use for 'current price/level of X'. Examples: '^NSEI' Nifty 50, '^BSESN' Sensex, 'RELIANCE.NS', 'AAPL'.

Inputs: symbol (required). Returns: result

invest_or_prepay_loanB

Should you invest surplus money or prepay an existing loan? Compares post-tax investment return vs effective loan cost.

Inputs: loan_rate (required), investment_return (required), tax_bracket, loan_has_tax_benefit. Returns: result

loan_amortizationA

Generate loan amortization schedule showing month-wise principal/interest split. Shows how the interest component decreases and principal component increases over time.

Inputs: principal (required), annual_rate (required), tenure_years (required). Returns: result

plan_educationC

Plan for child's education expense. Adjusts cost for education inflation (typically higher than CPI). Calculates monthly SIP needed.

Inputs: child_current_age (required), education_start_age (required), current_education_cost (required), inflation_rate, +2 more. Returns: result

plan_financial_goalA

Plan for a financial goal (education, house, car, wedding, etc.). Adjusts target for inflation, calculates monthly SIP needed.

Inputs: goal_name (required), years_to_goal (required), target_amount_today (required), inflation_rate, +2 more. Returns: result

plan_retirementB

Comprehensive retirement planning calculator. Calculates: corpus needed at retirement, monthly SIP needed, accounts for inflation on expenses and pension shortfall.

Inputs: current_age (required), retirement_age (required), life_expectancy (required), monthly_expenses (required), +5 more. Returns: result

rebalance_portfolioA

Calculate trades needed to rebalance portfolio to target allocation. target_allocation: {"equity": 60, "debt": 30, "gold": 10} (percentages). current_values: {"equity": 700000, "debt": 250000, "gold": 50000} (amounts).

Inputs: current_values_json (required), target_allocation_json (required), additional_investment. Returns: result

search_mutual_fundsA

Search Indian mutual-fund schemes by name (AMFI data) and get their scheme codes. Use when a user names a fund ('Parag Parikh Flexi Cap') and you need its code before fetching the live NAV.

Inputs: query (required), limit. Returns: result

suggest_asset_allocationB

Suggest asset allocation based on age, risk profile, and investment horizon. Uses 100-age equity rule with adjustments. This is the single source of truth for an equity/debt/gold split โ€” assess_risk_profile returns the same numbers. Pass monthly_investment to also get exact per-bucket monthly amounts. risk_profile: conservative, moderately_conservative, moderate, moderately_aggressive, aggressive.

Inputs: age (required), risk_profile (required), investment_horizon_years (required), monthly_investment. Returns: result

value_stock_dcfA

Discounted Cash Flow (DCF) valuation. Input projected Free Cash Flows as JSON array: [100, 120, 140, 160, 180]. EV = ฮฃ[FCF/(1+WACC)^t] + Terminal Value. Equity = EV - Net Debt.

Inputs: wacc (required), terminal_growth (required), free_cash_flows_json (required), net_debt, +1 more. Returns: result

value_stock_ddmB

Value a stock using Gordon Growth Model (Dividend Discount Model). P = D1 / (r - g). For stable, dividend-paying companies. required_return must be > growth_rate.

Inputs: growth_rate (required), required_return (required), current_dividend (required). Returns: result

value_stock_peB

Value stock using P/E ratio relative valuation. Fair Price = EPS ร— Industry P/E. Optionally calculates PEG ratio for growth-adjusted valuation.

Inputs: eps (required), industry_pe (required), company_growth, industry_growth. Returns: result

value_stock_two_stage_ddmA

Two-stage DDM for companies with initial high growth transitioning to stable growth. Stage 1: High growth dividends discounted. Stage 2: Gordon model terminal value.

Inputs: required_return (required), current_dividend (required), high_growth_rate (required), high_growth_years (required), +1 moโ€ฆ Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelogโ€ฆ

    TDQS

    B3.3/5.0

    Scored across 77 tools

    Disambiguation3/5

    Many tools cover similar financial concepts (e.g., calculate_emergency_fund and calculate_contingency_fund, assess_risk_profile and suggest_asset_allocation), causing potential confusion. However, most tools have distinct descriptions that clarify their specific use case.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case (e.g., calculate_future_value, plan_retirement). Verbs are descriptive and the pattern is maintained across all 77 tools.

    Tool Count3/5

    77 tools is high for a single MCP server, covering a vast range of personal finance calculators and metrics. While thorough, the count borders on overwhelming, and some tools are redundant (e.g., duplicate emergency fund tools).

    Completeness4/5

    The tool set covers an extensive range of personal finance domains: time value of money, loans, insurance, retirement, education, mutual funds, stocks, derivatives, and financial health. Minor gaps exist (e.g., tax planning), but the surface is remarkably comprehensive.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI assistants to access and analyze financial data such as stocks, ETFs, crypto, forex, commodities, company fundamentals, financial statements, and market insights through 250+ configurable tools.
      624 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI assistants to query and analyze stocks, ETFs, crypto, forex, commodities, company fundamentals, financial statements, market news, and economic data through 250+ tools, with dynamic, static, or full toolset modes.
      624 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables natural-language financial and market research across SEC filings, earnings transcripts, company financials, stock and crypto market data, and prediction markets, returning structured, source-backed insights. It also exposes live documentation tools and resources for setup, troubleshooting, and workflow discovery.
      MIT
    • A
      license
      Not graded
      quality
      A
      maintenance
      Enables AI assistants to access and analyze financial data through 250+ tools covering stocks, ETFs, crypto, forex, commodities, economics, company fundamentals, statements, metrics, technical indicators, quotes, news, SEC filings, and more. Supports dynamic, static, or full tool loading for flexible integration.
      624 npm
      Apache 2.0