mcp-server-scf
by MarkAC007
README.md
<p align="center">
<a href="https://scfcontrolsplatform.com/">
<img src="https://raw.githubusercontent.com/MarkAC007/mcp-server-scf/main/docs/assets/banner.png" alt="SCF Controls Platform — MCP server for security compliance, frameworks, and risk management for AI agents. Maintained by ComplianceGenie.io." width="100%">
</a>
</p>
# mcp-server-scf
<!-- Build & Security -->
[](https://github.com/MarkAC007/mcp-server-scf/actions/workflows/ci.yml)
[](https://github.com/MarkAC007/mcp-server-scf/actions/workflows/security.yml)
[](https://scorecard.dev/viewer/?uri=github.com/MarkAC007/mcp-server-scf)
[](https://socket.dev/npm/package/mcp-server-scf)
<!-- Package & License -->
[](https://www.npmjs.com/package/mcp-server-scf)
[](https://www.npmjs.com/package/mcp-server-scf)
[](https://packagephobia.com/result?p=mcp-server-scf)
[](LICENSE)
[](https://modelcontextprotocol.io)
<!-- Registries & Marketplaces -->
[](https://registry.modelcontextprotocol.io/v0/servers?search=scfcontrolsplatform)
<!-- Tech Stack -->
**Security compliance controls, frameworks, and risk management for AI agents.**
Give your AI assistant access to 1,451 SCF security controls, 354+ framework mappings (NIST 800-53, ISO 27001, SOC 2, FedRAMP, GDPR), evidence tracking, risk registers, and vendor risk management — all through the [Model Context Protocol](https://modelcontextprotocol.io).
Built for the **[SCF Controls Platform](https://scfcontrolsplatform.com/)**. Maintained by [ComplianceGenie.io](https://compliancegenie.io).
> 🆕 **The platform is now open-source, self-hosted software.** The SCF Controls Platform — SCF-native GRC tooling for the free Secure Controls Framework content — is published under AGPL-3.0 at **[scf-controls-platform-oss](https://github.com/MarkAC007/scf-controls-platform-oss)**. Companies download and host it themselves via Docker Compose.
> Having trouble? → [**docs/troubleshooting.md**](docs/troubleshooting.md) · API key setup → [**docs/authentication.md**](docs/authentication.md) · How it works → [**docs/architecture.md**](docs/architecture.md)
---
## Overview
`mcp-server-scf` connects AI assistants to the [SCF Controls Platform](https://scfcontrolsplatform.com/) via MCP, enabling natural language interaction with your compliance program. Your AI can browse the full SCF control catalog, track implementation progress, manage evidence collection, assess risks, and monitor third-party vendors — all without leaving your editor or chat.
**42 tools** over **225 platform operations**, in 16 groups. Each tool is one noun and direction — `scf_vendor_read`, `scf_vendor_write` — and its `method` argument picks the operation; the `method` description explains each one. Read tools are `readOnlyHint: true`, so a client can allow them all at once.
Only the **core** groups are in the tool list at startup (26 tools, about 27k tokens of schema instead of 71k). Call `scf_load_tools` with the groups you need — or `all` — and the rest appear; the server sends `notifications/tools/list_changed`. A client that ignores that notification can set `SCF_LOAD_ALL_TOOLS=true` to get everything up front. Per-group docs list every method with its parameters; [`docs/migration-consolidation.md`](docs/migration-consolidation.md) maps each pre-v4 tool name to its tool and method.
| Group | Loaded | Operations | Tools |
| -------------------------------------------------------------- | --------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| [catalog](docs/tools/catalog.md) | core | 8 | `scf_catalog_read` |
| [controls](docs/tools/scoped-controls.md) | core | 15 | `scf_control_read`, `scf_control_write` |
| [evidence](docs/tools/evidence.md) | core | 25 | `scf_evidence_read`, `scf_evidence_write`, `scf_evidence_file_read`, `scf_evidence_file_write`, `scf_list_evidence_tasks`, `scf_evidence_task_write` |
| [assessments](docs/tools/evidence.md) | core | 17 | `scf_assessment_read`, `scf_assessment_write` |
| [risk](docs/tools/risk.md) | core | 19 | `scf_risk_read`, `scf_risk_write`, `scf_custom_risk_read`, `scf_custom_risk_write` |
| [vendors](docs/tools/vendors.md) | core | 23 | `scf_vendor_read`, `scf_vendor_write`, `scf_vendor_record_write` |
| [systems](docs/tools/capabilities.md) | core | 19 | `scf_system_read`, `scf_system_write`, `scf_capability_theme_read` |
| [organization](docs/tools/organization.md) | core | 12 | `scf_org_read`, `scf_update_org_settings`, `scf_user_read`, `scf_mark_notifications_read` |
| [teams](docs/tools/teams.md) | on demand | 11 | `scf_team_read`, `scf_team_write` |
| [collaboration](docs/tools/collaboration.md) | on demand | 7 | `scf_collaboration_read`, `scf_collaboration_write` |
| [documents](docs/tools/documents.md) | on demand | 15 | `scf_document_read`, `scf_document_write` |
| [engagements](docs/tools/engagements.md) | on demand | 16 | `scf_engagement_read`, `scf_engagement_write` |
| [assurance](docs/tools/assurance.md) | on demand | 19 | `scf_assurance_read`, `scf_assurance_write` |
| [catalog-reconciliation](docs/tools/catalog-reconciliation.md) | on demand | 9 | `scf_catalog_reconciliation_read`, `scf_catalog_reconciliation_write` |
| [webhooks](docs/tools/webhooks.md) | on demand | 6 | `scf_webhook_read`, `scf_webhook_write` |
| [journey](docs/tools/journey.md) | on demand | 4 | `scf_journey_read`, `scf_journey_write` |
## Try it with MCP Inspector
Kick the tires without adding the server to a client — [MCP Inspector](https://github.com/modelcontextprotocol/inspector) launches a local UI that introspects every tool, its schema, and its description:
```bash
npx @modelcontextprotocol/inspector npx -y mcp-server-scf
```
Inspector opens on `http://localhost:6274` and connects to `mcp-server-scf` over stdio. You'll see the 26 core tools (set `SCF_LOAD_ALL_TOOLS=true` for all 42), each with a `method` picker and its Zod schema rendered as a live form.
Live tool calls need your instance's URL and an API key — export `SCF_API_URL` and `SCF_API_KEY` in the same shell before launching Inspector, or set them under the "Environment Variables" tab inside the Inspector UI. Without them, you can still browse schemas and descriptions; tool calls return a configuration error.
---
## Quick Start
### 1. Self-host the platform & get an API key
The SCF Controls Platform is **open-source software you host yourself** — there is no sign-up. Deploy it from [scf-controls-platform-oss](https://github.com/MarkAC007/scf-controls-platform-oss) (a Docker Compose stack with bundled PostgreSQL, Redis, and MinIO), then:
1. Set an `API_KEY` in the platform's `.env` (generate one with `openssl rand -hex 32`), or create a key in **Settings → API Keys** once the app is running.
2. Note your instance's API URL — `http://localhost:8000` by default, or your deployed host.
Use that key as `SCF_API_KEY` and the instance URL as `SCF_API_URL` (see [Configuration](#configuration)).
### 2. Install — one-click
Pick the route for your client.
**Claude Desktop** — the one-click path is the signed **[.mcpb Desktop Extension](#claude-desktop-extension-mcpb)** below. Claude Desktop does not register a custom URL scheme, so there is no clickable deeplink; instead you drag the `.mcpb` onto **Settings → Extensions** and paste your API key once. See [anthropics/claude-code#26952](https://github.com/anthropics/claude-code/issues/26952) for the upstream tracking issue.
**Cursor** — click the badge below. Cursor registers the `cursor://` scheme, so the deeplink opens the IDE with the server config pre-filled:
[](cursor://anysphere.cursor-deeplink/mcp/install?name=scf&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIm1jcC1zZXJ2ZXItc2NmIl0sImVudiI6eyJTQ0ZfQVBJX0tFWSI6InNjZl95b3VyX2FwaV9rZXlfaGVyZSIsIlNDRl9BUElfVVJMIjoiaHR0cDovL2xvY2FsaG9zdDo4MDAwIn19)
After install, edit the pre-filled `SCF_API_URL` to point at **your** instance — there is no hosted default.
Prefer to edit config by hand, or on a client without a deeplink (Windsurf, Docker)? See **[3. Manual config](#3-manual-config)** below.
### Claude Desktop Extension (.mcpb)
For Claude Desktop ≥ 0.11.0, the easiest install is a signed `.mcpb` bundle — no JSON editing, no `npx` runtime, no Node required on the host:
1. Download `mcp-server-scf-<version>.mcpb` from the [latest GitHub release](https://github.com/MarkAC007/mcp-server-scf/releases/latest).
2. Double-click the file (or drag it onto Claude Desktop → **Settings → Extensions**).
3. When prompted, paste your `scf_…` API key. It's stored in your OS keychain, not in a config file.
4. Claude Desktop restarts the server and the core tools are available; ask for more with `scf_load_tools`.
To uninstall or update the API key later: **Settings → Extensions → SCF Controls Platform → Configure**.
### 3. Manual config
**Claude Desktop** — edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
```json
{
"mcpServers": {
"scf": {
"command": "npx",
"args": ["-y", "mcp-server-scf"],
"env": {
"SCF_API_KEY": "your_api_key_here",
"SCF_API_URL": "http://localhost:8000"
}
}
}
}
```
**Claude Code:**
```bash
claude mcp add scf -- npx -y mcp-server-scf
export SCF_API_KEY="your_api_key_here"
export SCF_API_URL="http://localhost:8000"
```
**Cursor / Windsurf** — same JSON shape as Claude Desktop in `.cursor/mcp.json` (or the equivalent Windsurf path).
**Docker:**
```json
{
"mcpServers": {
"scf": {
"command": "docker",
"args": ["run", "-i", "--rm", "-e", "SCF_API_KEY", "-e", "SCF_API_URL", "markac007/mcp-server-scf"],
"env": {
"SCF_API_KEY": "scf_your_api_key_here",
"SCF_API_URL": "https://scf.your-domain.example"
}
}
}
}
```
---
## Configuration
| Variable | Required | Default | Description |
| ------------- | -------- | ------- | ------------------------------------------------------------------------------------------------------------------ |
| `SCF_API_KEY` | Yes | — | API key from your self-hosted platform instance |
| `SCF_API_URL` | Yes | — | Base URL of your self-hosted platform (e.g. `http://localhost:8000`). The former hosted default is decommissioned. |
---
`SCF_LOAD_ALL_TOOLS=true` lists every tool at startup instead of the core groups — for a client that does not act on `notifications/tools/list_changed` after `scf_load_tools`.
**Remote (Streamable HTTP):** `mcp-server-scf-http` serves the same tools by URL for a hosted, multi-user deployment. No server-side key: each caller sends their own `Authorization: Bearer scf_…`, forwarded to the one platform in `SCF_API_URL`. Connect with `claude mcp add --transport http scf https://<host>/mcp --header "Authorization: Bearer scf_…"`. Details and a hardened Compose example in [docs/authentication.md](docs/authentication.md#remote-streamable-http--bring-your-own-key).
## Example Prompts
Once connected, try asking your AI assistant:
- "What NIST 800-53 controls apply to access control?"
- "Show me my organization's control implementation progress."
- "List all critical vendors and their risk scores."
- "Create a risk assessment for our cloud migration."
- "What evidence do I need to collect for SOC 2 audit?"
- "Show the 5x5 risk matrix for my organization."
- "Run a DPSIA on our cloud provider vendor."
More examples live in each per-domain doc under [`docs/tools/`](docs/tools/).
---
## Documentation
- [**docs/authentication.md**](docs/authentication.md) — API key setup, rotation, self-hosted URL configuration, scopes.
- [**docs/architecture.md**](docs/architecture.md) — request flow, error model, rate limiting, what the server does and does not do.
- [**docs/troubleshooting.md**](docs/troubleshooting.md) — symptom/cause/fix for the common failure modes.
- [**docs/tools/**](docs/tools/) — per-domain reference with full parameter tables.
---
## Security
- API keys are never logged or included in error messages.
- Keys are SHA-256 hashed server-side. Use HTTPS for any instance reachable beyond localhost.
- Rate limiting: 100 req/min read, 20 req/min write.
- Multi-tenant — all operations scoped to your organization.
- npm package published with [provenance attestation](https://docs.npmjs.com/generating-provenance-statements) via OIDC trusted publishing.
- CI includes Gitleaks secret detection, CodeQL analysis, and Semgrep SAST.
See [SECURITY.md](SECURITY.md) to report a vulnerability.
---
## Privacy Policy
`mcp-server-scf` is a stateless connector — it stores no user data itself. All data flows directly between your MCP client and your own SCF Controls Platform instance, authenticated with your API key; nothing is sent to, or retained by, any third party. See the full [privacy policy](https://scfcontrolsplatform.com/privacy) for details.
---
## Development
```bash
git clone https://github.com/MarkAC007/mcp-server-scf.git
cd mcp-server-scf
npm install
npm run build
npm run dev # Watch mode
npm run lint # ESLint
npm test # Vitest
```
### Testing with MCP Inspector
```bash
SCF_API_KEY=scf_your_key npx @modelcontextprotocol/inspector node build/index.js
```
---
## Contributing
Contributions welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md) before submitting PRs.
This project follows the [Contributor Covenant](https://www.contributor-covenant.org/) — see [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.
1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request
---
## License
MIT — see [LICENSE](LICENSE).
---
## Links
- [scf-controls-platform-oss](https://github.com/MarkAC007/scf-controls-platform-oss) — the open-source, self-hosted platform (AGPL-3.0)
- [ComplianceGenie.io](https://compliancegenie.io) — maintainer
- [Model Context Protocol](https://modelcontextprotocol.io) — MCP specification
- [SCF Framework](https://securecontrolsframework.com) — Secure Controls Framework
- [npm Package](https://www.npmjs.com/package/mcp-server-scf) — npm registry
- [Changelog](CHANGELOG.md) — release history
TDQS
B3.4/5.0
Scored across 26 tools
Disambiguation4/5
Most tools are cleanly partitioned by domain (evidence, risks, vendors, controls, systems) and by read vs write, so tool selection is usually straightforward. However, the evidence area has several adjacent tools (tracking, files, tasks, and AI assessments), and work-queue/notification operations appear across org/user reads and standalone notification tools, creating some boundary ambiguity.
Naming Consistency4/5
The dominant pattern is scf_<domain>_<read|write>, used consistently across most paired domains. A few standalone names switch to verb_noun form (scf_load_tools, scf_list_evidence_tasks, scf_mark_notifications_read, scf_update_org_settings), and there are asymmetric pairs such as evidence_task_write with no matching read, so it is not fully uniform.
Tool Count3/5
26 tools is heavy for a single server and sits above the typical 3–15 range. The breadth of the SCF domain and the read/write pairing across many entities make it less excessive than the raw count suggests, but it is still borderline crowded and some standalone tools could be consolidated.
Completeness4/5
Core SCF operations are well covered: catalog/reference reads, control scoping, evidence tracking/files/tasks, assessments, risks, vendors, systems, org settings, and user notifications mostly have read and write paths. Gaps remain: evidence-task reading is only exposed via a list tool, notification reading is implied but not present as its own tool, and org/member administration is limited; load_tools mitigates missing groups but the current surface is not fully complete.
Maintenance
ActivityActive
ResponsivenessWithin a week