Try Chat Free Docs Pricing AI Analysis Repo Insights Free Tools About Blog
Sign in Get started free
< Back to blog
Research Velona Team ·12 November 2026 ·16 min read

What Does MCP Actually Cost in ₹? We Measured the Tool-Schema Token Tax of 5 Real MCP Servers (2026)

Short answer: connecting GitHub's official MCP server with its default tools, plus the reference Filesystem and PostgreSQL servers, adds 13,160 tokens of tool definitions to every request in our measurement, before the model reads a single line of your code. Over a 25-turn agent session, that overhead alone costs about ₹66 on Claude Sonnet 5.5 and ₹6.31 on DeepSeek V4 Flash at full input price. Prompt caching cuts it by about 85%. Sending only the seven tools the task actually needs cut the schema tokens by 90%, and a single shell-command tool needs just 58 tokens.

The Model Context Protocol (MCP) lets coding agents such as Claude Code, Cline, OpenCode and Cursor plug into GitHub, databases, browsers and your own services in a standard way. The catch is that most clients send every connected tool's full description and JSON schema with every request. You pay for those tokens on every turn, whether the agent uses the tools or not.

We measured that cost directly, on real servers, and priced it in rupees.

Key findings

Why is everyone talking about MCP context bloat?

Because the people who build agents keep running into it. Anthropic's engineering team wrote that most MCP clients load all tool definitions upfront into the context window, and that once too many servers are connected, tool definitions and results can consume excessive tokens and reduce agent efficiency [1]. In a follow-up, Anthropic described a five-server setup in which GitHub alone took about 26,000 tokens, and said it had seen tool definitions consume 134,000 tokens before optimisation [2].

The wider industry has noticed too. Thoughtworks' Technology Radar (April 2026) notes that agent skills are one reason teams are becoming more cautious about defaulting to MCP, because many use cases can be handled just as well by pointing an agent at a local CLI or script [3]. The same edition recommends dynamic retrieval that loads only the necessary MCP servers to avoid unnecessary context growth [4].

What was missing was a simple, reproducible count of what popular servers actually cost, in rupees. So we made one.

How we measured the MCP token tax

This is a measurement, not an estimate. On 12 November 2026 we:

  1. Ran five real MCP servers locally: GitHub's official github-mcp-server v2.1.0 (default toolsets, then all toolsets), the reference Filesystem server (@modelcontextprotocol/server-filesystem), the reference PostgreSQL server (@modelcontextprotocol/server-postgres 0.6.2, now archived) and Microsoft's Playwright server (@playwright/mcp 0.0.85).
  2. Asked each server for its tools using the standard MCP tools/list request, exactly as a client does.
  3. Converted each tool into the OpenAI function-calling format (name, description and JSON schema) that an OpenAI-compatible API receives.
  4. Counted tokens with the o200k tokenizer used by OpenAI's GPT-5 family, through the gpt-tokenizer library.
  5. Priced the result using Velona's live rupee prices where listed, and Velona's published formula for the rest.

Two caveats matter. Other tokenizers, including Claude's, count differently, so treat these numbers as a close guide rather than an exact bill for every model. And some providers add their own hidden formatting around tool definitions, which can push the real count slightly higher. Anthropic's figure of about 26,000 tokens for GitHub [2] used a different server version and tokenizer, which is why it differs from ours.

How many tokens does each MCP server add?

GitHub's server adds the most by a wide margin: 11,363 tokens with default settings and 23,595 with everything enabled.

MCP serverToolsTokens per requestAverage per toolLargest single tool
GitHub official, default toolsets4611,363247issue_write, 809
GitHub official, all toolsets9123,595259projects_write, 1,577
Playwright (Microsoft)254,061162browser_take_screenshot, 333
Filesystem (reference)141,764126read_text_file, 194
PostgreSQL (reference)13737query, 36

The pattern is clear: cost scales with the number of tools and the length of their descriptions. A single read-only database tool is almost free. A server that wraps a whole product API, like GitHub, is expensive.

What a realistic stack costs per request

StackToolsTokens per request
One shell-command tool (the CLI approach)158
Lean: 7 tools picked for one coding task71,359
Typical: GitHub default + Filesystem + PostgreSQL6113,160
Heavy: typical + Playwright8617,219
Everything: GitHub all toolsets + Filesystem + PostgreSQL + Playwright13129,451

The lean set was get_file_contents, search_code and create_pull_request from GitHub, read_text_file, edit_file and write_file from Filesystem, and query from PostgreSQL. That is enough to read code, change it, check the database and open a pull request.

What does the MCP token tax cost in rupees?

For the typical three-server stack, the overhead of a 25-turn session ranges from ₹1.66 to ₹132.81 at full price, depending on the model.

