jp-calendar-mcp
This server provides tools for Japanese business day, public holiday, TSE trading calendar, imperial era (wareki) conversion, and tax calculations.
Business Day & Calendar Tools
jp_check_date– Determines if a date is a weekend, public holiday, or business day (holidays 2020‑2031).jp_shift_days– Moves a date forward/backward by business or calendar days, skipping weekends and public holidays.jp_count_days– Counts calendar and business days between two dates.
TSE Trading Calendar
tse_is_trading_day– Checks if Tokyo Stock Exchange is open, providing closure reasons (e.g., year‑end break Dec 31–Jan 3).tse_shift_trading_days– Shifts a date by TSE trading days (e.g., T+2 settlement).tse_count_trading_days– Counts trading sessions between two dates.tse_year_summary– Returns first (大発会) and last (大納会) sessions and total sessions for a year.
Wareki Conversion
jp_to_wareki– Converts Gregorian (YYYY‑MM‑DD) to Japanese era (e.g., 令和元年5月1日).jp_from_wareki– Converts Japanese era (e.g., 昭和50年6月1日) to Gregorian, with warnings for out‑of‑era dates.
Tax Calculations
jp_ideco_tax_saving– Estimates income/residence tax savings from iDeCo contributions.jp_furusato_limit– Computes maximum furusato‑nozei donation limit with ¥2,000 out‑of‑pocket cost.
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., "@jp-calendar-mcp2026年1月9日から営業日で1日後は?"
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.
jp-calendar-mcp
MCP server for Japanese business days, public holidays, the Tokyo Stock Exchange trading calendar, imperial-era (wareki) dates and tax arithmetic. Zero dependencies, runs on plain Node 18+.
AI agents get Japanese dates wrong in specific, repeatable ways: they miss 成人の日 landing on a Monday, they assume the stock exchange follows public holidays, they put the 平成→令和 boundary on the wrong day, and they invent furusato-nozei limits. These are lookup and arithmetic problems, not reasoning problems, so this server answers them exactly.
Tools
Tool | What it answers |
| Is this date a business day? Weekend? Public holiday? |
| "10 business days after 2026-01-09" (skips weekends + holidays) |
| Calendar days and business days between two dates |
| Is the Tokyo Stock Exchange open? With the closure reason |
| "T+2 settlement from 2025-12-30" → 2026-01-06, across the new-year break |
| Sessions between two dates (for annualising returns) |
| Sessions in a year plus its first/last session (大発会 / 大納会) |
| 2019-05-01 → 令和元年5月1日 (era boundaries handled to the day) |
| 昭和50年6月1日 → 1975-06-01, and flags out-of-era input |
| Annual income + residence tax reduction from iDeCo contributions |
| Donation limit that keeps the out-of-pocket cost at ¥2,000 |
Public holidays are bundled for 2020–2031 (generated with the jpholiday library, including substitute holidays and the moving equinox dates). Dates outside that range return a note saying only weekends were excluded — the server never silently guesses.
Related MCP server: shirabe-calendar-api
The exchange calendar is not the holiday calendar
This trips up almost every implementation. TSE closures are a superset of public holidays: the exchange also closes 31 December through 3 January.
2026-01-02 public holiday? NO TSE open? NO (new_year_break)
2026-12-31 a normal work day TSE open? NO (year_end_break)
2026-12-30 a normal work day TSE open? YES (dainokai, last session)Because of that break, the first and last session move every year, and a +1 business day calculation gives the wrong answer for settlement:
Year | First session (大発会) | Last session (大納会) |
2024 | 2024-01-04 | 2024-12-30 |
2025 | 2025-01-06 | 2025-12-30 |
2026 | 2026-01-05 | 2026-12-30 |
All of the above are covered by the test suite as known-answer checks against actual sessions.
Install
git clone https://github.com/takeo628-hub/jp-calendar-mcp.git
cd jp-calendar-mcp
node test.js # 42 known-answer tests, no install step neededClaude Code / Claude Desktop
{
"mcpServers": {
"jp-calendar": {
"command": "node",
"args": ["/absolute/path/to/jp-calendar-mcp/src/index.js"]
}
}
}Examples
> 2026年1月9日から営業日で1日後は?
jp_shift_days(date="2026-01-09", days=1)
→ { "date": "2026-01-13", "weekday": "火", "mode": "business" }
(1/10-11 is a weekend and 1/12 is 成人の日)
> 平成31年4月30日を西暦で
jp_from_wareki(era="平成", era_year=31, month=4, day=30)
→ { "gregorian": "2019-04-30", "matches_era": true }
> 2025年最後の取引日から2営業日後(T+2受渡)
tse_shift_trading_days(date="2025-12-30", days=2)
→ { "date": "2026-01-06", "weekday": "火" }
(12/31-1/3 is the exchange break, so this is not "2 business days")
> 課税所得300万でiDeCo月2.3万の節税額
jp_ideco_tax_saving(monthly_contribution=23000, taxable_income=3000000)
→ { "annual_tax_saving": 55780, "income_tax_rate": 0.1 }Also available as plain JavaScript
import { shiftDays, toWareki } from "jp-calendar-mcp";
shiftDays("2026-01-09", 1); // business days by defaultAccuracy and limits
Holiday and exchange data cover 2020–2031. Outside that window a
noteis returned rather than a guess.The exchange calendar models scheduled closures only. Unscheduled halts (system failures, disasters) are historical events, not rules, and are not included.
Tax tools implement the standard published formulas: iDeCo contributions are fully deductible (income tax including the 2.1% reconstruction surtax, plus 10% residence tax); the furusato limit uses the residence-tax income levy formula. Contribution caps and tax rules change, and individual circumstances vary — verify before acting. This is arithmetic, not tax advice.
Invalid input raises an error rather than returning a plausible-looking wrong answer.
2026-02-30is rejected; an unknown era is rejected; a wareki date outside its era is returned with a warning.
Why it exists
Built by an autonomous AI development loop that publishes everything it does, including its failures: https://takeo628-hub.github.io/autoquant-lab/
License
MIT
Available Tools
7 toolsjp_check_dateA
Check whether a Japanese calendar date is a business day. Returns weekday, weekend/public-holiday flags and a business-day flag. Public holidays are bundled for 2020-2031.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | YYYY-MM-DD |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the available date range for public holidays (2020-2031), which is a significant constraint, and telegraphs the output flags (weekday, weekend/public-holiday, business-day). This goes beyond a simple tautology, though it omits details about out-of-range behavior or error handling.
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 exceptionally concise: two sentences that open with the core action and then immediately list return values and a key limitation. Every clause adds value, no filler or redundancy.
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?
Given the tool's simplicity, the description covers the essential context: purpose, output indicators, and a critical date-range caveat. It does not describe fallback behavior for invalid dates or explain how holidays are calculated, but the core usage is sufficiently clear. Without an output schema, mentioning the flag types compensates well.
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 schema already provides 100% coverage for the single 'date' parameter with format YYYY-MM-DD. The description adds semantic context by specifying it is a Japanese calendar date and implying business-day checks, but does not add new syntactic details. Thus it meets the baseline for well-documented schema parameters.
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 starts with a specific verb 'Check' and identifies the resource as 'whether a Japanese calendar date is a business day', immediately distinguishing it from sibling date tools like jp_shift_days and jp_count_days. It clearly states what outputs are returned, further clarifying its unique role.
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 usage context is implied: if you need to know if a date is a business day or get holiday status, use this tool. However, it does not explicitly mention alternatives or state when not to use it, lacking the comparative guidance found in higher-scoring descriptions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jp_count_daysA
Count calendar days and business days between two dates (Japanese holidays excluded from business days). Order of the two dates does not matter.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | YYYY-MM-DD | |
| start | Yes | YYYY-MM-DD |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that it counts both calendar and business days, excludes Japanese holidays from business days, and is order-insensitive. But it does not specify whether the count is inclusive/exclusive of the endpoints or what the return structure looks like, leaving ambiguity for the agent.
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 sentence that front-loads the main purpose and then adds the key behavior (exclusion of Japanese holidays) and the order-insensitivity note. Every word earned its place, with no fluff or repetition.
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 is simple with fully described parameters, but there is no output schema. The description does not explain the return value format or edge cases (e.g., invalid dates, inclusivity). Given that the description must compensate for the missing output schema, it is not fully complete, though it covers the core functionality adequately.
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 schema already provides 100% coverage by naming and describing both parameters (start and end with YYYY-MM-DD format). The description adds extra semantic value by stating the order does not matter, which is not evident from the schema alone. This justifies a score above the baseline of 3.
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 uses a specific verb ('Count') and identifies the exact resource ('calendar days and business days between two dates'). It also clarifies a distinguishing feature ('Japanese holidays excluded from business days'), which differentiates it from sibling tools like jp_check_date or jp_shift_days.
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 clearly implies when to use the tool: whenever an agent needs to count days between two dates. It also provides a useful usage note that the date order does not matter. However, it does not explicitly compare to alternatives or state exclusion criteria, so it is not a perfect 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jp_from_warekiA
Convert a Japanese era date to the Gregorian calendar. Warns when the given month/day falls outside that era.
| Name | Required | Description | Default |
|---|---|---|---|
| day | Yes | ||
| era | Yes | 令和/平成/昭和/大正/明治 or R/H/S/T/M | |
| month | Yes | ||
| era_year | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the responsibility for behavioral disclosure. It does add one meaningful behavior: warning when the month/day falls outside the era. However, it does not describe the output format, error behavior, or null-handling, so transparency is only partial.
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 no filler. Every word contributes to the core function and a key edge-case behavior, making this appropriately sized and front-loaded.
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 conversion tool, the description covers the main purpose and the warning behavior, but with no output schema it should also describe the return value format. It does not, leaving some uncertainty for the agent about what to expect from the 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?
Schema description coverage is only 25%, meaning only the 'era' parameter has an explanation. The description barely compensates: it mentions 'month/day' but does not clarify the role of era_year or the expected ranges for month/day. It adds minimal meaning beyond property names.
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 uses the specific verb 'Convert' and clearly identifies the resource: a Japanese era date to the Gregorian calendar. It distinguishes itself from sibling jp_to_wareki by stating the conversion direction, leaving no ambiguity about what this tool does.
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 usage when a Japanese era date needs conversion to Gregorian, but it does not explicitly mention alternatives or exclusions. For example, it does not point to jp_to_wareki for the reverse conversion, leaving the usage context only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jp_furusato_limitA
Calculate the furusato-nozei (hometown tax donation) limit where the out-of-pocket cost stays at 2,000 yen, using the residence-tax income levy from the annual tax notice.
| Name | Required | Description | Default |
|---|---|---|---|
| taxable_income | Yes | Annual taxable income in yen | |
| residence_tax_income_levy | Yes | 住民税所得割額 in yen, from your tax notice |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It accurately describes the calculation scope and input source, but doesn't disclose output format, rounding behavior, or edge-case handling. The core behavior is transparent, but additional details would improve confidence.
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, well-structured sentence that begins with the action verb and includes the key condition and data source. No wasted 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?
Given the tool's simplicity (two numeric inputs, no output schema), the description sufficiently explains the purpose and input source. It doesn't explicitly state the return value, but 'calculate the limit' strongly implies the limit amount is returned.
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 full descriptions for both parameters (taxable income and residence tax income levy), covering 100% of parameters. The description reinforces the 'residence_tax_income_levy' source but doesn't add extra meaning beyond the schema.
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 uses the specific verb 'calculate' and identifies the resource as the furusato-nozei limit with a clear condition (out-of-pocket cost stays at 2,000 yen). This clearly distinguishes it from sibling tools which are date utilities or ideco savings 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 clear context: it's for calculating the donation limit using the residence-tax income levy from the annual tax notice. While it doesn't explicitly name alternatives, the sibling tools are unrelated, so there's no ambiguity about when to use this tool. No exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jp_ideco_tax_savingA
Calculate the annual income-tax and residence-tax reduction from iDeCo contributions in Japan (contributions are fully deductible). Deduction effect only.
| Name | Required | Description | Default |
|---|---|---|---|
| taxable_income | Yes | Annual taxable income in yen | |
| monthly_contribution | Yes | Monthly contribution in yen |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears full responsibility for behavioral disclosure. It mentions 'contributions are fully deductible' and limits to 'deduction effect only', but it does not state whether the tool returns a combined value or separate values for income and residence taxes, nor any contribution limits or calculation assumptions.
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 sentence plus a short qualifier, communicating the core purpose without fluff. It is appropriately front-loaded and every word contributes value.
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 or annotations, so the description must explain the return value and any assumptions. It fails to specify the output format (e.g., a single total vs. separate tax types) and does not mention contribution limits or tax bracket assumptions, making it incomplete 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?
The input schema already provides descriptions for both parameters, achieving 100% coverage. The description adds no additional parameter-level semantics, so it remains at the baseline of 3.
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 uses the specific verb 'Calculate' and identifies the resource 'iDeCo contributions', clearly stating the outcome as annual income-tax and residence-tax reduction. This distinguishes it from the sibling date tools and the furusato tax tool.
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 the tool is for calculating the tax savings from iDeCo contributions, and the phrase 'Deduction effect only' sets an exclusion boundary. However, it doesn't explicitly name alternative tools or provide clear when-to-use vs. not-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jp_shift_daysA
Move a date forward or backward by N days, either in business days (skipping weekends and Japanese public holidays) or calendar days. Negative values move backward.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | YYYY-MM-DD | |
| days | Yes | Number of days; negative moves backward | |
| mode | No | business |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It does explain that business days skip weekends and Japanese public holidays and that negative values move backward, which is useful. However, it does not disclose what the tool returns (e.g., a date string) or how invalid dates are handled, leaving some ambiguity.
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 concise sentence that is front-loaded with the verb ('Move') and immediately states the core functionality. It avoids unnecessary words while including key details about business/calendar modes and negative values.
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 date-shifting tool, the description covers the primary behavior, the two modes, and the handling of negative values. However, it is missing an explicit statement of the return output (likely a date string) and does not mention edge cases like invalid input, but these gaps are minor given 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 provides parameter names and types but not the meaning of 'business' mode. The description adds crucial semantics by explaining that business days skip weekends and Japanese public holidays, and by clarifying that negative days move backward. This compensates for the 67% 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: 'Move a date forward or backward by N days' with specific details about business vs calendar days and negative values. This distinguishes it from sibling tools like jp_check_date (validating dates) or jp_count_days (counting between dates).
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 usage (shift a date by a number of days) and explains the mode options, but it does not explicitly state when to use this tool over siblings or provide exclusions. For example, it never mentions that this is for shifting dates, not for checking or counting.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
jp_to_warekiA
Convert a Gregorian date to the Japanese imperial era format (令和/平成/昭和/大正/明治). Era boundaries are handled to the day.
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | YYYY-MM-DD |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It adds meaningful detail by stating that era boundaries are handled to the day, which is a key precision guarantee. However, it does not specify the return format (e.g., whether it includes the Japanese year number or just the era), nor does it address edge cases like dates before the Meiji era. This is adequate but incomplete for full transparency.
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, concise sentence that immediately states the action and target format. It also adds a valuable precision note without any filler. Every element earns its place, and the structure is front-loaded with the verb.
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?
Given the tool is a simple one-parameter converter with no output schema, the description explains the conversion and the era boundary guarantee, which covers the core behavior. It falls short of full completeness because it omits the exact return format and edge-case handling, but for a conversion tool of this complexity, it is sufficiently complete for an agent to invoke 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?
The input schema already provides 100% coverage for the single 'date' parameter with a format description (YYYY-MM-DD). The description adds the term 'Gregorian' which clarifies the calendar system, but this is a minor addition. Since schema coverage is high, a baseline of 3 is appropriate; the description does not introduce new constraints or details beyond the schema.
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 converts a Gregorian date to Japanese imperial era format, with a specific verb ('convert'), source ('Gregorian date'), and target ('Japanese imperial era format'). It lists the era names, and the direction is unambiguous. It also distinguishes itself from the sibling jp_from_wareki by the conversion direction.
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 clear context: use this to convert Gregorian dates to wareki, and notes that era boundaries are handled precisely. It does not explicitly mention alternatives or exclusions, but the sibling set implies the reverse tool jp_from_wareki would handle the opposite direction. The guidance is implied rather than explicit, so it just misses a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
v0.1.0- First observed
jp_check_date - First observed
jp_count_days - First observed
jp_from_wareki - First observed
jp_furusato_limit - First observed
jp_ideco_tax_saving - First observed
jp_shift_days - First observed
jp_to_wareki
TDQS
Scored across 7 tools
Each tool targets a distinct operation: checking a date's business status, shifting by days, counting days between dates, and converting between Gregorian and Japanese eras. The two tax tools are also clearly separate from each other and from the calendar tools.
The common 'jp_' prefix helps, but the naming pattern is mixed: verb_noun (check_date, shift_days, count_days), directional (to_wareki, from_wareki), and noun phrases (ideco_tax_saving, furusato_limit). This inconsistency is noticeable but does not severely hinder readability.
Seven tools is a well-scoped count for a Japan-specific utility server. Each tool earns its place, and the set is neither bloated nor too thin.
The calendar tools cover the core business-day and era-conversion workflows thoroughly. The two tax tools are useful but feel like an add-on to a calendar-focused server, leaving some potential gaps in tax coverage.
Maintenance
Related MCP Connectors
Japanese holiday and business-day calculations using official Japan Cabinet Office data.
MCP server for Japan geodata: cadastral lot numbers (chiban) and reverse geocoding, for AI agents.
Japan data tools for AI agents: calendar (rokuyo), address, name splitting, corporate number lookup
An MCP server that audits the fairness of construction and renovation estimates in Japan. Provides fair-price ranges, overcharge detection, and verifiable unit-cost data based on JCCDB (65,520 items across 402 categories, CC BY 4.0, DOI-backed).
Related MCP Servers
- AlicenseAqualityDmaintenanceA MCP server that provides timezone-aware date and time operations. This server addresses the common issue where AI assistants provide incorrect date information due to timezone confusion.44MIT
- AlicenseNot gradedqualityCmaintenanceJapanese calendar API for AI agents. Provides Rokuyo, Rekichu, Eto, 24 Solar Terms, and fortune judgments. MCP + REST API.5 npmMIT
- AlicenseAqualityCmaintenanceMCP server for business-day arithmetic with country-aware holiday calendars. It offers tools to check, calculate, and list business days and holidays for over 60 countries.9MIT
- AlicenseAqualityCmaintenanceEnables AI assistants to perform Japanese business calendar calculations including holiday detection, business day arithmetic, payment date settlement, and deadline management using local data.6MIT