ccpp-tools-mcp
Click on "Install 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., "@ccpp-tools-mcpCalculate NPSHa for a fuel oil pump: 60 m3/h, 40°C, NPSHr 4 m"
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.
ccpp-tools-mcp
Deterministic, standards-traceable engineering calculations for combined-cycle power plant (CCPP) balance-of-plant design — exposed as an MCP server.
LLM agents are excellent at orchestrating an engineering workflow in natural language and terrible at arithmetic. This server splits the work accordingly: any MCP client (Claude Desktop, Claude mobile, Claude Code, Cursor, or an internal agent) drives the conversation, while every number comes from a pure, tested Python function that returns its evidence — the governing standard, the equation evaluated, the assumptions you must own, and the warnings you must not ignore.
"Verify this fuel-oil transfer system: 60 m³/h diesel at 40 °C,
180 m discharge run rising 18 m, flooded suction, NPSHr 4 m…"
Claude (orchestration, no arithmetic)
│ tank_capacity → 3,240 m³ working → 2 × 1,800 m³
│ fluid_props_liquid → ρ 819.8 kg/m³, μ 1.97 mPa·s [ASTM D341]
│ pipe_size_select → NPS 4 SCH 40, 2.03 m/s ✓ (1–3 band)
│ dp_segment_liquid → Re 8.6e4, f 0.0205, 9.76 m [Crane TP-410]
│ pump_tdh → TDH 28.8 m → rate at 32 m
│ pump_npsha → NPSHa 13.0 m vs NPSHr 4.0 ✓
└ valve_cv_liquid → Cv 11.9, not choked [ISA 75.01]The full conversation, produced by a real Claude client calling this server end to end, is preserved verbatim in docs/cases/case-01-transcript.md, and an interactive overview lets you step through the tool chain response by response.
Why trust the numbers
Every calculation is held by two independent legs (docs/verification.md):
Golden tests from the governing documents. The IAPWS-IF97 water/steam implementation is written from the release itself (regions 1/2/4 + R12-08 viscosity, stdlib only) and locked by the release's own computer-program verification tables at 8–9 significant figures.
Cross-validation against independent implementations. ~1,800 swept assertions compare the runtime core against
fluidsandiapws— which are test-only dependencies. The runtime has zero third-party calculation code, so the comparison is never circular.
The harness has already earned its keep: it caught a wall-thickness transcription error (NPS 18 SCH 80, 23.88 → 23.83 mm) and rejected five golden values written from memory instead of the document. Both incidents are kept in the verification log on purpose.
Related MCP server: eq-reference-mcp
Quick start
uvx ccpp-tools-mcp # stdio (once published to PyPI)
# or from a checkout:
uv run ccpp-tools-mcp # stdio
uv run ccpp-tools-mcp --transport streamable-http --port 8899 # HTTPClaude Desktop (claude_desktop_config.json):
{
"mcpServers": {
"ccpp-tools": {
"command": "uvx",
"args": ["ccpp-tools-mcp"]
}
}
}Claude Code:
claude mcp add ccpp-tools -- uvx ccpp-tools-mcpClaude mobile / web: run the HTTP transport, expose it (e.g.
cloudflared tunnel --url http://localhost:8899), and add
https://<your-tunnel>/mcp as a custom connector.
Then paste the demo prompt from docs/cases/case-01-fuel-oil-transfer.md and watch the tool chain run.
Tools (v1)
Tool | What it computes | Standard basis |
| ρ, ν/μ, Pv, SG for petroleum liquids (preset or custom 2-point fit) | API gravity / ASTM D341 |
| water/steam v, h, s, cp, μ; saturation states | IAPWS-IF97 / R12-08 (own implementation) |
| working/nominal volume, residence time | volume balance (ahead of API 650/620) |
| smallest NPS/SCH meeting a velocity limit | ASME B36.10M + continuity |
| pressure-design wall vs selected schedule | ASME B31.1 §104.1.2 |
| Darcy friction + Crane fitting losses, Re/velocity flags | Crane TP-410 / Colebrook-White |
| accepted fitting keys and their K basis | Crane TP-410 |
| total dynamic head balance | Hydraulic Institute |
| NPSH available + margin vs NPSHr | HI 9.6.1 concepts |
| hydraulic / shaft power | ρgQH |
| required Cv/Kv + choked-flow check | ISA 75.01 / IEC 60534-2-1 |
The response envelope
Every tool returns the same contract — a number you can defend:
{
"result": { "npsha_m": 12.99, "margin_m": 8.99 },
"method": { "standard": "Hydraulic Institute (HI 9.6.1 concepts)",
"equation": "NPSHa = (P_surface,abs - Pv)/(rho g) + z_static - h_f,suction" },
"assumptions": [ "atmospheric pressure 101.325 kPa(a)",
"vapor pressure 0.5 kPa(a) at pumping temperature" ],
"warnings": [],
"validity": "ok"
}Warnings are load-bearing: an undersized line answers with the number and a velocity flag; a deep-turndown case flags the laminar–turbulent transition; a near-saturation valve sizing reports choked flow. The orchestrating agent is expected to surface every warning to the user — the Case 01 transcript shows that happening.
Architecture
flowchart LR
subgraph clients [MCP clients]
A[Claude Desktop / mobile]
B[Claude Code / Cursor]
C[internal plant agent]:::private
end
subgraph server [ccpp-tools-mcp]
E[slim envelope<br/>result + method + assumptions + warnings]
subgraph core [stdlib-only calculation core]
P[pipe: B36.10M · B31.1]
H[hydro: Colebrook · Crane K]
Q[equipment: pump · tank · ISA 75.01]
F[props: ASTM D341 · IAPWS-IF97]
end
end
subgraph oracles [test-only oracles]
O1[fluids]
O2[iapws]
O3[official verification tables]
end
A & B & C -->|stdio / streamable-http| E --> core
core -.->|cross-validated in CI| oracles
classDef private stroke-dasharray: 5 5,stroke:#888,color:#888;The internal orchestrating agent shown dashed is a private, out-of-scope deployment; everything demonstrated here runs on generic public MCP clients.
Scope and honest limits
Decision support, not engineering of record. Results carry their assumptions; the responsible engineer owns criterion selection, margins, and code compliance.
v1 is liquid-service only; compressible dP, heat-exchanger rating, and parallel-flow distribution arrive in v1.1 with their own validated cases.
IF-97 regions 3 (near-critical) and 5 are deliberately not implemented — out-of-range inputs raise instead of extrapolating.
The bundled diesel preset is a representative ASTM D975 sample, not project fuel data, and says so in every response.
Full gap list: docs/verification.md.
Development
uv sync --dev
git config core.hooksPath .githooks # forbidden-token pre-commit gate
uv run pytest -q -m "not cross" # unit + golden
uv run pytest -q -m cross tests/cross # sweeps vs fluids / iapws
uv run ruff check . && uv run mypy # lint + strict typesLicense
Apache-2.0. Crane TP-410, ASME, ISA, HI, ASTM, and IAPWS are referenced as public standards; bring your own licensed copies for engineering use.
Available Tools
11 toolsdp_segment_liquidB
Darcy-Weisbach + Crane K pressure drop for one liquid pipe segment.
| Name | Required | Description | Default |
|---|---|---|---|
| nps_in | Yes | ||
| fittings | No | ||
| length_m | Yes | ||
| flow_m3_h | Yes | ||
| roughness_mm | No | ||
| density_kg_m3 | Yes | ||
| schedule_name | Yes | ||
| max_velocity_m_s | No | ||
| dynamic_viscosity_pa_s | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It names the calculation method but does not state assumptions (e.g., incompressible flow), limitations, or even confirm it is a read-only operation. This sparse disclosure is insufficient for a tool with this complexity.
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 front-loads the core purpose without wasted words. It is efficient, though perhaps too terse to be fully useful, it 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?
With 9 parameters, no annotations, and no schema descriptions, the description is grossly incomplete. It does not explain how fittings are handled, what schedule_name refers to, or any return value behavior. The output schema exists but the description still needs to provide more contextual glue.
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 0% for top-level parameters, and the description adds no explanation of parameters like schedule_name, roughness_mm, or fittings. The agent must rely on parameter titles alone, which are ambiguous for several inputs.
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 calculates pressure drop using Darcy-Weisbach + Crane K for one liquid pipe segment. This specific method and scope distinguish it from sibling tools like pump_tdh and valve_cv_liquid.
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 use for liquid pipe segments, but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The scope phrase gives some contextual clue but no direct comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fluid_props_liquidA
Petroleum-liquid density/viscosity/vapor pressure at a temperature.
Uses a named preset (currently 'diesel_no2', a representative ASTM D975 sample) or a custom fluid via api_gravity + two viscosity points [[T_degC, cSt], [T_degC, cSt]] (ASTM D341 fit) + vapor_pressure_kpa.
| Name | Required | Description | Default |
|---|---|---|---|
| preset | No | diesel_no2 | |
| api_gravity | No | ||
| temperature_c | Yes | ||
| viscosity_points | No | ||
| vapor_pressure_kpa | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears responsibility for disclosures. It reveals that a single preset ('diesel_no2') is currently available and that custom fluids are fit using ASTM D341, giving insight into calculation methods. It does not state explicitly that the operation is read-only or free of side effects, but for a property-lookup tool this is reasonably implied.
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 long, front-loads the primary purpose in the first sentence, and uses the second to methodically list the two input modes. No filler or redundant 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?
The tool has 5 parameters, no annotations, and an output schema, so the description does not need to explain return shape. It covers the main functionality and parameter semantics, but leaves some implicit rules about combining preset and custom fields and about the appropriate use of each mode, which could be ambiguous for an agent.
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 0%, so the description must supply meaning. It does so by explaining preset vs custom modes, detailing the viscosity_points format as [[T_degC, cSt], [T_degC, cSt]], and mentioning units for vapor pressure (kPa). This gives an agent sufficient understanding to populate parameters correctly.
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 computes density, viscosity, and vapor pressure for petroleum liquids at a specified temperature. It distinguishes itself from the sibling fluid_props_steam by explicitly targeting liquids, and from other sizing/selection tools by its fluid-properties scope.
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 establishes clear context for use—petroleum liquid property calculations—and explains the two input modes (preset or custom) which helps an agent decide what parameters to supply. However, it does not explicitly mention alternatives like fluid_props_steam or when not to use this tool, so it lacks formal exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fluid_props_steamA
Water/steam properties (own IAPWS-IF97 implementation).
Give both pressure and temperature for a single-phase state; only one of them for saturation properties at that pressure or temperature.
| Name | Required | Description | Default |
|---|---|---|---|
| temperature_c | No | ||
| pressure_bar_a | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosure. It explains the behavioral distinction between single-phase and saturation input modes and notes it is a custom implementation. However, it does not disclose valid ranges, error behavior, or what specific properties are returned (the output schema covers returns). This is useful but incomplete.
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 extremely concise: two sentences, with the purpose front-loaded in the first sentence and usage instructions in the second. Every sentence earns its place, and there is no redundant or filler content.
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?
Despite lacking annotations, the description covers the essential usage distinction and an output schema exists, so return values do not need to be described. The main gap is the absence of valid pressure/temperature ranges for IAPWS-IF97, but the description is otherwise sufficient for a fluid properties tool with simple inputs.
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 has zero description coverage, so the description must compensate. It directly explains the relationship between temperature_c and pressure_bar_a: both for single-phase, only one for saturation. This adds meaning beyond the schema's basic names and types. Unit hints are already in the parameter names (C, bar_a), so the description need not repeat them.
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 identifies the resource as 'Water/steam properties' and specifies the implementation standard (IAPWS-IF97), clearly distinguishing it from the sibling tool fluid_props_liquid. The verb 'Give' implies retrieval/calculation, though it is not as explicit as 'calculates' or 'returns'.
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 explicit instructions on when to supply both parameters versus only one: 'Give both pressure and temperature for a single-phase state; only one of them for saturation properties at that pressure or temperature.' This gives clear context for using the tool. It does not explicitly mention alternatives like 'use fluid_props_liquid for liquid properties', so it falls 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.
list_crane_fittingsA
List fitting keys accepted by dp_segment_liquid and their K basis.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of explaining behavior. It accurately conveys that the tool returns fitting keys and K basis values, but does not explicitly state that it is a read-only operation or describe any side effects. The behavior is straightforward for a list tool, so this is adequate but not detailed.
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?
A single concise sentence that front-loads the verb and resource, with no unnecessary words. It is appropriately sized for a zero-parameter tool.
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 zero-parameter tool with an output schema, the description is complete. It states the purpose and the connection to dp_segment_liquid, which is sufficient for an agent to select and invoke the tool 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?
There are no parameters, so the baseline is 4. The description correctly focuses on the tool's output rather than parameter semantics, as there are no parameters to document.
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 'List' and identifies the exact resource: fitting keys accepted by dp_segment_liquid, including their K basis. This clearly distinguishes it from sibling tools like dp_segment_liquid itself, which performs pressure drop calculations, and other fluid/pipe tools.
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 use for retrieving valid fitting keys for dp_segment_liquid but does not explicitly state when to use this vs alternatives. It could be clearer about being a lookup utility for pressure drop calculations, but the connection to dp_segment_liquid provides reasonable context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pipe_size_selectC
Select the smallest ASME B36.10M pipe meeting a velocity limit.
| Name | Required | Description | Default |
|---|---|---|---|
| flow_m3_h | Yes | ||
| schedule_name | No | 40 | |
| max_velocity_m_s | Yes | ||
| min_velocity_m_s | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It discloses the selection criterion (smallest, velocity limit) but omits important behavioral details such as error handling when no pipe size satisfies the constraints, the role of the optional min_velocity_m_s parameter, or any interaction with schedule_name. This is a significant gap for a selection 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?
The description is a single concise sentence, but it is under-specified for a tool with four parameters and no annotation support. While it is front-loaded and free of fluff, the lack of necessary detail makes it barely adequate, not appropriately sized.
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?
Despite having an output schema, the description is incomplete for a tool with four parameters including an optional min_velocity_m_s and schedule_name. It does not clarify how the velocity limit is applied, whether schedule affects selection, or what happens if no size meets the criteria. The description covers only a fraction of the tool's behavioral surface.
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 0% and the description does not explain any parameter. The phrase 'velocity limit' is ambiguous—it could refer to max_velocity_m_s only or both min and max limits. The description adds no meaning beyond the raw parameter names, which are not self-explanatory for units or usage.
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: selecting the smallest ASME B36.10M pipe based on a velocity limit. It uses a specific verb and resource, and the mention of ASME B36.10M distinguishes it from sibling tools like pipe_wall_thickness or fluid property calculators.
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 for pipe sizing under a velocity constraint, but it does not explicitly state when to use this tool versus alternatives. No exclusions or alternative tool references are given, leaving the context to be inferred from the tool name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pipe_wall_thicknessC
ASME B31.1 pressure-design wall check against a selected schedule.
| Name | Required | Description | Default |
|---|---|---|---|
| nps_in | Yes | ||
| coefficient_y | No | ||
| schedule_name | Yes | ||
| design_pressure_mpa | Yes | ||
| allowable_stress_mpa | Yes | ||
| weld_joint_efficiency | No | ||
| corrosion_allowance_mm | No | ||
| mill_tolerance_fraction | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the burden of behavioral transparency, but it only says 'check' without disclosing whether it calculates required thickness, returns pass/fail, uses schedule data, or has side effects. This is a substantial gap for an engineering calculation 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?
The description is a single, front-loaded sentence with no wasted words, naming the relevant standard. However, it is too sparse to be considered well-structured for an 8-parameter tool, omitting essential context that should accompany such a calculation.
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?
Although an output schema exists, the 8-parameter complexity and absence of annotations are not addressed. The description does not explain the calculation basis, assumptions, or how inputs relate, making it incomplete for an engineering tool of this scope.
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 0%, and the description does not explain any of the 8 parameters (e.g., design_pressure_mpa, coefficient_y, weld_joint_efficiency). It mentions 'schedule' but leaves the agent to infer the meaning and units of all inputs from names alone.
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 specific verb ('check'), a resource ('wall'), the governing standard ('ASME B31.1'), and a scope ('against a selected schedule'), which clearly identifies the tool's function and distinguishes it from siblings like pipe_size_select. However, it does not explicitly clarify whether it computes minimum required thickness or validates an existing wall thickness.
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?
No guidance is provided on when to use this tool versus alternatives, prerequisites, or exclusion scenarios. The description only states the function without helping the agent choose between this and sibling tools such as pipe_size_select or dp_segment_liquid.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pump_npshaC
NPSH available at the pump; margin check when NPSHr is supplied.
| Name | Required | Description | Default |
|---|---|---|---|
| npshr_m | No | ||
| density_kg_m3 | Yes | ||
| suction_loss_m | No | ||
| surface_gauge_kpa | No | ||
| vapor_pressure_kpa | Yes | ||
| static_suction_head_m | Yes | ||
| atmospheric_pressure_kpa | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that NPSH available is computed and that a margin check occurs when NPSHr is given. It does not explain the governing equation, assumptions, required system context, or what happens when inputs are missing. This is insufficient for a calculation 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?
The description is a single, terse line with no wasted words. It conveys the core purpose efficiently, though it reads more like a fragment than a complete sentence. For a tool of this simplicity, the brevity is acceptable, but it sacrifices completeness for conciseness.
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?
This is a 7-parameter engineering calculation tool with no annotations and only a vague description. It does not specify the NPSH formula, units, prerequisites, or any special cases. While an output schema exists, the description alone leaves the agent with too little information to correctly invoke the tool or interpret results. This falls well below the minimum viable threshold.
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 0%, and the description only references NPSHr (the optional margin-check input). It provides no explanation of vapor pressure, density, static suction head, suction loss, surface gauge pressure, or atmospheric pressure. Since the description must compensate for the lack of parameter documentation and it does not, this is a critical gap.
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 identifies the tool as calculating NPSH available at the pump, using domain-specific terminology. It distinguishes from sibling tools like pump_tdh and pump_power by focusing on NPSH, and also hints at a margin-check capability. However, it lacks an explicit verb like 'calculate' or 'compute', making it slightly less direct.
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 context: NPSH available is calculated, and when NPSHr is supplied, a margin check is performed. It does not provide explicit guidance on when to use this tool versus alternatives, but there are no other NPSH tools among siblings, so the context is reasonably clear. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pump_powerB
Hydraulic power, and shaft power when an efficiency is supplied.
| Name | Required | Description | Default |
|---|---|---|---|
| flow_m3_h | Yes | ||
| total_head_m | Yes | ||
| density_kg_m3 | Yes | ||
| pump_efficiency | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that shaft power is only computed when an efficiency is supplied, which is useful behavioral context. However, it omits details such as output format, units, or error behavior.
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?
A single, front-loaded sentence with no redundant words or fluff. It is appropriately concise for the amount of information conveyed.
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?
An output schema exists, so return values need not be described. However, the tool has no annotations and minimal description, leaving out usage guidance, unit conventions, or broader context that would help an agent select it confidently.
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 coverage is 0%, so the description must compensate. It clarifies that pump_efficiency is optional and alters the output to include shaft power, but it does not explain the meaning or units of the three required parameters beyond their self-descriptive 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 clearly identifies the tool as computing hydraulic power and optionally shaft power when efficiency is provided. It distinguishes itself from siblings like pump_tdh and pump_npsha, which focus on head and NPSH rather than power, though it lacks an explicit verb.
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 by naming the calculation, but it does not explicitly say when to use this tool versus alternatives. The conditional phrase 'when an efficiency is supplied' hints at a mode switch, but there are no direct usage scenarios or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pump_tdhC
Pump total dynamic head from static lift, line losses, and pressures.
| Name | Required | Description | Default |
|---|---|---|---|
| density_kg_m3 | No | ||
| static_head_m | Yes | ||
| suction_loss_m | No | ||
| discharge_loss_m | No | ||
| source_gauge_kpa | No | ||
| destination_gauge_kpa | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the behavioral disclosure burden. It only lists input categories and gives no details about assumptions, defaults (e.g., density), return values, or potential limitations.
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 with zero wasted words. It immediately front-loads the core purpose, making it easy for an agent to scan.
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 6 parameters, no schema descriptions, and no annotations, this description is extremely thin. It lacks essential guidance on formula, parameter defaults, and usage context, making it insufficient for reliable invocation.
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?
With 0% schema description coverage, the tool description is the only textual explanation. It maps 'static lift' to static_head_m, 'line losses' to suction/discharge losses, and 'pressures' to gauge pressures, but omits density_kg_m3 and does not explain parameter relationships or units.
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 that the tool computes pump total dynamic head from static lift, line losses, and pressures. This clearly distinguishes it from sibling tools like pump_npsha and pump_power, though the phrasing 'Pump total dynamic head' lacks an explicit verb like 'calculate'.
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?
No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios, exclusions, or comparisons to related tools such as pump_npsha or pump_power.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tank_capacityC
Storage-tank working/nominal volume and residence time from autonomy.
| Name | Required | Description | Default |
|---|---|---|---|
| autonomy_h | Yes | ||
| consumption_m3_h | Yes | ||
| working_fraction | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must disclose behavioral traits, but it only states the computed outputs. It does not mention whether the tool is a pure calculation, assumptions about constant consumption, or how working_fraction affects results. There is no mention of error handling or limitations.
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 an under-specified fragment rather than a clear, structured sentence. While it is short, it does not earn its place because it introduces ambiguity. A well-structured description would state the calculation and key inputs at minimum.
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 moderate complexity (3 parameters, no annotations, output schema present), the description is drastically incomplete. It does not explain the relationship between autonomy, consumption, and tank volume, nor the meaning of working versus nominal volume. An agent would struggle to decide when and how to invoke this 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 description fails to explain any of the three parameters, and schema description coverage is 0%. It hints at 'working/nominal' volume, which relates to working_fraction, but does not explicitly map inputs to roles. The consumption parameter is entirely absent from the description, so an agent cannot correctly construct arguments.
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 identifies the tool as computing storage-tank working/nominal volume and residence time, which indicates its function. However, it lacks an explicit verb and omits the consumption input, making the purpose somewhat vague. It does distinguish itself from siblings as a tank-sizing 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 no guidance on when to use this tool versus alternatives, such as comparing to pipe sizing or pump calculations. It does not state inputs, prerequisites, or typical use cases. This is a significant omission for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
valve_cv_liquidA
ISA 75.01 required Cv/Kv for turbulent liquid flow (Fp = 1).
Supply inlet/vapor/critical pressures to enable the choked-flow check (for water use critical_pressure_bar_a = 220.64).
| Name | Required | Description | Default |
|---|---|---|---|
| fl | No | ||
| dp_bar | Yes | ||
| flow_m3_h | Yes | ||
| specific_gravity | Yes | ||
| inlet_pressure_bar_a | No | ||
| vapor_pressure_bar_a | No | ||
| critical_pressure_bar_a | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| method | Yes | |
| result | Yes | |
| validity | No | |
| warnings | No | |
| assumptions | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing assumptions. It states the calculation basis (ISA 75.01, turbulent liquid, Fp=1) and the optional choking check, plus a practical hint for water (critical_pressure_bar_a = 220.64). This is strong for a non-destructive calculation tool, though it does not describe the exact output behavior.
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 short sentences, front-loaded with the core purpose, and every clause adds value. It is not padded or redundant, making it easy for an agent to parse quickly.
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 has an output schema, the description does not need to explain return values. It covers the calculation scope, flow regime, Fp assumption, and the optional pressure parameters for choking. The only notable gap is the unexplained 'fl' parameter, but overall the description is sufficiently complete for a 7-parameter 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 description adds meaning to the optional pressure parameters (inlet/vapor/critical) by explaining their role in the choked-flow check, and provides a concrete example value for water. However, it does not explain the 'fl' parameter (default 0.9) or the exact expected units/format for the core parameters. With 0% schema coverage, partial compensation is achieved.
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 computes ISA 75.01 required Cv/Kv for turbulent liquid flow, which is a specific verb+resource and distinguishes it from pump, pipe, and fluid property tools. The mention of Fp=1 further narrows its scope.
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?
It gives clear context for when to use the tool (turbulent liquid flow, Fp=1) and specific guidance for optional parameters to enable the choked-flow check. It does not explicitly mention alternatives, but sibling tool names make the domain obvious.
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. Dates show when Glama detected each change.
11 tool updates
v0.1.0- First observed
dp_segment_liquid - First observed
fluid_props_liquid - First observed
fluid_props_steam - First observed
list_crane_fittings - First observed
pipe_size_select - First observed
pipe_wall_thickness - First observed
pump_npsha - First observed
pump_power - First observed
pump_tdh - First observed
tank_capacity - First observed
valve_cv_liquid
TDQS
Each tool targets a distinct calculation or resource: fluid properties (liquid vs steam), tank sizing, pipe sizing/wall thickness/pressure drop, pump TDH/NPSHA/power, and valve Cv. No two tools overlap in purpose; even fluid_props_liquid and fluid_props_steam cover different fluids.
Tool names mostly follow a consistent object_attribute pattern (e.g., fluid_props_liquid, pipe_wall_thickness, pump_tdh). The one deviation is list_crane_fittings, which starts with a verb rather than a noun, but it is still clear and matches the underscore-separated lowercase style.
With 11 tools, the set is well-scoped for a chemical/process engineering domain. Each tool covers a distinct design step, and the count is within the ideal 3-15 range without feeling sparse or bloated.
The toolset covers a complete liquid piping and pump design workflow: fluid properties, tank capacity, pipe sizing, wall thickness, pressure drop, pump head/NPSH/power, and valve Cv. Minor gaps exist for gas/compressible flow calculations, but the domain appears intentionally liquid-focused.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Engineering calculation MCP server for oil and gas engineering applications.
MCP server for aerospace calculations: orbital mechanics, ephemeris, DSN operations, ...
Governed data discovery, exact queries, decisions, simulations, and runtime utilities over MCP.
Conformance checker for MCP servers. Free, no key, verdicts recomputable and re-measured daily.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA collection of MCP servers for chemical engineering and chemistry applications, enabling AI assistants to perform thermodynamic calculations, equation of state modeling, and phase equilibrium computations.MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for searching, browsing, solving, and interpolating engineering equations and reference tables. Provides access to 3,388 engineering equations across 10 subjects and 94 reference tables.MIT
- AlicenseAqualityBmaintenanceAn MCP server that gives an AI assistant a set of real mechanical-engineering tools. Provides deterministic tools like material properties, beam analysis, unit conversion, and curve fitting for engineering calculations.5MIT
- AlicenseAqualityBmaintenanceMCP server providing embedded engineering calculators and code generators as tools for AI agents, enabling precise, deterministic embedded math and C code generation.2982MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jinhyunan/ccpp-tools-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server