Eight tools covering the OpenFEMA data surface — convenience tools for the headline datasets, SQL analytics over large NFIP result sets via DuckDB canvas, and a generic escape hatch for datasets the convenience tools don't cover:

The primary entry point — "what disasters were declared in Texas in 2025?"

• Filter by state (2-letter code), incident type (Hurricane, Flood, Wildfire, etc.), declaration type (DR/EM/FM), date range, and county
• Returns deduplicated declaration-level summaries — one row per declaration, not per designated area
• Includes disaster number (the join key for PA and housing tools), title, state, incident type, declaration/incident dates, programs declared (IA/PA/HM), and designatedAreaCount
• Paginated via limit / offset

Fetch all designated-area records for a specific FEMA disaster number.

• Returns every county/municipality row for the declaration with programs activated, incident period, and FIPS codes
• Use after fema_search_disasters to drill into a specific event; the disaster number chains to PA and housing tools
• DisasterDeclarationsSummaries returns one row per designated area — a single declaration can span dozens of counties

Retrieve PA funded project details — where federal recovery money went after a disaster.

• Filter by disaster_number, state, or county; at least one of disaster_number or state is required
• Returns applicant, damage category, project size/status, federal share obligated, and total obligated
• Useful for journalists, researchers, and oversight analysts tracking federal grant flows

Individual assistance housing data for a disaster, broken down by county and ZIP.

• Returns owner and renter breakdowns via type param (owners/renters/both)
• Fields include valid registrations, total inspected, total damage, approved IHP amounts, repair/rental/other-needs amounts, and max grants
• Covers HousingAssistanceOwners and HousingAssistanceRenters datasets in a single call

NFIP flood insurance claims with optional DuckDB-backed SQL analytics for large result sets.

• Requires at minimum a state filter — unfiltered NFIP Claims is 2.7M rows
• Additional filters: county_code, zip_code, year_from, year_to; pagination via limit
• When CANVAS_PROVIDER_TYPE=duckdb is set and results exceed the inline cap, the full result set spills to a DataCanvas table and returns a canvas_id handle
• Use fema_dataframe_describe to inspect the schema, then fema_dataframe_query for aggregation, grouping, and time-series analysis without re-fetching

In-conversation SQL analytics over NFIP Claims data staged by fema_search_nfip on a DuckDB-backed DataCanvas.

• fema_dataframe_describe: lists columns, types, and row count for a canvas table — use before writing a query
• fema_dataframe_query: runs a single SELECT statement against the staged table; standard DuckDB SQL (GROUP BY, SUM, window functions, time-series)
• Workflow: fema_search_nfip (with canvas enabled) → fema_dataframe_describe → fema_dataframe_query
• Read-only — writes, DDL, and DROP are rejected by the framework SQL gate

Generic OData query against any OpenFEMA v2 dataset — the escape hatch for datasets the convenience tools don't cover.

• Accepts raw $filter, $select, $orderby, limit, and offset params
• Dataset name must match an actual OpenFEMA endpoint (e.g. FimaNfipPolicies, IndividualAssistanceHousingRegistrantsLargeDisasters)
• Validates that the API returns JSON (Content-Type check) and surfaces structured error codes on 400 responses

All resource data is also reachable via tools. Use fema_get_disaster for the same data with pagination and full designated-area detail.

Built on @cyanheads/mcp-ts-core:

• Declarative tool, resource, and prompt definitions — single file per primitive, framework handles registration and validation
• Unified error handling — handlers throw, framework catches, classifies, and formats
• Pluggable auth: none, jwt, oauth
• Swappable storage backends: in-memory, filesystem, Supabase, Cloudflare KV/R2/D1
• Structured logging with optional OpenTelemetry tracing
• STDIO and Streamable HTTP transports

FEMA/OpenFEMA-specific:

