How do I use CalcsLive MCP Server?

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., "@CalcsLive MCP Server calculate the torque for a 2 HP motor running at 100 rpm" 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.

CalcsLive MCP Server

by CalcsLive

Overview Schema Related Servers Score Discussions

JavaScript

Remote

CalcsLive MCP Server

Enable AI agents to perform unit-aware engineering calculations via Model Context Protocol (MCP)

Transform AI assistants like Claude into powerful engineering calculation tools with automatic unit conversion, dependency resolution, and professional-grade accuracy.

🎯 What is This?

The CalcsLive MCP Server connects AI agents to CalcsLive's calculation engine via the Model Context Protocol (MCP). This enables AI to:

✅ Perform complex engineering calculations with proper unit handling
✅ Automatically convert between unit systems (metric ↔ imperial)
✅ Resolve multi-step calculation dependencies
✅ Access 75+ unit categories with 500+ units
✅ Validate calculations with engineering accuracy

Example

User: "Calculate hydro power for a flow rate of 150 m³/s with a head of 25 meters"

AI (via CalcsLive MCP):

{
  "power": {
    "value": 36787.5,
    "unit": "kW"
  }
}

AI automatically handles the unit-aware calculation: P = ρ × g × H × Q × η

Related MCP server: Corrosion Engineering MCP Server

📋 Prerequisites

Node.js 18+ installed on your system
CalcsLive Account - Sign up at calcs.live
MCP API Key - Create from your Account > API Keys
- Select "MCP Integration (AI Agents)" as service type
- Free users: Get 30-day trial (starts on first API call)
- Premium users: Full unlimited access

🚀 Quick Start

1. Install Dependencies

cd /path/to/calcslive-mcp-server
npm install

2. Build the Server

npm run build

3. Configure Claude Desktop

Edit your Claude Desktop configuration file:

Location:

Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Add CalcsLive MCP server:

{
  "mcpServers": {
    "calcslive": {
      "command": "node",
      "args": [
        "/absolute/path/to/calcslive-mcp-server/dist/index.js"
      ],
      "env": {
        "CALCSLIVE_API_KEY": "your-mcp-api-key-here",
        "CALCSLIVE_API_URL": "https://www.calcs.live"
      }
    }
  }
}

Important:

Replace /absolute/path/to/calcslive-mcp-server with your actual installation path
Replace your-mcp-api-key-here with your actual MCP API key from CalcsLive

4. Restart Claude Desktop

Quit and restart Claude Desktop to load the MCP server.

5. Verify Installation

In Claude Desktop, you should see the CalcsLive tools available. Try asking:

"What CalcsLive tools do you have available?"

Claude should list calcslive_run_script, calcslive_calculate, and calcslive_validate.

🔧 Claude Code (VS Code Extension) Setup

If you're using Claude Code in VS Code, use the Claude CLI for easier configuration:

1. Install and Build

cd /path/to/calcslive-mcp-server
npm install
npm run build

2. Add MCP Server via Claude CLI

Use the claude mcp add command with stdio transport:

Linux/macOS:

claude mcp add --scope user --transport stdio calcslive node \
  --env CALCSLIVE_API_KEY=your-mcp-api-key-here \
  --env CALCSLIVE_API_URL=https://www.calcs.live \
  -- /absolute/path/to/calcslive-mcp-server/dist/index.js

Windows PowerShell:

claude mcp add --scope user --transport stdio calcslive node `
  --env CALCSLIVE_API_KEY=your-mcp-api-key-here `
  --env CALCSLIVE_API_URL=https://www.calcs.live `
  -- C:\absolute\path\to\calcslive-mcp-server\dist\index.js

Important Notes:

--scope user: Makes MCP available in all VS Code windows (recommended for global access)
- Without --scope user, MCP only works in the current project directory
- Alternative scopes: local (project-specific), project (shared in team)
Command structure: calcslive node where node is the command and path comes after --
Replace /absolute/path/to/calcslive-mcp-server (or C:\absolute\path\to\... on Windows) with your actual installation path
Replace your-mcp-api-key-here with your actual API key from CalcsLive API Keys
For local development, use CALCSLIVE_API_URL=http://localhost:3000

3. Verify in VS Code

Restart your VS Code window or reload Claude Code extension. The CalcsLive MCP tools should now be available to Claude Code AI.

