About MCP Census Server
An MCP server for accessing US Census Bureau data through JSON-RPC over HTTP. It is intended for applications and clients that need Census data, and includes response caching, API-key authentication, and a Next.js client.
Key features
- 01Retrieve Census data with census/get
- 02JSON-RPC single and batch requests
- 03Cache API responses for five minutes
- 04Validate requests and responses with Pydantic
- 05API-key auth, health check, and interactive docs
- 06Included Next.js client
Use cases
- 01Query Census Bureau data through an MCP tool
- 02Connect Census data to the Next.js client
- 03Protect service requests with an API key
MCP support
The server implements MCP initialization, tool listing, and tool calls, exposing census/get to clients through JSON-RPC over HTTP.
Configuration
Local server config is the same for every client. Copy it into your client’s MCP config file.
We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.
Tools
Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.
Details
From the project READMEMCP Census Server
A robust Model Context Protocol (MCP) server for accessing US Census Bureau data via JSON-RPC over HTTP.
Features
- JSON-RPC 2.0 (single and batch requests)
- Pydantic models for request/response validation
- Caching of Census API responses (TTL 5 minutes)
- Structured logging (via Python
logging) - API key authentication via
X-API-Keyheader - Health check endpoint (
/health) - Interactive API docs (Swagger UI available at
/docs) - MCP methods:
initialize: negotiate protocol version and capabilitiesnotifications/initialized: client ready notificationtools/list: list available tools (census/get)tools/call: invokecensus/getto retrieve Census Bureau data
Quickstart
- Clone the repository and enter the directory:
git clone https://github.com/kaman1/mcp_census_server.git cd mcp_census_server - Copy the environment template and set your keys:
cp .env.example .env # Edit .env: # CENSUS_API_KEY=<your_census_api_key> # SERVER_API_KEY=<your_mcp_server_secret_key> - Install dependencies:
pip install -r requirements.txt - Start the server:
uvicorn app:app --host 0.0.0.0 --port 8000 --reload - Send JSON-RPC requests to
http://localhost:8000/with headerX-API-Key: <SERVER_API_KEY>.
Example tools/list call:
curl -X POST http://localhost:8000/ \
-H "Content-Type: application/json" \
-H "X-API-Key: $SERVER_API_KEY" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
Development
- Tests:
pytest - Formatting:
black . - Imports:
isort . - Linting:
flake8 . - CI pipeline configured in
.github/workflows/ci.yml
Documentation
- Architecture:
docs/architecture.md - Usage Examples:
docs/usage.md - Authentication:
docs/authentication.md - Styled Documentation (MDX + Mintlify):
npm install npm run serve:docs
Hosted Documentation
You can publish these docs via GitHub Pages:
- In your GitHub repository, go to Settings > Pages.
- Under Source, choose the main branch and
/docsfolder. - Click Save.
The docs will be available at:
https://<username>.github.io/mcp_census_server/
You can add this URL in the repository About section as the project website.
Client Application
The client/ directory contains a Next.js-based MCP client that can interact with this server.
- Change into the client folder:
cd client - Copy the example environment file and fill in your keys and server URL:
cp .env.example .env.local # Set OPENAI_API_KEY, MCP_SERVER_URL (e.g. https://your-server), SERVER_API_KEY - Install dependencies and start the development server:
npm install npm run dev - Open http://localhost:3000 to use the client UI.
Quick Start Script
You can configure environments and launch both server and client in one step:
chmod +x start.sh
./start.sh
This will prompt for all required keys and run the MCP server and client concurrently.
Comments
New to MCP?
From what the protocol is to installing your first server, these answers cover most first questions.
An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.