Humanitarian MCP
The Humanitarian MCP server provides normalized, read-only access to trusted humanitarian datasets (UNHCR, World Bank, HDX/HAPI) covering refugees, conflict, food security, and funding — usable from any MCP-compatible AI client or analysis script.
Country Discovery & Profiles
Search countries by fuzzy name, ISO2/ISO3 code, or alias (including Arabic names)
Get a full humanitarian snapshot: hosted displaced populations, people displaced from it, and top origin countries
Displacement & Population Data
Query yearly displacement figures (refugees, asylum-seekers, IDPs, stateless) by host or origin country
Cross-filter by two countries (e.g., Syrians hosted in Egypt)
View demographic breakdowns (age/sex) of displaced populations
Asylum System Data
Track asylum applications filed per year
Analyze asylum decisions (recognized, complementary protection, rejected) with recognition rates
Crisis Context (HDX/HAPI)
Conflict event data — annual event counts and fatalities (ACLED)
Food security status — IPC phase breakdowns and people in crisis (IPC)
Humanitarian funding — appeal requirements vs. funding received (OCHA FTS)
Comparative & Analytical Tools
Compare 2–5 countries on any displacement metric over time
Rank countries by any metric (top hosts or origins), with per-capita or per-GDP normalization
Trend analysis: year-over-year changes, linear trend (slope, R²), CAGR, anomaly detection
Naive linear forecasts 1–5 years ahead (clearly caveated as non-official)
Visualization
Generate charts in Chart.js, Vega-Lite, Mermaid, or SVG formats
Generate GeoJSON maps with country centroid points sized by metric
Compose full markdown situation reports with embedded charts and key figures
Data Export & Reproducibility
Export data as CSV, JSON, Markdown, or GeoJSON
Include an extraction manifest (arguments, timestamp, server version, citation)
Include a codebook documenting every exported variable for research appendices
Infrastructure & Metadata
Inspect metadata about connected providers, datasets, metrics, and attribution
Check provider health (liveness and latency of each upstream source)
Built-in caching with offline mode, polite rate limiting with retries
Allows generating Chart.js v4 configuration JSON for displacement charts, including line, bar, and other chart types with options for normalization by population or GDP.
Allows exporting humanitarian data as Markdown tables, suitable for documentation or reports.
Allows generating Mermaid xychart block diagrams for displacement trends, ready to be rendered in Mermaid-compatible viewers.
Allows generating standalone SVG images of displacement charts, which can be embedded directly into documents or web pages.
Allows generating Vega-Lite v5 specifications for interactive displacement charts, compatible with Vega-embed and other Vega ecosystem tools.
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., "@Humanitarian MCPCompare refugee populations in Egypt and Jordan over the last five years."
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.
Humanitarian MCP
Trusted humanitarian data — refugees, conflict, hunger, funding — as one clean, citable interface for AI assistants and research code.