The table prices only the tool definitions: 13,160 tokens sent on each of 25 turns, or 329,000 input tokens per session. The cached column assumes the first turn pays full price and the next 24 read the definitions from cache at 10% of the input price, with a 25% surcharge on the first write for Claude models.

Model (Velona ID)Input ₹ per 1M tokensOverhead per session, no cacheOverhead per session, cached
GPT-5 Nano (openai/gpt-5-nano)₹5.05₹1.66₹0.23
Claude Haiku 5.5₹10.09₹3.32₹0.48
DeepSeek V4 Flash (deepseek/deepseek-v4-flash)₹19.18₹6.31₹0.86 or less
GPT-5 Mini (openai/gpt-5-mini)₹25.23₹8.30₹1.13
GPT-5.1₹126.15₹41.50₹5.64
Claude Sonnet 5.5₹201.85₹66.41₹9.70
Claude Opus 5.5₹403.68₹132.81₹19.39

GPT-5 Nano, DeepSeek V4 Flash and GPT-5 Mini use Velona's live prices on 12 November 2026, at ₹93.85 to the dollar [5, 6]. The other rows apply Velona's published formula (provider price × USD/INR × 1.005 forex buffer × 1.07 platform fee) to the provider list prices in our price per message guide. DeepSeek's cache discount is usually deeper than 10%, so its cached cost is likely lower than shown. Check each model's cached rate before you plan around it.

How much of a session is tool definitions?

A typical coding agent step sends about 30,000 tokens of code and conversation. Adding 13,160 tokens of tool definitions makes every step about 44% larger. On a heavy stack it is 57% larger. For short chat-style tasks the share is far higher, because the tools can be bigger than the conversation itself.

The same session on different stacks

StackClaude Sonnet 5.5, no cacheDeepSeek V4 Flash, no cache
One shell tool₹0.29₹0.03
Lean (7 tools)₹6.86₹0.65
Typical (61 tools)₹66.41₹6.31
Heavy (86 tools)₹86.89₹8.26
Everything (131 tools)₹148.62₹14.12

A developer running 10 such sessions a day on Claude Sonnet 5.5 with the typical stack and no caching spends about ₹664 a day on tool definitions alone, roughly ₹14,600 over 22 working days.

How do I cut MCP token costs?

Do three things, in this order: turn on caching, send fewer tools, and use a CLI where one exists.

  1. Make caching work. Keep tool definitions identical and in the same order on every request, and put them before anything that changes. Changing the tool list mid-session breaks the cache. On Velona, cached tokens appear in usage.prompt_tokens_details.cached_tokens and are billed at the model's cached rate [7].
  2. Enable only the toolsets you need. GitHub's server lets you pick toolsets, name individual tools with --tools, or run in --read-only mode. Most coding tasks need a handful of GitHub tools, not 46.
  3. Load tools on demand. Route each request to the tool groups it needs, as in the example below. Anthropic's tool search and code-execution approaches take the same idea further [1, 2].
  4. Prefer a CLI when one exists. Models already know git, gh and psql. One shell tool costs 58 tokens, though command output still counts as input when it comes back.
  5. Cap the cost. Set a budget on the API key the agent uses, so a looping agent stops instead of draining your wallet.

Python tutorial: a lean, budget-capped tool agent on Velona

This example sends only the tools a question needs, for two Indian business tasks: checking a GSTIN and reading Razorpay webhook logs. It tracks the rupee cost of each call and stops at a session budget. The tool functions are stubs, so replace them with your real GST and Razorpay calls.

import json
import os

from openai import OpenAI

client = OpenAI(
    api_key=os.environ["VELONA_API_KEY"],  # use a key with its own budget cap
    base_url="https://velona.in/v1",
)

MODEL = "deepseek/deepseek-v4-flash"
INPUT_RS_PER_M = 19.18    # Velona price, 12 Nov 2026. Check /models for today's rate.
OUTPUT_RS_PER_M = 51.47
SESSION_BUDGET_RS = 5.00  # stop the loop before it costs more than this

# Every tool you might ever need, grouped by job. None of these is sent by default.
TOOL_GROUPS = {
    "gst": [{
        "type": "function",
        "function": {
            "name": "get_gstin_status",
            "description": "Look up whether a GSTIN is active and its registered trade name.",
            "parameters": {
                "type": "object",
                "properties": {"gstin": {"type": "string", "description": "15-character GSTIN"}},
                "required": ["gstin"],
            },
        },
    }],
    "payments": [{
        "type": "function",
        "function": {
            "name": "get_razorpay_webhook_logs",
            "description": "Fetch recent Razorpay webhook deliveries for one event type.",
            "parameters": {
                "type": "object",
                "properties": {
                    "event": {"type": "string", "description": "For example payment.captured"},
                    "limit": {"type": "integer", "default": 10},
                },
                "required": ["event"],
            },
        },
    }],
}

