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., "@liendeadline-mcp What's the lien deadline for a Texas invoice dated 2026-07-01?"
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.
MCP server for US mechanics lien and preliminary notice deadlines. Covers all 50 states plus the District of Columbia.
Give it an invoice date and a state, get the statutory deadlines back. It wraps the public LienDeadline API, which needs no API key for these endpoints.
Claude Code:
claude mcp add liendeadline -- npx -y liendeadline-mcpClaude Desktop, in claude_desktop_config.json:
{
"mcpServers": {
"liendeadline": { "command": "npx", "args": ["-y", "liendeadline-mcp"] }
}
}No account or API key required.
Related MCP server: OpenWorkdays
Tool | What it does |
| Preliminary notice and lien filing deadlines from an invoice date and state |
| The 51 jurisdictions with rules available |
| The underlying rule for one state, with its statute citation |
| Every available guide, by code and title |
calculate_lien_deadline with state: "TX", invoice_date: "2026-07-01",
project_type: "Commercial":
{
"state": "TX",
"invoice_date": "2026-07-01",
"preliminary_notice_deadline": "2026-09-15",
"lien_deadline": "2026-10-15",
"prelim_deadline_days": 18,
"lien_deadline_days": 48,
"warnings": ["If 15th falls on weekend/holiday, extends to next business day"]
}get_state_lien_guide returns the rule behind that date, including
"statute": "Texas Property Code § 53.056", so an answer can be checked rather than trusted.
Two deliberate choices worth knowing about:
Responses are trimmed. The calculate endpoint returns the same object three times, and a state guide is ~16 KB of which roughly 7 KB is rendered HTML. Both are collapsed to the fields an agent can act on, which takes a guide from ~16,000 to ~4,300 characters.
Point it elsewhere with LIENDEADLINE_API_URL if you need staging.
Results are calculated estimates from published state rules, reviewed quarterly. Statutes change and facts vary between projects. Verify critical deadlines with counsel before relying on them. This is not a law firm and does not file anything on your behalf.
MIT
Calculates the preliminary notice deadline and the lien filing deadline for a US construction invoice. Needs the invoice or delivery date and the state. Returns dates, days remaining, and any warnings such as weekend or holiday rollover. Covers all 50 states plus DC. Not legal advice.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | Your role on the project, e.g. "supplier", "contractor", "subcontractor". | |
| state | Yes | Two-letter US state code, e.g. "TX", "CA", "DC". | |
| notice_date | No | Date a preliminary notice was actually sent, YYYY-MM-DD, if one was. | |
| invoice_date | Yes | Invoice or delivery date in YYYY-MM-DD format. | |
| project_type | No | Usually "Commercial" or "Residential". Changes the deadline in some states. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses what the tool returns (dates, days remaining, warnings) and boundaries (all states, not legal advice). It doesn't fully detail output format or edge-case behavior, but the main behavioral contract is clear.
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?
Four short sentences, each earning its place: function, requirements, return value, and coverage/disclaimer. Front-loaded with the core calculation before details.
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 output schema and no annotations, the description covers purpose, required inputs, outputs, and scope, while the schema covers optional parameters. Minor gaps remain around exact output formatting and error handling, but these are not critical given schema coverage.
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 100%, so the schema already documents all 5 parameters. The description adds only that invoice_date can be a delivery date, which the schema already states, so it doesn't materially increase semantic clarity.
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?
States a specific verb and resource: calculates preliminary notice and lien filing deadlines for US construction invoices. It also distinguishes itself from sibling guide/list tools by describing a computation rather than a reference lookup.
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?
Provides clear invocation criteria: needs invoice/delivery date and state, and covers all 50 states plus DC. It doesn't explicitly name sibling alternatives or state when not to use it, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns the underlying deadline rules for a state, including statute citations, the deadline table and common questions. Use this when the user asks why a deadline falls where it does, or wants the statute, rather than just a date.
| Name | Required | Description | Default |
|---|---|---|---|
| state | Yes | Two-letter US state code, e.g. "TX". |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and clearly states what the tool returns, including specific content categories. It does not discuss side effects or authorization, but 'Returns' indicates a read-only lookup and the level of detail is sufficient for this simple getter.
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 clean sentences, no fluff, with the return content front-loaded and usage guidance follow-up. Every sentence earns its place.
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 one-parameter tool with no output schema, the description appropriately enumerates what the return value contains and gives enough routing guidance to invoke the correct tool. The schema handles the parameter requirement and sibling tools cover the surrounding context.
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 fully documents the single 'state' parameter with the two-letter US state code constraint, and schema description coverage is 100%. The description adds no additional parameter-level meaning beyond 'for a state,' so the baseline of 3 is appropriate.
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 concrete action ('Returns the underlying deadline rules for a state') and enumerates the contents: statute citations, deadline table, and common questions. It also distinguishes itself from date-only tools by saying 'rather than just a date,' and the singular 'for a state' separates it from list_state_lien_guides.
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 gives explicit usage context: use it when the user asks why a deadline falls where it does or wants the statute. It also implies the alternative is a date-only tool, but it does not name calculate_lien_deadline or list_state_lien_guides directly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns every available state guide with its code, title and slug. Useful for discovering what exists before fetching one.
| 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 behavioral burden. It does state the tool 'returns' data and lists the returned fields, which implies a read-only listing operation. However, it does not disclose possible response size, pagination, ordering, or access constraints, though these are less critical for a simple no-parameter list tool.
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 short sentences with the core action and return fields front-loaded. The purpose statement adds value without unnecessary detail, making the description both concise and structured well.
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 no-argument listing tool, the description explains what is returned and why to call it, which is sufficient for basic selection. It could briefly describe the output structure or clarify the difference from list_supported_states, but those 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 tool has zero parameters and the input schema clearly documents that, so there is no parameter detail the description needs to add. The baseline for a no-parameter tool is 4, and the description does not conflict with 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 returns every available state guide and names the exact fields returned (code, title, slug). It differentiates itself from get_state_lien_guide by framing itself as the pre-fetch discovery step, but it does not explicitly contrast with sibling list_supported_states.
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 says it is useful for discovering what exists before fetching one, which guides the agent to use this before get_state_lien_guide. It does not explicitly mention when not to use it or how it compares to list_supported_states, but the discovery context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns the two-letter codes of every US jurisdiction with deadline rules available, all 50 states plus DC. Use this to check a code before calculating.
| 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 behavioral disclosure burden. It clearly states this is a read-only retrieval operation ('Returns...') and fully defines the scope ('all 50 states plus DC'), leaving no ambiguity about what data will be returned. It does not discuss output format or edge cases, but for a simple zero-parameter list tool this is sufficient.
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 with no filler. The primary action and return value are front-loaded, and the usage hint is placed at the end. Every sentence adds useful information.
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 parameters, no annotations, and no output schema, the description is complete: it states what is returned, the exact set of jurisdictions covered, and when to use it. There is no missing information an agent would need to invoke 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?
The tool has zero parameters, and the schema already covers 100% of its (empty) parameter surface. The description does not need to add parameter detail. The baseline of 4 applies because there are no parameters to document and the description focuses on the return value instead.
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 a specific verb ('Returns'), a specific resource ('two-letter codes of every US jurisdiction with deadline rules available'), and precise scope ('all 50 states plus DC'). This distinguishes it from sibling tools like calculate_lien_deadline and get_state_lien_guide, which clearly serve different functions.
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 tells the agent when to use this tool: 'Use this to check a code before calculating.' This provides clear usage context tied to the calculation workflow. It does not explicitly name alternatives or exclusions, but the sibling tools are different enough that no confusion remains.
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.0calculate_lien_deadlineget_state_lien_guidelist_state_lien_guideslist_supported_statesScored across 4 tools
Each tool has a clearly defined role: calculating a deadline, checking supported states, and interacting with state guides. The only minor ambiguity is between list_supported_states and list_state_lien_guides, since both enumerate states, but their purposes are distinct enough for an agent to choose correctly.
All tool names follow a consistent verb_noun snake_case pattern: calculate_, list_, get_, list_. The verbs and nouns are descriptive and match the tool's function, making the set predictable and easy to navigate.
Four tools is well-scoped for this focused domain. Each tool serves a necessary purpose: one core calculation, one validation lookup, and two guide discovery/retrieval operations. Nothing feels redundant or missing at this level of granularity.
The domain is construction lien deadline calculation, and the tool set covers the full workflow: verify state support, calculate the deadline, retrieve detailed rules, and discover available guides. There are no obvious dead ends, and the stateless nature of the domain does not require update or delete operations.
Zero-signup business-day date-math API: add days, count days between dates, is-business-day.
Deterministic date arithmetic with auditable receipts: business days, due dates, holidays.
Business-day, SLA, cron and recurrence calculations — offline, holiday-aware, no network.
Every deadline in a lease, mortgage or policy: date, consequence, source quote. $0.50, 3 free.
