datagovin-mcp
This server gives you natural-language access to India's Open Government Data platform: discover, inspect, and query live public datasets.
Search the full catalog – BM25 keyword search across 235,000+ datasets, with optional sector filtering.
List sectors – See available data categories (e.g. Environment, Agriculture, Health) and their dataset counts.
Inspect dataset schemas – Get a dataset's title, description, row count, and exact field names/types.
Query live dataset rows – Fetch real data using your API key, with filters, field projections, sorting, limit, and offset pagination.
Not just search – The same tools power a website and an MCP server, so any MCP client (Claude, Cursor, VS Code, etc.) can use it.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@datagovin-mcp What's the current AQI in Delhi?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
datagovin-mcp
Natural-language access to India's Open Government Data platform, data.gov.in — 235,000+ public datasets covering air quality, agriculture, health, fuel prices, census, education, rainfall, railways, crime, budgets and more.
Two faces, one codebase:
An MCP server — over stdio for local clients, or over Streamable HTTP so any MCP client connects by URL: Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, ChatGPT connectors, or anything built on an MCP SDK.
A website — instant catalog search plus natural-language answers, backed by the exact same tools.
The server ships no data of its own. Discovery runs against a local full-text index built from data.gov.in's own catalog endpoint; every row you actually read is a live call to data.gov.in using your own free API key.
Why this exists
data.gov.in has an enormous catalog but no full-text search API a program can call — the normal workflow is to browse the website and copy a dataset's resource ID off its "API" button. That's a poor fit for a language model.
This project closes the gap. It harvests the platform's /lists endpoint into a
local SQLite FTS5 index — 235,241 datasets in about 150 seconds, no API key
required — so a model can go from "what's the AQI in Delhi right now?" to real
rows without anyone hunting for a UUID. It also absorbs the upstream API's rough
edges (case-sensitive filters, occasional CSV responses, a last-page pagination
quirk) so the model doesn't have to.
Related MCP server: bharatlas-mcp
Tools
Tool | What it does |
| BM25-ranked full-text search across the whole catalog. |
| Sectors present in the catalog, with dataset counts. |
| Live schema: title, description, row count, exact field names + types. |
| Pull actual filtered rows, live. |
| How many datasets are indexed — distinguishes "no matches" from "not harvested yet". |
Setup
1. Install.
git clone https://github.com/<your-username>/datagovin-mcp.git
cd datagovin-mcp
python -m venv .venv && source .venv/bin/activate
pip install -e . # MCP server only
pip install -e ".[web]" # + the website2. Build the search index. No API key needed for this step.
datagovin-harvestHarvesting the data.gov.in catalog (no API key required)...
indexed 235,000/235,241 datasets (100%, 1,566/s)
Indexed 235,241 datasets in 150.2s -> ~/Library/Caches/datagovin-mcp/catalog.sqlite3 (346.2 MB)Until you run this, search falls back to a small bundled seed catalog — the server still works, it just knows about three datasets. Re-run it any time to refresh; hand-curated entries are preserved.
3. Get a free API key — needed to read rows, not to search. Register at data.gov.in and generate one from your profile page.
cp .env.example .env # then paste your key into itThe .env file is read automatically. Exporting DATA_GOV_IN_API_KEY works too,
and a real environment variable always wins over the file.
Connecting a client
Local (stdio)
Add to your MCP client config (claude_desktop_config.json or equivalent):
{
"mcpServers": {
"datagovin": {
"command": "/absolute/path/to/datagovin-mcp/.venv/bin/python",
"args": ["/absolute/path/to/datagovin-mcp/server.py"],
"env": { "DATA_GOV_IN_API_KEY": "your_key_here" }
}
}
}Remote (Streamable HTTP) — connects from anywhere
python server.py --transport http --host 0.0.0.0 --port 8000
# MCP endpoint: http://<host>:8000/mcpThen point any MCP client at the URL:
{
"mcpServers": {
"datagovin": { "url": "https://your-host.example.com/mcp" }
}
}Add --stateless to run several replicas behind a load balancer.
Before exposing this publicly, put it behind TLS and authentication. The server has no auth of its own, and it spends your data.gov.in API key on every request it serves.
The website
export ANTHROPIC_API_KEY=sk-ant-... # optional — enables the "Ask" button
datagovin-web # http://127.0.0.1:8000One process serves everything:
Route | |
| search UI — type-ahead catalog search, click a dataset for its live schema and sample rows |
| BM25 search as JSON, no LLM involved |
| live schema |
| live rows; any extra query param becomes an upstream filter |
| streaming natural-language answer (Server-Sent Events) |
| the MCP endpoint — so the same deployment serves browsers and MCP clients |
Search works with no keys at all. DATA_GOV_IN_API_KEY unlocks rows;
ANTHROPIC_API_KEY unlocks answers. The UI tells you which are missing.
How answers work. /api/ask runs a streaming Claude tool-use loop over the
same five tools, narrating each step ("Searching the catalog for…", "Fetching 100
rows where city=Delhi") before the answer streams in. Claude is instructed to
answer only from rows it actually fetched, to name the dataset it used, and to say
so plainly when the data doesn't answer the question rather than filling the gap
from memory.
The tool definitions the website gives Claude are read directly off the MCP
server via list_tools() — there is exactly one description and one schema per
tool in this project, so the two surfaces cannot drift apart.
Curating a dataset
Harvesting brings in every dataset automatically. Use this to improve one — attach search keywords, a worked example filter, or a corrected sector, and pin it above harvested results:
python scripts/add_dataset.py <resource_id> \
--sector Agriculture \
--keywords "wheat,crop,production" \
--example-filters '{"State":"Punjab"}'Curated fields survive later harvests.
Notes on the upstream API
Behaviours this server handles for you:
Filter field names are case-sensitive (
filters[State]≠filters[state]) and this is undocumented. Always use the exact fieldidfromget_dataset_info.Some legacy datasets return CSV regardless of
format=json; the client detects this by Content-Type and parses it anyway. CSV carries no row total, sototal_recordscomes backnullrather than a misleading page count.Last-page pagination can return an empty
recordsarray withstatus: ok;returned: 0means you're done.Max ~100 rows per request on
/resource— page withoffset./listsneeds no API key and pages up to 1000 records at a time. It is slow and occasionally times out, so the harvester retries every page with backoff.The API key travels in the query string (upstream's design). Every error this package raises is passed through a redactor first, so a key can never reach a log line, a tool result, or the model's context.
Project layout
datagovin-mcp/
├── server.py # entry point (kept for existing client configs)
├── datagovin/
│ ├── config.py # .env loading, cache paths
│ ├── client.py # async data.gov.in API wrapper (quirk handling)
│ ├── catalog.py # SQLite FTS5 index: search, sectors, stats
│ ├── harvest.py # builds the index from /lists
│ ├── mcp_server.py # the five tools; stdio + Streamable HTTP
│ ├── data/seed_catalog.json # bundled fallback, works before a harvest
│ └── web/
│ ├── app.py # FastAPI: search API, /api/ask, mounts /mcp
│ ├── agent.py # streaming Claude tool-use loop
│ └── static/index.html # the UI (no build step, no CDN)
├── scripts/add_dataset.py # curate/pin one dataset
└── tests/ # 87 tests, no network requiredThe index lives in your platform cache directory, not in the package — it is
generated data, it is ~350 MB, and an installed package directory is often
read-only. Override with DATAGOVIN_INDEX_PATH.
Development
pip install -e ".[web,dev]"
pytest # 87 tests, all offlineLicense
MIT
Available Tools
4 toolsget_dataset_infoA
Get the schema of a specific dataset: its title, description, total row count, and the exact list of field names and types.
Call this BEFORE query_dataset when you need to know which fields exist or
how to spell a filter field. Field names on data.gov.in are CASE-SENSITIVE
(e.g. "State" is not "state"), so always use the exact id returned here
when building filters.
Args: resource_id: The dataset UUID, e.g. from search_datasets or the portal.
Inputs: resource_id (required). Returns: result
list_sectorsA
List the sectors covered by the curated dataset catalog (e.g. Environment, Agriculture, Health). Useful for orienting the user before a search.
Inputs: no named parameters. Returns: result
query_datasetA
Pull actual rows from a data.gov.in dataset, optionally filtered.
Fetches live data using the user's API key. limit is capped at 100 rows
per call (the upstream maximum); page through larger result sets with
offset. If a call returns zero rows but a positive total, you have paged
past the end.
IMPORTANT: filter field names are case-sensitive and must match a field id
from get_dataset_info exactly. If a filter returns nothing unexpectedly, check
the capitalisation of the field name first.
Args: resource_id: The dataset UUID (from search_datasets or the portal). filters: Optional {field_id: value} pairs, e.g. {"city": "Delhi"}. fields: Optional list of field ids to return (projection). Omit for all. limit: Rows to return, 1-100 (default 10). offset: Row offset for pagination (default 0).
Inputs: resource_id (required), limit, fields, offset, +1 more. Returns: result
search_datasetsA
Find datasets on India's Open Government Data platform by keyword.
Use this FIRST when the user asks about Indian public data (air quality,
crop production, fuel prices, census, health, education, rainfall, etc.) and
you don't already have a resource ID. Returns matching datasets with their
resource_id, which the other tools need.
Searches a curated local index of verified data.gov.in datasets. If nothing matches, tell the user they can add any dataset by copying its resource ID from the dataset's "API" button on data.gov.in, then running scripts/add_dataset.py.
Args: query: Plain-language keywords, e.g. "air quality delhi" or "wheat production". limit: Max results to return (default 10).
Inputs: query (required), limit. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a distinct responsibility: discover datasets (search_datasets), browse categories (list_sectors), inspect schema (get_dataset_info), and retrieve rows (query_dataset). No two tools could be confused for the same action.
All four tool names follow a uniform verb_noun pattern (search_datasets, list_sectors, get_dataset_info, query_dataset). While the verbs differ, each one accurately maps to its unique action, and the snake_case style is consistent throughout.
With only 4 tools, the server is tightly scoped to the core use case of discovering and retrieving Indian open government data. Each tool is necessary and none feel redundant, making the tool count highly appropriate.
The tool surface covers the end-to-end read-only workflow: search, sector overview, schema inspection, and data extraction with pagination. Minor gaps include no direct way to list every dataset in the catalog and limited dataset metadata (e.g., update date), but agents can work around these via search and get_dataset_info.
Maintenance
Related MCP Connectors
Search India datasets; inspect sources, licences and previews; get notebook and Python examples.
Query India's open geo data, and author collect maps: register a link, moderate, publish.
Indian government statistics and public data: economy, elections, health, agriculture and more
Discover, resolve, and query official Brazilian economic data with semantic search and provenance.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceExposes India's open government data (data.gov.in) APIs via the Model Context Protocol, enabling agentic AI data exploration.2MIT
- AlicenseAqualityBmaintenanceDescription: Query India's open geo data in natural language. 8 tools: list layers, inspect schemas, filter/group any column, point-in-polygon locate, spatial proximity search, downloads in 5 formats. Covers admin boundaries (state to village), city wards, forests, rivers, dams, hospitals, highways, airports, and more.1743MIT
- AlicenseAqualityDmaintenanceEnables querying and analyzing over 90,000 public datasets from the Spanish Government Open Data Portal (datos.gob.es) using natural language, with tools for search, filtering, metadata access, and SPARQL queries.105MIT

MoSPI MCP Serverofficial
AlicenseNot gradedqualityCmaintenanceProvides AI-ready access to Indian government statistics through MCP, enabling natural language queries for economic, demographic, and social indicators.148MIT