Climatiq MCP Server
Supports loading Climatiq API key from a .env configuration file for secure credential management.
Provides repository access for the MCP server code and includes demo examples hosted on GitHub assets.
Includes example Jupyter notebook for demonstrating Climatiq API usage and carbon calculation capabilities.
Click on "Deploy 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., "@Climatiq MCP Server calculate the carbon emissions for a 500-mile flight from New York to Chicago"
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.
Climatiq MCP Server
 
A Model Context Protocol (MCP) server for accessing the Climatiq API to calculate carbon emissions. This allows AI assistants to perform real-time carbon calculations and provide climate impact insights.
Demo
https://github.com/user-attachments/assets/c253d6d1-ccf6-4c14-965e-6023ba2a0296
https://github.com/user-attachments/assets/d61c1181-acf6-4d9f-9a48-537fc64ac4c3
Related MCP server: RL-MCP
Features
This MCP server integrates with the Climatiq API to provide carbon emission calculations for AI assistants:
Tools
set-api-key: Configure the Climatiq API key used for authentication
electricity-emission: Calculate carbon emissions from electricity consumption
travel-emission: Calculate carbon emissions from travel by car, plane, or train
search-emission-factors: Search for specific emission factors in the Climatiq database
custom-emission-calculation: Perform custom calculations using specific emission factors
cloud-computing-emission: Calculate emissions from cloud computing resources usage
freight-emission: Calculate emissions from freight transportation
procurement-emission: Calculate emissions from procurement spending
hotel-emission: Calculate emissions from hotel stays
travel-spend: Calculate emissions from travel expenses
Resources
Carbon calculation results are exposed as resources with a
climatiq://calculation/{id}URI schemeEach resource contains detailed information about an emission factor and calculation results
Prompts
climate-impact-explanation: Generate natural language explanations about the climate impact of specific emission calculations
Installation
From Source
This project uses uv for virtual environment and dependency management. Make sure to install uv first.
# Clone the repository
git clone https://github.com/your-org/climatiq-mcp-server.git
cd climatiq-mcp-server
# Create a virtual environment
uv venv
# Activate the virtual environment
# On macOS/Linux:
source .venv/bin/activate
# On Windows:
.venv\Scripts\activate
# Install dependencies with development extras
uv sync --dev --extra allUsing uv
uv pip install climatiq-mcp-serverAPI Key Configuration
The server requires a Climatiq API key to function. You have several options to provide it:
Environment Variable: Set the
CLIMATIQ_API_KEYenvironment variable before starting the serverexport CLIMATIQ_API_KEY=your_climatiq_api_keyConfiguration During Installation:
CLIMATIQ_API_KEY=your_climatiq_api_key uv pip install climatiq-mcp-serverset-api-key Tool: Use the
set-api-keytool to configure it during runtime within the AI assistantConfiguration File: Create a
.envfile in the project directory:CLIMATIQ_API_KEY=your_climatiq_api_key
To get a Climatiq API key:
Sign up at app.climatiq.io
Follow the instructions at Getting API Keys
Running the Server
The server can be started directly from the command line:
climatiq-mcp-serverSetup in AI Assistants
Claude Desktop
On MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json
On Windows: %APPDATA%/Claude/claude_desktop_config.json
"mcpServers": {
"climatiq-mcp-server": {
"command": "climatiq-mcp-server",
"env": {
"CLIMATIQ_API_KEY": "your_climatiq_api_key"
}
}
}Examples and Utilities
Examples Directory
The examples/ directory contains:
climatiq.ipynb: A Jupyter notebook demonstrating direct API usage with Climatiq
simple_test.py: A simple utility for testing the API integration directly without MCP protocol
# Run the simple test
python examples/simple_test.pyUtility Scripts
The utils/ directory contains several helpful scripts:
Test Client
The test_client.py script tests all the tools, prompts, and resources:
python utils/test_client.pyLLM Example Client
The llm_example_client.py script demonstrates how a Large Language Model (like Claude) could interact with the Climatiq MCP server:
python utils/llm_example_client.pyKey features:
Complete API wrapper with error handling and timeout management
Resource and result caching to preserve calculation history
Example prompts showing how to generate natural language explanations
Demonstrates electricity emission, travel emission, and emission factor search capabilities
CLI Tool
A command-line interface tool for direct API access without the MCP server complexity:
# For electricity emissions
python utils/climatiq_cli.py electricity --energy 1000 --unit kWh --region US
# For travel emissions
python utils/climatiq_cli.py travel --mode car --distance 100 --unit km --region USRun MCP Server Script
Use the run_mcp_server.py script to directly run the server without installing:
python utils/run_mcp_server.pyKey Concepts
Activity IDs
An Activity ID is a key concept in Climatiq's API that groups similar emission factors together:
Each emission factor in the Climatiq database has an activity ID
Activity IDs group emission factors describing the same activity across regions, years, sources, etc.
Examples:
electricity-supply_grid-source_residual_mix(electricity),passenger_vehicle-vehicle_type_car(car travel)
Calculation Methods
The Climatiq MCP server supports multiple calculation methods:
Distance-based method for travel emissions
Advanced travel calculations with origin-destination pairs
Spend-based method for when you only have expenditure data
Direct calculations using specific emission factors
Troubleshooting
API Key Issues
Ensure
CLIMATIQ_API_KEYis set correctly in your environment or .env fileVerify the API key is active in your Climatiq dashboard
Use
examples/simple_test.pyto check if your API key works correctly
Advanced Usage
For detailed documentation on using specific tools and advanced features, see the docs/README.md file.
About Climatiq
Climatiq provides a powerful API for carbon intelligence, allowing you to calculate emissions from electricity usage, transportation, procurement, and more. This MCP server makes those capabilities accessible to AI assistants through the Model Context Protocol.
For more information about Climatiq, visit climatiq.io.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Available Tools
10 toolscloud-computing-emissionC
Calculate emissions from cloud computing services by provider, service type, and region to assess digital carbon footprint.
Inputs: provider (required), service (required), region (required), usage_amount (required), +1 more.
custom-emission-calculationB
Calculate emissions using any specific emission factor identified by its activity_id, allowing for precise and flexible carbon calculations.
Inputs: activity_id (required), value (required), unit (required).
electricity-emissionC
Calculate carbon emissions from electricity consumption based on energy amount and regional grid mix.
Inputs: energy (required), energy_unit (required), region.
freight-emissionC
Calculate emissions from freight transportation across different modes (truck, rail, ship, air) based on weight and distance.
Inputs: mode (required), weight (required), distance (required), weight_unit, +1 more.
hotel-emissionB
Calculate carbon emissions from hotel stays based on the number of nights stayed and the location of the hotel.
Inputs: hotel_nights (required), location (required), year.
procurement-emissionB
Calculate Scope 3.1 emissions from procurement spending using economic input-output life cycle assessment methods.
Inputs: amount (required), category (required), currency, country.
search-emission-factorsB
Search Climatiq's database for emission factors by keyword, category, region, year, source, and other metadata to find appropriate factors for calculations.
Inputs: query (required), category, region, year, +3 more.
set-api-keyA
Set the Climatiq API key for authentication. This allows the server to make authorized requests to the Climatiq API.
Inputs: api_key (required).
travel-emissionC
Calculate emissions from passenger travel via car, plane, or train, with options for vehicle types and passenger count.
Inputs: mode (required), distance, distance_unit, passengers, +7 more.
travel-spendC
Calculate carbon emissions from travel-related spending based on spend type, amount, currency, location, and year.
Inputs: spend_type (required), money (required), money_unit (required), spend_location (required), +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 10 tools
Each tool has a clearly distinct purpose targeting specific domains like cloud computing, electricity, freight, hotel stays, procurement, travel, and emission factor search. There is no overlap in functionality, and the descriptions precisely differentiate each tool's scope, making misselection unlikely.
All tool names follow a consistent hyphenated pattern with a clear noun-emission or action-emission structure (e.g., cloud-computing-emission, search-emission-factors, set-api-key). This uniformity enhances readability and predictability across the tool set.
With 10 tools, the server is well-scoped for carbon emission calculations across various domains. Each tool earns its place by covering distinct aspects like transportation, energy, procurement, and authentication, providing a comprehensive yet manageable surface for the Climatiq API.
The tool set offers complete coverage for carbon emission calculations, including key domains (electricity, travel, freight, procurement), a search tool for emission factors, a custom calculation option, and authentication via set-api-key. There are no obvious gaps, enabling agents to handle full workflows from data lookup to emission assessment.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
The official Model Context Protocol server for Ambee. It gives any MCP-compatible AI assistant — Claude, ChatGPT, Cursor, VS Code, Ollama, and more direct access to live air quality, pollen, and weather data. To get started, including information on signing up and obtaining your Ambee key, check out the Ambee documentation on https://docs.ambeedata.com
A Model Context Protocol server for Wix AI tools
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn open standard server implementation that enables AI assistants to directly access APIs and services through Model Context Protocol, built using Cloudflare Workers for scalability.-
- FlicenseNot gradedqualityDmaintenanceA Model Context Protocol server that provides AI models with structured access to external data and services, acting as a bridge between AI assistants and applications, databases, and APIs in a standardized, secure way.2-
- AlicenseAqualityDmaintenanceA Model Context Protocol server providing tools for DB queries, API calls, file I/O, and text transformations, enabling AI agents like Claude to perform real-world actions.10MIT
- AlicenseNot gradedqualityDmaintenanceModel Context Protocol server that standardizes tool discovery, execution, and context management for AI applications.MIT