energy-mcp
Integrates with LangChain's MCP adapters to provide AI agents with tools for retrieving and analyzing hourly electricity demand, peak loads, and temperature data across US balancing authorities.
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., "@energy-mcpCompare CISO and PJM demand for the first week of January"
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.
energy-mcp
An MCP server for US electricity demand and weather data. It exposes the data as MCP tools, resources, and prompts, runs locally over stdio, and works with any MCP client: Claude Desktop, Claude Code, LangChain's MCP adapters, or the MCP Inspector.
The data ships as a small SQLite file of real observations, so you can clone the repo and run it without a database or an API key.
Python 3.11+ · MCP SDK 1.x (FastMCP) · MIT
What is MCP
MCP is an open protocol from Anthropic. It gives an AI client one standard way to call external tools and read external data, instead of a custom integration per app. A server advertises what it offers, and a client connects and uses it. Servers can offer three things:
Tools: functions the model can call.
Resources: read-only content the client loads as context.
Prompts: reusable templates a user can pick.
This server provides all three.
Related MCP server: euenergy-mcp
Tools, resources, and prompts
Tools:
list_regions(): regions available, with row counts and date coverage.query_demand(region, start, end, limit=168): hourly demand in MWh for a date range.daily_demand(region, start, end): daily average, peak, and minimum.peak_demand(region, start, end): the single highest-demand hour.compare_regions(start, end, regions=None): average and peak across regions.demand_vs_weather(region, start, end): daily demand joined to that region's temperature.
Resources:
schema://energy: a plain description of the tables.docs://coverage: which regions and dates are currently loaded.
Prompts:
analyze_demand(region): a starter that walks a region through the tools.
Quickstart
You need uv.
git clone https://github.com/visethchapman/energy-mcp
cd energy-mcp
uv run energy-mcp # starts the server on stdio; it waits for a clientTo click around the tools in a UI, use the MCP Inspector:
uv run mcp dev src/energy_mcp/server.pyConnect it to a client
Claude Desktop
Add this to claude_desktop_config.json (on macOS,
~/Library/Application Support/Claude/claude_desktop_config.json) and restart
Claude Desktop:
{
"mcpServers": {
"energy": {
"command": "uv",
"args": ["--directory", "/absolute/path/to/energy-mcp", "run", "energy-mcp"]
}
}
}Claude Code
claude mcp add energy -- uv --directory /absolute/path/to/energy-mcp run energy-mcpThen ask in plain language, and the client picks the tools:
"Which US grid had the highest average demand in July 2024?"
"When did ERCOT peak in 2024, and how hot was Houston that day?"
"Compare CISO and PJM demand for the first week of January."
Example output
Real results from the bundled data when a client calls a tool:
> peak_demand(region="ERCO", start="2024-01-01", end="2024-12-31")
{ "region": "ERCO", "period": "2024-08-20 23:00:00", "demand_mwh": 85544.0 }
> compare_regions(start="2024-07-01", end="2024-07-31")
[ {"region":"PJM", "avg_mwh":109674.4, "peak_mwh":153121.0},
{"region":"ERCO", "avg_mwh": 60200.6, "peak_mwh": 81200.0},
{"region":"CISO", "avg_mwh": 32008.4, "peak_mwh": 44727.0},
{"region":"NYIS", "avg_mwh": 21494.1, "peak_mwh": 28990.0} ]
> demand_vs_weather(region="ERCO", start="2024-07-01", end="2024-07-03")
[ {"day":"2024-07-01", "avg_mwh":67736.3, "tmax_c":37.8, "tmin_c":26.7},
{"day":"2024-07-02", "avg_mwh":68463.9, "tmax_c":36.1, "tmin_c":27.2},
{"day":"2024-07-03", "avg_mwh":68017.8, "tmax_c":34.4, "tmin_c":26.7} ]demand_vs_weather is the interesting one. ERCOT demand climbs with Houston
temperature in summer (air-conditioning load), and the tool returns both series
so a model can point at the link.
Data
Everything is real, trimmed to calendar year 2024 to keep the file around 5 MB.
Table | Source | Rows |
| EIA Open Data API, 4 balancing authorities: ERCO, CISO, PJM, NYIS | ~35k |
| NOAA GHCN-Daily, one station near each region's main load zone | ~1.5k |
| NOAA station metadata | 4 |
| table documentation | 3 |
The SQLite file is committed, so nothing is fetched at runtime. To rebuild it or widen the date range (this needs a free EIA API key):
uv run --extra build python scripts/build_sample_db.py --start 2023-01-01 --end 2024-12-31Set ENERGY_MCP_DB to point the server at a different SQLite file.
Safety
Read-only. The database is opened with SQLite
mode=ro, so no tool can write.Parameterized SQL. Arguments are bound as parameters, not formatted into the query string, so they cannot inject SQL.
Validated inputs. Region and date arguments are checked before they reach the database, and bad input comes back as a clear error the model can act on.
No secrets to run. The data is in the repo; the EIA key is only for rebuilding it.
Development
uv run pytest
uv run mcp dev src/energy_mcp/server.pyLayout:
src/energy_mcp/
server.py # FastMCP server: tools, resources, prompts
db.py # read-only SQLite access
data/energy_sample.sqlite # bundled real data
scripts/build_sample_db.py # how the sample was assembled
tests/test_tools.pyThe project uses the MCP 1.x SDK (the FastMCP API), which is what the current
Claude Desktop docs and the mcp CLI use. The 2.x SDK is a newer redesign.
Related
energy-text2sql is a text-to-SQL agent over the same EIA and NOAA data. Same data, different interface: one answers questions by writing SQL, this one serves the data as MCP tools.
License
MIT
Available Tools
6 toolscompare_regionsA
Compare average and peak demand across regions over the same date range. Useful for questions like "which grid was busiest last summer?".
Args:
start: Inclusive start date, 'YYYY-MM-DD'.
end: Inclusive end date, 'YYYY-MM-DD'.
regions: Optional subset of region codes. Defaults to all regions.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | ||
| start | Yes | ||
| regions | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not disclose behavioral traits such as data aggregation details, performance implications for many regions, or any side effects. Since no annotations are provided, the description carries the full burden but only provides basic usage info.
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 concise, with a clear purpose and example, followed by parameter details. The example is helpful, though the 'Args' section could be integrated more seamlessly.
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 there is an output schema and sibling tools exist, the description adequately distinguishes the tool and explains inputs. It could be more complete by mentioning that the output includes both average and peak metrics, or by noting that region codes can be obtained via list_regions.
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 explains the start and end parameters with date format and inclusiveness, and clarifies the optional regions parameter defaults to all. However, schema coverage is 0%, so the description compensates partially but does not specify accepted region codes or error handling for invalid 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 states it compares average and peak demand across regions over a date range, with a specific example of use, clearly distinguishing it from siblings like peak_demand or daily_demand.
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 an example question to indicate when to use the tool, but does not explicitly state when not to use it or mention alternative tools for single-region queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
daily_demandA
Return daily demand statistics (average, peak, minimum MWh) for one region over a date range. Use this instead of query_demand for ranges longer than a few days.
Args:
region: Balancing authority code.
start: Inclusive start date, 'YYYY-MM-DD'.
end: Inclusive end date, 'YYYY-MM-DD'.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | ||
| start | Yes | ||
| region | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so description carries full burden. It states the output includes average, peak, and minimum MWh, likely aggregated daily. However, it does not disclose whether the tool is read-only, whether it handles time zones, or what happens if data is missing for a date range. These gaps limit transparency.
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 plus a parameter list, all relevant. It front-loads the purpose and usage recommendation. The parameter list is typical for Google-style docstrings but adds a bit of vertical space. No wasted sentences.
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 3 simple string parameters, an output schema exists (presumably documenting return fields), and no nested objects, the description is largely complete. It provides purpose, usage, and parameter formats. Missing details like valid region codes or date range limits are minor given the output schema's presumed coverage.
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 explains region as a balancing authority code, start and end as inclusive dates with 'YYYY-MM-DD' format. This adds significant meaning beyond the bare schema property titles. However, it does not specify valid region codes or constraints on date range length.
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 returns daily demand statistics (average, peak, minimum MWh) for a region over a date range. It distinguishes itself from the sibling query_demand by explicitly recommending use for ranges longer than a few days.
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?
Provides explicit guidance on when to use this tool over query_demand ('for ranges longer than a few days') and lists three parameters with format hints. No exclusions or alternatives are elaborated beyond query_demand, but the recommendation is specific and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
demand_vs_weatherA
Join daily average demand against daily temperature for a region, using the NOAA weather station nearest that region's main load zone. Reveals the demand-temperature relationship (heating and cooling load).
Args:
region: Balancing authority code.
start: Inclusive start date, 'YYYY-MM-DD'.
end: Inclusive end date, 'YYYY-MM-DD'.
Returns one row per day: average demand (MWh) and that day's max/min temp (C).
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | ||
| start | Yes | ||
| region | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for transparency. It discloses the method ('using the NOAA weather station nearest that region's main load zone'), the output structure (one row per day, average demand MWh, max/min temp C), and the join logic. It does not mention potential limitations like missing data or time zone handling, but the core behavior is well explained.
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 concise and well-structured: a lead sentence explaining the purpose, followed by a bullet-like Args list. Every sentence adds value, and there is no redundancy. The key information is front-loaded.
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 required parameters, output schema exists), the description is complete. It explains the input format, the join logic, and the output structure (one row per day, demand and temperature). The presence of an output schema means the full return format is already defined, so the description's summary is sufficient.
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 provides clear, actionable semantics for all three parameters. It explains region as 'Balancing authority code', start and end as 'Inclusive start date, YYYY-MM-DD' and 'Inclusive end date, YYYY-MM-DD'. This adds significant value beyond the schema, which only has titles. With 0% schema description coverage, the description fully compensates.
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 purpose: joining daily average demand against daily temperature for a region to reveal the demand-temperature relationship. It uses a specific verb ('join') and resource ('demand vs weather') and distinguishes itself from sibling tools like query_demand, daily_demand, and compare_regions by focusing on the combined analysis.
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 explains the tool's use case (revealing heating and cooling load relationships) but does not explicitly state when to avoid it or name alternatives. However, the context (sibling tools) and the description's wording imply that this tool is for combined demand-weather analysis, which is a distinct purpose among the siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_regionsA
List the balancing authorities available, with row counts and the date range of demand data for each. Call this first to see what you can query.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries the burden. It clearly indicates a read operation (listing), no side effects mentioned but context implies safe discovery. Could be more explicit about read-only nature, but adequate for a listing 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?
Two sentences: first explains output, second provides usage guidance. Front-loaded, no wasted words, each sentence 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?
For a zero-parameter listing tool with an output schema, the description tells what is returned (balancing authorities, row counts, date ranges) and when to use it. Complete for the agent to understand and invoke 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?
No parameters exist, and schema coverage is 100% trivially. Description does not need to add parameter info. Baseline 4 is appropriate as no value beyond schema is necessary.
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?
Description clearly states the tool lists balancing authorities with row counts and date ranges. Distinguishes from siblings by specifying the output content (row counts, date ranges) and by positioning it as a discovery tool to be called first.
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?
Explicitly says 'Call this first to see what you can query,' providing a clear when-to-use instruction and implying it is a prerequisite for other tools like query_demand or daily_demand.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
peak_demandA
Find the single highest-demand hour for one region over a date range, returning the timestamp and the demand in MWh.
Args:
region: Balancing authority code.
start: Inclusive start date, 'YYYY-MM-DD'.
end: Inclusive end date, 'YYYY-MM-DD'.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | ||
| start | Yes | ||
| region | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully carries the burden of behavioral disclosure. It states that the tool returns a single timestamp and demand value, which is clear. However, it does not cover edge cases (e.g., no data in range, invalid region), error handling, or any mutation aspects. For a simple read-only query, this is adequate but not thorough.
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: one purpose sentence followed by a parameter list. Every sentence is necessary and there is no fluff. The key information is front-loaded in the first sentence.
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 simplicity of the tool (3 string parameters, no output schema, no annotations), the description covers purpose, parameters, and return value. It is complete enough for an agent to use correctly. Missing details like error handling or behaviour when no data exists are minor gaps for such a straightforward query.
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 explain parameters. It does: region is a 'balancing authority code', start and end are 'inclusive start/end date' with format 'YYYY-MM-DD'. This adds meaningful context beyond the schema's plain string type. However, it could be improved by providing examples or a list of valid region codes.
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 a specific verb 'Find' and identifies the resource as 'single highest-demand hour', with clear scope of 'one region over a date range'. It also mentions the return values (timestamp and demand in MWh). This clearly distinguishes it from sibling tools like query_demand (general data) and daily_demand (per-day peaks).
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 when it is appropriate, when not to use it, or how it compares to sibling tools like query_demand, daily_demand, or compare_regions. The context of 'one region' is stated but not contrasted with multi-region tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
query_demandA
Return hourly electricity demand (MWh) for one region over a date range.
Args:
region: Balancing authority code (e.g. ERCO, CISO, PJM, NYIS).
start: Inclusive start date, 'YYYY-MM-DD'.
end: Inclusive end date, 'YYYY-MM-DD'.
limit: Max rows to return (default 168 = one week of hours).
Returns hourly rows ordered by time. For long ranges prefer daily_demand.
| Name | Required | Description | Default |
|---|---|---|---|
| end | Yes | ||
| limit | No | ||
| start | Yes | ||
| region | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations exist, the description carries full burden. It discloses sorting behavior ('Returns hourly rows ordered by time'), the default limit meaning (168 = one week of hours), and the effect of using long ranges (prefer daily_demand). It does not mention pagination behavior, whether the limit is a hard cap or default, or what happens if range exceeds limit, but the essential behavioral traits are adequately covered given the tool's simplicity.
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 concise at under 70 words, front-loaded with the core purpose and unit (MWh), then uses a structured Args list for parameters, followed by behavior and usage guidance. Every sentence serves a distinct purpose, and there is no redundancy or fluff.
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 4 parameters (3 required, 0 enums, 0% schema coverage) and an output schema, the description appropriately covers input semantics, behavior (ordered hourly rows), and usage guidance with sibling reference. With no annotations, it compensates well. The output schema presumably describes return fields, so the description's lack of explicit return format is acceptable.
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 compensate. It provides clear, helpful semantics for each parameter: region meaning (Balancing authority code with examples), start/end format ('YYYY-MM-DD') with 'inclusive' clarified, and limit meaning (max rows, default 168 = one week of hours). This adds substantial value beyond the schema labels (e.g., 'Region', 'Start', 'End', 'Limit').
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 explicitly states the tool returns hourly electricity demand (MWh) for one region over a date range, using a specific verb 'Return' and identifying the resource (demand data), region, and output unit (MWh). It also distinguishes itself from siblings like daily_demand and peak_demand by mentioning hourly data and the limit default of 168 rows (one week of hours), and directly points to daily_demand as an alternative for long ranges.
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 gives clear when-to-use guidance: 'For long ranges prefer daily_demand', explicitly naming the sibling alternative. It also defines the purpose (hourly data for one region) implicitly telling the agent not to use this for multiple regions or aggregated summaries (compare_regions, peak_demand). The Args docstring reinforces required parameters and their formats.
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.
6 tool updates
v0.1.0- First observed
compare_regions - First observed
daily_demand - First observed
demand_vs_weather - First observed
list_regions - First observed
peak_demand - First observed
query_demand
TDQS
Each tool serves a distinct purpose: listing regions, retrieving hourly/daily/peak demand, comparing across regions, and correlating demand with weather. No functional overlap.
All six tool names follow a consistent verb_noun pattern with snake_case: list_regions, query_demand, daily_demand, peak_demand, compare_regions, demand_vs_weather. Naming is predictable and clear.
With 6 tools, the server is well-scoped for its purpose – covering region discovery, multiple demand granularities, inter-region comparison, and weather integration. No bloat or deficiency.
Core demand querying workflows are fully supported. A minor gap is the lack of a raw hourly multi-region query (compare_regions only returns averages/peaks). Overall, the surface is thorough for typical use cases.
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
MCP server for building and testing AI agents with multi-model experimentation and insights.
- UnifAPIOAuthcom.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
MCP server for querying and analyzing data from ad platforms, analytics tools, and spreadsheets
Hosted MCP server exposing US hospital procedure cost data to AI assistants
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceA production-ready Python MCP server providing tools for fetching live weather data, querying local SQLite databases, reading files, summarizing webpages, and performing safe mathematical calculations. It enables MCP-compatible LLM clients to execute these tasks autonomously as part of agentic workflows.-
- FlicenseNot gradedqualityBmaintenanceA read-only MCP server that exposes European day-ahead electricity prices for ~41 bidding zones via tools like hourly prices, cheapest hours, current price, and cross-zone summary, enabling AI agents to query energy market data.1-
- AlicenseNot gradedqualityCmaintenanceA no-API-key-required MCP server that wraps Open-Meteo APIs to provide geocoding and weather forecast data, enabling city lookups and multi-day forecasts through tools, resources, and prompts.MIT
- FlicenseAqualityCmaintenanceAn MCP server that exposes the U.S. Energy Information Administration (EIA) Open Data API, enabling LLMs to browse and query energy data across 17 datasets with generic, composable tools.4-
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/visethchapman/energy-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server