This MCP server provides AI cost tracking and budget management across Claude Code, Cline, Cursor, and Claude Desktop, supporting 11 LLM providers via two sets of tools.
Proxy Tools (API Key Required)
Usage stats: Query total spend, request counts, top models, and cache hit rates for today, week, or month
Cost breakdowns: Analyze costs grouped by provider, model, session, or day
Budget status: Check budget limits and remaining balances
Session summaries: Review recent proxy sessions with cost, duration, and models used
API key management: List all keys with status and creation dates
Health check: Ping the proxy and measure response time
Local Tools (No API Key Needed)
Current session cost: Aggregate real-time costs across all detected AI coding tools (Claude Code, Cline)
Project overview: View cumulative costs ranked by spend across all projects
Cache savings: Analyze how much prompt caching has saved you
Monthly forecast: Project monthly spending and compare against Claude Max subscription cost
Subagent attribution: Break down costs by subagent within a Claude Code session
Additionally, a SessionEnd hook automatically logs session costs when Claude Code exits. Data is auto-detected and aggregated from Claude Code, Cline (VS Code, Cursor, Windsurf), WSL installations, and remote VS Code/Cursor Server extensions.
Automatically detects and aggregates cost data from AI coding tools used within VSCodium, offering insights into session costs, project spending, and prompt caching savings.
AI cost inspection for supported Claude Code sessions and Cline task data found in VS Code-family storage. Eleven tools cover local session evidence, authenticated gateway spend, and budget queries.
Part of LLMKit, an open-source API gateway with cost tracking and budget enforcement.
Add to your .mcp.json (Claude Code) or .cursor/mcp.json (Cursor):
{
"mcpServers": {
"llmkit": {
"command": "npx",
"args": ["-y", "@f3d1/llmkit-mcp-server"]
}
}
}The local tools (llmkit_local_*) need no API key. They read supported Claude Code sessions and
Cline task data from supported editor storage. Proxy tools require an existing LLMKit API key in
LLMKIT_API_KEY. Check llmkit.sh for current account and service availability.
Related MCP server: Langfuse MCP Server
Tool | What it does |
| Spend, requests, top models for a period |
| Costs grouped by provider, model, session, or day |
| Budget limits and remaining balance |
| Recent sessions with cost, duration, models |
| All keys with status and creation date |
| Proxy ping with response time |
The local tools detect supported installations and aggregate their session data.
Tool | What it does |
| Current Claude Code session or latest detected Cline task cost |
| Cumulative cost across all projects and sessions |
| Claude Code prompt caching savings using model-bound prices |
| 30-day API-rate projection from detected local history |
| Subagent cost attribution (Claude Code) |
Auto-log session costs when Claude Code exits:
{
"hooks": {
"SessionEnd": [
{
"type": "command",
"command": "npx @f3d1/llmkit-mcp-server --hook"
}
]
}
}Variable | Required | Description |
| No | API key for proxy tools. Local tools work without it. |
| No | Proxy URL (defaults to hosted service) |
| No | Override Cline data directory path |
| No | Set to |
The local tools read data from:
Claude Code (~/.claude/projects/)
Cline extension storage in VS Code, Insiders, VSCodium, Cursor, and Windsurf
WSL installations when LLMKIT_SCAN_WSL=1 (scans distro homes via UNC paths on Windows)
VS Code, Cursor, and Windsurf server directories for supported remote extension storage
MIT
Check budget limits and remaining balance
| Name | Required | Description | Default |
|---|---|---|---|
| budgetId | No | Specific budget ID, or omit for all |
| Name | Required | Description |
|---|---|---|
| budgets | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly, destructive, and idempotent hints. The description adds no extra behavioral details beyond the stated purpose, but does not contradict annotations.
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?
Single, direct sentence that efficiently conveys the tool's purpose with no wasted words.
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 simple tool, optional parameter, safety annotations, and presence of an output schema, the description is adequate. It covers the core action but could briefly mention that omitting budgetId fetches all budgets (already in schema).
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 100% with clear description for the only parameter. The description does not add additional meaning beyond the schema.
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 'Check' and resource 'budget limits and remaining balance', clearly distinguishing it from siblings like 'llmkit_cost_query'.
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 on when to use this tool vs alternatives; no exclusions or context provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query cost breakdown grouped by provider, model, session, or day
| Name | Required | Description | Default |
|---|---|---|---|
| groupBy | Yes | How to group results | |
| days | No | Days to look back (default 30) | |
| provider | No | Filter by provider | |
| model | No | Filter by model |
| Name | Required | Description |
|---|---|---|
| groupBy | Yes | |
| days | Yes | |
| breakdown | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds no extra behavioral context, which is acceptable given annotation coverage, but does not enhance understanding beyond them.
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?
Single sentence efficiently conveys the tool's purpose without unnecessary words. It is front-loaded with the key action and grouping options.
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 read-only query tool with a comprehensive input schema and an output schema available, the description is complete enough. It covers the main purpose and grouping dimension.
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?
Input schema provides 100% coverage with descriptions for all parameters. The description adds no additional semantic value beyond what the schema already offers; baseline score of 3 is appropriate.
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 specifies verb (Query) and resource (cost breakdown) with grouping options (provider, model, session, day). It effectively communicates the tool's function, though it does not explicitly differentiate from sibling tools like llmkit_usage_stats.
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 on when to use this tool versus alternatives such as llmkit_budget_status or llmkit_usage_stats. The description lacks context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check proxy health and response time
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| status | Yes | |
| responseTimeMs | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds marginal value by specifying 'response time'. However, it does not disclose what happens if the proxy is unhealthy (e.g., timeout, error). The behavioral context is adequate but not enriched beyond annotations.
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 (5 words) and front-loaded with the core purpose. Every word earns its place with no redundancy.
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 zero parameters, full annotation coverage, and presence of an output schema, the description is complete enough. It covers the essential action (health check) and an extra detail (response time) without needing more.
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?
There are no parameters (0 params), so the description bears no burden for parameter explanation. Schema coverage is 100% trivially. Baseline for 0 params is 4, which is appropriate.
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 'Check proxy health and response time' uses a specific verb and resource, clearly distinguishing it from sibling tools like llmkit_budget_status or llmkit_usage_stats, which serve different purposes.
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 explicit guidance on when to use this tool versus alternatives. While it's implied as a baseline check, the description does not mention prerequisites, context, or when it should be used before other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all API keys with status and creation date
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| keys | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, indicating safe, idempotent operation. The description adds context about returned fields (status and creation date), which enhances transparency without contradicting annotations.
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 a single, well-structured sentence with no unnecessary words. It front-loads the action and resource, making it easy to parse.
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 tool with no parameters, a rich output schema, and comprehensive annotations, the description is complete. It explains what the tool does and what it returns, leaving no gaps in understanding.
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, so schema coverage is 100%. The description adds no parameter info, but the baseline for zero-parameter tools is 4. The description is adequate given no parameters to document.
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 lists API keys with status and creation date. 'List' is a specific verb, and 'API keys' is a distinct resource. This distinguishes it from sibling tools like 'llmkit_budget_status' or 'llmkit_cost_query', which have different purposes.
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 implies usage when a user needs to list API keys. However, it offers no explicit guidance on when not to use this tool or alternatives. Given the simple nature and clear sibling differentiation, it is adequate but lacks exclusionary advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Subagent cost attribution for the current Claude Code session. Shows which agents cost the most.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| sessionId | Yes | |
| totalCostUsd | Yes | |
| mainConversationCostUsd | No | |
| subagentsTotalCostUsd | No | |
| agentCount | Yes | |
| byType | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and non-destructive/idempotent. The description adds behavioral context (shows top-costing agents) but does not elaborate on aggregation level, data freshness, or any limits. With strong annotations, the description adds moderate value.
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?
Single sentence is maximally concise and front-loaded. Every word adds value; no filler.
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?
With zero parameters and an output schema (not shown), the description is sufficient for basic selection. It covers the 'what' and 'scope' but could mention if returns list or aggregate. Overall adequate.
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, so schema coverage is 100%. Baseline for 0 params is 4; description does not need to explain parameters.
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 it attributes costs to subagents in the current session and shows the most costly agents. It distinguishes from siblings like llmkit_cost_query by focusing on subagents and session context, though 'subagent cost attribution' could be more specific.
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 mentions the context ('current Claude Code session') but provides no explicit guidance on when to use over siblings like llmkit_cost_query or llmkit_budget_status. No when-not-to-use or alternative suggestions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Cache savings analysis across all detected AI coding tools. Shows how much prompt caching saved.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| savings | No | |
| totalSavedUsd | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the tool is clearly safe and idempotent. The description adds context about prompt caching but does not disclose any additional behavioral traits beyond what annotations provide.
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: two sentences that immediately state the tool's function without extraneous information. Every sentence adds value, and there is no wasted space.
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?
Despite the short description, it is sufficient for a parameterless tool with annotations and an output schema. It clearly explains what the tool does ('cache savings analysis'), and the output schema presumably details the return format. No critical information is missing.
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 input schema has no parameters, so schema description coverage is effectively 100%. The description does not need to explain parameters. According to guidelines, 0 parameters yields a baseline score of 4.
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: 'Cache savings analysis across all detected AI coding tools. Shows how much prompt caching saved.' It uses specific verbs ('analysis', 'shows') and identifies the resource (cache savings), effectively distinguishing it from sibling tools like 'llmkit_cost_query' or 'llmkit_budget_status' which focus on other aspects.
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 implies usage for cache savings queries but does not explicitly provide when-to-use vs alternatives or list exclusion criteria. Given the tool's name and title, the context is clear, but there is no explicit guidance on when not to use it or how it compares to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Monthly cost projection based on local AI tool usage. Compares to Max subscription.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| projectedMonthlyUsd | Yes | |
| dailyAverageUsd | Yes | |
| totalTrackedUsd | No | |
| totalSessions | No | |
| maxSubscriptionSavingsUsd | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety. The description adds context about projection and comparison, but does not disclose additional behavioral traits like data freshness, assumptions, or update frequency. It adds some value beyond annotations but is not rich.
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 consists of two short sentences with no extraneous words. It is front-loaded with the core purpose and effectively communicates the tool's function in a concise manner.
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 no parameters, a present output schema, and annotations covering safety, the description is largely complete. It explains the purpose and output comparison, though it does not elaborate on what 'Max subscription' means or how projections are calculated. Still, it is sufficient for a simple tool.
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?
There are zero parameters, and schema description coverage is 100% (trivially). Per guidelines, the baseline is 3 when coverage is high. The description does not need to add parameter information, so a score of 3 is appropriate.
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 it provides a 'monthly cost projection based on local AI tool usage' and 'compares to Max subscription.' This is a specific verb-resource pair, and it distinguishes itself from siblings like llmkit_budget_status (budget status) and llmkit_cost_query (raw cost queries).
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 context by mentioning comparison to a 'Max subscription,' but does not explicitly state when to use this tool versus alternatives like llmkit_cost_query or llmkit_budget_status. Usage guidance is implied but not made explicit for the AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Cumulative cost across all projects and sessions from all detected AI coding tools, ranked by spend.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| projects | Yes | |
| totalCostUsd | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint, idempotentHint, and destructiveHint flags, covering safety. The description adds that results are cumulative and ranked, providing extra context, but does not detail other behavioral aspects like pagination or data freshness.
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 a single, concise sentence that conveys all necessary information without extraneous words. It is front-loaded with the key action ('cumulative cost') and structured effectively.
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 no parameters, an output schema, and clear annotations, the description is complete. It sufficiently explains what the tool returns and its ranking, meeting the needs for agent invocation.
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, so the description does not need to elaborate on parameter meanings. The baseline score is 4 as parameter semantics are not applicable.
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 cumulative cost across all projects and sessions, ranked by spend. It uses a specific verb ('cumulative cost') and resource ('projects and sessions from all detected AI coding tools'), making the purpose unambiguous.
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 does not explicitly state when to use this tool versus alternatives like llmkit_cost_query or llmkit_budget_status. While the context is clear, there is no guidance on exclusions or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Current session cost across all detected AI coding tools (Claude Code, Cline). No API key needed.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| sessions | No | |
| totalCostUsd | Yes | |
| sourceCount | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly=true, idempotent=true. The description adds the behavioral detail that no API key is required, which is useful. However, it does not disclose what happens when no tools are detected or any other execution traits beyond what annotations cover.
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, efficiently conveying purpose and a key usage detail. Every word serves a purpose, no fluff, and it is front-loaded with primary information.
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 simplicity (zero params, output schema present, clear annotations), the description fully covers what an AI agent needs: what it returns (session cost across tools) and an important precondition (no API key). No gaps remain.
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?
With zero parameters and 100% schema coverage, the description needs to add no extra meaning. It correctly states the absence of required inputs ('No API key needed'), meeting the baseline expectation for a parameterless tool.
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 the current session cost across detected AI coding tools, specifically naming Claude Code and Cline. This verb+resource+scope effectively distinguishes it from siblings like budget_status or cost_query.
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?
It mentions 'No API key needed' implying ease of use, but lacks explicit guidance on when to use this tool vs alternatives like llmkit_cost_query or llmkit_session_summary. Context is implied but not directly compared.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent proxy sessions with cost, duration, and models used
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | No | Specific session ID | |
| limit | No | Number of sessions (default 10) |
| Name | Required | Description |
|---|---|---|
| sessions | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering safety. The description adds that the tool returns cost, duration, and models used, but lacks details on pagination, ordering, or potential side effects.
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 a single, front-loaded sentence with no redundant words. Every word adds value.
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?
With an output schema present and low complexity, the description adequately covers purpose and returned data. However, it omits explanation of 'proxy sessions' and how to integrate with sibling tools.
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 100%, so baseline is 3. The description does not add new parameter details beyond what the schema provides (sessionId, limit). It implies recency but doesn't specify default limit or format.
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 verb 'Get', the resource 'recent proxy sessions', and the specific data points returned (cost, duration, models). This effectively distinguishes it from sibling tools like llmkit_cost_query or llmkit_usage_stats.
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 explicit guidance on when to use this tool versus alternatives. It does not mention filtering, prerequisites, or scenarios where other tools like llmkit_cost_query would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get usage statistics (spend, requests, top models) for a time period
| Name | Required | Description | Default |
|---|---|---|---|
| period | No | Time period | month |
| Name | Required | Description |
|---|---|---|
| period | Yes | |
| requests | Yes | |
| totalSpendUsd | Yes | |
| inputTokens | No | |
| outputTokens | No | |
| cacheReadTokens | No | |
| cacheHitRate | No | |
| topModels | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds no extra behavioral context beyond 'get usage statistics', failing to explain any side effects or data aggregation behavior.
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 a single, front-loaded sentence that efficiently conveys the tool's purpose. It earns its place without unnecessary words.
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 complexity (single parameter, rich annotations, output schema present), the description is too sparse. It omits details about the output format or what specific stats are included, leaving the agent to infer from the schema.
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 100%, so baseline is 3. The description mentions 'for a time period', which aligns with the period parameter, but does not elaborate on the enum values or default. Thus, it adds minimal meaning beyond the schema.
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 'gets usage statistics' and specifies components: 'spend, requests, top models'. It is action-oriented and identifies the resource. While it distinguishes from siblings like budget_status or cost_query, it does not explicitly contrast them.
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. The description lacks context on prerequisites, exclusions, or preferred use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.1llmkit_budget_status2 fields changedInput schema / properties / budgetId / descriptionPrevious value: -"Specific budget ID, or omit for all budgets"New value: +"Specific budget ID, or omit for all"Output schema / (root)Previous value: -nullNew value: +{
+ "properties": {
+ "budgets": {
+ "items": {
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "limitUsd": {
+ "type": "number"
+ },
+ "name": {
+ "type": "string"
+ },
+ "period": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "budgets"
+ ],
+ "type": "object"
+}llmkit_cost_query5 fields changedInput schema / properties / days / descriptionPrevious value: -"Number of days to look back (default 30)"New value: +"Days to look back (default 30)"Input schema / properties / groupBy / descriptionPrevious value: -"How to group the results"New value: +"How to group results"Input schema / properties / model / descriptionPrevious value: -"Filter by model name"New value: +"Filter by model"Input schema / properties / provider / descriptionPrevious value: -"Filter by provider name"New value: +"Filter by provider"Output schema / (root)Previous value: -nullNew value: +{
+ "properties": {
+ "breakdown": {
+ "items": {
+ "properties": {
+ "costUsd": {
+ "type": "number"
+ },
+ "inputTokens": {
+ "type": "number"
+ },
+ "key": {
+ "type": "string"
+ },
+ "outputTokens": {
+ "type": "number"
+ },
+ "requests": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "days": {
+ "type": "number"
+ },
+ "groupBy": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "groupBy",
+ "days",
+ "breakdown"
+ ],
+ "type": "object"
+}llmkit_health1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "properties": {
+ "responseTimeMs": {
+ "type": "number"
+ },
+ "status": {
+ "enum": [
+ "ok",
+ "degraded",
+ "unreachable"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "status"
+ ],
+ "type": "object"
+}llmkit_list_keys1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "properties": {
+ "keys": {
+ "items": {
+ "properties": {
+ "created": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "prefix": {
+ "type": "string"
+ },
+ "status": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "keys"
+ ],
+ "type": "object"
+}llmkit_local_agentsllmkit_local_cachellmkit_local_forecastllmkit_local_projectsllmkit_local_sessionllmkit_session_summary3 fields changedInput schema / properties / limit / descriptionPrevious value: -"Number of recent sessions (default 10)"New value: +"Number of sessions (default 10)"Input schema / properties / sessionId / descriptionPrevious value: -"Specific session ID to query"New value: +"Specific session ID"Output schema / (root)Previous value: -nullNew value: +{
+ "properties": {
+ "sessions": {
+ "items": {
+ "properties": {
+ "costUsd": {
+ "type": "number"
+ },
+ "durationMinutes": {
+ "type": "number"
+ },
+ "models": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "providers": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "requests": {
+ "type": "number"
+ },
+ "sessionId": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "sessions"
+ ],
+ "type": "object"
+}llmkit_usage_stats2 fields changedInput schema / properties / period / descriptionPrevious value: -"Time period to query"New value: +"Time period"Output schema / (root)Previous value: -nullNew value: +{
+ "properties": {
+ "cacheHitRate": {
+ "type": "number"
+ },
+ "cacheReadTokens": {
+ "type": "number"
+ },
+ "inputTokens": {
+ "type": "number"
+ },
+ "outputTokens": {
+ "type": "number"
+ },
+ "period": {
+ "type": "string"
+ },
+ "requests": {
+ "type": "number"
+ },
+ "topModels": {
+ "items": {
+ "properties": {
+ "model": {
+ "type": "string"
+ },
+ "requests": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "totalSpendUsd": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "period",
+ "requests",
+ "totalSpendUsd"
+ ],
+ "type": "object"
+}v0.1.0llmkit_budget_statusllmkit_cost_queryllmkit_healthllmkit_list_keysllmkit_session_summaryllmkit_usage_statsScored across 11 tools
Tools are mostly distinct, targeting different aspects like budget, cost breakdown, health, keys, local session, etc. However, llmkit_cost_query, llmkit_usage_stats, and llmkit_session_summary have overlapping purposes (cost/spend/usage data) which could cause some confusion.
All tools follow a consistent pattern with the 'llmkit_' prefix and descriptive noun phrases separated by underscores, e.g., llmkit_budget_status, llmkit_cost_query. No mixing of conventions.
With 11 tools, the count is well within the recommended 3-15 range. Each tool covers a distinct aspect of proxy cost monitoring and management, justifying its inclusion.
The tool surface covers major monitoring needs: health, budget, cost, keys, sessions, and local attribution. However, it lacks management capabilities (e.g., create/update keys or budgets) and could include actions like setting usage limits, which are minor gaps for a read-only analytics server.
Query cloud, AI and SaaS spend across 25+ providers: costs, budgets, anomalies, unit economics.
Query OneLens cloud-cost data in natural language: breakdowns, trends, cost centers. Read-only.
Enforce AI budgets before the model call and track cost per customer across 10 providers.
Track, analyze, and act on your streaming and SaaS subscriptions from any AI agent.