KEYWORDS = {
    "gst": ["gst", "gstin", "invoice", "tax"],
    "payments": ["razorpay", "webhook", "payment", "refund", "upi"],
}


def pick_tools(question: str) -> list:
    """Send only the tool groups this question needs, not every tool you own."""
    q = question.lower()
    tools = []
    for group, words in KEYWORDS.items():
        if any(w in q for w in words):
            tools.extend(TOOL_GROUPS[group])
    return tools


def run_tool(name: str, args: dict) -> str:
    # Replace these stubs with your real GST and Razorpay calls.
    # Never return Aadhaar, PAN or full UPI IDs to the model unless the task needs them.
    if name == "get_gstin_status":
        return json.dumps({"gstin": args["gstin"], "status": "Active", "trade_name": "Example Traders"})
    if name == "get_razorpay_webhook_logs":
        return json.dumps({"event": args["event"], "deliveries": [{"status": 200, "attempts": 1}]})
    return json.dumps({"error": f"unknown tool {name}"})


def cost_rs(usage) -> float:
    # Upper bound: treats every prompt token as uncached.
    # Cached tokens show up in usage.prompt_tokens_details.cached_tokens and cost less.
    return (usage.prompt_tokens * INPUT_RS_PER_M + usage.completion_tokens * OUTPUT_RS_PER_M) / 1_000_000


def ask(question: str, max_turns: int = 8) -> str:
    messages = [
        {"role": "system", "content": "You are a support engineer for an Indian D2C store. Use tools only when needed."},
        {"role": "user", "content": question},
    ]
    tools = pick_tools(question)  # 61 to 131 tokens of tool schema here, not 13,160
    spent = 0.0

    for _ in range(max_turns):
        kwargs = {"model": MODEL, "messages": messages, "max_tokens": 600}
        if tools:
            kwargs["tools"] = tools
        resp = client.chat.completions.create(**kwargs)
        spent += cost_rs(resp.usage)
        # Example: 1,200 prompt tokens + 180 output tokens = about 0.03 rupees on deepseek/deepseek-v4-flash
        if spent > SESSION_BUDGET_RS:
            return f"Stopped: session cost reached about Rs {spent:.2f}"

        msg = resp.choices[0].message
        if not msg.tool_calls:
            print(f"Session cost: about Rs {spent:.4f}")
            return msg.content

        messages.append(msg)
        for call in msg.tool_calls:
            result = run_tool(call.function.name, json.loads(call.function.arguments or "{}"))
            messages.append({"role": "tool", "tool_call_id": call.id, "content": result})

    return "Stopped: too many turns"


if __name__ == "__main__":
    print(ask("Is GSTIN 27AAPFU0939F1ZV active, and did the last payment.captured webhook succeed?"))

We measured the two tool groups at 61 and 72 tokens, or 131 tokens together. Keyword routing is deliberately simple. In production you can route with a cheap classifier model, or let the agent call a small "search tools" tool first, which is the idea behind Anthropic's tool search [2].

Is MCP safe? The main security risks in India

MCP itself is a protocol. The risks come from what an agent can reach and what it reads. These are the three that matter most for Indian teams.

1. Indirect prompt injection

Any text a tool returns can contain instructions. In May 2025, Invariant Labs showed that a malicious issue on a public GitHub repository could hijack an agent using GitHub's MCP server and make it leak data from the user's private repositories [8]. The researchers said the problem cannot be solved by server-side patches alone and needs architectural controls [9]. Treat issues, pull request comments, web pages and database rows written by users as untrusted input.

2. Over-privileged access

The injection only worked because the agent's token could see private repositories. Analysis of the incident points out that if the token can only reach public repositories, an attempt to read private ones fails [10]. Use fine-grained tokens scoped to one repository, GitHub's --read-only mode where you only need to read, and a read-only database role for the PostgreSQL tool.

3. Personal data leaking into prompts and logs

Tool results often carry customer data: names, phone numbers, Aadhaar or PAN numbers, GSTINs and UPI IDs. Everything a tool returns is sent to the model provider. India's Digital Personal Data Protection Rules were notified on 14 November 2025 with an 18-month phased rollout [11], and the DPDP Act allows penalties of up to ₹250 crore for failing to keep reasonable security safeguards [12]. Mask personal data before it reaches the model. Our Python guide to anonymising data before an LLM shows how, including Aadhaar and UPI ID detection.

Cap the damage with a budget per key

A looping agent can make hundreds of calls in minutes. On Velona, each API key can have an optional budget cap, and requests are rejected with HTTP 402 once the key's spend reaches it [7]. Create a separate key for each agent or MCP host, give it a small budget such as ₹50, and you limit both runaway costs and the blast radius of a leaked key.

When should I use MCP and when a plain CLI script?

Use MCP for services without a good CLI or with complex sign-in, and a CLI or script when one already exists.

