Click on "Deploy 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., "@Personal Expense Tracker Add a $12.50 lunch expense for today and summarize my food spending this week"
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.
A simple expense tracking API built with FastAPI, SQLite, and FastMCP.
The project lets you add expenses, view them by date range, and get a quick summary of spending by category.
Add a new expense
Store expenses in SQLite
Filter expenses by date range
Get spending totals by category
Optional category filtering for summaries
Expose the FastAPI app through an MCP server
Related MCP server: Expense Tracker MCP Server
Python 3.12+
FastAPI
SQLite
Pydantic
FastMCP
uv
PersonalExpenseTracker/
│
├── main.py # FastAPI application and API routes
├── server.py # FastMCP server
├── categories.json # Expense categories
├── pyproject.toml # Project configuration
├── uv.lock # Locked dependencies
├── .gitignore
└── README.mdClone the repository:
git clone https://github.com/bhuvpal/PersonalExpenseTracker.git
cd PersonalExpenseTrackerInstall dependencies:
uv syncRun the FastAPI server:
uv run uvicorn main:app --reloadThe API will be available at:
http://127.0.0.1:8000FastAPI also provides interactive API documentation at:
http://127.0.0.1:8000/docsMethod | Endpoint | Purpose |
GET |
| Check if the API is running |
POST |
| Add an expense |
GET |
| Get expenses for a date range |
GET |
| Get spending summary by category |
{
"amount": 250,
"date": "2026-09-04",
"category": "Food",
"sub_category": "Lunch",
"note": "Lunch with friends"
}The project also includes a FastMCP server that exposes the FastAPI application for MCP-based usage.
Run it with:
uv run python server.pyExpenses are stored locally in a SQLite database.
Each expense contains:
Amount
Date
Category
Sub-category
Note
I built this project to practice building APIs with FastAPI and explore how existing APIs can be exposed through Model Context Protocol (MCP).
Bhuv Pal
GitHub: @bhuvpal
Add an expense to the database.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | ||
| note | No | ||
| amount | Yes | ||
| category | Yes | ||
| sub_category | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It implies a write/mutation but discloses nothing about required permissions, duplicate handling, validation rules, or side effects such as whether the expense is immediately persisted or visible to other users.
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 single sentence is front-loaded and free of padding, but its brevity reflects under-specification rather than economy. It is appropriately sized for what little it attempts to say.
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?
An output schema exists, so return values need not be explained here, but for a five-parameter mutation with no annotations and 0% schema coverage the description leaves the agent without the field-level or behavioral information needed to call it correctly.
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?
Schema description coverage is 0% with five parameters (amount, date, category, note, sub_category) and the description mentions none of them. No format hints are given for date, no currency/unit hint for amount, and no allowed values for category, leaving every parameter undocumented in both the schema and the description.
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?
It states a clear verb and resource (add an expense), so the basic operation is unambiguous and it does not overlap with the list/summarize siblings. However, it adds nothing beyond what the tool name already conveys and gives no sense of scope, such as what constitutes a valid expense or which fields are needed.
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?
There is no guidance on when to use this tool, when not to, or how it relates to the sibling tools list_expenses and summarize_expenses. The agent must infer usage entirely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Home
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing. There is no indication of what the operation does, whether it mutates state, what it returns, or any side effects.
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 a single word with no structure or front-loaded information. This is under-specification rather than conciseness, since no substance exists to be concise about.
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 tool with no annotations, no parameters, no output schema, and no surrounding explanation, the description is completely inadequate. An agent has no basis to decide whether or how to invoke it.
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 takes zero parameters and the schema is empty, so there is nothing to document and no parameter semantics to compensate for. Baseline for a zero-parameter tool 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?
Tautological: description restates name/title.
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?
There is no guidance whatsoever on when to use this tool, when not to, or which sibling to prefer. Given siblings like list_expenses_expenses_get and add_expense_expenses_post, the absence of routing information is a serious gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all expenses in the database.
| Name | Required | Description | Default |
|---|---|---|---|
| end_date | Yes | ||
| start_date | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about read-only semantics, pagination, result ordering, or how the required date window bounds the results. The only behavioral message ('all expenses') actively misleads about filtering.
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?
One short, front-loaded sentence with no wasted clauses, so it is structurally clean, but its brevity comes at the cost of under-specification rather than efficiency.
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?
An output schema exists, so return values need not be explained, but the description leaves two required, undocumented date parameters and the absence of any annotation coverage unaddressed. For a two-required-parameter query tool this is not sufficient to call it correctly.
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?
Both parameters are required and schema description coverage is 0%, so the description is the only place their meaning could be conveyed. Instead it never mentions start_date or end_date and claims to return 'all' expenses, which contradicts the mandatory date-range constraint.
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 states a clear verb ('List') and resource ('expenses'), but 'in the database' adds no scope information and the phrase 'all expenses' conflicts with the tool's required start_date/end_date filtering. It also does nothing to distinguish this tool from the sibling summarize_expenses_expenses_summarize_get.
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?
There is no when-to-use guidance, no mention of the date range that the tool requires, and no routing to or away from the siblings add_expense or summarize_expenses. The agent must infer everything from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Summarize expenses by category.
| Name | Required | Description | Default |
|---|---|---|---|
| category | No | ||
| end_date | Yes | ||
| start_date | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden, and it says almost nothing. It does not disclose whether this is a read-only aggregation, how dates bound the result, whether zero-expense categories appear, or what permissions are needed. The only behavioral hint is the 'by category' grouping.
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 single sentence is front-loaded and free of filler, so it is concise. But at this length it is under-specified rather than efficient, so it earns only a middling score.
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?
An output schema exists, so return values need not be documented. Everything else is missing: no annotations, three undocumented parameters, no usage context, and no distinction from the sibling list tool, leaving the agent with little to call this correctly.
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?
Schema description coverage is 0%, so the description must compensate and largely does not. It names 'category' but leaves its semantics unresolved (filter vs. grouping key) and says nothing about the required start_date/end_date formats or whether the range is inclusive.
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 verb 'Summarize' and resource 'expenses' are clear, and 'by category' hints at grouping. However, it is ambiguous whether the 'category' parameter filters the data or is the grouping dimension, and it never contrasts itself with the sibling list_expenses_expenses_get, which is the obvious alternative for raw data.
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?
There is no when-to-use guidance, no mention of alternatives such as list_expenses_expenses_get, and no prerequisites stated. The agent must infer that this is the aggregated-view counterpart to the list tool purely from the name.
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.
v0.1.0add_expense_expenses_posthomelist_expenses_expenses_getsummarize_expenses_expenses_summarize_getScored across 4 tools
The three core tools (list, add, summarize expenses) target clearly distinct operations. However, the fourth tool 'home' has a vague description that gives no indication of what it does, creating one point of ambiguity.
The three expense tools use verbose auto-generated route-style names with redundant doubled segments and HTTP-method suffixes (e.g. list_expenses_expenses_get), while 'home' follows no pattern at all. The conventions are mixed and unpredictable.
Four tools is on the thin side for an expense tracker, and one of them ('home') appears to be a non-functional placeholder rather than a real capability. The count is borderline but not egregious.
The surface only supports create, list, and summarize; there is no update or delete for expenses, and no filtering or retrieval of a single expense. These are significant lifecycle gaps for an expense tracker.
Log, query, and edit expenses, budgets, and accounts in Manilo from any MCP-compatible AI assistant.
Log, query, and edit expenses, budgets, and accounts in Manilo (formerly Ledgy) from any MCP-compatible AI assistant.
Log, query, and edit expenses, budgets, and accounts in Ledgy from any MCP-compatible AI assistant.
Corporate travel booking and expense management for TripGain, exposed as an MCP server.