Test it:

"Calculate the torque for a 2 HP motor running at 100 rpm"

Claude Code should use the calcslive_run_script tool to perform the calculation.

Alternative: Manual Configuration

If Claude CLI is not available, you can manually edit the Claude Code MCP configuration file, but the CLI method is strongly recommended for reliability.

🛠️ Available Tools

`calcslive_run_script` ⭐ NEW

Run stateless unit-aware calculations from Physical Quantity (PQ) script definitions. No article creation needed - fully stateless and on-the-fly.

Example Usage:

User: "Calculate the area of a circle with radius 5 cm in mm²"

AI uses: calcslive_run_script
- pqs: [
    {
      sym: "r",
      description: "radius",
      value: 5,
      unit: "cm"
    },
    {
      sym: "A",
      description: "circle area",
      expression: "pi * r^2",
      unit: "cm²"
    }
  ]
- outputs: {
    A: { unit: "mm²" }
  }

Response:

Calculation completed with 1 output

Results:
• circle area (A): 7853.982 mm² = pi * r^2

Detailed calculation:
{
  "inputs": {
    "r": { "value": 5, "unit": "cm", "baseValue": 0.05, "baseUnit": "m" }
  },
  "outputs": {
    "A": { "value": 7853.982, "unit": "mm²", "baseValue": 0.007854, "baseUnit": "m²" }
  }
}

Key Features:

✅ No article creation required (stateless)
✅ Define calculations on-the-fly with PQ JSON
✅ Supports Greek letters (α, β, η, ρ, etc.)
✅ Automatic dependency resolution
✅ Unit conversion for inputs and outputs
✅ Mathematical expressions with MathJS

`calcslive_calculate`

Perform unit-aware calculations using existing CalcsLive articles.

Example Usage:

User: "Calculate the kinetic energy of a 1500 kg car traveling at 25 m/s"

AI uses: calcslive_calculate
- articleId: "kinetic-energy"
- inputs: {
    mass: { value: 1500, unit: "kg" },
    velocity: { value: 25, unit: "m/s" }
  }
- outputs: {
    energy: { unit: "kJ" }
  }

Response:

{
  "energy": {
    "value": 468.75,
    "unit": "kJ",
    "expression": "0.5 * mass * velocity^2"
  }
}

`calcslive_validate`

Discover available inputs/outputs for a calculation article.

Example Usage:

User: "What parameters does the hydro power calculation accept?"

AI uses: calcslive_validate
- articleId: "hydro-power"

Response:

{
  "articleTitle": "Hydro Power Calculation",
  "inputPQs": [
    {
      "symbol": "Q",
      "description": "Flow rate",
      "unit": "m³/s",
      "categoryId": "volumetric_flow_rate"
    },
    {
      "symbol": "H",
      "description": "Head",
      "unit": "m",
      "categoryId": "length"
    }
  ],
  "outputPQs": [
    {
      "symbol": "P",
      "description": "Power output",
      "unit": "kW",
      "expression": "rho * g * H * Q * eta"
    }
  ]
}

💡 Usage Examples

Example 1: Unit Conversion

User: "Convert 65 mph to km/h"

AI: Uses CalcsLive to create a simple calculation:

Input: velocity = 65 mph
Output: velocity in km/h = 104.6 km/h

Example 2: Multi-Step Engineering Calculation

User: "Calculate pump power needed for 100 gallons per minute at 50 psi with 85% efficiency"

AI:

Validates pump calculation article
Converts units (gpm → m³/s, psi → Pa)
Performs calculation with dependencies
Returns power in kW

Example 3: Complex Physics Problem

User: "A projectile is launched at 45° with initial velocity 30 m/s. What's the maximum height?"

AI:

Uses projectile motion calculation article
Inputs: angle = 45°, velocity = 30 m/s
Calculates: max_height = (v² × sin²θ) / (2g) = 22.96 m

🔧 Development

Build & Watch

npm run dev

This runs TypeScript in watch mode for development.

Testing Locally

Run the server directly to test:

export CALCSLIVE_API_KEY=your_key_here
npm start

You should see:

CalcsLive MCP server running on stdio
API Base: https://www.calcs.live
Ready to perform unit-aware calculations for AI agents!

