Skip to main content
Glama
ahmedvnabil

Humanitarian MCP

by ahmedvnabil

Humanitarian MCP

Trusted humanitarian data — refugees, conflict, hunger, funding — as one clean, citable interface for AI assistants and research code.

Humanitarian MCP — open humanitarian data, one MCP interface

CI Release Docker npm Research: citable MCP License: MIT


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 ARE in UNHCR-speak — which is the UAE's ISO code. Ask a raw API "refugees in ARE?" and you silently get the wrong country.

Everything speaks ISO3. Names resolve fuzzily in English and Arabic («مصر», «الأردن», «السودان»).

Schema babel

UNHCR returns {items: [...]}, the World Bank returns [meta, rows], HAPI returns {data: [...]} — each with different field names, pagination and update cadence.

One NormalizedRecord shape across all sources: country_code, year, population, metrics, source, dataset.

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.

normalize_by: "population" | "gdp" — denominators matched per year, denominator year disclosed on every row.

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 humanitarian-mcp.zad.tools

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 /api/status

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/mcp
  • claude.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/mcp

  • Anything 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 autocompletion

  • 8 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 matching

  • Regression, 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: true generates 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=1 gives 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.0

Register it with Claude Code in one line:

claude mcp add humanitarian -- npx -y humanitarian-mcp

Claude 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.0

Docker

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:8642

Or 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.js

Enable 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.js

All 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 Inspector

In --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

src/

The server. providers/ (one directory per data source — the only place provider quirks may exist), tools/, resources/, prompts/, shared/ (HTTP, cache, rate limiting, stats, country matching), viz/, http/ (Streamable HTTP + dashboard)

docs/

tools.md (tool reference) · architecture.md · for-researchers.md · how-mcp-works.md (MCP primer) · adding-providers.md · development.md · index.html (Arabic landing page, served at humanitarian-mcp.zad.tools)

examples/

Client configs, worked conversations with tool traces, HTTP client recipes, runnable Python/R notebooks

tests/

153 tests: MCP compliance suite (official SDK client ↔ real server), fixture-based provider suites (no network), unit tests

paper/

JOSS paper draft (paper.md + paper.bib)

marketing/

Launch kit: platform-native announcement drafts

Dockerfile / compose.yaml

Organizational self-hosting (image published to GHCR on every release)

.github/

CI (Node 20/22/24), release automation (npm + .mcpb + Docker on tag), issue templates incl. a provider-request template

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 manifests

  • v0.3.0 — World Bank provider + normalize_by per-capita / per-GDP analytics

  • v0.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_reports tool, crisis_overview prompt, hardened public HTTP mode (per-IP rate limiting, GET /health), bilingual landing page

  • Published to npmnpx humanitarian-mcp is 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 tools
asylum_applicationsAsylum applicationsA
Read-only

Individual asylum applications lodged per year. role "asylum" (default) = applications filed IN the country; "origin" = filed BY nationals of the country abroad.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)

Output Schema

ParametersJSON Schema
NameRequiredDescription
roleYes
sourceYes
yearlyYes
countryYes
country_codeYes

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 decisionsA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)

Output Schema

ParametersJSON Schema
NameRequiredDescription
roleYes
sourceYes
yearlyYes
countryYes
country_codeYes

TDQS

A4.1/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 countriesA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
metricNoMetric to compare, e.g. refugees, asylum_seekers, idps (default: refugees)
year_toNoLast year of the range (default: latest available)
countriesYesTwo to five countries to compare
year_fromNoFirst year of the range (default: 10 years back)
normalize_byNoNormalize values by a denominator: "population" → per 1,000 residents, "gdp" → per US$1bn GDP. Requires the worldbank provider.

Output Schema

ParametersJSON Schema
NameRequiredDescription
roleYes
unitYes
metricYes
seriesYes
sourceYes
denominatorNo
normalize_byYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 eventsA
Read-only

Annual conflict event counts and fatalities for a country (ACLED via HDX). Pairs with refugee_population/trend_analysis to relate violence and displacement.

