# Area Program Calculator MCP MCP

> Area Program Calculator determines the minimum total programmatic area needed for any building project. Stop guessing on square footage requirements. This MCP accurately estimates required space by factoring in room function, structural overhead, and circulation needs—ensuring your initial design budget meets real-world zoning rules.

## Overview
- **Category:** construction
- **Price:** Free
- **Tags:** area-calculation, programmatic-needs, building-code, tpa, ergonomics

## Description

Building a new structure means more than just tallying up rooms. The biggest headache for architects and developers is calculating the true minimum programmatic area (TPA). If you underestimate overhead or necessary space, you face expensive redesigns or outright zoning violations down the line.

The Area Program Calculator handles this complex math in three steps. First, it establishes the core usable square footage for every room type, like a study or bathroom. Next, it applies structural overhead using complexity levels—simple, medium, or high—to calculate necessary extra space for MEP systems and hallways. Finally, it rolls everything up to give you one solid estimate of total programmatic needs. You connect this MCP through the Vinkius catalog, giving your agent the precise data needed from day one.

## Tools

### adjust_area_for_structure
Calculates the extra space needed for MEP systems and circulation based on structural complexity.

### get_base_area_by_function
Provides the minimum required usable square footage for any environment by its function type.

### calculate_programmatic_needs
Returns the total estimated programmatic area for all environments in a building program.

## Prompt Examples

**Prompt:** 
```
I need a plan for a small family home. It has 1 bedroom, 2 bathrooms, and a kitchenette. Use medium complexity.
```

**Response:** 
```
The total estimated area is X sq meters. This was calculated by first finding the base areas using `get_base_area_by_function` for all components, then applying the 1.25 multiplier via `adjust_area_for_structure`, and finally summing it up with `calculate_programmatic_needs`.
```

**Prompt:** 
```
Calculate the base area needed for a high-tech study room (StudyArea) that supports working functions. Use simple complexity first.
```

**Response:** 
```
The minimum usable area is Y sq meters, as determined by `get_base_area_by_function`. If we apply the structural adjustment now using `adjust_area_for_structure` with 'simple', the total becomes Z sq meters.
```

**Prompt:** 
```
Final check: Give me the total programmatic needs for 3 bedrooms, 2 bathrooms, and 1 livingroom, assuming high complexity.
```

**Response:** 
```
The final required area is A sq meters. This result was derived by running all components through `calculate_programmatic_needs` with the 'high' structural standard applied consistently across the entire program.
```

## Capabilities

### Determine Base Space
Gets the minimum usable area for a specific room type based on its function.

### Calculate Structural Overhead
Adds necessary extra square footage for HVAC, circulation, and structural elements based on complexity.

### Estimate Total Programmatic Area
Combines all components to deliver a single, reliable estimate of the building's total required footprint.

## Use Cases

### Designing a multi-story office building.
The developer needs to know if their planned 10 floors are enough space. They use get_base_area_by_function for all departments, then run the total through adjust_area_for_structure (using 'high' complexity) before calling calculate_programmatic_needs. This gives them a definitive TPA required for zoning approval.

### Revising an existing residential plan.
An architect is updating a small home layout with new rooms (bedrooms, bathrooms). They use get_base_area_by_function for each component and then calculate the total using adjust_area_for_structure to account for medium complexity plumbing and hallways.

### Checking feasibility for a commercial expansion.
A facility manager has a new wing planned. They use get_base_area_by_function to check the minimum space needed for specific functions (e.g., 'kitchenette', 'storage'). They then run those totals through calculate_programmatic_needs to confirm it fits within the current zoning limit.

## Benefits

- Eliminate costly redesigns. By running a calculation through adjust_area_for_structure, you immediately account for structural overhead and circulation hallways, so your initial plans aren't too small.
- Build with confidence knowing your numbers are right. Using get_base_area_by_function ensures the core usable space for every room type meets minimum code standards before you even start drawing.
- Get one final number. calculate_programmatic_needs aggregates all inputs—the base area, the structural overhead, and everything else—into a single, reliable total programmatic estimate.
- Stay ahead of zoning issues. This MCP helps validate that your initial planning budget is accurate from day one by modeling real-world required square footage.
- Speed up pre-design checks. Instead of manually cross-referencing code books for every room type, you let your agent handle the base area calculation with a simple prompt.

## How It Works

The bottom line is that you get an accurate TPA calculation that accounts for both room function and build complexity.

1. First, you input the primary function (e.g., 'sleeping area') to determine the core usable space using get_base_area_by_function.
2. Next, you define the structural complexity of the project—simple, medium, or high—to apply necessary overhead adjustments via adjust_area_for_structure.
3. Finally, it runs all calculated components through calculate_programmatic_needs to return a single, reliable total programmatic area estimate.

## Frequently Asked Questions

**How does calculate_programmatic_needs work?**
It takes the results from other area calculations—like base areas and structural adjustments—and sums them up. It gives you one final, reliable total programmatic estimate for the entire building program.

**What is the difference between get_base_area_by_function and calculate_programmatic_needs?**
get_base_area_by_function only determines the minimum usable area for a single room type. calculate_programmatic_needs aggregates those base areas along with all structural overheads into one final total.

**Can I use adjust_area_for_structure without knowing my complexity?**
No. You must specify the complexity level (simple, medium, or high). The tool uses this input to calculate the correct necessary space for MEP and circulation.

**Does Area Program Calculator handle different building types?**
Yes. It processes requirements based on defined functions, making it useful for residential homes, commercial offices, or specialized facilities.

**If I use `get_base_area_by_function` with an unrecognized room type, what happens?**
The function returns a specific error code. It flags the missing function and requires you to manually supply a base area estimate before calculation continues.

**Does the rate limit for running `calculate_programmatic_needs` affect large projects?**
No, we support high-throughput processing. You can submit multiple program calculations in a single batch job to efficiently handle entire development sites.

**What specific data inputs are required when calling `adjust_area_for_structure`?**
You must provide the original base area, the structural complexity level (simple, medium, or high), and the unit of measurement. The system validates these three parameters before running the adjustment.

**Does Vinkius secure the architectural data passed to `get_base_area_by_function`?**
Yes, all data transmitted is encrypted end-to-end and treated as confidential. We only store the resulting programmatic needs, never your raw building plans.

**What is the difference between base area and final adjusted area?**
The initial minimum usable space is found using `get_base_area_by_function`. The final, total required size includes structural overhead (hallways, utilities), which is calculated by the `adjust_area_for_structure` tool. Always use both for an accurate total.

**Can I calculate the final area without listing all components?**
No. The `calculate_programmatic_needs` tool requires a complete list of environments, their functions, and component counts to ensure every required space is accounted for before giving a total area estimate.

**What if my building structure changes from simple to high complexity?**
You must re-run the calculation using `adjust_area_for_structure` with the new 'high' complexity level. This change significantly increases the multiplier, accounting for major infrastructure shifts that affect the total program area.