📊 API Rate Limits

User Tier	Rate Limit	Trial Period
Free	60 calls/min	30 days
Premium	60 calls/min	N/A (unlimited)
Enterprise	Unlimited	N/A

Note: Trial starts automatically on first API call. Upgrade to Premium before trial expires for continued access.

🐛 Troubleshooting

"API key not found or inactive"

Solution: Check your API key in Account > API Keys

Ensure service type is "MCP Integration (AI Agents)"
Verify key is active (not expired)
Copy key exactly (no extra spaces)

"Article not found"

Solution:

Ensure article is set to Public access level
Use the article's Short ID, not UUID
Verify you own the article (can't access others' articles via API)

"Trial has expired"

Solution: Upgrade to Premium to restore MCP access

Claude Desktop Not Finding Tools

Solution:

Check config file syntax (valid JSON)
Verify path to dist/index.js is correct
Ensure npm run build completed successfully
Restart Claude Desktop completely
Check Claude Desktop logs for errors

"Unknown unit" Error

Solution:

CalcsLive supports both superscript (m³) and caret (m^3) notation
Use caret notation if typing: m^3 instead of m³
Check Units Reference for valid units

🌟 Advanced Usage

Custom API Base URL (Development)

For local development or custom deployments:

{
  "mcpServers": {
    "calcslive": {
      "env": {
        "CALCSLIVE_API_URL": "http://localhost:3000",
        "CALCSLIVE_API_KEY": "your-dev-key"
      }
    }
  }
}

Multiple API Keys

You can configure separate MCP servers for different projects:

{
  "mcpServers": {
    "calcslive-project-a": {
      "command": "node",
      "args": ["..."],
      "env": {
        "CALCSLIVE_API_KEY": "project-a-key"
      }
    },
    "calcslive-project-b": {
      "command": "node",
      "args": ["..."],
      "env": {
        "CALCSLIVE_API_KEY": "project-b-key"
      }
    }
  }
}

📚 Resources

CalcsLive Platform: calcs.live
MCP Documentation: modelcontextprotocol.io
Units Reference: calcs.live/help/units-reference
API Integration Guide: calcs.live/help/api-integration
Create Calculations: calcs.live/editor/new

🤝 Support

Documentation: calcs.live/help
Community: GitHub Discussions
Premium Support: Available for Premium/Enterprise subscribers

📝 License

MIT License - See LICENSE file for details

🚀 What's Next?

Create Custom Calculations: Build your own calculation articles at calcs.live/editor/new
Explore Unit Categories: Browse 75+ categories at Units Reference
Upgrade for More: Premium plans unlock unlimited calculations
Share & Collaborate: Make calculations public for others to use via MCP

Built with ❤️ for AI-powered engineering

Available Tools

3 tools

calcslive_calculateA

Perform unit-aware engineering calculations using CalcsLive articles. Automatically handles unit conversions and dependency calculations. Example: Calculate hydro power with flow rate 150 m³/s and head 25m. Returns calculated outputs with values and units.

ParametersJSON Schema

Name	Required	Description
`articleId`	Yes	Article Short ID (e.g., 'pump-calc-abc'). Use calcslive_validate to discover available articles.
`inputs`	Yes	Input PQ values with units. Example: {velocity: {value: 25, unit: 'm/s'}, mass: {value: 1500, unit: 'kg'}}
`outputs`	No	Optional output unit preferences. Example: {distance: {unit: 'km'}}

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: automatic unit conversions, dependency calculations, and the return format ('calculated outputs with values and units'). However, it doesn't mention error handling, performance characteristics, or authentication requirements that might be relevant for a calculation service.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is perfectly sized with three sentences that each earn their place: purpose statement, key capabilities, and concrete example with return format. It's front-loaded with the core functionality and wastes no words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a calculation tool with 3 parameters, 100% schema coverage, and no output schema, the description provides good context about what the tool does and how it behaves. The main gap is the lack of output schema, which means the description doesn't detail the structure of returned results beyond mentioning 'values and units'.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, providing comprehensive parameter documentation. The description adds minimal value beyond the schema - it mentions 'unit-aware engineering calculations' which aligns with the schema's unit handling, but doesn't provide additional syntax, format details, or constraints beyond what's already in the schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Perform unit-aware engineering calculations'), the resource ('CalcsLive articles'), and distinguishes from siblings by focusing on calculation rather than validation or script execution. The hydro power example concretely illustrates the purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool (engineering calculations with unit handling) and references a sibling tool ('calcslive_validate' for discovering articles). However, it doesn't explicitly state when NOT to use it or provide alternatives beyond the validation reference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