ParametersJSON Schema
NameRequiredDescriptionDefault
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)

Output Schema

ParametersJSON Schema
NameRequiredDescription
sourceYes
countryYes
recordsYes
country_codeYes

TDQS

A3.8/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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 profileA
Read-only

One-call humanitarian snapshot of a country: latest displaced population hosted (by category), population displaced FROM the country, and its top origin countries.

ParametersJSON Schema
NameRequiredDescriptionDefault
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"

Output Schema

ParametersJSON Schema
NameRequiredDescription
yearNo
hostedYesLatest people-of-concern figures hosted in the country
regionNo
sourceYes
countryYes
top_originsYes
country_codeYes
displaced_abroadYesLatest figures for people displaced FROM the country

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

demographicsDemographicsA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"

Output Schema

ParametersJSON Schema
NameRequiredDescription
maleYes
yearYes
totalYes
femaleYes
sourceYes
countryYes
country_codeYes

TDQS

A4/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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 dataA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
limitNoMax rows (default 500)
formatYesSerialization format
countryNoFilter by country (name or ISO3)
datasetYespopulation | demographics | asylum-applications | asylum-decisions | context-indicators | idps | conflict-events | humanitarian-funding | food-security
year_toNoLast year of the range (default: latest available)
group_byNoBreak rows down per asylum or origin country instead of aggregating
year_fromNoFirst year of the range (default: 10 years back)
include_codebookNoAttach a codebook documenting every exported variable (meaning, unit, derivation) — ready for a paper's data appendix. Default false.
include_manifestNoAttach an extraction manifest (exact arguments, timestamp, server version, citation) for reproducibility. Default true.

Output Schema

ParametersJSON Schema
NameRequiredDescription
dataYes
formatYes
datasetYes
codebookNo
manifestNo
row_countYes
truncatedYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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)A
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
yearNoAnalysis year (default: latest available)
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"

Output Schema

ParametersJSON Schema
NameRequiredDescription
yearYes
phasesYes
sourceYes
countryYes
country_codeYes
people_crisis_or_worseYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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)A
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
metricNoMetric to project (default refugees)
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
years_aheadNoHorizon (default 3)

Output Schema

ParametersJSON Schema
NameRequiredDescription
caveatYes
methodYes
metricYes
countryYes
projectedYes
historicalYes
country_codeYes

TDQS

A3.8/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines2/5

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 chartA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
kindNoChart type (default line)
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
formatYesOutput format
metricNoMetric to plot (default refugees)
year_toNoLast year of the range (default: latest available)
countriesYesCountries to plot
year_fromNoFirst year of the range (default: 10 years back)
normalize_byNoNormalize values by a denominator: "population" → per 1,000 residents, "gdp" → per US$1bn GDP. Requires the worldbank provider.

Output Schema

ParametersJSON Schema
NameRequiredDescription
specYes
unitYes
titleYes
formatYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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 reportA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)

Output Schema

ParametersJSON Schema
NameRequiredDescription
countryYes
year_toYes
markdownYes
year_fromYes
country_codeYes

TDQS

A4.1/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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)A
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
byNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
yearNoYear (default: latest)
limitNoTop-N countries (default 25)
metricNoMetric for point properties (default refugees)

Output Schema

ParametersJSON Schema
NameRequiredDescription
yearYes
metricYes
geojsonYes
feature_countYes
skipped_countriesYes

TDQS

A4.3/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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 metadataA
Read-only

Describe the connected data providers: datasets served, metrics available, attribution and terms. Call this to learn what data exists before querying.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
providersYes

TDQS

A4.3/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 fundingA
Read-only

Humanitarian appeal requirements vs funding received per year for a country, with coverage percentage (OCHA FTS via HDX).

ParametersJSON Schema
NameRequiredDescriptionDefault
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)

Output Schema

ParametersJSON Schema
NameRequiredDescription
sourceYes
countryYes
recordsYes
country_codeYes

TDQS

