Plumbing Fixture Units MCP for AI. Calculate loads and size pipes per code standards.

Q: Can I use aggregatebuildingimplements if my rooms are already calculated?

Yes. If you have run calculateroomfixtureload on several separate rooms, you feed those individual results into aggregatebuildingimplements to get the building total.

Claude

ChatGPT

Cursor

Gemini

Windsurf

VS Code

JetBrains

Vercel

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Connect to your AI in seconds.

Plumbing Fixture Units Calculator determines Drainage and Water Supply Fixture Unit (DFU/WSFU) loads for rooms, aggregates these totals across an entire building, and calculates the precise minimum pipe diameter needed to pass those cumulative loads according to IPC/UPCA standards.

What your AI can do

Aggregate building implements

Calculates the total cumulative load for an entire building by summing multiple rooms' loads.

Calculate room fixture load

Determines the combined drainage and water supply loads for a single room based on its fixtures.

Estimate minimum pipe diameter

Finds the smallest required pipe diameter that can safely handle a specified cumulative load.

Calculate single-room fixture loads

Determines the combined DFU and WSFU for a specific space based on installed fixtures.

Aggregate total building load

Sums up the calculated loads from multiple rooms to find the overall facility demand.

Determine minimum pipe diameter

Calculates the smallest required pipe size that can safely manage a specific drainage or water supply flow rate.

Ask an AI about this

Included with Plan

Waiting for input…

AI Agent

Plumbing Fixture Units Calculator (3 Tools)

These tools let you calculate fixture unit loads for rooms, sum those loads across a whole building, and size the necessary plumbing pipes.

Make your AI actually useful.

Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.

Start using Plumbing Fixture Units Calculator on Vinkius

Aggregate Building Implements

Calculates the total cumulative load for an entire building by summing multiple rooms' loads.

Calculate Room Fixture Load

Determines the combined drainage and water supply loads for a single room based on...

Estimate Minimum Pipe Diameter

Finds the smallest required pipe diameter that can safely handle a specified...

Security and governance baked right in.

Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.

Claude AI

Open Claude Settings

Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.

Add Custom Connector

Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:

https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp

Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com. For OAuth-protected servers, expand Advanced settings to add credentials.

Start a conversation

Open a new chat. The Plumbing Fixture Units integration is available immediately — no restart needed.

Antigravity

Configure Agent Environment

Open your Antigravity agent's workspace configuration or mcp-servers.json file.

Bind the Endpoint

Add the Vinkius endpoint URL to your agent's MCP connections list:

"mcp_servers": {
  "plumbing-fixture-units-calculator": {
    "serverUrl": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
  }
}

Provide your secure token in place of [YOUR_TOKEN_HERE] to ensure your agent requests are authenticated.

Execute

Start your Antigravity session. The agent will autonomously discover and utilize the Plumbing Fixture Units tools with full Vinkius guardrails applied.

VS Code Copilot

⚡

One-Click Install (Recommended)

In your Vinkius Dashboard, simply click the Add to VS Code button for this server. We'll automatically configure your local workspace.

Or configure manually

Open MCP Settings

Open VS Code, press Ctrl/Cmd + Shift + P, and search for GitHub Copilot: MCP Servers.

Add Server Config

Add the Vinkius endpoint configuration to your mcp-servers.json file:

"plumbing-fixture-units-calculator": {
  "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp"
}

Ensure you replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.

LangChain

Install Dependencies

Install the LangChain MCP adapters for your environment:

pip install langchain-mcp-adapters

Connect the Server

Use the SSEClient in LangChain to connect to the Vinkius managed endpoint:

from langchain_mcp_adapters.client import SSEClient

