llm-cost

List every LLM API provider ComparEdge tracks, with model count, whether a batch API is available, and the cheapest model per provider. BEHAVIOR: Returns every provider we track (OpenAI, Anthropic, Google, DeepSeek, Amazon, Groq, Mistral, xAI, and more), each with its model count and a one-line cheapest-model summary. Prices are USD per 1M tokens. USAGE GUIDELINES: - Use first when the user asks "which providers exist?" or "who sells the cheapest tokens?". - Use before list_models when you want the provider slug to filter by. - No parameters. EXAMPLE QUERIES: "What LLM providers are there?", "Which providers have a batch API?", "Show me the model vendors you cover"

List LLM models with their per-1M-token input and output prices, cached-input rate where offered, context window, and tier. Optionally filter to one provider. BEHAVIOR: Returns every model (or just one provider's) with id, display name, input/output/cached rates, context window, and tier (flagship, standard, fast, reasoning). The id is what estimate_cost, compare_models_cost, and monthly_budget expect. USAGE GUIDELINES: - Use to find the exact model id before pricing a call. - Pass provider (a slug like "openai", "anthropic", "google") to narrow the list. - Use cheapest_models instead when the user wants the lowest price rather than a full list. EXAMPLE QUERIES: "List Anthropic models and prices", "What does GPT-5.5 cost per token?", "Show all reasoning models", "Which Gemini models have a 1M context window?"

Estimate the exact dollar cost of one LLM call, or a batch of identical calls, from input and output token counts. Returns a per-call breakdown plus cached-input and batch-API savings where the model supports them. BEHAVIOR: Resolves the model reference (id or display name, fuzzy matched), then computes input_tokens/1M x input_rate + output_tokens/1M x output_rate. Multiplies by calls for a total. If the model offers cached-input pricing or a batch API, it shows those cheaper totals too. USAGE GUIDELINES: - Use whenever the user knows roughly how many tokens a call reads and writes. - A rough token rule: 1 token is about 4 English characters, or 0.75 words. A page of text is ~500 tokens. - Set calls when the same-shaped request runs many times (e.g. one per support ticket). - Use monthly_budget instead when the user thinks in calls-per-day rather than a fixed batch. - Use compare_models_cost to price the same call across several models at once. EXAMPLE QUERIES: "What does a 10k-token prompt with a 2k-token answer cost on Claude Opus 4.8?", "Price 50,000 GPT-5-mini calls at 800 in / 400 out tokens", "How much for a 200k-token document summarized by Gemini 3.1 Pro?"

Price the same call across 2 to 6 models and rank them from cheapest to most expensive, with a multiplier showing how much more each costs than the cheapest option. BEHAVIOR: Resolves each model reference, computes the per-call cost at the given token counts, sorts ascending, and reports each model's cost and its ratio to the cheapest. If any reference cannot be resolved, it says which one and stops so you can correct it. USAGE GUIDELINES: - Use when the user is choosing between named models for a known workload. - Pick the token counts that reflect the real task, not a round guess, so the ranking is meaningful. - Use cheapest_models instead when the user has not named specific models. EXAMPLE QUERIES: "Compare GPT-5.5, Claude Opus 4.8, and Gemini 3.1 Pro for a 5k/1k call", "Cheapest of Haiku 4.5, GPT-5-mini, Gemini 3 Flash for classification", "Opus vs Sonnet vs Fable at 20k in 2k out"

List the cheapest LLM models, optionally filtered to those with at least a given context window. Ranked by a blended input:output rate. BEHAVIOR: Ranks models by a blended per-1M rate weighted 3:1 input to output (most workloads read more than they write), lowest first. min_context filters out models with a smaller context window. Returns the blended rate plus the raw input and output rates so you can sanity-check against your own token split. USAGE GUIDELINES: - Use when the user wants "the cheapest model" without naming candidates. - Pass min_context when the task needs a large window; it accepts "200" (read as 200K) or "200000" (raw tokens). - Follow up with estimate_cost using the real token split, since the blended ranking is an approximation. EXAMPLE QUERIES: "What are the cheapest LLMs right now?", "Cheapest model with at least a 1M context window", "Five lowest-cost models for high-volume tagging"

Project the daily, monthly, and yearly spend for a recurring LLM workload from calls-per-day and average token counts. Includes cached-input and batch-API projections where available. BEHAVIOR: Computes per-call cost from average input and output tokens, then scales to daily (x calls), monthly (x30 days), and yearly (x365) totals, and reports the monthly token volume. Cheaper cached-input and batch paths are shown when the model supports them. USAGE GUIDELINES: - Use for planning a feature that calls an LLM on a steady cadence (per ticket, per user action, per cron run). - avg_input_tokens and avg_output_tokens should be typical values, not worst case. - Use estimate_cost instead for a one-off or fixed batch. EXAMPLE QUERIES: "Monthly cost if we run 5,000 Claude Haiku calls a day at 1,200 in / 300 out", "Budget GPT-5-mini for 200 summaries an hour", "Yearly spend on Gemini 3 Flash at 50k calls/day, 500/200 tokens"