calcslive_run_scriptB

Run stateless unit-aware calculations from Physical Quantity (PQ) script definitions. Define inputs and outputs as PQ objects with symbols, values, units, and expressions. No article creation needed - fully stateless. Automatically handles unit conversions, dependency graphs, and Greek letters. Example: Calculate circle area from radius using expression 'pi * r^2'.

ParametersJSON Schema

Name	Required	Description
`pqs`	Yes	Array of Physical Quantity definitions. Each PQ can be an input (with value) or output (with expression).
`inputs`	No	Optional: Override input PQ values. Example: {r: {value: 5, unit: 'cm'}}
`outputs`	No	Optional: Specify output unit preferences. Example: {A: {unit: 'mm²'}}

TDQS

B3.4/5.0

Behavior3/5

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 effectively describes key traits: 'stateless' (no persistence), 'automatically handles unit conversions, dependency graphs, and Greek letters' (functionality), and 'No article creation needed' (scope limitation). However, it lacks details on error handling, performance limits (e.g., computation time), or output format, which are important 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.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by key features and an example. Each sentence adds value (e.g., explaining statelessness, automation features). It could be slightly more structured by separating usage notes from features, but it avoids redundancy and is efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (3 parameters with nested objects, no output schema, no annotations), the description is moderately complete. It covers the tool's purpose, key behaviors, and provides an example, but lacks details on output format, error cases, or how it differs from siblings. For a stateless calculation tool with rich input schema, more contextual guidance would be beneficial.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

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 parameters thoroughly. The description adds some context by mentioning 'Define inputs and outputs as PQ objects' and providing an example, but it doesn't explain parameter semantics beyond what the schema provides (e.g., how 'pqs' array interacts with 'inputs'/'outputs' overrides). This meets the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Run stateless unit-aware calculations from Physical Quantity (PQ) script definitions.' It specifies the verb ('Run'), resource ('calculations'), and key characteristics ('stateless', 'unit-aware', 'from PQ script definitions'). However, it doesn't explicitly differentiate from sibling tools like 'calcslive_calculate' or 'calcslive_validate', which prevents a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context by stating 'No article creation needed - fully stateless' and providing an example, which suggests this tool is for one-off calculations. However, it doesn't explicitly state when to use this tool versus its siblings ('calcslive_calculate', 'calcslive_validate'), nor does it mention any prerequisites or exclusions. The guidance is present but not comprehensive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

calcslive_validateA

Discover available inputs and outputs for a calculation article. Use this before calculate to understand what parameters are available and their units. Returns article metadata including all input/output PQs with descriptions, units, and available unit options.

ParametersJSON Schema

Name	Required	Description	Default
`articleId`	Yes	Article Short ID to validate (e.g., 'hydro-power-calc')

TDQS

A4.2/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It describes the return content (metadata with PQs, descriptions, units) but lacks details on error handling, rate limits, or authentication needs. It adds some behavioral context but not comprehensively.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the main purpose, followed by usage context and return details in two efficient sentences. Every sentence adds value without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple single-parameter input and no output schema, the description adequately covers purpose, usage, and return format. However, as a tool with no annotations, it could benefit from more behavioral details like error cases or permissions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the schema already documents the single parameter 'articleId' with description and type. The description adds no additional parameter semantics beyond implying it's used for validation, aligning with the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with specific verbs ('discover available inputs and outputs') and resource ('calculation article'), and distinguishes it from sibling tools by explicitly mentioning its preparatory role before 'calculate'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides explicit guidance on when to use this tool ('before calculate to understand what parameters are available') and names an alternative ('calculate'), making it clear this is for discovery rather than execution.

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.

3 tool updatesDec 30, 2025
- First observedcalcslive_calculate
- First observedcalcslive_run_script
- First observedcalcslive_validate

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.9/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose with no overlap: 'calcslive_calculate' performs calculations using articles, 'calcslive_run_script' runs stateless scripts, and 'calcslive_validate' discovers metadata. The descriptions explicitly differentiate their functions, making misselection unlikely.