QuestionMCP serverCLI or script
Token cost per turn37 to 23,595 tokens per server, every turn, in our measurementAbout 58 tokens for one shell tool, plus command output
SetupInstall and configure each server once, then any MCP client can use itNothing to install if the CLI exists, but the agent needs shell access
SecurityScoped per tool, but every visible tool is reachable by a prompt injectionA shell is powerful, so run it in a sandbox or restricted environment
Best forSaaS products without a CLI, OAuth sign-in, shared team setupsgit, gh, psql, cloud CLIs, and your own repeatable scripts

Many teams end up with both: a few lean MCP servers for services that need them, and a shell tool for everything with a CLI.

Frequently asked questions

How much does MCP add to API costs in rupees?

In our measurement, GitHub's official MCP server with default tools adds 11,363 tokens to every request. A three-server stack with Filesystem and PostgreSQL adds 13,160 tokens, which costs about ₹66 per 25-turn session on Claude Sonnet 5.5 and ₹6.31 on DeepSeek V4 Flash before caching.

How many tokens does the GitHub MCP server use?

Version 2.1.0 of GitHub's official server exposes 46 tools worth 11,363 tokens with default toolsets, and 91 tools worth 23,595 tokens with all toolsets, counted with the GPT-5 family tokenizer.

Which is the cheapest LLM for MCP tool calling in India?

On input price alone, GPT-5 Nano at ₹5.05 per million tokens and Claude Haiku 5.5 at about ₹10 are the cheapest options in our table. Price is not the only factor, because cheap models are more likely to pick the wrong tool or produce invalid arguments. Test on your own tasks, as described in our benchmark of cheap LLMs for agents.

Does prompt caching reduce MCP costs?

Yes, a lot. Tool definitions are identical on every turn, so they cache well. If cached tokens cost 10% of the normal input price, the overhead of a 25-turn session falls by about 85%. Keep the tool list stable during a session, or the cache breaks.

How do I connect Cline or Claude Code to Velona and pay with UPI?

Velona is OpenAI-compatible, so any agent that accepts a custom OpenAI base URL can use https://velona.in/v1 with a Velona API key, while its MCP servers keep running locally as before. Top up from ₹10 with UPI. Our guide to using Velona with coding agents has the setup for each tool.

Limits of this measurement

Reproduce our count

Ask any MCP server for its tools, then count them. This Node.js snippet counts a saved tools/list result.

// npm install gpt-tokenizer
import fs from 'node:fs';
import { encode } from 'gpt-tokenizer/encoding/o200k_base';

const tools = JSON.parse(fs.readFileSync('tools.json', 'utf8'));  // the "tools" array from tools/list
const asFunctions = tools.map(t => ({
  type: 'function',
  function: { name: t.name, description: t.description || '', parameters: t.inputSchema },
}));
console.log(tools.length, 'tools,', encode(JSON.stringify(asFunctions)).length, 'tokens');

Try it on Velona

Velona gives you one OpenAI-compatible API key for GPT, Claude, DeepSeek and 300+ other models, prices every request in rupees, shows cached tokens in each response, and lets you put a budget cap on each key. Top up from ₹10 with GPay, PhonePe or Paytm, with no international card needed.

Create a free Velona account, then make a budget-capped key for your MCP agent.

Disclosure: Velona publishes this measurement and sells access to these models. If your card already works with a provider, paying them directly avoids Velona's 7% platform fee.

Last measured: 12 November 2026.

References

  1. Code execution with MCP: building more efficient agents, Anthropic Engineering
  2. Introducing advanced tool use, Anthropic Engineering
  3. Technology Radar, Volume 34: Techniques (Agent Skills), Thoughtworks, April 2026
  4. Technology Radar, Volume 34: Techniques (context engineering and dynamic retrieval), Thoughtworks, April 2026
  5. DeepSeek V4 Flash price, Velona, refreshed 12 November 2026
  6. Cheapest models, Velona, 12 November 2026
  7. Velona API documentation: key budgets, prompt caching and tool calling, Velona
  8. GitHub MCP exploited: accessing private repositories via MCP, Invariant Labs, 26 May 2025
  9. AI GitHub agents: how an issue leaked private repos, UpGuard
  10. Pulling on the thread of MCP risks, Formal
  11. DPDP Rules, 2025 notified, Press Information Bureau, 17 November 2025
  12. Digital Personal Data Protection Rules, 2025, Vikaspedia
  13. github-mcp-server, GitHub (v2.1.0 measured)
  14. @modelcontextprotocol/server-filesystem, npm
  15. @modelcontextprotocol/server-postgres, npm (0.6.2, archived)
  16. @playwright/mcp, npm (0.0.85 measured)
  17. gpt-tokenizer, npm

Related: Context engineering for AI coding agents, what an AI coding agent really costs in India and Cline vs Aider vs OpenCode vs OpenClaw.