greenpick 0.6.3__tar.gz → 0.7.0__tar.gz

{greenpick-0.6.3/src/greenpick.egg-info → greenpick-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.6.3
+Version: 0.7.0
 Summary: Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs.
 Author-email: "Data Science Advisers, LLC" <info@datascienceadvisers.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT" />
   <img src="https://img.shields.io/badge/tests-passing-brightgreen" alt="Tests: passing" />
   <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+" />
-  <img src="https://img.shields.io/badge/MCP%20tools-19-0ea5e9" alt="MCP tools: 19" />
+  <img src="https://img.shields.io/badge/MCP%20tools-20-0ea5e9" alt="MCP tools: 20" />
 </p>
 
 A **design-time sustainability co-pilot** that runs as an MCP server inside your vibe-coding
@@ -52,7 +52,7 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 19 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> **Status: working — 20 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
 > IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
@@ -143,7 +143,7 @@ See `docs/user-questions-backlog.md`.
 
 ## MCP tools
 
-19 tools, grouped by what you're trying to do.
+20 tools, grouped by what you're trying to do.
 
 ### Pick a region
 
@@ -176,6 +176,7 @@ See `docs/user-questions-backlog.md`.
 |------|--------------|
 | `greener_instance_family` | A greener same-size family in the same region via perf-per-watt (newer generation / ARM Graviton-class does the same work on less energy). |
 | `rightsizing_check` | Right-sizing (the #1 FinOps win) with a carbon twin: if you're over-provisioned, a smaller size cuts **both** cost and carbon → the right-sized target with monthly $ and kg CO₂ saving. |
+| `serverless_check` | For a mostly idle or spiky service: an always-on server vs. paying per request (AWS Lambda, Cloud Run). Monthly cost of each, the break-even request count, and estimated carbon (serverless as a lower bound). |
 | `offhours_check` | For dev/test/staging that doesn't need to run 24/7: the monthly $ and kg CO2 saved by running it only N hours a week. Compute only, directional. |
 | `data_locality_egress_check` | Warn when running compute away from where your data lives backfires: directional egress $ + coarse transfer carbon, and whether a greener-region move is still a net win. |
 | `migration_payoff` | Does moving the **data** to the compute's region pay off? Payback in months, one-off vs monthly egress and transfer carbon, net over 12 months. Egress only. |

{greenpick-0.6.3 → greenpick-0.7.0}/README.md

@@ -14,7 +14,7 @@
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT" />
   <img src="https://img.shields.io/badge/tests-passing-brightgreen" alt="Tests: passing" />
   <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+" />
-  <img src="https://img.shields.io/badge/MCP%20tools-19-0ea5e9" alt="MCP tools: 19" />
+  <img src="https://img.shields.io/badge/MCP%20tools-20-0ea5e9" alt="MCP tools: 20" />
 </p>
 
 A **design-time sustainability co-pilot** that runs as an MCP server inside your vibe-coding
@@ -22,7 +22,7 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 19 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> **Status: working — 20 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
 > IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
@@ -113,7 +113,7 @@ See `docs/user-questions-backlog.md`.
 
 ## MCP tools
 
-19 tools, grouped by what you're trying to do.
+20 tools, grouped by what you're trying to do.
 
 ### Pick a region
 
@@ -146,6 +146,7 @@ See `docs/user-questions-backlog.md`.
 |------|--------------|
 | `greener_instance_family` | A greener same-size family in the same region via perf-per-watt (newer generation / ARM Graviton-class does the same work on less energy). |
 | `rightsizing_check` | Right-sizing (the #1 FinOps win) with a carbon twin: if you're over-provisioned, a smaller size cuts **both** cost and carbon → the right-sized target with monthly $ and kg CO₂ saving. |
+| `serverless_check` | For a mostly idle or spiky service: an always-on server vs. paying per request (AWS Lambda, Cloud Run). Monthly cost of each, the break-even request count, and estimated carbon (serverless as a lower bound). |
 | `offhours_check` | For dev/test/staging that doesn't need to run 24/7: the monthly $ and kg CO2 saved by running it only N hours a week. Compute only, directional. |
 | `data_locality_egress_check` | Warn when running compute away from where your data lives backfires: directional egress $ + coarse transfer carbon, and whether a greener-region move is still a net win. |
 | `migration_payoff` | Does moving the **data** to the compute's region pay off? Payback in months, one-off vs monthly egress and transfer carbon, net over 12 months. Egress only. |

{greenpick-0.6.3 → greenpick-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "greenpick"
-version = "0.6.3"
+version = "0.7.0"
 description = "Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs."
 readme = "README.md"
 requires-python = ">=3.11"

{greenpick-0.6.3 → greenpick-0.7.0}/src/greenpick/__init__.py

@@ -4,7 +4,7 @@ Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
 delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
 """
 
-__version__ = "0.6.3"
+__version__ = "0.7.0"
 
 # httpx logs every request URL at INFO, and our live sources pass their API key / token as a URL
 # query parameter — so at the default log level the secret would land in the MCP client's logs.

greenpick-0.7.0/src/greenpick/data/power.json

@@ -0,0 +1,21 @@
+{
+  "_comment": "Simple, documented power model for the carbon ESTIMATE. Turns a workload (vCPU, RAM) into average watts, then kWh/month. These are deliberately rough published-style coefficients; this is an estimate, not a measurement. PUE is the datacenter overhead multiplier.",
+  "watts_per_vcpu": 3.5,
+  "watts_per_gb_ram": 0.4,
+  "pue_default": 1.2,
+  "_sources": "Coefficients are order-of-magnitude figures consistent with public cloud power-model literature (e.g. Cloud Carbon Footprint methodology). Replace with cited values before any non-directional use.",
+  "_utilization_comment": "Used only when a caller gives a CPU utilisation. Per-vCPU power scales from an idle minimum to a full-load maximum: watts = min + utilisation x (max - min) (the Cloud Carbon Footprint / Etsy Cloud Jewels method). Without a utilisation GreenPick keeps the flat watts_per_vcpu above, which equals the AWS full-load figure, so it is a conservative (high) estimate. RAM watts do not change with load.",
+  "min_watts_per_vcpu": {
+    "aws": 0.74,
+    "gcp": 0.71,
+    "azure": 0.78
+  },
+  "max_watts_per_vcpu": {
+    "aws": 3.5,
+    "gcp": 4.26,
+    "azure": 3.76
+  },
+  "serverless_assumed_utilization": 0.5,
+  "serverless_mb_per_vcpu": 1792,
+  "_utilization_sources": "Cloud Carbon Footprint methodology, average min/max watts per vCPU by provider from SPECpower (https://www.cloudcarbonfootprint.org/docs/methodology/), checked 2026-11-10. Serverless: CCF's Lambda approach (1,792 MB = 1 vCPU; 50% average utilisation for hyperscale servers)."
+}

greenpick-0.7.0/src/greenpick/data/pricing.json

@@ -0,0 +1,65 @@
+{
+  "_comment": "DATED, STATIC pricing ballpark for v1. Deterministic — the LLM must never invent these. Figures are rough on-demand approximations for a general-purpose vCPU+RAM service and per-GB internet egress; refresh periodically and update _as_of. NOT a quote.",
+  "_as_of": "2026-10-12",
+  "_units": {
+    "compute": "USD per vCPU-hour and USD per GB-RAM-hour",
+    "egress": "USD per GB to internet"
+  },
+  "_egress_comment": "Egress is NOT one price — it's a tier ladder by WHERE the bytes cross. We price the locality tier (same-region / cross-region / cross-cloud+internet) as a LOW-HIGH RANGE because region-pair rates vary. Per-GB, USD, DIRECTIONAL list prices as of _as_of; excludes free-tier allowances, committed-use/negotiated discounts, and NAT/load-balancer processing fees. Not a quote. Keys: internet rate stays per-provider (differs most); same-region & cross-region tiers are broadly consistent across AWS/GCP/Azure so we use one shared range.",
+  "_egress_tiers_usd_per_gb": {
+    "same_region": {
+      "low": 0.0,
+      "high": 0.01,
+      "note": "Same region: free within an AZ over private IP; ~$0.01/GB each way if it crosses AZs."
+    },
+    "cross_region_same_cloud": {
+      "low": 0.01,
+      "high": 0.02,
+      "note": "Inter-region within one cloud: most pairs ~$0.01-0.02/GB; a few source regions/continent pairs run higher."
+    },
+    "cross_cloud": {
+      "low": 0.085,
+      "high": 0.12,
+      "note": "Leaving the cloud to another provider or the public internet: the expensive tier; GCP Premium ~$0.12, AWS ~$0.09, Azure ~$0.087 at entry bands."
+    }
+  },
+  "_egress_sources": "AWS/GCP/Azure published data-transfer pricing pages + corroborating 2026 guides (usage.ai, nops.io, egresscost.com, redresscompliance, bacancy, tatacommunications). Rounded to ranges; verify against the provider pricing page for a specific region pair.",
+  "aws": {
+    "compute_usd_per_vcpu_hour": 0.0469,
+    "compute_usd_per_gb_ram_hour": 0.0039,
+    "egress_usd_per_gb": 0.09
+  },
+  "gcp": {
+    "compute_usd_per_vcpu_hour": 0.0438,
+    "compute_usd_per_gb_ram_hour": 0.0037,
+    "egress_usd_per_gb": 0.085
+  },
+  "azure": {
+    "compute_usd_per_vcpu_hour": 0.0472,
+    "compute_usd_per_gb_ram_hour": 0.0039,
+    "egress_usd_per_gb": 0.087
+  },
+  "_source": "Compute coefficients for [aws+azure+gcp] derived from Vantage live data using ONE matched method: general-purpose 4GB/vCPU families (AWS m5/m6i, GCP n2-standard, Azure D-series v5), on-demand Linux, mean $/vCPU across regions, 25% split to RAM. Egress remains static. Apples-to-apples DIRECTIONAL comparison, not a quote.",
+  "_serverless_usd": {
+    "_as_of": "2026-11-10",
+    "_comment": "On-demand list prices for request-driven serverless compute, before free tiers and discounts. DIRECTIONAL, not a quote. Azure Functions prices are not bundled (the public page renders prices client-side and could not be verified).",
+    "aws": {
+      "product": "AWS Lambda (event functions, x86, first tier)",
+      "usd_per_gb_second": 1.66667e-05,
+      "usd_per_million_requests": 0.2,
+      "free_requests": 1000000,
+      "free_gb_seconds": 400000,
+      "source": "https://aws.amazon.com/lambda/pricing/"
+    },
+    "gcp": {
+      "product": "Cloud Run (request-based billing, tier 1)",
+      "usd_per_vcpu_second": 2.4e-05,
+      "usd_per_gib_second": 2.5e-06,
+      "usd_per_million_requests": 0.4,
+      "free_requests": 2000000,
+      "free_vcpu_seconds": 180000,
+      "free_gib_seconds": 360000,
+      "source": "https://cloud.google.com/run/pricing"
+    }
+  }
+}

{greenpick-0.6.3 → greenpick-0.7.0}/src/greenpick/server.py

@@ -1,4 +1,4 @@
-"""MCP server: exposes GreenPick's 19 tools over FastMCP.
+"""MCP server: exposes GreenPick's 20 tools over FastMCP.
 
 Thin layer — parse/validate inputs, call services, return JSON-friendly dicts. All math
 lives in services/; this file only wires tools to them.
@@ -26,7 +26,7 @@ from .services import (
     carbon_service, recommender, scheduling_service, instance_service, locality_service,
     training_service, forecast_service, serving_service, metric_scaffold_service,
     rightsizing_service, inference_service, offhours_service, typical_ranking_service,
-    justification_service, migration_service,
+    justification_service, migration_service, serverless_service,
 )
 from .models import ServingHub
 from .services.data_hint import with_hint
@@ -41,7 +41,8 @@ GreenPick advises on cloud infrastructure decisions BEFORE you deploy, weighing
 latency together. Strongest uses, in order:
 1. Right-sizing (rightsizing_check): an over-provisioned instance cut to a standard, buyable size \
 saves money and carbon in the same move. Lead with the monthly dollar saving. For dev, test or other \
-environments that don't need to run 24/7, offhours_check shows what switching them off saves.
+environments that don't need to run 24/7, offhours_check shows what switching them off saves. For a \
+mostly idle or spiky service, serverless_check compares an always-on server with paying per request.
 2. Scheduling deferrable jobs: cleanest_hours_to_run (one-off), cleanest_time_of_day (recurring), \
 carbon_forecast (EU day-ahead).
 3. GPU training and LLM inference footprints: estimate_training_carbon (gpu_hours is the TOTAL across \
@@ -148,13 +149,19 @@ async def estimate_workload_carbon(
     vcpu: float,
     ram_gb: float,
     hours_per_month: float = 730,
+    avg_cpu_utilization: Optional[float] = None,
 ) -> dict:
     """Rough kgCO2/month for a workload running in a region. An ESTIMATE (documented power
-    model x grid intensity), not a measurement."""
+    model x grid intensity), not a measurement. Without avg_cpu_utilization it assumes the CPU is
+    fully busy (a conservative, high figure). Pass the observed average CPU utilisation as a fraction
+    (0.1 for 10%) for a more realistic figure: an idle server draws far less than a busy one."""
+    err = _fraction_error("avg_cpu_utilization", avg_cpu_utilization, allow_zero=True)
+    if err:
+        return {"provider": provider, "region": region, "error": err}
     reading = await carbon_service.carbon_now(_repo, provider, region)  # type: ignore[arg-type]
     wl = Workload(vcpu=vcpu, ram_gb=ram_gb, hours_per_month=hours_per_month)
     kg = carbon_service.estimate_kg_co2_per_month(wl, reading)
-    return with_hint({
+    out = {
         "provider": provider,
         "region": region,
         "estimated_kg_co2_per_month": kg,
@@ -162,7 +169,15 @@ async def estimate_workload_carbon(
         "carbon_source": reading.source,
         "carbon_quality": reading.quality,
         "note": "Estimate only: documented power model x grid intensity. Not a measurement.",
-    })
+    }
+    if avg_cpu_utilization is not None:
+        out["estimated_kg_co2_per_month_at_full_load"] = kg
+        out["estimated_kg_co2_per_month"] = carbon_service.estimate_kg_co2_per_month_at(
+            wl, reading, avg_cpu_utilization)
+        out["avg_cpu_utilization"] = avg_cpu_utilization
+        out["note"] = ("Estimate only. CPU power follows the utilisation you gave (Cloud Carbon Footprint "
+                       "min/max watts per vCPU); RAM power does not change with load. Not a measurement.")
+    return with_hint(out)
 
 
 @mcp.tool(annotations=LIVE_DATA_TOOL)
@@ -273,6 +288,37 @@ async def rightsizing_check(
     return with_hint(advice.model_dump())
 
 
+@mcp.tool(annotations=LIVE_DATA_TOOL)
+async def serverless_check(
+    provider: str,
+    region: str,
+    vcpu: float,
+    ram_gb: float,
+    avg_cpu_utilization: float,
+    monthly_requests: float,
+    avg_duration_ms: float,
+    function_memory_gb: float = 1.0,
+) -> dict:
+    """Would serverless change the math? Compares an always-on server (its size and observed average CPU
+    utilisation as a fraction, 0.05 for 5%) with a request-driven serverless platform (AWS Lambda or
+    Google Cloud Run) for the same traffic: monthly requests, average duration per request in ms, and the
+    function's memory in GB. Returns the monthly cost of each, the request count where they break even,
+    and estimated carbon for each. Lead with the dollar figure. Serverless carbon is a LOWER BOUND
+    (platform overhead isn't published); cost is list price before free tiers. Azure serverless cost is
+    not priced (carbon only). Ask the user for traffic figures rather than assuming them."""
+    err = _fraction_error("avg_cpu_utilization", avg_cpu_utilization, allow_zero=True)
+    if err:
+        return {"provider": provider, "region": region, "error": err}
+    if monthly_requests < 0 or avg_duration_ms <= 0 or not 0.125 <= function_memory_gb <= 10.24:
+        return {"provider": provider, "region": region,
+                "error": "monthly_requests must be >= 0, avg_duration_ms > 0, and function_memory_gb "
+                         "between 0.125 and 10.24 (Lambda's range)."}
+    return with_hint(await serverless_service.serverless_check(
+        _repo, provider, region, vcpu, ram_gb, avg_cpu_utilization,
+        monthly_requests, avg_duration_ms, function_memory_gb,
+    ))
+
+
 @mcp.tool(annotations=LIVE_DATA_TOOL)
 async def offhours_check(
     provider: str,

greenpick-0.7.0/src/greenpick/services/carbon_service.py

@@ -0,0 +1,51 @@
+"""Carbon readings (via the repository) + a workload CO2 ESTIMATE.
+
+The estimate turns a workload into average watts (power model) -> kWh/month ->
+multiply by grid intensity. Clearly an estimate, not a measurement.
+"""
+from __future__ import annotations
+
+from ..models import CarbonReading, Workload, Provider
+from ..data.repository import CarbonRepository
+from ..data.static_data import power_model
+
+
+async def carbon_now(repo: CarbonRepository, provider: Provider, region: str) -> CarbonReading:
+    return await repo.carbon_now(provider, region)
+
+
+def workload_kwh_per_month(workload: Workload) -> float:
+    pm = power_model()
+    watts = workload.vcpu * pm["watts_per_vcpu"] + workload.ram_gb * pm["watts_per_gb_ram"]
+    watts *= pm["pue_default"]
+    kwh = watts / 1000.0 * workload.hours_per_month
+    return kwh
+
+
+def estimate_kg_co2_per_month(workload: Workload, reading: CarbonReading) -> float:
+    kwh = workload_kwh_per_month(workload)
+    grams = kwh * reading.g_co2_per_kwh
+    return round(grams / 1000.0, 2)
+
+
+def watts_per_vcpu_at(provider: str, cpu_utilization: float) -> float:
+    """Average watts per vCPU at a given CPU utilisation (0..1): idle minimum plus the load share of
+    the gap to full load (Cloud Carbon Footprint method). Unknown providers use the AWS range."""
+    pm = power_model()
+    lo = pm["min_watts_per_vcpu"].get(provider, pm["min_watts_per_vcpu"]["aws"])
+    hi = pm["max_watts_per_vcpu"].get(provider, pm["max_watts_per_vcpu"]["aws"])
+    u = max(0.0, min(1.0, cpu_utilization))
+    return lo + u * (hi - lo)
+
+
+def workload_kwh_per_month_at(workload: Workload, provider: str, cpu_utilization: float) -> float:
+    """Like workload_kwh_per_month, but CPU power follows utilisation instead of assuming full load.
+    RAM power is unchanged (memory draws roughly the same whether busy or not)."""
+    pm = power_model()
+    watts = workload.vcpu * watts_per_vcpu_at(provider, cpu_utilization) + workload.ram_gb * pm["watts_per_gb_ram"]
+    return watts * pm["pue_default"] / 1000.0 * workload.hours_per_month
+
+
+def estimate_kg_co2_per_month_at(workload: Workload, reading: CarbonReading, cpu_utilization: float) -> float:
+    kwh = workload_kwh_per_month_at(workload, reading.provider, cpu_utilization)
+    return round(kwh * reading.g_co2_per_kwh / 1000.0, 2)

greenpick-0.7.0/src/greenpick/services/serverless_service.py

@@ -0,0 +1,144 @@
+"""Would serverless change the math? An always-on server vs. paying only for the time code runs.
+
+A mostly idle service on an always-on server pays (and draws power) around the clock, even when it is
+doing nothing. A request-driven serverless platform (AWS Lambda, Google Cloud Run) charges, and keeps
+hardware busy, only while requests run. Which is cheaper depends on how much traffic there is: low or
+spiky traffic favours serverless, steady high traffic favours a server. This compares the two on cost
+and on estimated carbon, and gives the monthly request count where they break even on cost.
+
+Directional on both axes. The server side uses the utilisation-aware power model (Cloud Carbon
+Footprint min/max watts per vCPU). The serverless side counts only the compute time requests run, at
+the CCF Lambda assumptions (1,792 MB of memory = 1 vCPU, 50% average utilisation), so it is a LOWER
+BOUND: platform overhead such as warm instances and control planes is not published and is not
+included. Prices are dated on-demand list prices, before free tiers and discounts.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from ..data.repository import CarbonRepository
+from ..data.static_data import power_model, pricing
+from ..models import Workload
+from . import carbon_service, cost_service
+
+HOURS_PER_MONTH = 730
+
+
+def _serverless_cost(provider: str, requests: float, active_seconds: float, memory_gb: float,
+                     vcpu_equiv: float) -> tuple[Optional[float], Optional[float]]:
+    """(cost, cost per million requests) for a month, before free tiers; (None, None) if unpriced."""
+    p = (pricing().get("_serverless_usd") or {}).get(provider)
+    if not p:
+        return None, None
+    if provider == "aws":
+        per_req_compute = (active_seconds / requests if requests else 0) * memory_gb * p["usd_per_gb_second"]
+    else:   # gcp, Cloud Run request-based: vCPU-seconds + GiB-seconds while requests run
+        per_req_compute = ((active_seconds / requests if requests else 0)
+                           * (vcpu_equiv * p["usd_per_vcpu_second"] + memory_gb * p["usd_per_gib_second"]))
+    per_req = per_req_compute + p["usd_per_million_requests"] / 1e6
+    return round(per_req * requests, 2), per_req * 1e6
+
+
+async def serverless_check(
+    repo: CarbonRepository,
+    provider: str,
+    region: str,
+    vcpu: float,
+    ram_gb: float,
+    avg_cpu_utilization: float,
+    monthly_requests: float,
+    avg_duration_ms: float,
+    function_memory_gb: float = 1.0,
+) -> dict:
+    pm = power_model()
+    reading = await carbon_service.carbon_now(repo, provider, region)   # type: ignore[arg-type]
+
+    # Always-on server: the bill for every hour, and power that follows its real utilisation.
+    vm = Workload(vcpu=vcpu, ram_gb=ram_gb, hours_per_month=HOURS_PER_MONTH)
+    vm_cost = cost_service.estimate_monthly_cost_usd(provider, vm)      # type: ignore[arg-type]
+    vm_kg = carbon_service.estimate_kg_co2_per_month_at(vm, reading, avg_cpu_utilization)
+    vm_kg_full = carbon_service.estimate_kg_co2_per_month(vm, reading)
+
+    # Serverless: only the time requests run, with CPU allocated in proportion to memory.
+    active_seconds = monthly_requests * avg_duration_ms / 1000.0
+    active_hours = active_seconds / 3600.0
+    vcpu_equiv = min(6.0, function_memory_gb * 1024 / pm["serverless_mb_per_vcpu"])
+    sl = Workload(vcpu=max(vcpu_equiv, 1e-6), ram_gb=function_memory_gb, hours_per_month=max(active_hours, 1e-9))
+    sl_kg = (carbon_service.estimate_kg_co2_per_month_at(sl, reading, pm["serverless_assumed_utilization"])
+             if active_hours > 0 else 0.0)
+    sl_cost, per_million = _serverless_cost(provider, monthly_requests, active_seconds, function_memory_gb, vcpu_equiv)
+
+    breakeven = None
+    if vm_cost is not None and per_million:
+        breakeven = round(vm_cost / per_million * 1e6)
+    cost_saving = round(vm_cost - sl_cost, 2) if vm_cost is not None and sl_cost is not None else None
+    cost_pct = round(cost_saving / vm_cost * 100, 1) if cost_saving is not None and vm_cost else None
+    kg_saving = round(vm_kg - sl_kg, 2)
+    carbon_pct = round(kg_saving / vm_kg * 100, 1) if vm_kg > 0 else None
+
+    # Does this traffic fit inside the provider's monthly free tier? Then the real bill could be $0.
+    free = (pricing().get("_serverless_usd") or {}).get(provider) or {}
+    in_free_tier = None
+    if free:
+        req_ok = monthly_requests <= free.get("free_requests", 0)
+        if provider == "aws":
+            use_ok = active_seconds * function_memory_gb <= free.get("free_gb_seconds", 0)
+        else:
+            use_ok = (active_seconds * vcpu_equiv <= free.get("free_vcpu_seconds", 0)
+                      and active_seconds * function_memory_gb <= free.get("free_gib_seconds", 0))
+        in_free_tier = bool(req_ok and use_ok)
+
+    if cost_saving is None:
+        cost_txt = ("Serverless cost isn't priced for this provider in GreenPick (check the provider's pricing "
+                    "page); the comparison below is carbon only.")
+        verdict = "carbon_only"
+    elif cost_saving > 0:
+        cost_txt = (f"Serverless would cost about ${sl_cost:,.2f} a month against ${vm_cost:,.2f} for the always-on "
+                    f"server: about ${cost_saving:,.0f} a month less ({cost_pct:.0f}%).")
+        verdict = "serverless_cheaper"
+    else:
+        cost_txt = (f"Serverless would cost about ${sl_cost:,.2f} a month against ${vm_cost:,.2f} for the always-on "
+                    f"server: about ${-cost_saving:,.0f} a month MORE. At this traffic a server is the cheaper choice.")
+        verdict = "server_cheaper"
+    free_txt = (" This traffic fits within the provider's monthly free tier, so the actual serverless bill "
+                "could be $0." if in_free_tier else "")
+    be_txt = (f" They break even at about {breakeven:,} requests a month at this duration and memory; above that, "
+              "the server wins on cost." if breakeven else "")
+    summary = (f"{cost_txt}{free_txt}{be_txt} Estimated carbon: about {sl_kg:.2f} kg CO2 a month serverless (a lower bound) "
+               f"against {vm_kg:.2f} kg for the server at {avg_cpu_utilization * 100:.0f}% CPU use "
+               f"({reading.quality} grid data).")
+
+    return {
+        "summary": summary,
+        "verdict": verdict,
+        "provider": provider,
+        "region": region,
+        "server": {"vcpu": vcpu, "ram_gb": ram_gb, "avg_cpu_utilization": avg_cpu_utilization,
+                   "hours_per_month": HOURS_PER_MONTH},
+        "serverless": {"monthly_requests": monthly_requests, "avg_duration_ms": avg_duration_ms,
+                       "function_memory_gb": function_memory_gb, "vcpu_equivalent": round(vcpu_equiv, 2),
+                       "billed_hours_per_month": round(active_hours, 1)},
+        "server_cost_usd_per_month": vm_cost,
+        "serverless_cost_usd_per_month": sl_cost,
+        "monthly_usd_saving": cost_saving,
+        "cost_saving_pct": cost_pct,
+        "breakeven_monthly_requests": breakeven,
+        "within_free_tier": in_free_tier,
+        "server_kg_co2_per_month": vm_kg,
+        "server_kg_co2_per_month_at_full_load": vm_kg_full,
+        "serverless_kg_co2_per_month_lower_bound": sl_kg,
+        "monthly_kg_co2_saving": kg_saving,
+        "carbon_saving_pct": carbon_pct,
+        "carbon_source": reading.source,
+        "carbon_quality": reading.quality,
+        "limitations": (
+            "Directional. Serverless bills each request's full duration, including time spent waiting on a "
+            "database or another service, while a server handles many requests at once, so I/O-heavy services "
+            "favour a server more than these figures suggest. Serverless cost is on-demand list price before free tiers (AWS gives 1M requests and "
+            "400,000 GB-seconds a month free; Cloud Run 2M requests and some vCPU/GiB-seconds), and excludes "
+            "API gateway, data transfer and provisioned-concurrency charges. Serverless carbon counts only the "
+            "time requests run and leaves out platform overhead such as warm instances, so it is a lower bound. "
+            "The server side assumes on-demand pricing; reserved capacity and savings plans change the cost. "
+            "Cold starts, request time limits and concurrency limits can rule serverless out regardless of price. "
+            "Power follows Cloud Carbon Footprint's min/max watts per vCPU."),
+    }

{greenpick-0.6.3 → greenpick-0.7.0}/src/greenpick/services/sources.py

@@ -35,6 +35,9 @@ _PRICING = {
               "https://azure.microsoft.com/en-us/pricing/details/bandwidth/"),
 }
 _PROVIDER_NAME = {"aws": "AWS", "gcp": "Google Cloud", "azure": "Azure"}
+_SERVERLESS = {"aws": ("AWS Lambda", "https://aws.amazon.com/lambda/pricing/"),
+               "gcp": ("Cloud Run", "https://cloud.google.com/run/pricing"),
+               "azure": ("Azure Functions", "https://azure.microsoft.com/en-us/pricing/details/functions/")}
 
 _SOURCE_KEYS = ("source", "carbon_source", "transfer_carbon_source",
                 "from_carbon_source", "to_carbon_source")
@@ -56,7 +59,7 @@ def verify_at(result: dict) -> list[dict]:
     """The primary sources behind the carbon and cost figures in a tool result (may be empty)."""
     carbon: set[str] = set()
     providers: set[str] = set()
-    has_cost = has_egress = False
+    has_cost = has_egress = has_serverless = False
     for key, value in _walk(result):
         if key in _SOURCE_KEYS and isinstance(value, str):
             base = value[len("typical_"):] if value.startswith("typical_") else value
@@ -71,7 +74,9 @@ def verify_at(result: dict) -> list[dict]:
         if isinstance(value, (int, float)) and not isinstance(value, bool):
             if "usd" not in key:
                 continue
-            if "egress" in key:
+            if "serverless" in key:
+                has_serverless = True
+            elif "egress" in key:
                 has_egress = True
             elif "cost" in key or "saving" in key:      # compute cost or a saving on it
                 has_cost = True
@@ -86,6 +91,9 @@ def verify_at(result: dict) -> list[dict]:
         if has_cost:
             out.append({"figure": "compute cost", "based_on": f"{name} on-demand list prices (dated)",
                         "url": compute_url})
+        if has_serverless:
+            product, url = _SERVERLESS[prov]
+            out.append({"figure": "serverless cost", "based_on": f"{product} list prices (dated)", "url": url})
         if has_egress:
             out.append({"figure": "data-transfer (egress) cost",
                         "based_on": f"{name} data-transfer prices (dated)", "url": transfer_url})

{greenpick-0.6.3 → greenpick-0.7.0/src/greenpick.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.6.3
+Version: 0.7.0
 Summary: Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs.
 Author-email: "Data Science Advisers, LLC" <info@datascienceadvisers.com>
 License-Expression: MIT
@@ -44,7 +44,7 @@ Dynamic: license-file
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License: MIT" />
   <img src="https://img.shields.io/badge/tests-passing-brightgreen" alt="Tests: passing" />
   <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python 3.11+" />
-  <img src="https://img.shields.io/badge/MCP%20tools-19-0ea5e9" alt="MCP tools: 19" />
+  <img src="https://img.shields.io/badge/MCP%20tools-20-0ea5e9" alt="MCP tools: 20" />
 </p>
 
 A **design-time sustainability co-pilot** that runs as an MCP server inside your vibe-coding
@@ -52,7 +52,7 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 19 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> **Status: working — 20 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
 > IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
@@ -143,7 +143,7 @@ See `docs/user-questions-backlog.md`.
 
 ## MCP tools
 
-19 tools, grouped by what you're trying to do.
+20 tools, grouped by what you're trying to do.
 
 ### Pick a region
 
@@ -176,6 +176,7 @@ See `docs/user-questions-backlog.md`.
 |------|--------------|
 | `greener_instance_family` | A greener same-size family in the same region via perf-per-watt (newer generation / ARM Graviton-class does the same work on less energy). |
 | `rightsizing_check` | Right-sizing (the #1 FinOps win) with a carbon twin: if you're over-provisioned, a smaller size cuts **both** cost and carbon → the right-sized target with monthly $ and kg CO₂ saving. |
+| `serverless_check` | For a mostly idle or spiky service: an always-on server vs. paying per request (AWS Lambda, Cloud Run). Monthly cost of each, the break-even request count, and estimated carbon (serverless as a lower bound). |
 | `offhours_check` | For dev/test/staging that doesn't need to run 24/7: the monthly $ and kg CO2 saved by running it only N hours a week. Compute only, directional. |
 | `data_locality_egress_check` | Warn when running compute away from where your data lives backfires: directional egress $ + coarse transfer carbon, and whether a greener-region move is still a net win. |
 | `migration_payoff` | Does moving the **data** to the compute's region pay off? Payback in months, one-off vs monthly egress and transfer carbon, net over 12 months. Egress only. |

{greenpick-0.6.3 → greenpick-0.7.0}/src/greenpick.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ src/greenpick/services/recommender.py
 src/greenpick/services/residency_service.py
 src/greenpick/services/rightsizing_service.py
 src/greenpick/services/scheduling_service.py
+src/greenpick/services/serverless_service.py
 src/greenpick/services/serving_service.py
 src/greenpick/services/sources.py
 src/greenpick/services/training_service.py

{greenpick-0.6.3 → greenpick-0.7.0}/tests/test_services.py

@@ -1802,7 +1802,7 @@ def test_every_tool_declares_all_four_annotation_hints():
     import asyncio
     from greenpick import server
     tools = asyncio.run(server.mcp.list_tools())
-    assert len(tools) == 19
+    assert len(tools) == 20
     for t in tools:
         a = t.annotations
         assert a is not None, t.name
@@ -2091,3 +2091,68 @@ async def test_reverse_pr_text_does_not_repeat_backfire():
                                            4, 16, monthly_cross_boundary_gb=100)
     assert "would RAISE" in r["pr_text"] and "backfires" not in r["pr_text"]
     assert "unless the data moves too" not in r["pr_text"] and "on top." in r["pr_text"]
+
+
+# --- 0.7.0: utilisation-aware power and serverless_check ---
+def test_utilisation_power_spans_min_to_max_and_full_load_matches_flat_model():
+    from greenpick.services import carbon_service as cs
+    from greenpick.models import CarbonReading
+    assert cs.watts_per_vcpu_at("aws", 0) == 0.74 and cs.watts_per_vcpu_at("aws", 1) == 3.5
+    assert abs(cs.watts_per_vcpu_at("gcp", 0.5) - (0.71 + 0.5 * (4.26 - 0.71))) < 1e-9
+    wl = Workload(vcpu=4, ram_gb=16, hours_per_month=730)
+    rd = CarbonReading(region="us-east-1", provider="aws", g_co2_per_kwh=400, source="mock",
+                       timestamp="2026-11-10T00:00:00Z", quality="mock")
+    assert cs.estimate_kg_co2_per_month_at(wl, rd, 1.0) == cs.estimate_kg_co2_per_month(wl, rd)
+    assert cs.estimate_kg_co2_per_month_at(wl, rd, 0.05) < cs.estimate_kg_co2_per_month(wl, rd) / 2
+
+
+@pytest.mark.asyncio
+async def test_estimate_workload_carbon_utilisation_is_optional_and_additive(monkeypatch):
+    from greenpick import server
+    monkeypatch.setattr(server, "_repo", TypicalCarbonRepository())
+    plain = await _tool("estimate_workload_carbon")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16)
+    assert "avg_cpu_utilization" not in plain and "estimated_kg_co2_per_month_at_full_load" not in plain
+    low = await _tool("estimate_workload_carbon")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16,
+                                                 avg_cpu_utilization=0.05)
+    assert low["estimated_kg_co2_per_month_at_full_load"] == plain["estimated_kg_co2_per_month"]
+    assert low["estimated_kg_co2_per_month"] < plain["estimated_kg_co2_per_month"]
+    bad = await _tool("estimate_workload_carbon")(provider="aws", region="us-east-1", vcpu=4, ram_gb=16,
+                                                 avg_cpu_utilization=5)
+    assert "Did you mean 0.05?" in bad["error"]
+
+
+@pytest.mark.asyncio
+async def test_serverless_check_quiet_vs_busy_and_breakeven(monkeypatch):
+    from greenpick import server
+    monkeypatch.setattr(server, "_repo", TypicalCarbonRepository())
+    t = _tool("serverless_check")
+    quiet = await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                    monthly_requests=1_000_000, avg_duration_ms=100, function_memory_gb=0.5)
+    assert next(iter(quiet)) == "summary" and quiet["verdict"] == "serverless_cheaper"
+    assert quiet["within_free_tier"] is True and "free tier" in quiet["summary"]
+    busy = await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.6,
+                   monthly_requests=100_000_000, avg_duration_ms=100, function_memory_gb=0.5)
+    assert busy["verdict"] == "server_cheaper" and busy["monthly_usd_saving"] < 0
+    # The break-even request count is where serverless cost meets the server's.
+    be = quiet["breakeven_monthly_requests"]
+    at_be = await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                    monthly_requests=be, avg_duration_ms=100, function_memory_gb=0.5)
+    assert abs(at_be["serverless_cost_usd_per_month"] - at_be["server_cost_usd_per_month"]) < 0.05
+    assert {v["figure"] for v in quiet["verify_at"]} >= {"compute cost", "serverless cost"}
+    run = await t(provider="gcp", region="us-central1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                  monthly_requests=1_000_000, avg_duration_ms=100, function_memory_gb=0.5)
+    assert run["serverless_cost_usd_per_month"] is not None
+
+
+@pytest.mark.asyncio
+async def test_serverless_check_azure_is_carbon_only_and_inputs_validated():
+    t = _tool("serverless_check")
+    az = await t(provider="azure", region="eastus", vcpu=2, ram_gb=4, avg_cpu_utilization=0.05,
+                 monthly_requests=1_000_000, avg_duration_ms=100)
+    assert az["verdict"] == "carbon_only" and az["serverless_cost_usd_per_month"] is None
+    assert "error" in await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=5,
+                              monthly_requests=1000, avg_duration_ms=100)
+    assert "error" in await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.1,
+                              monthly_requests=1000, avg_duration_ms=0)
+    assert "error" in await t(provider="aws", region="us-east-1", vcpu=2, ram_gb=4, avg_cpu_utilization=0.1,
+                              monthly_requests=1000, avg_duration_ms=100, function_memory_gb=64)

greenpick-0.6.3/src/greenpick/data/power.json

@@ -1,7 +0,0 @@
-{
-  "_comment": "Simple, documented power model for the carbon ESTIMATE. Turns a workload (vCPU, RAM) into average watts, then kWh/month. These are deliberately rough published-style coefficients; this is an estimate, not a measurement. PUE is the datacenter overhead multiplier.",
-  "watts_per_vcpu": 3.5,
-  "watts_per_gb_ram": 0.4,
-  "pue_default": 1.2,
-  "_sources": "Coefficients are order-of-magnitude figures consistent with public cloud power-model literature (e.g. Cloud Carbon Footprint methodology). Replace with cited values before any non-directional use."
-}

greenpick-0.6.3/src/greenpick/data/pricing.json

@@ -1,31 +0,0 @@
-{
-  "_comment": "DATED, STATIC pricing ballpark for v1. Deterministic \u2014 the LLM must never invent these. Figures are rough on-demand approximations for a general-purpose vCPU+RAM service and per-GB internet egress; refresh periodically and update _as_of. NOT a quote.",
-  "_as_of": "2026-10-12",
-  "_units": {
-    "compute": "USD per vCPU-hour and USD per GB-RAM-hour",
-    "egress": "USD per GB to internet"
-  },
-  "_egress_comment": "Egress is NOT one price — it's a tier ladder by WHERE the bytes cross. We price the locality tier (same-region / cross-region / cross-cloud+internet) as a LOW-HIGH RANGE because region-pair rates vary. Per-GB, USD, DIRECTIONAL list prices as of _as_of; excludes free-tier allowances, committed-use/negotiated discounts, and NAT/load-balancer processing fees. Not a quote. Keys: internet rate stays per-provider (differs most); same-region & cross-region tiers are broadly consistent across AWS/GCP/Azure so we use one shared range.",
-  "_egress_tiers_usd_per_gb": {
-    "same_region": { "low": 0.0, "high": 0.01, "note": "Same region: free within an AZ over private IP; ~$0.01/GB each way if it crosses AZs." },
-    "cross_region_same_cloud": { "low": 0.01, "high": 0.02, "note": "Inter-region within one cloud: most pairs ~$0.01-0.02/GB; a few source regions/continent pairs run higher." },
-    "cross_cloud": { "low": 0.085, "high": 0.12, "note": "Leaving the cloud to another provider or the public internet: the expensive tier; GCP Premium ~$0.12, AWS ~$0.09, Azure ~$0.087 at entry bands." }
-  },
-  "_egress_sources": "AWS/GCP/Azure published data-transfer pricing pages + corroborating 2026 guides (usage.ai, nops.io, egresscost.com, redresscompliance, bacancy, tatacommunications). Rounded to ranges; verify against the provider pricing page for a specific region pair.",
-  "aws": {
-    "compute_usd_per_vcpu_hour": 0.0469,
-    "compute_usd_per_gb_ram_hour": 0.0039,
-    "egress_usd_per_gb": 0.09
-  },
-  "gcp": {
-    "compute_usd_per_vcpu_hour": 0.0438,
-    "compute_usd_per_gb_ram_hour": 0.0037,
-    "egress_usd_per_gb": 0.085
-  },
-  "azure": {
-    "compute_usd_per_vcpu_hour": 0.0472,
-    "compute_usd_per_gb_ram_hour": 0.0039,
-    "egress_usd_per_gb": 0.087
-  },
-  "_source": "Compute coefficients for [aws+azure+gcp] derived from Vantage live data using ONE matched method: general-purpose 4GB/vCPU families (AWS m5/m6i, GCP n2-standard, Azure D-series v5), on-demand Linux, mean $/vCPU across regions, 25% split to RAM. Egress remains static. Apples-to-apples DIRECTIONAL comparison, not a quote."
-}

greenpick-0.6.3/src/greenpick/services/carbon_service.py

@@ -1,28 +0,0 @@
-"""Carbon readings (via the repository) + a workload CO2 ESTIMATE.
-
-The estimate turns a workload into average watts (power model) -> kWh/month ->
-multiply by grid intensity. Clearly an estimate, not a measurement.
-"""
-from __future__ import annotations
-
-from ..models import CarbonReading, Workload, Provider
-from ..data.repository import CarbonRepository
-from ..data.static_data import power_model
-
-
-async def carbon_now(repo: CarbonRepository, provider: Provider, region: str) -> CarbonReading:
-    return await repo.carbon_now(provider, region)
-
-
-def workload_kwh_per_month(workload: Workload) -> float:
-    pm = power_model()
-    watts = workload.vcpu * pm["watts_per_vcpu"] + workload.ram_gb * pm["watts_per_gb_ram"]
-    watts *= pm["pue_default"]
-    kwh = watts / 1000.0 * workload.hours_per_month
-    return kwh
-
-
-def estimate_kg_co2_per_month(workload: Workload, reading: CarbonReading) -> float:
-    kwh = workload_kwh_per_month(workload)
-    grams = kwh * reading.g_co2_per_kwh
-    return round(grams / 1000.0, 2)