• Typed OpenFEMA REST client with OData parameter building (%24-encoded to satisfy Akamai's Drupal layer), response parsing, and structured error classification (JSON 400 vs HTML 404)
• Automatic deduplication of DisasterDeclarationsSummaries — one row per designated area collapsed to declaration-level summaries with designatedAreaCount
• NFIP Claims guard: state filter is required to prevent unbounded 2.7M-row fetches
• DataCanvas spillover for NFIP analytics — large NFIP result sets materialize as DuckDB tables queryable via SQL without re-fetching
• No API keys required — OpenFEMA is a free, public API

Agent-friendly output:

• Disaster number is the explicit join key across all datasets — every tool that touches a disaster surfaces it prominently so agents can chain calls without re-searching
• Typed error contracts on every tool — invalid_state, no_results, missing_filter, state_required, unknown_dataset, invalid_filter — with recovery hints telling agents the concrete next step
• designatedAreaCount on search results so agents know whether to drill in with fema_get_disaster without having to fetch the full record first

A public instance is available at https://fema.caseyjhand.com/mcp — no installation required. Point any MCP client at it via Streamable HTTP:

{
  "mcpServers": {
    "fema-mcp-server": {
      "type": "streamable-http",
      "url": "https://fema.caseyjhand.com/mcp"
    }
  }
}

Add the following to your MCP client configuration file.

{
  "mcpServers": {
    "fema-mcp-server": {
      "type": "stdio",
      "command": "bunx",
      "args": ["@cyanheads/fema-mcp-server@latest"],
      "env": {
        "MCP_TRANSPORT_TYPE": "stdio",
        "MCP_LOG_LEVEL": "info"
      }
    }
  }
}

Or with npx (no Bun required):

{
  "mcpServers": {
    "fema-mcp-server": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@cyanheads/fema-mcp-server@latest"],
      "env": {
        "MCP_TRANSPORT_TYPE": "stdio",
        "MCP_LOG_LEVEL": "info"
      }
    }
  }
}

Or with Docker:

{
  "mcpServers": {
    "fema-mcp-server": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "MCP_TRANSPORT_TYPE=stdio",
        "ghcr.io/cyanheads/fema-mcp-server:latest"
      ]
    }
  }
}

For Streamable HTTP, set the transport and start the server:

MCP_TRANSPORT_TYPE=http MCP_HTTP_PORT=3010 bun run start:http
# Server listens at http://localhost:3010/mcp

To enable DuckDB-backed SQL analytics for NFIP Claims:

{
  "mcpServers": {
    "fema-mcp-server": {
      "type": "stdio",
      "command": "bunx",
      "args": ["@cyanheads/fema-mcp-server@latest"],
      "env": {
        "MCP_TRANSPORT_TYPE": "stdio",
        "CANVAS_PROVIDER_TYPE": "duckdb"
      }
    }
  }
}

• Bun v1.3.0 or higher (or Node.js v24+).
• No API keys required — OpenFEMA is a free, public API.
• Optional: set CANVAS_PROVIDER_TYPE=duckdb to enable SQL analytics over large NFIP Claims result sets.

1. Clone the repository:

git clone https://github.com/cyanheads/fema-mcp-server.git

2. Navigate into the directory:

cd fema-mcp-server

3. Install dependencies:

bun install

4. Configure environment:

cp .env.example .env
# edit .env — no required vars, but CANVAS_PROVIDER_TYPE=duckdb enables SQL analytics

All configuration is validated at startup via Zod schemas in src/config/server-config.ts. Key environment variables:

See .env.example for the full list of optional overrides.

• Build and run:

  # One-time build
  bun run rebuild
  
  # Run the built server
  bun run start:stdio
  # or
  bun run start:http

• Run checks and tests:

  bun run devcheck   # Lint, format, typecheck, security
  bun run test       # Vitest test suite
  bun run lint:mcp   # Validate MCP definitions against spec

docker build -t fema-mcp-server .
docker run --rm -e MCP_TRANSPORT_TYPE=stdio fema-mcp-server

The Dockerfile defaults to HTTP transport, stateless session mode, and logs to /var/log/fema-mcp-server. OpenTelemetry peer dependencies are installed by default — build with --build-arg OTEL_ENABLED=false to omit them. The @duckdb/node-api native binary is copied from the build stage, so the production image doesn't need build tools.

See CLAUDE.md for development guidelines and architectural rules. The short version:

• Handlers throw, framework catches — no try/catch in tool logic
• Use ctx.log for request-scoped logging, ctx.state for tenant-scoped storage
• Register new tools and resources via the barrels in src/mcp-server/*/definitions/index.ts
• Wrap external API calls: validate raw → normalize to domain type → return output schema; never fabricate missing fields

Issues and pull requests are welcome. Run checks and tests before submitting:

bun run devcheck
bun run test

Data is provided by the OpenFEMA API, a free public API maintained by the Federal Emergency Management Agency. Usage is subject to OpenFEMA Terms and Conditions.

This product uses the Federal Emergency Management Agency's OpenFEMA API, but is not endorsed by FEMA. The Federal Government or FEMA cannot vouch for the data or analyses derived from these data after the data have been retrieved from the Agency's website(s).

When citing OpenFEMA datasets in research or publications, use the format FEMA specifies:

Federal Emergency Management Agency (FEMA), OpenFEMA Dataset: <name>. Retrieved from <URL> on <date>.

Apache-2.0 — see LICENSE for details.