Naming Consistency5/5

All tool names follow a consistent 'calcslive_' prefix with descriptive suffixes ('calculate', 'run_script', 'validate'), using snake_case uniformly. This pattern is predictable and enhances readability across the set.

Tool Count4/5

With 3 tools, the count is slightly low but reasonable for the server's purpose of unit-aware engineering calculations. It covers core operations (calculate, script execution, validation), though additional tools for managing articles or scripts might enhance scope.

Completeness4/5

The tool set provides solid coverage for performing and validating calculations, including both article-based and stateless script approaches. A minor gap exists in lifecycle management (e.g., creating or listing articles), but agents can work around this with the available tools.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

metamodel A
io.github.joegra2003
AI-callable calculators and engineering models with real formulas. No hallucinated math.
Developer Tools AI & Machine Learning
42
Unit & Currency Converter A
io.github.guptaprakhariitr
60+ units, live FX, timezones, and date arithmetic for AI agents.
Finance Location Services
621
arithym AOAuth
xyz.arithym
Precision math engine for AI agents. 203 exact methods. Zero hallucination.
Developer Tools Code Execution Autonomous Agents
2
Inferventis MCP Server A
ai.bankee
Loan & mortgage calculator, compound interest, ROI, crypto prices, FX conversion for AI agents.
Finance Cryptocurrency
202

Related MCP Servers

pyResToolbox MCP Server
Research & Data
gabrielserrao
A
license
A
quality
D
maintenance
Enables AI assistants to perform petroleum engineering calculations including PVT analysis, well performance modeling, and reservoir simulation support using industry-standard correlations and field units.
Updated 6 months ago (2026-03-11 09:04 UTC)
45
44
GPL 3.0
Corrosion Engineering MCP
Research & Data Biology & Medicine
puran-water
A
license
Not graded
quality
F
maintenance
Provides AI agents with physics-based corrosion engineering calculations, from rapid handbook lookups to mechanistic electrochemical models with dual-tier pitting assessment for material compatibility screening and corrosion rate prediction.
Updated 6 months ago (2026-03-10 02:54 UTC)
1
MIT
ucon-mcp
Developer Tools AI & Machine Learning
the-radiativity-company
A
license
Not graded
quality
B
maintenance
Verified unit conversion and dimensional analysis for AI agents. 190+ units, 31 domain formulas (clinical, physics, aerospace, SRE), physical constants with uncertainty propagation. Refuses invalid conversions structurally: the tool that won't convert mg to mL and knows the difference between torque and energy.
Updated 3 months ago (2026-06-17 08:11 UTC)
AGPL 3.0
precision-math-mcp
Developer Tools
nerdo
A
license
Not graded
quality
D
maintenance
Provides LLMs with accurate mathematical computation through a real calculator powered by math.js, offering tools for arithmetic, algebra, calculus, unit conversion, and more.
Updated 7 months ago (2026-01-29 23:27 UTC)
15
3
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/CalcsLive/calcslive-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

CalcsLive MCP Server

🎯 What is This?

Example

📋 Prerequisites

🚀 Quick Start

1. Install Dependencies

2. Build the Server

3. Configure Claude Desktop

4. Restart Claude Desktop

5. Verify Installation

🔧 Claude Code (VS Code Extension) Setup

1. Install and Build

2. Add MCP Server via Claude CLI

3. Verify in VS Code

Alternative: Manual Configuration

🛠️ Available Tools

calcslive_run_script ⭐ NEW

calcslive_calculate

calcslive_validate

💡 Usage Examples

Example 1: Unit Conversion

Example 2: Multi-Step Engineering Calculation

Example 3: Complex Physics Problem

🔧 Development

Build & Watch

Testing Locally

📊 API Rate Limits

🐛 Troubleshooting

"API key not found or inactive"

"Article not found"

"Trial has expired"

Claude Desktop Not Finding Tools

"Unknown unit" Error

🌟 Advanced Usage

Custom API Base URL (Development)

Multiple API Keys

📚 Resources

🤝 Support

📝 License

🚀 What's Next?

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

`calcslive_run_script` ⭐ NEW

`calcslive_calculate`

`calcslive_validate`