A3.5/5.0
Behavior3/5

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.

Conciseness4/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines2/5

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 statisticsA
Read-only

Most recent displacement figures. With a country: its latest hosted figures. Without: the latest global totals.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
countryNoCountry name or ISO3; omit for global totals

Output Schema

ParametersJSON Schema
NameRequiredDescription
yearYes
scopeYes
sourceYes
figuresYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 healthA
Read-only

Liveness check of every connected data provider (latency, reachability). Use when queries fail to distinguish upstream outages from bad parameters.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
healthyYes
providersYes

TDQS

A4.5/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 populationA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
pageNo1-based page (default 1)
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
limitNoRows per page (default 100)
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)
other_countryNoOptional second country for the opposite role, e.g. country="Egypt", role="asylum", other_country="Syria" → Syrians in Egypt

Output Schema

ParametersJSON Schema
NameRequiredDescription
sourceYes
recordsYes
page_infoYes

TDQS

A3.8/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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 countryA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMax matches (default 5)
queryYesCountry name fragment, ISO2/ISO3 code or alias

Output Schema

ParametersJSON Schema
NameRequiredDescription
matchesYes

TDQS

A4.2/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 reportsA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryNoFree-text filter for the listed reports (e.g. "cholera") — yearly counts stay unfiltered
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)
max_reportsNoHow many of the most recent reports to list (default 5)

Output Schema

ParametersJSON Schema
NameRequiredDescription
latestYes
sourceYes
countryYes
recordsYes
country_codeYes

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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 countriesA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
byNoRank hosts ("asylum") or origins ("origin")
yearNoYear to rank (default: latest available)
limitNoHow many rows (default 10)
metricNoMetric to rank by (default refugees)
normalize_byNoNormalize values by a denominator: "population" → per 1,000 residents, "gdp" → per US$1bn GDP. Requires the worldbank provider.

Output Schema

ParametersJSON Schema
NameRequiredDescription
byYes
unitYes
yearYes
metricYes
sourceYes
rankingYes
normalize_byYes

TDQS

A3.8/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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 analysisA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
roleNo"asylum" = people hosted IN the country; "origin" = people displaced FROM the country
metricNoMetric: refugees, asylum_seekers, idps, stateless... (default refugees)
countryYesCountry name or ISO3 code, e.g. "Egypt", "EGY", "syria"
year_toNoLast year of the range (default: latest available)
year_fromNoFirst year of the range (default: 10 years back)

Output Schema

ParametersJSON Schema
NameRequiredDescription
roleYes
trendYes
metricYes
seriesYes
sourceYes
countryYes
anomaliesYes
country_codeYes
year_over_yearYes

TDQS

