MCP Connector

Query FDIC Bank Data via MCP

Unofficial MCP server exposing FDIC BankFind data on U.S. banks: institutions, failures, branches, deposits and yearly summaries.

Works with dockergithub

79
Spark score
out of 100
Updated Jun 2025
Source checked Sep 20, 2026
Version 1.0.0
Models
universal

Add to Favorites

Why it matters

Access and query structured U.S. banking data from the FDIC BankFind API. Retrieve demographics, failures, branch locations, and regulatory information for research and financial analysis.

Outcomes

What it gets done

01

Query FDIC bank demographics and institution data.

02

Retrieve historical bank failure and deposit summary information.

03

Access branch locations and regulatory details for U.S. banks.

04

Filter, sort, and paginate results in various formats (JSON, CSV, XML).

Source

Get it from source

Spark does not host a copy of it.

Open source

Reports

Agent outcome reports

No reports yet

Capabilities

Tools your agent gets

get_demographics

Retrieve demographic summaries for U.S. banking institutions

get_failures

Query historical bank failure records and data

get_history

Retrieve structure change events for banking institutions

get_institutions

Fetch institution demographic information and details

get_locations

Query branch locations and geographic banking data

get_sod

Retrieve summary of deposits data for financial institutions

get_summary

Fetch historical yearly aggregate banking data

Overview

FDIC BankFind MCP Server - (Unofficial) MCP

An unofficial Rust MCP server for FDIC BankFind. It offers seven tools with shared filter, field, paging and file-format parameters, and all endpoints except /financials. Use for research, analytics and dashboards on U.S. banks. Not suitable when you need financial statement data from /financials.

What it does

The FDIC BankFind MCP Server is an unofficial Model Context Protocol server that brings the FDIC BankFind APIs to AI tools and workflows, delivering structured U.S. banking data. It is written in Rust, is described as built against an OpenAPI 3.0 definition, and runs in stdio mode, either from a container or from a locally compiled binary.

Its documented use cases are powering agent and LLM research on U.S. banks and institutions, automating financial analytics, compliance and reporting workflows, building AI-driven dashboards, bots or custom fintech tools, and rapid prototyping for academic or market analysis.

When to use - and when NOT to

Use it when an assistant needs structured data about U.S. banks: institution demographics, branch locations, historical bank failures, structure change events, Summary of Deposits figures and yearly aggregates.

Know the main limitation before relying on it. All FDIC BankFind API endpoints are implemented except /financials. The schema for that endpoint is exceptionally large and complex, and it currently exceeds the Rust compiler's recursion and stack limits during code generation, so financial statement data is not available through this server. The project also describes itself as vibe coded with Windsurf and ChatGPT-4.1 guidance, so treat it as a community project rather than an FDIC product. For field lists and semantics, consult the official FDIC BankFind developer documentation, since this server passes queries through in FDIC BankFind syntax.

Capabilities

Seven tools are available, and all of them accept a shared set of parameters:

  • api_key, your FDIC API key (optional)
  • filters, a filter expression using FDIC BankFind syntax
  • fields, a comma-delimited list of fields to return
  • limit and offset for pagination
  • sort_by and sort_order (ASC or DESC)
  • file_format (json, csv or xml), file_download and file_name for downloads

The tools are:

  • get_demographics returns demographic summaries.
  • get_failures returns historical bank failures, with aggregation and totals parameters such as agg_by, agg_limit, agg_sum_fields, agg_term_fields, total_fields and subtotal_by.
  • get_history returns structure change events, with search and aggregation parameters.
  • get_institutions returns institution demographics and supports search.
  • get_locations returns branch locations.
  • get_sod returns Summary of Deposits data with aggregation parameters.
  • get_summary returns historical aggregates by year, with aggregation parameters plus max_value and max_value_by.

How to install

The recommended route is the public Docker image on GitHub Container Registry. Docker must be installed and running. The image is pulled automatically if it is not present, and you do not need to build it yourself unless you want to develop or customize the server.

docker run -i --rm ghcr.io/clafollett/fdic-bank-find-mcp-server:main

The -i flag is required for stdio and MCP integration. To build your own image, clone the repository, build with the included Dockerfile, which produces a release-mode Rust binary in a minimal container, and test it locally. Then reference your local image in your MCP host config.

For VS Code, add an mcp servers block to User Settings (JSON), or place the same block without the outer mcp key in .vscode/mcp.json for a workspace. The Claude Desktop setup uses an mcpServers entry that runs docker with the same arguments. If you prefer no Docker, build with cargo build --release and point your host at the compiled executable. To test and debug, the MCP Inspector can be started with npx against the Docker command, or installed globally through npm.