# Connect to Vinkius
client = SSEClient(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")
tools = client.get_tools()

CrewAI

Define the Tool

Load the Vinkius MCP tools into your CrewAI agents:

from crewai import Agent
from mcp_crewai import MCPTool

# Connect securely to Vinkius
vinkius_tools = MCPTool(url="https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp")

# Assign to Agent
researcher = Agent(
    role='Data Researcher',
    tools=vinkius_tools.get_all()
)

Execute Task

Run your CrewAI process. The agent will autonomously route tasks to the Vinkius managed server.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

Import from OpenAPI, Swagger, or YAML specs
Create Agent Skills with progressive disclosure
Deploy to edge with MCPFusion framework
Built in DLP, auth, and compliance on every call
Real time usage dashboard and cost metering
Publish to catalog or keep private

Start building

Make Your AI Do More

Start with Plumbing Fixture Units Calculator, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.

Use this MCP plus 5,100+ others, all in one place
Add new capabilities to your AI anytime you want
Every connection is secured and compliant automatically
Track usage and costs across all your servers
Works with Claude, ChatGPT, Cursor, and more
New servers added to the catalog every week

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Plumbing Fixture Units. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

Your data is protected. See how we built it.

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This connection provides 3 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.

The current process of plumbing load calculation is error-prone and slow.

Right now, calculating the total required pipe size involves manually logging fixture counts for every room on a spreadsheet. You calculate room loads individually, then have to cross-reference those totals with local code tables—all while making sure you sum up all floor levels correctly.

With this MCP, your agent handles the entire process. You input the basic facts: what fixtures are in which rooms. The system calculates the load for every space and gives you a single, verified total building load that feeds directly into the final pipe sizing calculation.

The `estimate_minimum_pipe_diameter` tool delivers guaranteed compliance.

Before, determining the required diameter meant looking up tables based on an estimated load. If you missed one floor or miscalculated the aggregate total, the resulting pipe size would be insufficient, leading to costly rework once the crew hit a bottleneck in the main riser.

Now, after calculating the full building load using `aggregate_building_implements`, running that figure through this tool gives you an immediate, code-verified minimum diameter. It's definitive.

Support 24/7 support@vinkius.com ↗

Security Vinkius Trust Center ↗

SLA Service Level Agreement ↗

Report Listing Send Report ↗

What your AI can actually do with this

You calculate plumbing loads using standardized engineering metrics. Start by determining the combined drainage and water supply units for each individual room based on its fixtures—like toilets, sinks, or showers. Next, you sum up these room totals to figure out the full building load. Finally, the system takes that total load and calculates the smallest pipe diameter required for both vertical stacks and horizontal branches to safely handle the flow.

It makes sure your plumbing design meets code standards without guesswork. This capability is one of the core services Vinkius provides in its catalog, giving you access to specialized engineering tools right where you need them.

Built · Hosted · Managed by Vinkius Plumbing Fixture Units Calculator - Load & Pipe Sizing MCP

Server ID 019eec0f-394c-733d-a5ca-06d9caf212cd

Vinkius Inspector

Compliance Grade A+

Score 100/100

Report View Report ↗

What Changes When You Connect

Use the calculate_room_fixture_load tool to nail down DFU and WSFU totals for any single space, eliminating guesswork about fixture contributions.

The aggregate_building_implements tool handles the big picture. It takes individual room calculations and sums them up to get a reliable total building load figure.

Stop guessing pipe size. Use estimate_minimum_pipe_diameter to guarantee your pipes are sized correctly for any calculated cumulative load, preventing failure on site.

The system forces you through the necessary calculation steps (room load -> building load -> minimum diameter), ensuring code adherence at every turn.

By validating these calculations upfront, you drastically cut down on costly change orders and re-engineering time during construction.

See it in action

01 01

Designing a multi-unit residential building

A designer needs to know the total plumbing capacity for 10 identical apartments. They use calculate_room_fixture_load on one unit, then feed that output into aggregate_building_implements ten times (or once, if possible) before running the final figure through estimate_minimum_pipe_diameter.

02 02

Retrofitting a commercial space

The existing building has fixtures that were never designed for modern load standards. The engineer must use calculate_room_fixture_load to find the current, precise DFU/WSFU loads and then compare them against what the old pipes can handle.

03 03

Checking a single bathroom layout

A contractor needs quick confirmation on fixture loads. They run calculate_room_fixture_load with just the sink and toilet count to get immediate DFU/WSFU totals for that specific room.

04 04

Sizing main building risers

The project manager needs a final pipe size for the vertical stack. They must first use aggregate_building_implements on all floors, and then run the total output into estimate_minimum_pipe_diameter to get the definitive answer.

The honest tradeoffs

Calculating pipe size from room totals

Anti-pattern

Assuming that summing up the fixtures in three rooms means you can just use a large, standard pipe diameter without checking the actual combined flow rate.

The Fix

You must first run calculate_room_fixture_load for every room. Then, aggregate those results using aggregate_building_implements. Only then should you pass that final total load to estimate_minimum_pipe_diameter.

Ignoring the weakest link

Anti-pattern

Using a pipe diameter based on only the largest single room's load, which fails when multiple rooms are factored into the system.

The Fix

Always use aggregate_building_implements to get the true cumulative building load. This figure is non-negotiable for sizing the main risers.

Hand calculations on paper

Anti-pattern

Attempting to manually track DFU/WSFU loads across a multi-story project using spreadsheets, risking transcription errors and mathematical mistakes.

The Fix

Let your agent handle it. Run the numbers through calculate_room_fixture_load for each floor, then use aggregate_building_implements, followed by estimate_minimum_pipe_diameter.

When It Fits, When It Doesn't

Use this MCP if your project requires determining pipe dimensions based on calculated fixture loads and adherence to IPC/UPCA codes. This is mandatory for MEP design in residential, commercial, or institutional buildings. Don't use it if you only need general guidance; these tools require specific inputs like DFU/WSFU values and fixture counts. If your primary task is calculating structural load bearing capacity (like weight on beams), this MCP won't help—you need a dedicated civil engineering tool for that. However, if you have the loads but don't know how to combine them across multiple zones, rely on aggregate_building_implements before proceeding.

Questions you might have

How do I use calculate_room_fixture_load for a single bathroom? +

Input the specific fixture types and quantities (toilets, sinks) into calculate_room_fixture_load. It returns the combined DFU and WSFU totals for that room.

Can I use aggregate_building_implements if my rooms are already calculated? +

Yes. If you have run calculate_room_fixture_load on several separate rooms, you feed those individual results into aggregate_building_implements to get the building total.

What happens after I use aggregate_building_implements? +

You get the sum of all room loads across the entire structure. This combined load is what you must then pass to estimate_minimum_pipe_diameter to size your main pipes.

Does estimate_minimum_pipe_diameter account for both DFU and WSFU? +

Yes, the tool considers the overall cumulative load derived from both drainage (DFU) and water supply (WSFU) requirements when determining the minimum required pipe size.

If I use `calculate_room_fixture_load` and include an invalid or non-standard fixture, how should I handle the input? +

The tool throws a validation error for unrecognized fixtures. Before running, always confirm that your fixture type and model are listed in the current IPC/UPCA code tables to ensure accurate loads.

When using `aggregate_building_implements`, do I need to provide both DFU and WSFU values for every room? +

Yes, you must supply separate data arrays containing the calculated Drainage Fixture Units (DFU) loads and Water Supply Fixture Units (WSFU) loads for each room listed.

Does `estimate_minimum_pipe_diameter` allow me to specify pipe material types? +

Yes, the tool requires you to define the pipe material (e.g., PVC or cast iron). This is critical because different materials have varying load thresholds and standards.

If my calculated building load using `aggregate_building_implements` results in zero units, what does the system recommend? +

The tool will return a total load of 0 DFU/WSFU. In this case, you should manually check local plumbing codes for minimum required drain sizes, as the calculation alone won't size the pipe.

Connect to your AI in seconds.

Aggregate building implements

Calculate room fixture load

Estimate minimum pipe diameter

Plumbing Fixture Units Calculator (3 Tools)

Make your AI actually useful.

Aggregate Building Implements

Calculate Room Fixture Load

Estimate Minimum Pipe Diameter

Security and governance baked right in.

Claude AI

Open Claude Settings

Add Custom Connector

Start a conversation

Claude Code

Open your terminal

Add the MCP Server

Start coding

Cursor

One-Click Install (Recommended)

Open Cursor Settings

Add New Server

Use in Composer

Antigravity

Configure Agent Environment

Bind the Endpoint

Execute

VS Code Copilot

One-Click Install (Recommended)

Open MCP Settings

Add Server Config

Windsurf

One-Click Install (Recommended)

Open Windsurf Settings

Add Server Endpoint

LangChain

Install Dependencies

Connect the Server

CrewAI

Define the Tool

Execute Task

Choose How to Get Started

Build Your Own

Make Your AI Do More

Works with Claude, ChatGPT, Cursor, and more

The current process of plumbing load calculation is error-prone and slow.

The `estimate_minimum_pipe_diameter` tool delivers guaranteed compliance.

What your AI can actually do with this

Here's how it actually works

Who is this actually for?

What Changes When You Connect

See it in action

Designing a multi-unit residential building

Retrofitting a commercial space

Checking a single bathroom layout

Sizing main building risers

The honest tradeoffs

Calculating pipe size from room totals

Ignoring the weakest link

Hand calculations on paper

When It Fits, When It Doesn't

Questions you might have