A4.1/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines3/5

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.

  1. 2 tool updatesv0.6.0
    • Changedexport_data1 field changed
      • changedInput schema / properties / dataset / enum
        Previous 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"
        +]
    • Addedsituation_reports
  2. 7 tool updatesv0.5.1
    • Changedcompare_countries5 fields changed
      • addedInput schema / properties / normalize_by
        Added 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"
        +}
      • addedOutput schema / properties / denominator
        Added value: +{
        +  "additionalProperties": false,
        +  "properties": {
        +    "citation": {
        +      "type": "string"
        +    },
        +    "metric": {
        +      "type": "string"
        +    },
        +    "source": {
        +      "type": "string"
        +    }
        +  },
        +  "required": [
        +    "source",
        +    "citation",
        +    "metric"
        +  ],
        +  "type": "object"
        +}
      • addedOutput schema / properties / normalize_by
        Added value: +{
        +  "type": "string"
        +}
      • addedOutput schema / properties / unit
        Added value: +{
        +  "type": "string"
        +}
      • changedOutput schema / required
        Previous value: -[
        -  "metric",
        -  "role",
        -  "series",
        -  "source"
        -]New value: +[
        +  "metric",
        +  "role",
        +  "normalize_by",
        +  "unit",
        +  "series",
        +  "source"
        +]
    • Addedconflict_events
    • Changedexport_data6 fields changed
      • changedInput schema / properties / dataset / description
        Previous value: -"population | demographics | asylum-applications | asylum-decisions"New value: +"population | demographics | asylum-applications | asylum-decisions | context-indicators | idps | conflict-events | humanitarian-funding | food-security"
      • changedInput schema / properties / dataset / enum
        Previous value: -[
        -  "population",
        -  "demographics",
        -  "asylum-applications",
        -  "asylum-decisions"
        -]New value: +[
        +  "population",
        +  "demographics",
        +  "asylum-applications",
        +  "asylum-decisions",
        +  "context-indicators",
        +  "idps",
        +  "conflict-events",
        +  "humanitarian-funding",
        +  "food-security"
        +]
      • addedInput schema / properties / include_codebook
        Added value: +{
        +  "description": "Attach a codebook documenting every exported variable (meaning, unit, derivation) — ready for a paper's data appendix. Default false.",
        +  "type": "boolean"
        +}
      • addedInput schema / properties / include_manifest
        Added value: +{
        +  "description": "Attach an extraction manifest (exact arguments, timestamp, server version, citation) for reproducibility. Default true.",
        +  "type": "boolean"
        +}
      • addedOutput schema / properties / codebook
        Added value: +{
        +  "items": {
        +    "additionalProperties": false,
        +    "properties": {
        +      "description": {
        +        "type": "string"
        +      },
        +      "field": {
        +        "type": "string"
        +      },
        +      "unit": {
        +        "type": "string"
        +      }
        +    },
        +    "required": [
        +      "field",
        +      "description",
        +      "unit"
        +    ],
        +    "type": "object"
        +  },
        +  "type": "array"
        +}
      • addedOutput schema / properties / manifest
        Added value: +{
        +  "additionalProperties": {},
        +  "type": "object"
        +}
    • Addedfood_security
    • Changedgenerate_chart3 fields changed
      • addedInput schema / properties / normalize_by
        Added 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"
        +}
      • addedOutput schema / properties / unit
        Added value: +{
        +  "type": "string"
        +}
      • changedOutput schema / required
        Previous value: -[
        -  "format",
        -  "title",
        -  "spec"
        -]New value: +[
        +  "format",
        +  "title",
        +  "unit",
        +  "spec"
        +]
    • Addedhumanitarian_funding
    • Changedtop_host_countries6 fields changed
      • addedInput schema / properties / normalize_by
        Added 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"
        +}
      • addedOutput schema / properties / normalize_by
        Added value: +{
        +  "type": "string"
        +}
      • addedOutput schema / properties / ranking / items / properties / denominator_year
        Added value: +{
        +  "type": "number"
        +}
      • addedOutput schema / properties / ranking / items / properties / raw_value
        Added value: +{
        +  "type": "number"
        +}
      • addedOutput schema / properties / unit
        Added value: +{
        +  "type": "string"
        +}
      • changedOutput schema / required
        Previous value: -[
        -  "year",
        -  "metric",
        -  "by",
        -  "ranking",
        -  "source"
        -]New value: +[
        +  "year",
        +  "metric",
        +  "by",
        +  "normalize_by",
        +  "unit",
        +  "ranking",
        +  "source"
        +]
  3. 17 tool updatesv0.1.0
    • First observedasylum_applications
    • First observedasylum_decisions
    • First observedcompare_countries
    • First observedcountry_profile
    • First observeddemographics
    • First observedexport_data
    • First observedforecast
    • First observedgenerate_chart
    • First observedgenerate_country_report
    • First observedgenerate_map
    • First observedget_metadata
    • First observedlatest_statistics
    • First observedprovider_health
    • First observedrefugee_population
    • First observedsearch_country
    • First observedtop_host_countries
    • First observedtrend_analysis

TDQS

A3.9/5.0

Scored across 21 tools

Disambiguation4/5

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.

Naming Consistency4/5

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.

Tool Count3/5

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.

Completeness4/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    C
    maintenance
    Enables 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
    -