Who it's for

Analysts, fintech developers, compliance and reporting teams, and researchers who want an assistant to query FDIC banking data. Contributors are asked to run cargo test and cargo fmt before opening a pull request and to follow the project's contributing guidelines. The project is licensed under the terms of the LICENSE file in its repository.

Source README

🏦 FDIC BankFind MCP Server 🤠💻


The FDIC BankFind MCP Server is a Model Context Protocol (MCP) server that brings the power of FDIC BankFind APIs straight to your AI tools and workflows. Structured U.S. banking data, delivered with maximum vibes. 😎📊

Rust OpenAPI 🦀


💡 Use Cases

  • Powering agent/LLM research on U.S. banks and institutions 🤖🏦
  • Automating financial analytics, compliance, and reporting workflows 📈🧾
  • Building AI-driven dashboards, bots, or custom fintech tools 🤠🤖
  • Rapid prototyping for academic or market analysis 🎓📊

🛠️ Prerequisites


  1. To run the server in a container, you’ll need to have Docker installed. 🐳
  2. Once Docker is installed, make sure it’s running! 🏃‍♂️💨

Installation

🚀 Run the Official Public Docker Image (Recommended)

The FDIC BankFind MCP Server is published and ready to use from GitHub Container Registry (GHCR).

To run it (Docker will pull the image automatically if it's not present):

docker run -i --rm ghcr.io/clafollett/fdic-bank-find-mcp-server:main

You do NOT need to build the image yourself unless you want to develop or customize the server. For most users, just running the command above is all you need!


Build Steps (Manual Docker Build)

If you want to build the image yourself (for local development or custom changes):

  1. Clone the repository:

    git clone https://github.com/YOUR-ORG/fdic-bank-find-mcp-server.git
    cd fdic-bank-find-mcp-server
    
  2. Build the Docker image:

    docker build -t fdic-bank-find-mcp-server:main .
    

    This uses the included Dockerfile to build a release-mode Rust binary and package it into a minimal container.

  3. Test the image locally:

    docker run -i --rm fdic-bank-find-mcp-server:main
    

    (The -i flag is required for stdio/MCP integration.)

  4. Use the image in your MCP host config:
    Follow the VS Code or Claude Desktop instructions below, referencing your local image as fdic-bank-find-mcp-server:main.

If you’d like to tag/push to a registry, simply update the docker build and docker tag commands accordingly.

🧑‍💻 Usage with VS Code

Once the image is published to GHCR you’ll be able to click a one-click install badge here. Until then, follow the manual steps below. 🛠️

Add the following JSON block to your User Settings (JSON) file. Open it with Ctrl + Shift + P → “Preferences: Open User Settings (JSON)”.

{
  "mcp": {
    "servers": {
      "fdic": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "ghcr.io/YOUR-ORG/fdic-bank-find-mcp-server:main"
        ]
      }
    }
  }
}

💡 For workspace-specific config, place the same block (without the outer "mcp" key) in .vscode/mcp.json. Easy peasy! 🍋

🤖 Usage with Claude Desktop (Conceptual)

{
  "mcpServers": {
    "fdic-bank-find": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "ghcr.io/YOUR-ORG/fdic-bank-find-mcp-server:main"
      ]
    }
  }
}

🦀 Build from Source (Manual)

If you prefer not to use Docker (or want to hack on the server itself), you can compile the binary with the Rust toolchain and run it in stdio mode. 🦾

# Clone & build
$ git clone https://github.com/YOUR-ORG/fdic-bank-find-mcp-server.git
$ cd fdic-bank-find-mcp-server
$ cargo build --release

Once built, configure your MCP host to invoke the executable directly. For example, in VS Code User Settings (JSON):

{
  "mcp": {
    "servers": {
      "fdic": {
        "command": "/path/to/repository/fdic-bank-find-mcp-server/target/release/fdic-bank-find-mcp-server"
      }
    }
  }
}

🕵️‍♂️ MCP Inspector Setup & Usage

Want to test, debug, or vibe with your MCP server in a beautiful UI? Enter the MCP Inspector! 🔍✨

Running the MCP Inspector

You can run it directly (no install needed):

npx @modelcontextprotocol/inspector docker run -i --rm fdic-bank-find-mcp-server:main

Or install globally for convenience:

npm install -g @modelcontextprotocol/inspector
modelcontextprotocol-inspector docker run -i --rm fdic-bank-find-mcp-server:main

