# io.github.pouriaetab/llmledger (pypi · llmledger-mcp)

Which AI model, and what it costs: LiteLLM prices, Arena ratings and price history.

- Trust score: 71/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `llmledger-mcp`: 71/100 (this document), [markdown](https://verifymcp.io/servers/pouriaetab-llmledger/llmledger-mcp.md), [page](https://verifymcp.io/servers/pouriaetab-llmledger/llmledger-mcp)

## Channel facts

- Registry: `pypi`
- Package: `llmledger-mcp`
- Version: `0.2.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 40/100
  - Malware scan not yet available for this package.
  - CVE check failed: a known medium-severity CVE affects fastmcp 4.1.0, a direct dependency. A fixed version is available.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 1 of 15 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to pouriaetab/llmledger).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 14 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 76/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 2558 tokens (~213/item across 12 items; 11 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 60/100
  - Stability observed for 18 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 11 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 13 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the io.github.pouriaetab/llmledger MCP server?

io.github.pouriaetab/llmledger runs locally as a PyPI package, launched with uvx llmledger-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add pouriaetab-llmledger -- uvx llmledger-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "pouriaetab-llmledger": {
      "command": "uvx",
      "args": [
        "llmledger-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "pouriaetab-llmledger": {
      "command": "uvx",
      "args": [
        "llmledger-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add pouriaetab-llmledger -- uvx llmledger-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "pouriaetab-llmledger": {
      "type": "local",
      "command": [
        "uvx",
        "llmledger-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add pouriaetab-llmledger --command uvx --arg llmledger-mcp
```

### Hermes

```yaml
mcp_servers:
  pouriaetab-llmledger:
    command: "uvx"
    args: ["llmledger-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "pouriaetab-llmledger": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "llmledger-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add pouriaetab-llmledger -t stdio -c uvx -a llmledger-mcp
```

### Other

```json
{
  "mcpServers": {
    "pouriaetab-llmledger": {
      "command": "uvx",
      "args": [
        "llmledger-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 71, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-03 (score 86, +1)

No change was recorded against any check on this day. Stability & Change Management went from 50 to 53. That category is still filling its 30-day observation window: 15 days of observed history at the previous scan, 16 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-01 (score 85, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-31 (score 84, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-30 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40. That category is still filling its 30-day observation window: 11 days of observed history at the previous scan, 12 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-29 (score 68, −15)

- [security regression] Malware scan: pass → unverified

### 2026-10-28 (score 83, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-26 (score 82, +16)

- [security improvement] Malware scan: unverified → pass

## MCP tools (11)

### `find_models` (~227 tokens)

Find Models

List the highest rated models for a kind of work within price, prompt size, ability and maker limits, each
at its cheapest listing with its rating; or, with `name`, look one model up and list every host that offers
it. Use when browsing or filtering the catalogue, or to find a model's exact name. Not for choosing between
named models (compare_models), for a prompt you have in hand (suggest_for_project), or for a budget
(estimate_cost).

Input parameters:

- `limit` (integer): How many models to list (up to 200 for the whole catalogue)
- `maker`: Only this maker, for example anthropic or openai
- `max_output_price`: Highest answer price, dollars per 1M tokens
- `min_context`: Smallest prompt size the model must take, in tokens
- `name`: Look up one model by name instead of browsing: all its listings
- `needs` (array): What the model must be able to do
- `task` (string): The kind of work, as Arena rates it

### `compare_models` (~225 tokens)

Compare Models

Compare 2 to 6 named models for a kind of work: rating, prices, cost per task (or how fast each uses a
Claude or ChatGPT plan), the pick, and for each model the share of answer tokens at which it would beat the
pick. Use when the user already has candidate models in mind. Not for finding candidates (find_models), for
reading a prompt to guess the work (suggest_for_project), or for a monthly budget (estimate_cost).

Input parameters:

- `answer_tokens`: Answer tokens per model when they differ, by the names given
- `input_tokens` (integer): Prompt tokens per task
- `models` (array, required): 2 to 6 model names, for example claude-opus-5.5, gpt-6.1-sol
- `output_tokens` (integer): Answer tokens per task, including hidden thinking
- `pay` (string): api: dollars; claude or chatgpt: how fast each uses that plan
- `task` (string): The kind of work, as Arena rates it

### `estimate_cost` (~186 tokens)

Estimate Cost

Price a workload on 1 to 10 models at each one's cheapest listing: dollars per call, per day and per 30
days, and with cache tokens the saving the cache makes. Use when the question is a budget or a bill: token
counts and calls a day are known. Not for deciding which model is better (compare_models) or for pricing
past usage from an export (price_my_usage).

Input parameters:

- `cache_write_tokens` (integer): How many of the prompt tokens are written to the cache
- `cached_tokens` (integer): How many of the prompt tokens are read from the cache
- `calls_per_day` (number): Calls per day
- `input_tokens` (integer, required): Prompt tokens per call
- `models` (array, required): 1 to 10 model names
- `output_tokens` (integer, required): Answer tokens per call, including hidden thinking

### `price_history` (~177 tokens)

Price History

Show one model's price history: every price and retirement date change since 2023 on every host, each
with the LiteLLM change behind it, the chance of a price change, retirement or removal in the next 90 days
and year, and with `date`, the prices on that day. Use when the question is about one model over time, a
past price, or how likely a price is to move. Not for today's cheapest price of several models (find_models
or estimate_cost).

Input parameters:

- `date`: A day as YYYY-MM-DD: each listing's prices that day and the change that set them
- `model` (string, required): A model name, for example claude-opus-5.5, or one listing such as bedrock/anthropic.claude-opus-5-5

### `suggest_for_project` (~155 tokens)

Suggest For Project

Suggest a model and effort level for a prompt or a described project: it guesses the kind of work and
names the best value (the cheapest model the votes cannot tell apart from the top), the top rated and the
cheapest rated, each with its cost per task. Use when the user asks "which model should I use for this" and
the work itself is in hand. Not for named candidates (compare_models) or for browsing by limits
(find_models).

Input parameters:

- `answer` (string): Typical answer length
- `pay` (string): api: dollars; claude or chatgpt: compare within that plan
- `prompt` (string, required): The project's starting prompt, or a description of the work

### `not_yet_priced` (~96 tokens)

Not Yet Priced

List the models Arena has rated that LiteLLM's catalogue does not price yet, with how soon the catalogue
usually prices a maker's models after Arena first shows them. Use when a brand-new model is missing from the
other tools' answers, or to ask what is coming. Not for models that already have a price (find_models).

Input parameters:

- `maker`: Only this maker, for example meta or ibm

### `estimate_time` (~194 tokens)

Estimate Time

Estimate how long one call and a whole job take, as a usual time and a slow day, from the user's own timed
runs of that model called that way (kept by log_run). Use when the question is time, not money, and some
runs have been logged; it says so when none have. Not for cost (estimate_cost) or for a job you have a
promptfoo sample of (forecast_job gives time and cost together).

Input parameters:

- `calls` (integer): How many calls the job makes
- `concurrency` (integer): Calls running at once
- `input_tokens` (integer, required): Prompt tokens per call
- `model` (string, required): A model name, as the catalogue or Ollama names it
- `output_tokens` (integer, required): Answer tokens per call, including hidden thinking
- `thinking` (boolean): Thinking turned on
- `way` (string): How the model is called

### `log_run` (~215 tokens)

Log Run

Record a timed run (model, tokens, seconds, how it was called), or every result of a promptfoo results
file, in a file on this computer so estimate_time can learn from it. Use right after a call or a promptfoo
run whose time is known. Not a query: it stores and returns what it stored. Nothing is sent anywhere.

Input parameters:

- `input_tokens`: Prompt tokens of the call
- `model`: The model that ran
- `output_tokens`: Answer tokens of the call, hidden thinking included
- `promptfoo_results`: Path of a promptfoo results file (promptfoo eval -o results.json): every result becomes a run
- `seconds`: How long the call took
- `task`: The kind of work, if known
- `thinking` (boolean): Thinking was on (a promptfoo result that counts thinking tokens is marked on by itself)
- `way`: How the model was called (default api; for a promptfoo file, read from each provider)

### `forecast_job` (~250 tokens)

Forecast Job

Estimate a whole job's time, cost and accuracy from a promptfoo run of a sample of it: for each model in
the sample, the time as a usual time and a slow day, the cost at its cheapest listing next to the listing the
sample used, the 90-day chance of a price change, how often it was right (95% range) and the break-even
against the pick. Use when a promptfoo results file of a sample exists and the whole job's size is known.
Not for a job with no sample (estimate_cost for money, estimate_time for time).

Input parameters:

- `concurrency`: Calls running at once in the whole job (default: as the sample ran)
- `items` (integer, required): How many tests the whole job has
- `promptfoo_results` (string, required): Path of a promptfoo results file from a sample of the job (promptfoo eval --filter-sample 20 -o sample.json)
- `thinking` (boolean): Thinking turned on
- `way`: How the models are called (default: read from each provider)
- `wrong_answer_cost`: Dollars a wrong answer costs you to catch and fix; the pick then counts it

### `local_or_cloud` (~329 tokens)

Local Or Cloud

Compare running an open model on a computer you buy with paying a cloud model per call: the cost a month
each way, the month the computer pays for itself, and whether it keeps up with the load. Use when the
question is whether to buy hardware for a local model. Needs timed runs of the local model (log_run) and the
computer's price; electricity comes from EIA or the user's own rate. Not for cloud-only comparisons
(compare_models or estimate_cost).

Input parameters:

- `cached_tokens` (integer): Prompt tokens read from the cloud model's cache
- `calls_per_month` (number, required): Calls a month
- `cloud_models` (array, required): 1 to 5 cloud models to compare with
- `electricity_price`: Your electricity price, dollars per kWh (default: EIA's average for homes)
- `hardware_price` (number, required): What the computer costs you, in dollars
- `input_tokens` (integer, required): Prompt tokens per call
- `local_model` (string, required): The open model you would run at home, as Ollama names it, for example llama3.1:8b
- `local_way` (string): How the local model is called
- `months` (integer): How many months to compare over
- `output_tokens` (integer, required): Answer tokens per call, including hidden thinking
- `state`: A US state, for EIA's average there, for example Texas
- `thinking` (boolean): Thinking turned on for the local model
- `watts`: Power the computer draws while it answers, in watts

### `price_my_usage` (~271 tokens)

Price My Usage

Price the user's own past coding agent usage, from a ccusage or codeburn export, on every rated model:
each session at the price of its day, the models that keep the rating and cost less, a 95% range for the cost
per session, and whether two models differ for real or the data cannot tell. Use when a usage export (or a
list of token mixes) exists and the question is what the same work would have cost elsewhere. Not for a
future workload (estimate_cost) or for a prompt (suggest_for_project). Reads token counts, names and dates
only; nothing leaves the computer.

Input parameters:

- `compare`: Two models to test against each other on the same sessions
- `export`: Path of a token export on this computer: `ccusage daily --json > f.json`, `ccusage session --json > f.json`, or `codeburn export -f json -o f.json`
- `limit` (integer): How many models to list in every_model (the cheapest first)
- `mix`: Instead of a file: token mixes as {model, date, input, output, cache_read, cache_write, session?}
- `task`: The kind of work the sessions were (default: codeburn's categories, else coding)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/pouriaetab-llmledger/llmledger-mcp#diagnostics

## Score history

- 2026-11-05: 71
- 2026-11-04: 86
- 2026-11-03: 86
- 2026-11-02: 85
- 2026-11-01: 85
- 2026-10-31: 84
- 2026-10-30: 69
- 2026-10-29: 68
- 2026-10-28: 83
- 2026-10-27: 82
- 2026-10-26: 82
- 2026-10-25: 66
- 2026-10-24: 66
- 2026-10-23: 68
- 2026-10-22: 68
- 2026-10-21: 57
- 2026-10-20: 80
- 2026-10-19: 65
- 2026-10-18: 66

## Common questions

### What is the io.github.pouriaetab/llmledger MCP server?

io.github.pouriaetab/llmledger is an MCP server listed in the public MCP registry as io.github.pouriaetab/llmledger. Which AI model, and what it costs: LiteLLM prices, Arena ratings and price history. This page covers its PyPI package (llmledger-mcp).

### Is the io.github.pouriaetab/llmledger MCP server safe to use?

io.github.pouriaetab/llmledger scores 71 out of 100 on VerifyMCP. We recorded 2 known advisories against it as of 5 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.pouriaetab/llmledger MCP server expose?

io.github.pouriaetab/llmledger exposes 11 tools: find_models, compare_models, estimate_cost, price_history, suggest_for_project, and 6 more. Their descriptions and schemas cost roughly 2,325 tokens of context every time the server is loaded.

### Is the io.github.pouriaetab/llmledger MCP server still maintained?

io.github.pouriaetab/llmledger is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.pouriaetab/llmledger MCP server under?

io.github.pouriaetab/llmledger declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/llmledger-mcp/
- Socket report: https://socket.dev/pypi/package/llmledger-mcp
- Repository: https://github.com/pouriaetab/llmledger
- Changelog RSS feed: https://verifymcp.io/servers/pouriaetab-llmledger/llmledger-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/pouriaetab-llmledger/llmledger-mcp.json
- HTML version of this page: https://verifymcp.io/servers/pouriaetab-llmledger/llmledger-mcp