What is Humanitarian MCP?
Humanitarian MCP is an open-source server that gives AI assistants and analysis scripts reliable, normalized, read-only access to trusted humanitarian datasets: 75 years of UNHCR displacement statistics, World Bank context indicators, HDX crisis data (conflict events, food security, humanitarian funding, internal displacement), and ReliefWeb situation reports.
MCP in one paragraph: the Model Context Protocol is an open standard — think "USB for AI tools" — that lets any AI application (Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, custom agents) plug into external systems through one protocol. A server like this one exposes tools the model can call, resources it can read, and prompts it can reuse. Connect it once, and every question your assistant answers about displacement is grounded in the real numbers instead of its training data. New to MCP? Read docs/how-mcp-works.md.
Humanitarian data is public but hostile to programmatic use — different country-code schemes, different schemas, silent failure modes (details below). This project normalizes multiple humanitarian datasets into one consistent record shape, one country-code scheme (ISO3), one interface, with the citation attached to every payload.
Related MCP server: UNHCR Chart Generation MCP Server
Why this project exists
Every trap below is real, encoded in this codebase, and covered by tests:
Problem | Example | What this server does |
Country-code chaos | UNHCR's internal codes disagree with ISO3 for 99 of 232 countries. Egypt is | Everything speaks ISO3. Names resolve fuzzily in English and Arabic («مصر», «الأردن», «السودان»). |
Schema babel | UNHCR returns | One |
Dirty cells | Numeric values arrive as numbers, numeric strings, or | Cleaned once, at the provider layer. Missing stays missing — never silently zero. |
Silent empties | Most query mistakes return an empty list, not an error. An AI confidently reports "no data". | Errors come back as actionable text: "No country matched 'Atlantis'. Try search_country first." |
Aggregation traps | IDP assessment rounds must not be summed (double-counts people); funding coverage must be recomputed, never averaged; IPC projections must not be mixed with current analyses. | Each dataset's aggregation semantics are encoded and unit-tested. |
Misleading absolute numbers | Lebanon and Germany host similar refugee counts. Per 1,000 residents, they are worlds apart. |
|
Missing citations | Models paraphrase numbers with no provenance. | Every payload carries its source; exports attach a reproducible extraction manifest and optional codebook. |
Without a trusted middleware, an LLM pointed at raw humanitarian APIs re-discovers these traps every session — and the failure mode is not a crash, it is a plausible-looking wrong number. This server exists so that never happens.
Architecture
flowchart TD
U["You"] --> C["Claude Desktop · Claude Code · Cursor · VS Code · Windsurf<br/>or your own MCP agent"]
C -->|"MCP (stdio or Streamable HTTP)"| S["Humanitarian MCP<br/>21 tools · 11+ resources · 8 prompts"]
S --> R["Provider registry<br/>(tools never see provider internals)"]
R --> P1["UNHCR provider<br/>displacement · demographics · asylum"]
R --> P2["World Bank provider<br/>population · GDP · poverty"]
R --> P3["HDX/HAPI provider<br/>conflict · food security · funding · IDPs"]
R --> P4["ReliefWeb provider<br/>situation reports · narrative context"]
P1 & P2 & P3 & P4 --> H["Shared HTTP layer<br/>retry · backoff · rate limit · ETag · cache · offline mode"]
H --> A1[("api.unhcr.org")]
H --> A2[("api.worldbank.org")]
H --> A3[("hapi.humdata.org")]
H --> A4[("api.reliefweb.int")]Three invariants hold everywhere: (1) nothing provider-specific leaks outside src/providers/<id>/; (2) every tool is read-only and annotated as such; (3) errors reach the model as actionable text, never stack traces. Deep dive: docs/architecture.md.
Two ways to use it
TL;DR — researchers and organizations who care about control: self-host. Everyone who just wants answers: use the hosted endpoint.
🖥️ Self-hosted | ☁️ Hosted endpoint | |
Setup | Install Node/Docker, run the server | None — paste one URL |
Who runs it | You, on your machine or infra | Maintainer-operated at |
Privacy | Queries never leave your machine (except to the public data APIs) | Queries pass through the hosted server |
Offline / fieldwork | ✅ full offline mode with a warmed cache | ❌ needs internet |
Configuration | Every knob: providers, cache, rate limits | Fixed server-side |
Updates | You pull releases | Updated for you (caching, normalization, rate limiting, source fixes, monitoring handled) |
Version | Always the latest release | Rolling; may briefly lag the newest release — check |
Guarantees | Yours to make | Best-effort community service, no SLA today |
Cost | Free (MIT) | Free today; free and paid plans may be introduced later |
Best for | Researchers, NGOs with data policies, enterprises, air-gapped fieldwork | Quick starts, demos, journalists, students |
Mode 1 — Self-hosted
You install and run the server yourself. You own everything: the process, the cache, the configuration. Your MCP client talks to it over stdio (desktop) or HTTP (remote/containers). Full instructions in Installation below.
// Claude Desktop — claude_desktop_config.json
{
"mcpServers": {
"humanitarian": {
"command": "node",
"args": ["/absolute/path/to/humanitarian-mcp/dist/index.js"],
},
},
}Mode 2 — Hosted endpoint
No infrastructure. Connect any Streamable-HTTP-capable MCP client to:
https://humanitarian-mcp.zad.tools/mcpclaude.ai / Claude Desktop (remote connector): add a custom connector with that URL.
Claude Code:
claude mcp add --transport http humanitarian https://humanitarian-mcp.zad.tools/mcpAnything that speaks HTTP: see examples/http-client.md — the endpoint is stateless JSON-RPC, no session juggling.
No API key is required today. The service is operated on a best-effort basis by the maintainer; free and paid tiers may be introduced in the future — nothing beyond what you see here is promised. If you need guarantees, self-host: it is the same code.
Features
Data access
21 semantic, read-only tools — full reference: country profiles, comparisons, yearly series, demographics, asylum applications/decisions with recognition rates, conflict events, food security (IPC), humanitarian funding, situation reports, rankings, trend analysis with anomaly detection, (loudly caveated) naive forecasts
11+ MCP resources (
country://EGY,report://SDN,chart://UGA,metadata://providers…) with URI autocompletion8 built-in prompts (situation summary, donor briefing, crisis overview, anomaly hunt…)
Country intelligence
Fuzzy name resolution in English and Arabic — «مصر», "egypt",
EGY, "DRC", "ivory coast" all land correctly; Arabic matching folds hamza/alef forms, taa marbuta and the definite article («الأردن» = «الاردن» = «اردن»)The UNHCR↔ISO3 code mismatch (99/232 countries) handled invisibly
Analytics
normalize_by: per-capita (per 1,000 residents) and per-GDP (per US$1bn) comparisons, rankings and charts, with per-year denominator matchingRegression, year-over-year, CAGR, z-score anomaly detection
Charts as Chart.js / Vega-Lite / Mermaid / SVG; maps as GeoJSON
Research reproducibility
Extraction manifest on every export: exact arguments, timestamp, server version, citation — a repeatable recipe for a paper's appendix
Optional variable-level codebook matching exactly the exported columns
CSV / JSON / Markdown / GeoJSON export; CSV manifests ride in
#comment lines (pd.read_csv(..., comment="#"))Runnable Python & R notebooks reproducing four research workflows
CITATION.cff + JOSS paper draft in paper/
Operations
Two transports: stdio (desktop) and stateless Streamable HTTP (remote) + a built-in dashboard with a query playground
Serious caching: memory or SQLite (zero native deps), TTL + ETag revalidation, stale-while-revalidate, full offline mode for fieldwork
Polite by design: token-bucket rate limiting, retries with backoff, identified User-Agent, strictly read-only
Docker image + compose for organizational self-hosting
Live data sources
Provider | Datasets | What it contributes | Key |
UNHCR Refugee Statistics (default) | population, demographics, asylum-applications, asylum-decisions | The displacement backbone: refugees, asylum-seekers, IDPs, stateless and others of concern, 1951–present, by origin and asylum country; age/sex breakdowns; asylum decisions with recognition rates | none |
World Bank Indicators (default) | context-indicators | The denominators: national population, GDP, GDP per capita, extreme-poverty rates — what turns "how many" into "how heavy a burden" | none |
HDX HAPI (opt-in) | conflict-events, food-security, humanitarian-funding, idps | The crisis context, citing original producers: conflict events & fatalities (ACLED), IPC food-insecurity phases (IPC), appeal requirements vs funding (OCHA FTS), IDP stocks (IOM DTM) | free app identifier (.env.example) |
ReliefWeb (opt-in) | situation-reports | The narrative context: situation-report counts per country-year plus the latest report titles, publishers and links (UN OCHA / ReliefWeb) — what grounds trends and anomalies in published reporting | pre-approved appname (.env.example) |
Example questions
Real prompts, real production numbers (extracted 2026-07-10 — figures are revised upstream over time):
"What are the top refugee-hosting countries per capita?" → Lebanon 130.7 per 1,000 residents, Chad 63.0, Moldova 56.6, Jordan 55.7 — a very different list than the absolute ranking.
"Was there anything unusual in Sudan's displacement data?" → 2023 flagged as an anomaly (z ≈ +2.6, +78.8% YoY), coinciding with the April 2023 war.
"Relate Sudan's conflict to its displacement since 2022." → conflict fatalities 2,770 → 21,020 → 22,987 (2022–2024, ACLED) alongside IDPs 3.78M → 9.05M → 11.56M (IOM DTM).
"How well is Sudan's humanitarian response funded?" → 58.5% of requirements in 2023, 76.4% in 2024 (OCHA FTS).
"«قارن بين عدد اللاجئين في مصر والأردن»" → works — country resolution is bilingual.
"Export Jordan's series as citation-ready CSV with a codebook." →
export_data({..., include_codebook: true}).
More worked conversations with tool traces: examples/conversations.md.
Why researchers like it
Citable: GitHub's Cite this repository button (CITATION.cff); a JOSS paper is drafted in paper/.
Reproducible: every export carries a manifest (exact call, timestamp, server version, source citation) — paste it in your appendix and anyone can re-run the extraction.
Documented data:
include_codebook: truegenerates variable-level documentation (meaning, unit, derivation — including how recognition rates and funding coverage are computed) for exactly the columns you exported.Join-ready: every row carries ISO3, so merges against World Bank / V-Dem / UCDP panels need no country-name crosswalk.
Honest methods: end-year stock semantics, denominator years, truncation and forecast naivety are stated in the output, not hidden.
Fieldwork-ready: warm the SQLite cache once, then
HMCP_OFFLINE=1gives the full toolset with zero connectivity.
Start here: docs/for-researchers.md · notebooks.
Installation
Requires Node.js ≥ 20 for source installs (SQLite cache uses built-in node:sqlite on Node ≥ 22.5; older Nodes fall back to memory automatically). Docker route needs only Docker.
From npm — no clone needed
npx humanitarian-mcp --version # → humanitarian-mcp 0.6.0Register it with Claude Code in one line:
claude mcp add humanitarian -- npx -y humanitarian-mcpClaude Desktop — one click (no terminal)
Download humanitarian-mcp.mcpb from the latest release and double-click it. Done.
From source
git clone https://github.com/ahmedvnabil/humanitarian-mcp
cd humanitarian-mcp
npm install
npm run build
node dist/index.js --version # → humanitarian-mcp 0.6.0Docker
docker run -p 8642:8642 -v hmcp-cache:/data ghcr.io/ahmedvnabil/humanitarian-mcp
# → MCP endpoint at http://localhost:8642/mcp + dashboard at http://localhost:8642Or docker compose up -d with the provided compose.yaml.
Connect your client (self-hosted, stdio)
{
"mcpServers": {
"humanitarian": {
"command": "node",
"args": ["/absolute/path/to/humanitarian-mcp/dist/index.js"]
}
}
}Sample with cache tuning: examples/claude-desktop-config.json.
claude mcp add humanitarian -- node /absolute/path/to/humanitarian-mcp/dist/index.js{
"mcpServers": {
"humanitarian": {
"command": "node",
"args": ["/absolute/path/to/humanitarian-mcp/dist/index.js"]
}
}
}{
"servers": {
"humanitarian": {
"type": "stdio",
"command": "node",
"args": ["/absolute/path/to/humanitarian-mcp/dist/index.js"]
}
}
}{
"mcpServers": {
"humanitarian": {
"command": "node",
"args": ["/absolute/path/to/humanitarian-mcp/dist/index.js"]
}
}
}Then ask: "What are the top refugee-hosting countries this year?"
Enable the HDX crisis datasets (optional)
# one-time: generate a free identifier (base64 of app-name:email — not a secret)
curl 'https://hapi.humdata.org/api/v2/encode_app_identifier?application=<your-app>&email=<your-email>'
HMCP_PROVIDERS=unhcr,worldbank,hdx HMCP_HDX_APP_ID=<identifier> node dist/index.jsEnable ReliefWeb situation reports (optional)
# one-time: request a pre-approved appname (short form, reviewed by ReliefWeb)
# https://apidoc.reliefweb.int/parameters#appname
HMCP_PROVIDERS=unhcr,worldbank,reliefweb HMCP_RELIEFWEB_APPNAME=<appname> node dist/index.jsAll configuration knobs: .env.example.
Verify without any client
npm run dashboard # → http://localhost:8642 — providers, health, live logs, query playground
npm run inspect # → official MCP InspectorIn --http mode, GET /health is a dependency-free liveness probe for uptime
monitors, and every other route is rate limited per client IP
(HMCP_HTTP_RATE_LIMIT_RPM, default 120/min) so a public endpoint cannot be
used to exhaust the upstream quotas all providers share.
Repository tour
Path | What lives there |
The server. | |
tools.md (tool reference) · architecture.md · for-researchers.md · how-mcp-works.md (MCP primer) · adding-providers.md · development.md · | |
Client configs, worked conversations with tool traces, HTTP client recipes, runnable Python/R notebooks | |
153 tests: MCP compliance suite (official SDK client ↔ real server), fixture-based provider suites (no network), unit tests | |
JOSS paper draft ( | |
Launch kit: platform-native announcement drafts | |
Organizational self-hosting (image published to GHCR on every release) | |
CI (Node 20/22/24), release automation (npm + |
Development
npm run dev # stdio server via tsx
npm run dev:http # HTTP + dashboard on :8642
npm test # vitest — unit + integration + MCP compliance
npm run check # typecheck + lint + format + tests (run before pushing)
npm run build # emit dist/Releases: bump the version, tag v*, push — CI publishes the GitHub release with the .mcpb bundle, the Docker image to GHCR, and (once the npm token is configured) the npm package. Full guide: docs/development.md · adding a data source: docs/adding-providers.md.
Roadmap
✅ Completed
v0.1.0 — UNHCR provider, 17 tools, resources, prompts, caching/offline, dashboard, compliance suite
v0.2.0 — release automation (npm workflow +
.mcpb), CITATION.cff, Arabic country names, reproducible extraction manifestsv0.3.0 — World Bank provider +
normalize_byper-capita / per-GDP analyticsv0.4.0 — HDX/HAPI provider (conflict, food security, funding, IDPs) + 3 crisis tools + Docker/GHCR
v0.5.0 — codebooks, Python/R notebooks, JOSS paper draft
v0.5.1 — HDX fixes from the first live verification round (per-theme admin levels, server-side year windows, pagination)
v0.6.0 — ReliefWeb provider (situation reports + latest report links),
situation_reportstool,crisis_overviewprompt, hardened public HTTP mode (per-IP rate limiting,GET /health), bilingual landing pagePublished to npm —
npx humanitarian-mcpis live
🚧 In progress
Zenodo DOI per release
JOSS paper review & submission
npm provenance signing on future releases (via the release workflow once its token is configured)
🔭 Future (contributions welcome)
ReliefWeb disasters dataset (the situation-reports pipeline already shipped)
Full Arabic report generation (
locale: "ar")UNHCR Operational Data Portal situations
Sturdier statistics (confidence intervals, changepoint detection)
Redis cache backend
FAQ
No. MCP (Model Context Protocol) is the plumbing standard that connects AI apps to tools. You paste a config or double-click the .mcpb file; your assistant does the rest. Curious anyway? docs/how-mcp-works.md.
No — UNHCR and World Bank need none. Only the optional HDX datasets need a free "app identifier" (base64 of your app name + email, generated in one curl; not a secret).
No. It is an independent open-source project. All data is © its original producers (UNHCR, World Bank, ACLED, IPC, OCHA, IOM via HDX), and every payload carries that attribution.
Because the failure mode is silent wrong answers: UNHCR's ARE is Egypt, but ISO's ARE is the UAE; empty results look like "no data"; "-" cells break math. This server encodes those traps once, with 153 tests. See Why this project exists.
It is as fresh as the sources: UNHCR publishes end-year (and mid-year) statistics, the World Bank annual indicators, HDX themes on their producers' cadence. The server caches responses (default 1 h fresh, stale-while-revalidate after) — it never makes data older than the source.
Usually one of: news quotes flows ("X arrived this month") while these are stocks ("X present at year-end"); different population categories (refugees vs all people of concern); or upstream revisions — UNHCR revises series retroactively. Record your extraction date (the manifest does it for you).
Each category is a separate metric (refugees, idps, asylum_seekers, stateless…), and the codebook defines every one. The population headline per dataset is documented in docs/tools.md and in generated codebooks.
asylum = people hosted in the country (default); origin = people displaced from it. Mixing them up is the most common analysis error — the server's instructions teach connected models this convention up front.
normalize_by: "population" divides by the country's population of the same year (World Bank), scales per 1,000 residents, re-sorts the ranking, and discloses the denominator year on every row. "gdp" does the same per US$1bn. Countries lacking denominator data are counted, never silently dropped.
Yes — country resolution covers official UN Arabic names for 100% of countries served, plus common variants, with spelling-variant folding («الأردن» = «الاردن» = «اردن»). Tool output is currently English; full Arabic report generation is on the roadmap.
Yes. npm run dashboard gives you a query playground and a plain HTTP bridge (POST /api/call) — the Python/R notebooks use exactly that. The /mcp endpoint is also plain JSON-RPC (examples/http-client.md).
Self-host if you need control, privacy guarantees, offline mode, or custom configuration (it's the same MIT-licensed code). Use the hosted endpoint to be running in 30 seconds. Full comparison: Two ways to use it.
The hosted instance runs this open-source code, which keeps in-memory usage counters (per-tool call counts/latency for its dashboard) and standard server logs. It has no accounts, no API keys, and stores no personal data by design. If that is still too much, self-host.
Yes (self-hosted): run once online with HMCP_CACHE=sqlite to warm the cache, then HMCP_OFFLINE=1 serves everything from cache and fails loudly on misses.
Anything that speaks MCP: Claude Desktop & claude.ai, Claude Code, Cursor, VS Code, Windsurf, and custom agents via the official SDKs (stdio or Streamable HTTP). Config snippets are in Installation.
All three — plain Node with zero native dependencies (the SQLite cache uses Node's built-in node:sqlite). The Docker image covers anything that runs containers.
Two runtime dependencies (the MCP SDK and zod), no database server required, and the Docker image is a slim multi-stage Node build. It runs comfortably on the smallest VPS tier.
They are deliberately naive (OLS extrapolation) and say so in their own output. Use them as a baseline sanity check, never as planning figures — UNHCR publishes no such projections through this API.
The server rate-limits itself (token bucket, default 4 req/s per provider), retries with backoff, and serves stale cache when a source is down — your session degrades gracefully instead of erroring.
See Citation below — BibTeX/APA/Chicago provided, plus GitHub's "Cite this repository" button. Cite the data as its original producers (the manifests include the right citation string per dataset).
One directory, one interface, fixture-based tests — the full worked guide is docs/adding-providers.md, and there's a provider-request issue template. IOM DTM and UNHCR ODP situations are the most-wanted next providers.
Yes — that's what the Docker image and compose file are for. MIT license, commercial use fine. Keep the HTTP endpoint behind your reverse proxy/VPN (it is unauthenticated by design — see SECURITY.md).
No. Everything is aggregate national statistics from public sources. Still: these numbers represent people — present them with the care they deserve (see Data & responsibility).
Contributing
Contributions welcome — most wanted: new providers (IOM DTM, UNHCR ODP situations), country-alias corrections, and documentation in more languages. Start with CONTRIBUTING.md; the golden rules: read-only always, provider isolation, no network in tests, attribution is not optional.
Citation
Software (also available via GitHub's "Cite this repository" button — CITATION.cff; a Zenodo DOI per release is being set up):
BibTeX
@software{nabil_humanitarian_mcp_2026,
author = {Nabil, Ahmed},
title = {humanitarian-mcp: a Model Context Protocol server for humanitarian open data},
year = {2026},
version = {0.6.0},
url = {https://github.com/ahmedvnabil/humanitarian-mcp},
license = {MIT}
}APA — Nabil, A. (2026). humanitarian-mcp: A Model Context Protocol server for humanitarian open data (Version 0.6.0) [Computer software]. https://github.com/ahmedvnabil/humanitarian-mcp
Chicago — Nabil, Ahmed. humanitarian-mcp: A Model Context Protocol Server for Humanitarian Open Data. V. 0.6.0. Computer software, 2026. https://github.com/ahmedvnabil/humanitarian-mcp.
Cite the data as its producers: UNHCR Refugee Data Finder; World Bank World Development Indicators (CC BY 4.0); ACLED / IPC / OCHA FTS / IOM DTM via HDX HAPI — every export's manifest carries the exact citation string for its dataset. Method notes: docs/for-researchers.md.
Data, attribution & responsibility
Data © its original producers: UNHCR (Refugee Data Finder), World Bank (CC BY 4.0), and via HDX HAPI: ACLED, IPC, OCHA FTS, IOM DTM. This project is unofficial and unaffiliated.
The server is strictly read-only and respects upstream rate limits.
Figures are end-year stocks; recent years may be preliminary; series get revised — record extraction dates (manifests do).
Forecasts are naive extrapolations, clearly labelled.
These numbers represent people. Present them with the care they deserve.
License
MIT — free for research, NGO, commercial and government use.
Available Tools
21 toolsasylum_applicationsAsylum applicationsARead-only
Individual asylum applications lodged per year. role "asylum" (default) = applications filed IN the country; "origin" = filed BY nationals of the country abroad.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) |
Output Schema
| Name | Required | Description |
|---|---|---|
| role | Yes | |
| source | Yes | |
| yearly | Yes | |
| country | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, indicating safe read and potentially incomplete data. The description adds that data is 'per year' and the role semantics, but does not elaborate on behavior like data freshness or handling of missing years. With annotations covering the safety profile, the additional contribution is moderate.
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 long, directly stating the tool's purpose and the key role distinction. Every word is necessary; no fluff or repetition.
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, the description does not need to detail return values. It covers the core functionality (yearly data, role selection) adequately. Minor gaps: no mention of how openWorldHint affects results or that output schema exists, but overall sufficient given the complexity.
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 description coverage is 100%, so the schema already documents all parameters. The description re-emphasizes the role default and meaning, but adds little beyond the schema's own descriptions (e.g., year range defaults are only in schema). Baseline 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 'Individual asylum applications lodged per year' which identifies the resource (asylum applications) and the verb (lodged per year). It distinguishes between two roles ('asylum' vs 'origin'), which helps differentiate from sibling tools like asylum_decisions or refugee_population.
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 explains when to use each role ('asylum' for applications filed IN the country, 'origin' for filed BY nationals abroad), providing clear context. However, it does not explicitly guide when to choose this tool over siblings like 'asylum_decisions' or 'trend_analysis', leaving room for ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
asylum_decisionsAsylum decisionsARead-only
Decisions on individual asylum applications per year — recognized, complementary protection, rejected, otherwise closed — plus the recognition rate. role "asylum" (default) = decided IN the country.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) |
Output Schema
| Name | Required | Description |
|---|---|---|
| role | Yes | |
| source | Yes | |
| yearly | Yes | |
| country | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. Description adds that results are per-year with specific categories, but does not reveal other behavioral traits like data freshness, pagination, or limitations. With annotations covering safety, 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?
Two sentences: first lists the data returned, second explains the role parameter. No wasted words, front-loaded with core information. Perfectly concise.
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 output schema present, the description is sufficient. It explains the key data categories and the role parameter's effect. An agent can correctly invoke the tool based on this description alone.
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 each parameter already has a description. The tool description does not add additional semantic meaning beyond what the schema provides. Baseline 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?
Clearly states the tool returns decisions on individual asylum applications per year, categorized by outcome types (recognized, complementary protection, rejected, otherwise closed) plus recognition rate. Distinguishes from sibling 'asylum_applications' by focusing on decisions rather than applications.
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?
Explains the role parameter default and meaning ('asylum' = decided in the country). Provides context for when to use each role value, but does not explicitly state when to use this tool vs alternatives like 'asylum_applications' or 'compare_countries'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compare_countriesCompare countriesARead-only
Compare a displacement metric across 2–5 countries over a year range. Defaults to refugees hosted (role "asylum") over the last 10 years. Set normalize_by to compare per 1,000 residents or per US$1bn GDP instead of absolute numbers.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| metric | No | Metric to compare, e.g. refugees, asylum_seekers, idps (default: refugees) | |
| year_to | No | Last year of the range (default: latest available) | |
| countries | Yes | Two to five countries to compare | |
| year_from | No | First year of the range (default: 10 years back) | |
| normalize_by | No | Normalize values by a denominator: "population" → per 1,000 residents, "gdp" → per US$1bn GDP. Requires the worldbank provider. |
Output Schema
| Name | Required | Description |
|---|---|---|
| role | Yes | |
| unit | Yes | |
| metric | Yes | |
| series | Yes | |
| source | Yes | |
| denominator | No | |
| normalize_by | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral context beyond annotations: it specifies the domain (displacement), role option, and normalization. Annotations already declare readOnlyHint and openWorldHint, which are consistent. The description does not contradict annotations and adds useful detail.
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 only two sentences, front-loaded with the main purpose, and every sentence adds value. No unnecessary 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 complexity of 6 parameters and an existing output schema, the description adequately covers the tool's functionality and defaults. Minor omissions like data source mention are acceptable as schema covers return values and parameters.
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 parameter descriptions already present. The description adds context for defaults (e.g., refugees, last 10 years) but does not significantly enhance understanding of individual parameters beyond what the schema provides. Baseline 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 the action ('compare'), resource ('displacement metric'), and scope ('2–5 countries over a year range'). It also specifies defaults and normalization, which distinguishes it from sibling tools that typically focus on single-country or single-metric analysis.
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 provides defaults and the option for normalization, giving context on typical usage. However, it does not explicitly state when not to use this tool or point to alternative tools for other scenarios, so it falls short of explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
conflict_eventsConflict eventsARead-only
Annual conflict event counts and fatalities for a country (ACLED via HDX). Pairs with refugee_population/trend_analysis to relate violence and displacement.
| Name | Required | Description | Default |
|---|---|---|---|
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) |
Output Schema
| Name | Required | Description |
|---|---|---|
| source | Yes | |
| country | Yes | |
| records | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and completeness profile is clear. Description adds little beyond stating the data source (ACLED via HDX) and annual periodicity.
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?
Two sentences, front-loaded with purpose and data source, no waste. Every sentence 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?
Given 3 parameters with full schema coverage and an output schema available, the description is sufficient. It could optionally mention the annual aggregation or data update frequency, but is 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?
Schema description coverage is 100% with clear parameter descriptions (country, year_from, year_to including examples and defaults). The tool description does not add extra 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?
Description clearly states it provides annual conflict event counts and fatalities for a country via ACLED/HDX, with a specific verb+resource. It distinguishes from siblings by mentioning pairing with refugee_population/trend_analysis.
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?
Description gives a use case pairing with other tools, but does not explicitly state when to use this vs alternatives among many siblings. No exclusions or alternative tools mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
country_profileCountry profileARead-only
One-call humanitarian snapshot of a country: latest displaced population hosted (by category), population displaced FROM the country, and its top origin countries.
| Name | Required | Description | Default |
|---|---|---|---|
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" |
Output Schema
| Name | Required | Description |
|---|---|---|
| year | No | |
| hosted | Yes | Latest people-of-concern figures hosted in the country |
| region | No | |
| source | Yes | |
| country | Yes | |
| top_origins | Yes | |
| country_code | Yes | |
| displaced_abroad | Yes | Latest figures for people displaced FROM the country |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds that it's a 'snapshot' of latest data, clarifying point-in-time nature, and lists specific components. No contradictions.
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 that front-loads the purpose and lists output content 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's simplicity (one parameter, no nested objects) and the existence of an output schema, the description sufficiently explains what the tool returns, making it complete for agent usage.
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 schema covers the single 'country' parameter with a description (100% coverage). The description does not add new meaning to the parameter beyond what the schema provides, so baseline 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 the tool provides a humanitarian snapshot including displaced population hosted, population displaced from the country, and top origin countries. This is specific and distinct from siblings like 'refugee_population' or 'compare_countries'.
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 use when needing a quick overview of displacement data for a country. It does not explicitly exclude scenarios or mention alternatives, but the sibling list provides context for other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
demographicsDemographicsARead-only
Latest age/sex breakdown of displaced people connected to a country (role "asylum" = hosted there, default; "origin" = from there). UNHCR publishes demographics for recent years only.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" |
Output Schema
| Name | Required | Description |
|---|---|---|
| male | Yes | |
| year | Yes | |
| total | Yes | |
| female | Yes | |
| source | Yes | |
| country | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds behavioral context about data recency (recent years only) and role defaults, which goes beyond annotations. No contradiction.
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?
Two sentences that front-load the purpose and add constraints. No redundant or vague wording. Every sentence contributes meaning.
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 an output schema, the description adequately covers what data is returned (age/sex breakdown), population scope (displaced people connected to a country), and data limitation (recent years only). Could mention typical use cases but sufficient.
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 description adds limited value beyond parameter descriptions. It explains roles in context ('asylum' = hosted, 'origin' = from) but essentially paraphrases schema. Baseline 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 age/sex breakdown of displaced people by country, with roles 'asylum' (hosted) and 'origin' (from). It distinguishes from sibling tools like 'refugee_population' or 'latest_statistics' by focusing on demographic breakdown.
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 data recency ('UNHCR publishes demographics for recent years only') and default role, but does not explicitly guide when to use this tool vs. alternatives like 'top_host_countries' or 'trend_analysis'. Usage context is implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
export_dataExport dataARead-only
Export normalized records from any dataset as csv, json, markdown or geojson (geojson only makes sense with group_by set, so rows map to countries). Use this when the user wants raw data to download or paste elsewhere.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| limit | No | Max rows (default 500) | |
| format | Yes | Serialization format | |
| country | No | Filter by country (name or ISO3) | |
| dataset | Yes | population | demographics | asylum-applications | asylum-decisions | context-indicators | idps | conflict-events | humanitarian-funding | food-security | |
| year_to | No | Last year of the range (default: latest available) | |
| group_by | No | Break rows down per asylum or origin country instead of aggregating | |
| year_from | No | First year of the range (default: 10 years back) | |
| include_codebook | No | Attach a codebook documenting every exported variable (meaning, unit, derivation) — ready for a paper's data appendix. Default false. | |
| include_manifest | No | Attach an extraction manifest (exact arguments, timestamp, server version, citation) for reproducibility. Default true. |
Output Schema
| Name | Required | Description |
|---|---|---|
| data | Yes | |
| format | Yes | |
| dataset | Yes | |
| codebook | No | |
| manifest | No | |
| row_count | Yes | |
| truncated | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly and openWorld hints. The description adds that it exports normalized records and mentions format-specific behavior (geojson requires group_by), which is helpful 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?
Two sentences, front-loaded with the main action and available formats. No 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?
Output schema exists, so return values are covered. The description includes the key behavioral nuance about geojson and group_by. With 10 parameters, it could add more context about filtering options, but the schema descriptions fill in the gaps.
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 the description adds limited extra meaning beyond the schema descriptions. The geojson/group_by hint provides some value, but for 10 parameters, the description does not elaborate on most.
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 exports normalized records from any dataset in multiple formats, and the context of geojson with group_by differentiates it from sibling tools that focus on analysis or visualization.
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 explicitly says to use when the user wants raw data to download or paste elsewhere, and notes the geojson caveat with group_by. It does not explicitly state when not to use, but the purpose is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
food_securityFood security (IPC)ARead-only
Latest IPC food-insecurity phase breakdown for a country: people per phase 1–5, with phase 3+ ("crisis or worse") as the headline. Data: IPC via HDX.
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Analysis year (default: latest available) | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" |
Output Schema
| Name | Required | Description |
|---|---|---|
| year | Yes | |
| phases | Yes | |
| source | Yes | |
| country | Yes | |
| country_code | Yes | |
| people_crisis_or_worse | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds value beyond annotations by revealing the data source (IPC via HDX) and output structure (phase breakdown with headline). This complements the readOnlyHint and openWorldHint annotations, though it could mention real-time update caveats.
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, front-loading the essential purpose and data source. Every word contributes meaning, with no redundancy or fluff.
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 low complexity (2 params, output schema exists), the description adequately covers the output and data source. It could explicitly note the optionality of the year parameter, but the schema already does so.
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 reinforces that 'country' is the main filter and indicates the output is a breakdown per country. It adds moderate context beyond the schema's property descriptions.
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 provides 'Latest IPC food-insecurity phase breakdown for a country' and specifies the output details (people per phase 1–5, phase 3+ headline). This distinguishes it from sibling tools, none of which focus on food security.
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 food security data retrieval but does not provide explicit when-to-use or when-not-to-use guidance, nor does it compare to sibling tools like 'conflict_events' or 'demographics'. Usage context is inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
forecastForecast (naive)ARead-only
Naive linear projection of a displacement metric 1–5 years ahead, based on the last 10 years. This is a statistical extrapolation, NOT a UNHCR planning figure — always present it with that caveat.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| metric | No | Metric to project (default refugees) | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| years_ahead | No | Horizon (default 3) |
Output Schema
| Name | Required | Description |
|---|---|---|
| caveat | Yes | |
| method | Yes | |
| metric | Yes | |
| country | Yes | |
| projected | Yes | |
| historical | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that the tool performs a statistical extrapolation and is not official planning data, which adds behavioral context beyond the readOnlyHint and openWorldHint annotations. It also instructs the user to present the result with a caveat.
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 concise, consisting of two sentences that front-load the purpose and then add an important caveat. Every sentence adds value 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 availability of an output schema and full parameter descriptions, the tool description adequately covers the projection methodology and its limitations. It could mention the output format briefly, but the output schema likely handles that.
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?
All four parameters are fully described in the input schema (100% coverage). The tool description does not provide additional parameter-level details beyond what the schema offers, so the 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?
The description clearly states it is a naive linear projection of a displacement metric 1-5 years ahead based on the last 10 years. It also explicitly distinguishes itself from UNHCR planning figures, providing specificity beyond a mere verb-resource pair.
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 provide guidance on when to use this tool versus alternatives. It lacks explicit when-to-use, when-not-to-use, or comparison with sibling tools like 'trend_analysis'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_chartGenerate chartARead-only
Render a displacement metric for one or more countries as a chart specification. Formats: "chartjs" (Chart.js v4 config JSON), "vega-lite" (v5 spec), "mermaid" (xychart block), "svg" (standalone image markup). Set normalize_by to plot per 1,000 residents or per US$1bn GDP.
| Name | Required | Description | Default |
|---|---|---|---|
| kind | No | Chart type (default line) | |
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| format | Yes | Output format | |
| metric | No | Metric to plot (default refugees) | |
| year_to | No | Last year of the range (default: latest available) | |
| countries | Yes | Countries to plot | |
| year_from | No | First year of the range (default: 10 years back) | |
| normalize_by | No | Normalize values by a denominator: "population" → per 1,000 residents, "gdp" → per US$1bn GDP. Requires the worldbank provider. |
Output Schema
| Name | Required | Description |
|---|---|---|
| spec | Yes | |
| unit | Yes | |
| title | Yes | |
| format | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and openWorldHint=true, but the description adds valuable behavioral context: it specifies that the tool returns chart specifications (not actual rendered images) for various formats, and explains normalization behavior. No contradictions with 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 two sentences, front-loaded with the core purpose and formats, then a second sentence adding key parameter context. No unnecessary words; every sentence earns its place.
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 8 parameters, full schema coverage, and an output schema, the description covers the main points (formats, normalization). It does not detail all parameters, but those are documented in the schema. The presence of an output schema reduces the need to describe return values. Slight gap in explaining kind and metric defaults, but overall sufficient.
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 description coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by clarifying normalization (per 1,000 residents or per US$1bn GDP) and implicitly explaining the role parameter (asylum vs. origin). This adds value.
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 'render' and clearly identifies the resource as 'displacement metric for one or more countries as a chart specification'. It lists four distinct output formats, distinguishing this chart tool from sibling tools like generate_map or country_profile.
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 explains what the tool does and mentions format and normalization options, but does not explicitly state when to use this tool versus alternatives such as compare_countries, trend_analysis, or generate_map. Usage context is implied but not articulated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_country_reportGenerate country reportARead-only
Compose a full markdown humanitarian situation report for a country: key figures, refugee trend with an embedded chart, origins of hosted refugees, asylum decisions and demographics. Reports progress while assembling.
| Name | Required | Description | Default |
|---|---|---|---|
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) |
Output Schema
| Name | Required | Description |
|---|---|---|
| country | Yes | |
| year_to | Yes | |
| markdown | Yes | |
| year_from | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and openWorldHint=true. The description adds value by specifying the output format (markdown) and progress reporting. No behavioral contradictions or missing critical details.
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, highly efficient sentence. It is front-loaded with the main action and lists components 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's complexity, full schema coverage, presence of output schema, and annotations, the description covers all essential aspects: what the report contains, output format, and progress behavior. 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?
Schema descriptions cover 100% of parameters with clear explanations (country as name/code, year defaults). The description adds no additional meaning beyond the schema, so baseline score applies.
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 composes a full markdown humanitarian situation report, listing specific components (key figures, refugee trend with chart, origins, asylum decisions, demographics). This distinguishes it from sibling tools like 'country_profile' or 'generate_chart'.
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 use for comprehensive overviews but does not explicitly state when to use this tool versus alternatives like 'country_profile' or 'generate_chart'. No when-not or alternative guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_mapGenerate map (GeoJSON)ARead-only
GeoJSON FeatureCollection of country centroid points sized by a displacement metric — drop it into any GeoJSON viewer (geojson.io, Leaflet, Kepler). by="asylum" maps host countries, by="origin" maps origins.
| Name | Required | Description | Default |
|---|---|---|---|
| by | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| year | No | Year (default: latest) | |
| limit | No | Top-N countries (default 25) | |
| metric | No | Metric for point properties (default refugees) |
Output Schema
| Name | Required | Description |
|---|---|---|
| year | Yes | |
| metric | Yes | |
| geojson | Yes | |
| feature_count | Yes | |
| skipped_countries | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. Description adds concrete behavioral details: output is a GeoJSON FeatureCollection suitable for viewers, and explains how the 'by' parameter affects map mapping. No contradictions.
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?
Two sentences, front-loaded with output format and usage hints. Every sentence is informative and concise.
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?
Description covers purpose, output format, parameter behavior, and usage tips. Given the output schema exists and annotations are clear, no further details needed.
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 descriptions for all 4 parameters. Description adds value by explaining the output structure (centroid points sized by displacement metric) and the meaning of the 'by' parameter values 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?
Description clearly states it generates a GeoJSON FeatureCollection of country centroid points sized by a displacement metric, and specifies the two modes (asylum/origin). This distinguishes it from sibling tools like generate_chart or export_data.
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?
Description implies usage for creating maps of displacement data, but does not explicitly mention when to use this tool versus alternatives like export_data or generate_chart. No when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_metadataGet metadataARead-only
Describe the connected data providers: datasets served, metrics available, attribution and terms. Call this to learn what data exists before querying.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| providers | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and openWorldHint=true, so the description's main contribution is detailing what information is returned (datasets, metrics, attribution, terms). It does not contradict annotations or add major behavioral context beyond that.
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?
Two concise sentences with no wasted words. The purpose and usage guidance are front-loaded, making it easy for an agent to quickly understand the tool.
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, the presence of an output schema, and annotations conveying read-only and open-world nature, the description is complete. It tells the agent exactly what to expect and when to call this 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 no parameters (0 params), so the baseline is 4. The description adds value by explaining the output content, which compensates for the lack of parameter documentation.
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 function: 'Describe the connected data providers: datasets served, metrics available, attribution and terms.' It uses a specific verb ('describe') and identifies the resource ('connected data providers'), distinguishing it from sibling tools like 'latest_statistics' or 'demographics'.
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 explicitly advises when to use it: 'Call this to learn what data exists before querying.' This provides clear context for usage, though it does not explicitly state when not to use it or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
humanitarian_fundingHumanitarian fundingARead-only
Humanitarian appeal requirements vs funding received per year for a country, with coverage percentage (OCHA FTS via HDX).
| Name | Required | Description | Default |
|---|---|---|---|
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) |
Output Schema
| Name | Required | Description |
|---|---|---|
| source | Yes | |
| country | Yes | |
| records | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds that data is per year and includes coverage percentage, which is consistent. However, it does not disclose any behavioral traits beyond what annotations provide, such as data latency or filtering 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 sentence that front-loads the key purpose and data source. It is concise and free of fluff, though it could be slightly more structured with bullet points.
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?
The description adequately covers the data type (requirements vs funding, coverage percentage), granularity (per year, for a country), and source. With an output schema present, the description does not need to detail return format. It is sufficiently complete for a simple retrieval 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?
Schema description coverage is 100% (all parameters described in schema). The description does not add extra meaning beyond the schema's parameter descriptions; it only mentions the country context. Baseline 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 the tool retrieves humanitarian appeal requirements vs funding received per year for a country, including coverage percentage and data source. This specific verb-resource combination distinguishes it from sibling tools like asylum_applications or conflict_events.
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. For example, it does not mention when to prefer this over compare_countries or trend_analysis for cross-country or trend purposes. No exclusions or prerequisites are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
latest_statisticsLatest statisticsARead-only
Most recent displacement figures. With a country: its latest hosted figures. Without: the latest global totals.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| country | No | Country name or ISO3; omit for global totals |
Output Schema
| Name | Required | Description |
|---|---|---|
| year | Yes | |
| scope | Yes | |
| source | Yes | |
| figures | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint, openWorldHint) indicate safe read and potentially incomplete data. Description adds that figures are 'most recent' and explains behavior based on country parameter, which is useful beyond annotations. No contradiction.
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?
Two concise sentences with no redundant information. Front-loaded with core purpose. Every word earns its place.
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 simple tool with 2 parameters, no required fields, and an output schema, the description covers the essential behavior. It could mention the role parameter explicitly, but the schema covers it. Adequate for the tool's complexity.
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 descriptions for both parameters. Description does not add new meaning beyond explaining tool behavior based on country presence. Baseline 3 is appropriate as description complements but does not significantly enhance 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?
Description clearly states the tool retrieves most recent displacement figures, distinguishing between global totals (no country) and country-specific hosted figures. The verb 'get' is implied, and the resource 'displacement figures' is specific. This differentiates from sibling tools like refugee_population or top_host_countries.
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?
Explicitly guides when to use with a country vs. without. While it does not mention alternatives or exclusions, the instruction is clear enough for an agent to decide appropriate context. The sibling list provides further options, but the description itself offers sufficient usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
provider_healthProvider healthARead-only
Liveness check of every connected data provider (latency, reachability). Use when queries fail to distinguish upstream outages from bad parameters.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| healthy | Yes | |
| providers | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=true and openWorldHint=true, so the tool is safe and non-destructive. The description adds behavioral details beyond annotations by specifying it checks latency and reachability, providing concrete insight into what the tool does.
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 at two sentences, with the key information front-loaded. Every sentence adds value: the first states the core function, the second gives a usage scenario. 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 tool's simplicity (no parameters, output schema exists), the description fully covers its purpose and usage context. It tells the agent exactly what it does and when to use it, making it complete for effective 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?
The tool has zero parameters, and the schema coverage is 100% (trivially). The description does not need to explain parameters, and the absence is noted. With 0 parameters, baseline is 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 with a specific verb ('liveness check') and resource ('every connected data provider'), and explicitly mentions what is checked (latency, reachability). It also distinguishes itself from sibling tools, which are focused on asylum, country profiles, and trends, not provider health.
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?
Provides explicit guidance on when to use the tool: 'Use when queries fail to distinguish upstream outages from bad parameters.' While it doesn't include when not to use or alternatives, the context is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
refugee_populationRefugee populationARead-only
Yearly displacement figures for a country: refugees, asylum-seekers, IDPs, stateless and others. role "asylum" (default) = hosted in the country; role "origin" = displaced from it. Optionally cross-filter by a second country (e.g. Syrians hosted in Egypt). Paginated.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | 1-based page (default 1) | |
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| limit | No | Rows per page (default 100) | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) | |
| other_country | No | Optional second country for the opposite role, e.g. country="Egypt", role="asylum", other_country="Syria" → Syrians in Egypt |
Output Schema
| Name | Required | Description |
|---|---|---|
| source | Yes | |
| records | Yes | |
| page_info | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds value by disclosing pagination ('Paginated'), default year ranges (10 years back from year_from, latest for year_to), and default limit (100). It also explains the behavior of the role and other_country parameters beyond the schema. No destructive actions are described, consistent with 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: three sentences that cover the main purpose, role parameter, and optional cross-filter/pagination. All information is front-loaded in the first sentence. There is no superfluous text; every sentence earns its place.
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 7 parameters, a diverse set of sibling tools, and the presence of an output schema, the description covers the key behaviors: data type, role, cross-filter, and pagination. It could mention error handling or the lack of filtering beyond country/role, but it is sufficiently complete for an agent to understand the tool's scope and basic usage.
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 adds an example for other_country (e.g., Syrians in Egypt) and clarifies the role parameter with 'hosted IN' vs 'displaced FROM.' However, much of this information is already present in the schema descriptions (e.g., country ISO3 examples, year defaults). The added value is modest.
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 that the tool provides 'Yearly displacement figures for a country: refugees, asylum-seekers, IDPs, stateless and others.' This specifies the type of data and the resource (a country's displacement figures), which distinguishes it from sibling tools like asylum_applications and asylum_decisions. However, it lacks an imperative verb like 'List' or 'Get,' which slightly reduces clarity.
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 explains the role parameter and the optional cross-filter with other_country, giving guidance on how to query for hosted vs origin populations and cross-reference second countries. It does not explicitly state when to use this tool versus siblings (e.g., when displacement figures are needed vs asylum applications), relying on implicit differentiation. No exclusions or alternative tool names are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_countrySearch countryARead-only
Resolve a free-text country query ("egypt", "DRC", "syria") to canonical names and ISO3 codes. Use this first when unsure how a country is spelled in the data.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max matches (default 5) | |
| query | Yes | Country name fragment, ISO2/ISO3 code or alias |
Output Schema
| Name | Required | Description |
|---|---|---|
| matches | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds context that the tool returns canonical names and ISO3 codes, and accepts free-text input, which goes beyond the 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?
Two sentences, front-loaded with purpose. Every sentence earns its place with no waste. Efficient and clear.
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 simple resolution tool with an output schema (not shown), the description adequately covers purpose, usage context, and basic behavior. It is complete enough to guide an AI agent.
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 100% coverage with descriptions for both parameters (query, limit). The description ties parameters to the task but does not add significant new detail beyond the schema. Baseline 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 the tool resolves free-text country queries to canonical names and ISO3 codes, with examples like 'egypt', 'DRC', 'syria'. It distinguishes from sibling tools that focus on data analysis or comparisons.
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 explicitly says 'Use this first when unsure how a country is spelled', providing clear guidance on when to use this tool. It does not explicitly mention when not to use it or name alternatives, but the context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
situation_reportsSituation reportsARead-only
Situation reports published about a country: yearly counts plus the most recent report titles and links (ReliefWeb). Use it to ground trends and anomalies from other tools in what was actually reported at the time.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | Free-text filter for the listed reports (e.g. "cholera") — yearly counts stay unfiltered | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) | |
| max_reports | No | How many of the most recent reports to list (default 5) |
Output Schema
| Name | Required | Description |
|---|---|---|
| latest | Yes | |
| source | Yes | |
| country | Yes | |
| records | Yes | |
| country_code | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true and openWorldHint=true, covering the basic safety profile. The description adds that output includes yearly counts and recent report titles/links, which is helpful but does not disclose additional behaviors like rate limits or auth requirements. With annotations, the description's contribution to transparency is moderate.
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, dense sentences. The first sentence defines the tool's output in one clause; the second provides usage guidance. Every word earns its place with no redundancy or wasted text.
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 5 parameters, 1 required, and an output schema exists to describe return values, the description is sufficiently complete. It conveys the core purpose and a common use case. However, it could briefly mention that output schema details the structure, but this is minor given the existing 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 description coverage is 100%, so the baseline is 3. The description does not add parameter-specific details beyond what the schema already provides. The mention of 'yearly counts' implicitly relates to the year parameters, but no new semantic information is added.
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 retrieves situation reports for a country, providing yearly counts and recent report titles/links from ReliefWeb. This specific verb+resource combination, along with the mention of the source, distinguishes it from sibling tools like conflict_events or asylum_applications.
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 explicitly advises using the tool to 'ground trends and anomalies from other tools in what was actually reported at the time,' giving clear context for when to use it. While it does not list explicit alternatives or when-not-to-use scenarios, the usage guidance is strong and practical.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
top_host_countriesTop host / origin countriesARead-only
Rank countries by a displacement metric for a year. by="asylum" (default) ranks host countries; by="origin" ranks countries people fled from. Set normalize_by="population" to rank per 1,000 residents (or "gdp" per US$1bn) — the ranking that shows Lebanon and Chad ahead of large economies.
| Name | Required | Description | Default |
|---|---|---|---|
| by | No | Rank hosts ("asylum") or origins ("origin") | |
| year | No | Year to rank (default: latest available) | |
| limit | No | How many rows (default 10) | |
| metric | No | Metric to rank by (default refugees) | |
| normalize_by | No | Normalize values by a denominator: "population" → per 1,000 residents, "gdp" → per US$1bn GDP. Requires the worldbank provider. |
Output Schema
| Name | Required | Description |
|---|---|---|
| by | Yes | |
| unit | Yes | |
| year | Yes | |
| metric | Yes | |
| source | Yes | |
| ranking | Yes | |
| normalize_by | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and open-world hints. The description adds value by explaining the default behavior ('by' defaults to 'asylum'), the effect of 'normalize_by' with a concrete example, and the dependency on the worldbank provider for normalization. This goes beyond what annotations provide, though it does not cover all potential behavioral nuances like rate limits.
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, consisting of two sentences. The first sentence states the primary purpose, and the second elaborates on key parameters with an example. Every word serves a purpose, with no redundancy or unnecessary detail.
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 complexity (5 parameters, output schema present), the description covers the essential behavioral aspects: metric ranking, two main parameter groups, normalization effect, and provider dependency. The output schema handles return values, so description is complete for an agent to use the tool effectively.
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 100% coverage with descriptions. The tool's description enhances understanding by explaining the meaning and default of 'by', the impact of 'normalize_by' with a vivid example ('Lebanon and Chad ahead of large economies'), and the provider dependency. This provides meaningful context beyond the schema alone.
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 ranks countries by a displacement metric for a year, specifying verb and resource. It explains the 'by' and 'normalize_by' parameters with examples, making the purpose distinct. However, it does not explicitly differentiate from sibling tools like 'refugee_population' or 'trend_analysis', preventing a score of 5.
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 provides usage details for parameters (e.g., default 'by' value, effect of 'normalize_by') but offers no guidance on when to choose this tool over alternatives. No explicit context for when not to use it or which sibling tool might be better suited is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
trend_analysisTrend analysisARead-only
Analyse how a displacement metric evolved for a country: yearly series, year-over-year changes, linear trend (slope, R²), CAGR and statistically anomalous years. Default: refugees hosted, last 10 years.
| Name | Required | Description | Default |
|---|---|---|---|
| role | No | "asylum" = people hosted IN the country; "origin" = people displaced FROM the country | |
| metric | No | Metric: refugees, asylum_seekers, idps, stateless... (default refugees) | |
| country | Yes | Country name or ISO3 code, e.g. "Egypt", "EGY", "syria" | |
| year_to | No | Last year of the range (default: latest available) | |
| year_from | No | First year of the range (default: 10 years back) |
Output Schema
| Name | Required | Description |
|---|---|---|
| role | Yes | |
| trend | Yes | |
| metric | Yes | |
| series | Yes | |
| source | Yes | |
| country | Yes | |
| anomalies | Yes | |
| country_code | Yes | |
| year_over_year | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint and openWorldHint. The description adds value by detailing analytical outputs (e.g., linear trend, CAGR) beyond the structured fields, but does not fully disclose all behavioral traits (e.g., data source, refresh frequency).
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?
Two sentences with no fluff. First sentence lists what the tool computes; second sentence provides default configuration. Every sentence is purposeful.
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 5 parameters, output schema, and annotations, the description covers purpose, default behavior, and analytical components. It does not need to repeat output format since an output schema exists.
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 description coverage is 100%, so baseline is 3. The description adds default metric and time range context, but does not significantly enhance understanding beyond the schema's parameter descriptions.
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 analyzes displacement metric evolution for a country, listing specific outputs (yearly series, YoY changes, linear trend, CAGR, anomalous years). This distinguishes it from siblings like country_profile or demographics.
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 trend analysis but does not explicitly state when to use this tool vs alternatives like forecast or compare_countries. No exclusions or when-not guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
v0.6.0- Changed
export_data1 field changed- changed
Input schema / properties / dataset / enumPrevious value: -[ - "population", - "demographics", - "asylum-applications", - "asylum-decisions", - "context-indicators", - "idps", - "conflict-events", - "humanitarian-funding", - "food-security" -]New value: +[ + "population", + "demographics", + "asylum-applications", + "asylum-decisions", + "context-indicators", + "idps", + "conflict-events", + "humanitarian-funding", + "food-security", + "situation-reports" +]
- Added
situation_reports
7 tool updates
v0.5.1- Changed
compare_countries5 fields changed- added
Input schema / properties / normalize_byAdded value: +{ + "description": "Normalize values by a denominator: \"population\" → per 1,000 residents, \"gdp\" → per US$1bn GDP. Requires the worldbank provider.", + "enum": [ + "population", + "gdp", + "none" + ], + "type": "string" +} - added
Output schema / properties / denominatorAdded value: +{ + "additionalProperties": false, + "properties": { + "citation": { + "type": "string" + }, + "metric": { + "type": "string" + }, + "source": { + "type": "string" + } + }, + "required": [ + "source", + "citation", + "metric" + ], + "type": "object" +} - added
Output schema / properties / normalize_byAdded value: +{ + "type": "string" +} - added
Output schema / properties / unitAdded value: +{ + "type": "string" +} - changed
Output schema / requiredPrevious value: -[ - "metric", - "role", - "series", - "source" -]New value: +[ + "metric", + "role", + "normalize_by", + "unit", + "series", + "source" +]
- Added
conflict_events - Changed
export_data6 fields changed- changed
Input schema / properties / dataset / descriptionPrevious value: -"population | demographics | asylum-applications | asylum-decisions"New value: +"population | demographics | asylum-applications | asylum-decisions | context-indicators | idps | conflict-events | humanitarian-funding | food-security" - changed
Input schema / properties / dataset / enumPrevious value: -[ - "population", - "demographics", - "asylum-applications", - "asylum-decisions" -]New value: +[ + "population", + "demographics", + "asylum-applications", + "asylum-decisions", + "context-indicators", + "idps", + "conflict-events", + "humanitarian-funding", + "food-security" +] - added
Input schema / properties / include_codebookAdded value: +{ + "description": "Attach a codebook documenting every exported variable (meaning, unit, derivation) — ready for a paper's data appendix. Default false.", + "type": "boolean" +} - added
Input schema / properties / include_manifestAdded value: +{ + "description": "Attach an extraction manifest (exact arguments, timestamp, server version, citation) for reproducibility. Default true.", + "type": "boolean" +} - added
Output schema / properties / codebookAdded value: +{ + "items": { + "additionalProperties": false, + "properties": { + "description": { + "type": "string" + }, + "field": { + "type": "string" + }, + "unit": { + "type": "string" + } + }, + "required": [ + "field", + "description", + "unit" + ], + "type": "object" + }, + "type": "array" +} - added
Output schema / properties / manifestAdded value: +{ + "additionalProperties": {}, + "type": "object" +}
- Added
food_security - Changed
generate_chart3 fields changed- added
Input schema / properties / normalize_byAdded value: +{ + "description": "Normalize values by a denominator: \"population\" → per 1,000 residents, \"gdp\" → per US$1bn GDP. Requires the worldbank provider.", + "enum": [ + "population", + "gdp", + "none" + ], + "type": "string" +} - added
Output schema / properties / unitAdded value: +{ + "type": "string" +} - changed
Output schema / requiredPrevious value: -[ - "format", - "title", - "spec" -]New value: +[ + "format", + "title", + "unit", + "spec" +]
- Added
humanitarian_funding - Changed
top_host_countries6 fields changed- added
Input schema / properties / normalize_byAdded value: +{ + "description": "Normalize values by a denominator: \"population\" → per 1,000 residents, \"gdp\" → per US$1bn GDP. Requires the worldbank provider.", + "enum": [ + "population", + "gdp", + "none" + ], + "type": "string" +} - added
Output schema / properties / normalize_byAdded value: +{ + "type": "string" +} - added
Output schema / properties / ranking / items / properties / denominator_yearAdded value: +{ + "type": "number" +} - added
Output schema / properties / ranking / items / properties / raw_valueAdded value: +{ + "type": "number" +} - added
Output schema / properties / unitAdded value: +{ + "type": "string" +} - changed
Output schema / requiredPrevious value: -[ - "year", - "metric", - "by", - "ranking", - "source" -]New value: +[ + "year", + "metric", + "by", + "normalize_by", + "unit", + "ranking", + "source" +]
17 tool updates
v0.1.0- First observed
asylum_applications - First observed
asylum_decisions - First observed
compare_countries - First observed
country_profile - First observed
demographics - First observed
export_data - First observed
forecast - First observed
generate_chart - First observed
generate_country_report - First observed
generate_map - First observed
get_metadata - First observed
latest_statistics - First observed
provider_health - First observed
refugee_population - First observed
search_country - First observed
top_host_countries - First observed
trend_analysis
TDQS
Scored across 21 tools
Most tools target distinct resources and actions, with clear separation between snapshot, time-series, comparison, analysis, visualization, and export functions. A few tools overlap slightly—country_profile, latest_statistics, and refugee_population all surface displacement counts—but their descriptions clarify the differing levels of detail and scope.
Names use a mostly consistent snake_case convention, and there is a recognizable split: data-access tools are noun phrases (refugee_population, conflict_events) while actionable tools use verbs (generate_chart, export_data, search_country). Minor deviations like provider_health and latest_statistics break the pattern slightly but do not cause confusion.
At 21 tools, the server is on the heavier side and sits in the 16–25 range that feels bulky. The count is partially justified by the broad multi-dataset humanitarian scope, but the set could likely be consolidated to reduce discovery burden.
The tool surface covers the core humanitarian data workflow well: country resolution, displacement metrics, demographics, asylum, conflict, food security, funding, reports, trend analysis, forecasting, visualization, export, metadata, and health checks. Minor gaps exist, such as no explicit tool for enumerating which countries have available data, but most analysis paths can be completed without dead ends.
Maintenance
Related MCP Connectors
Discover, resolve, and query official Brazilian economic data with semantic search and provenance.
Semantic search across 5 US government healthcare databases.
Search and analyze global news coverage and US TV transcripts via the GDELT Project APIs.
Query 29,500+ World Bank development indicators for 200+ countries across 60+ years.
Related MCP Servers
- AlicenseAqualityDmaintenanceProvides access to UNHCR refugee statistics through a standardized interface, allowing AI agents to query data by country of origin, country of asylum, and year.5MIT
- FlicenseNot gradedqualityDmaintenanceEnables AI agents to generate UNHCR-styled data visualizations including bar, line, pie, and scatter charts with refugee and population data, returning charts as base64-encoded images.-
- FlicenseNot gradedqualityCmaintenanceEnables querying 10,000 years of historical social-complexity data from the Seshat Global History Databank through 9 tools, allowing counterfactual analysis and comparison of polities in natural language.1-
- AlicenseNot gradedqualityCmaintenanceEnables querying Eurostat statistical data through natural language or direct MCP tools, wrapping the Eurostat API without authentication.9MIT