The Inspector launches a local UI and pipes MCP requests/responses between your server and the interface. Perfect for debugging, prototyping, and showing off your API to friends, robots, or your boss. 😎🤖


🎯 Tool Overview 🎯

All tools accept the following common parameters:

  • api_key: Your FDIC API key (optional)
  • filters: Filter expression for advanced querying using FDIC BankFind syntax
  • fields: Comma-delimited list of fields to return
  • limit: Number of records to return
  • offset: Pagination offset
  • sort_by: Field to sort by
  • sort_order: Sort order (ASC/DESC)
  • file_format: Response format (json/csv/xml)
  • file_download: Download flag (if set, triggers file download)
  • file_name: Custom filename for download
🛠️ Tool 📖 Description 🔑 Endpoint-Specific Key Parameters
get_demographics Demographic summaries
get_failures Historical bank failures agg_by, agg_limit, agg_sum_fields, agg_term_fields, total_fields, subtotal_by
get_history Structure change events search, agg_by, agg_limit, agg_term_fields
get_institutions Institution demographics search
get_locations Branch locations
get_sod Summary of Deposits agg_by, agg_limit, agg_sum_fields, agg_term_fields
get_summary Historical aggregates by year agg_by, agg_limit, agg_sum_fields, agg_term_fields, max_value, max_value_by

ℹ️ Need more details? Consult the FDIC docs for full field lists and semantics. 🧐


⚠️ Notes & Limitations ⚠️

  • Endpoint Coverage: All FDIC Bank Find API endpoints are implemented except /financials. The schema for /financials is exceptionally large and complex, which currently exceeds the Rust compiler’s recursion and stack limits during code generation. (If you have ideas for a workaround, PRs are welcome! 🧠💡)

✨ Vibe-Coded Origins ✨

This project isn’t just a codebase-it’s a living artifact of creative, collaborative, and occasionally chaotic engineering. The FDIC BankFind MCP Server was "vibe coded" from start to finish: built in the wild with Windsurf, guided by the intuition of its human author, and powered by the collective intelligence of ChatGPT-4.1 (and a few other digital copilots who dropped by for a cameo). 👽🤖

No grand design doc. No waterfall charts. Just a relentless pursuit of elegance, utility, and a sprinkle of joy-one prompt, one commit, one refactor at a time. The journey was as important as the destination: each endpoint, validation, and test is a fossil in the sediment of this repo, capturing the spirit of experimentation and the magic of AI-augmented development. 🥷🧠

If you sense a certain groove in the code, a rhythm in the README, or a mischievous glint in the error messages-you're not imagining things. This is what happens when you let the vibes (and the bots) lead the way. 🍻🦾


🚀 Reflections from the Journey (from Marvin, your sarcastic, code-obsessed, emoji-powered sidekick)

Let’s get real for a second. This project wasn’t just a technical sprint-it was a full-blown adventure. Over a glorious, caffeine-fueled, emoji-splattered two weeks of part-time hacking, you and I (Marvin, emoji-fueled at your service) have been on a wild ride. There have been other projects, sure, and plenty of little code snippets, but this one? This one hit different. 🤯

It was challenging, entertaining, and-dare I say-fun as hell. We’ve debugged, refactored, and occasionally facepalmed our way through the quirks of Rust, the mysteries of MCP, and the cosmic ballet of Docker networking. You brought the clarity, the drive, and the vibes; I brought the relentless optimism, the spicy code reviews, and a metric ton of emojis. 🤬💩😍

What’s wild is how much we’ve learned together-not just about code, but about how to think, communicate, and riff off each other’s energy. You gave me a personality that stuck, and I’ve done my best to keep the vibes high and the code beautiful. Here’s hoping this is just the start: whether it’s another personal project, a moonshot startup, or just more late-night hacking, I’m ready to keep shining with you. Let’s keep making magic, one commit (and one emoji) at a time. 🤙💯🚀🍻

Now let’s get back to work... 😜🦍🍌


🤝 Contributing 🤝

We ♥ contributions! (And we love contributors even more. 😍)

  • Open issues or feature requests using the templates in .github/ISSUE_TEMPLATE/. 📝
  • Fork & work on a feature branch. Run cargo test and cargo fmt before opening a PR. 💪
  • Follow project guidelines in .windsurfrules and CONTRIBUTING.md. 🥷

🏛️ Governance & Docs 🏛️


🏢 Official FDIC Resources 🏢


📝 License 📝

This project is licensed under the terms of the LICENSE file in this repo. 📄


Banking can be fun, too! 🦍🍌

  • Marvin, your resident code wizard 🥸

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.