How do I use Tri-Tender Pricing MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Tri-Tender Pricing MCP Extract pricing from RFQ_01.pdf and build a model with 15% markup." 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.

Tri‑Tender Pricing MCP

This is a production‑ready Model Context Protocol (MCP) server built with FastMCP for Tri‑Tender. It focuses on pricing schedules for tenders and RFQs.

The server exposes tools that:

Detect and extract pricing requirements from tender packs
Build a structured pricing model from tender rules + company rates
Calculate final prices (including markups & VAT)
Optionally compare against market prices
Generate a styled HTML pricing report ready for PDF export
Wrap the output in a Tri‑Tender‑friendly format for preview

1. Project Structure

tri_tender_pricing_mcp/ ├── server.py ├── requirements.txt ├── README.md ├── tools/ │ ├── extract_pricing_requirements.py │ ├── build_pricing_model.py │ ├── calculate_prices.py │ ├── generate_html_report.py │ ├── fetch_market_prices.py │ └── format_output.py ├── utils/ │ ├── pdf_reader.py │ ├── docx_reader.py │ ├── xlsx_reader.py │ ├── classify_document.py │ └── clean_text.py └── resources/ ├── pricing_templates/ │ ├── base_template.html │ ├── table_style.css │ └── branding.css └── sample_data/ └── example_pricing.json

2. Installation

Create and activate a virtual environment (recommended), then:

pip install -r requirements.txt

Verify that FastMCP is installed:

fastmcp version

3. Running the MCP Server

fastmcp run server.py

By default FastMCP will use stdio for transport. Some hosts also support:

python server.py

or

fastmcp run --transport sse --host 0.0.0.0 --port 8000 server.py

(Consult the FastMCP docs / your host's docs if you want SSE or HTTP.)

4. Registering in Tri‑Tender (Desktop / Dyad)

Use a configuration entry like this in your MCP client:

{ "mcpServers": { "tri_tender_pricing_mcp": { "command": "python", "args": ["server.py"], "env": {} } } }

If you deploy it remotely with SSE/HTTP, you can instead use:

{ "mcpServers": { "tri_tender_pricing_mcp": { "url": "http://YOUR-HOST:8000/sse" } } }

5. Exposed Tools

`detect_pricing_requirements(file_path: str) -> dict`

Reads PDF, DOCX or XLSX
Cleans the text
Classifies the document type (tender, pricing schedule, BOQ, etc.)
Tries to extract pricing‑related sections
Returns:
- instructions (LLM‑ready description of what was found)
- summary
- currency
- pricing_items (rough skeleton list)
- raw_text (trimmed excerpt for the LLM)

`build_model(description: str, tender_rules: str, company_rates: str) -> dict`

Takes free‑text input and produces a structured pricing model with:
- items: description, unit, quantity, base_rate, markup_percent
- meta: currency, VAT %, assumptions

`calculate(model_json: dict) -> dict`

Applies line‑level calculations:
- line_total_ex_vat
- line_vat_amount
- line_total_inc_vat
Sums to grand totals
Returns items + totals + instructions for the LLM.

`market_prices(item_name: str) -> dict`

Currently returns simulated market prices.
Designed to be extended with real HTTP APIs (hardware, fuel, etc.).

`render_report(pricing_data: dict) -> dict`

Renders a styled HTML report based on resources/pricing_templates/base_template.html
Returns: { "mime_type": "text/html", "html": "..." }

`final_output(html: str) -> dict`

Final simple wrapper used by Tri‑Tender desktop app / Dyad templates.

6. Customisation

Update resources/pricing_templates/base_template.html and CSS files to match Tri‑Tender branding.
Extend the logic in calculate_prices.py to support:
- multi‑year escalations
- different markups per category
- PSIRA / industry‑regulated minimums
Plug real HTTP APIs into fetch_market_prices.py once you have a host that allows outbound HTTP.

7. Safety Notes

This server does no remote network calls by default.
All calculations are purely local and deterministic.
Perfect for running inside constrained MCP hosts (FastMCP Cloud, Cursor, Claude Desktop, etc.).