Skip to content
Back to search

mcp-security

SkillOfficial: GoogleGitHub

Google Security Operations and Threat Intelligence MCP Server

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/google--mcp-security/badge.svg)](/listings/google--mcp-security)

HTML

<a href="/listings/google--mcp-security"><img src="/api/listings/google--mcp-security/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

You can install the packages using `uv tool install` (recommended):

# Install packages
uv tool install google-secops-mcp
uv tool install gti-mcp
uv tool install scc-mcp
uv tool install secops-soar-mcp

Alternatively, you can use pip:

pip install google-secops-mcp
pip install gti-mcp
pip install scc-mcp
pip install secops-soar-mcp

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 406 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Google Security Operations and Threat Intelligence MCP Server
  2. This repository contains Model Context Protocol (MCP) servers that enable MCP clients (like Claude Desktop or the cline.bot VS Code extension) to access Google's security products and services:
  3. 1. **Remote MCP Server for Google SecOps** - Fully managed, enterprise-ready MCP server (Recommended)
  4. 2. **Google Security Operations (Chronicle)** - For threat detection, investigation, and hunting
  5. 3. **Google Security Operations SOAR** - For security orchestration, automation, and response
  6. 4. **Google Threat Intelligence (GTI)** - For access to Google's threat intelligence data
  7. 5. **Security Command Center (SCC)** - For cloud security and risk management
  8. For the new **Remote MCP Server**, please see the [launch announcement](https://security.googlecloudcommunity.com/community-blog-42/google-cloud-remote-mcp-server-for-secops-6559) and the [setup guide](docs/remote_server.md).
  9. Each server can be enabled and run separately, allowing flexibility for environments that don't require all capabilities.
  10. ## Documentation
  11. Comprehensive documentation is available in the `docs` folder. You can:
  12. 1. Read the markdown files directly in the repository
  13. 2. View the documentation website at [https://google.github.io/mcp-security/](https://google.github.io/mcp-security/)
  14. 3. Generate HTML documentation locally using Sphinx (see instructions in the docs folder)
  15. The documentation covers:
  16. - Detailed information about each MCP server
  17. - Configuration options and requirements
  18. - Usage examples and best practices
  19. To get started with the documentation, see [docs/index.md](docs/index.md).
  20. ## Authentication
  21. The server uses Google's authentication. Make sure you have either:
  22. 1. Set up Application Default Credentials (ADC)
  23. 2. Set a GOOGLE_APPLICATION_CREDENTIALS environment variable
  24. 3. Used `gcloud auth application-default login`
  25. ## Standalone Usage
  26. Each MCP server can be installed and used as a standalone package.
  27. ### Installation
  28. You can install the packages using `uv tool install` (recommended):
  29. ```bash
  30. # Install packages
  31. uv tool install google-secops-mcp
  32. uv tool install gti-mcp
  33. uv tool install scc-mcp
  34. uv tool install secops-soar-mcp
  35. ```
  36. Alternatively, you can use pip:
  37. ```bash
  38. pip install google-secops-mcp
  39. pip install gti-mcp
  40. pip install scc-mcp
  41. pip install secops-soar-mcp
  42. ```
  43. ### Running Standalone
  44. After installation, you can run the servers directly using uvx:
  45. ```bash
  46. # Run SecOps MCP server
  47. uvx --from google-secops-mcp secops_mcp
  48. # Run GTI MCP server
  49. uvx gti_mcp
  50. # Run SCC MCP server
  51. uvx scc_mcp
  52. # Run SecOps SOAR MCP server (with optional integrations)
  53. uvx secops_soar_mcp --integrations CSV,OKTA
  54. ```
  55. With environment variables:
  56. ```bash
  57. CHRONICLE_PROJECT_ID="your-project-id" \
  58. CHRONICLE_CUSTOMER_ID="01234567-abcd-4321-1234-0123456789ab" \
  59. CHRONICLE_REGION="us" \
  60. uvx secops_mcp
  61. ```
  62. ### Using with MCP Clients (Recommended)
  63. You can configure MCP clients to use the installed packages with uvx. Here's an example configuration:
  64. ```json
  65. {
  66. "mcpServers": {
  67. "secops": {
  68. "command": "uvx",
  69. "args": [
  70. "--from",
  71. "google-secops-mcp",
  72. "secops_mcp"
  73. ],
  74. "env": {
  75. "CHRONICLE_PROJECT_ID": "your-project-id",
  76. "CHRONICLE_CUSTOMER_ID": "01234567-abcd-4321-1234-0123456789ab",
  77. "CHRONICLE_REGION": "us"
  78. }
  79. },
  80. "gti": {
  81. "command": "uvx",
  82. "args": [
  83. "gti_mcp"
  84. ],
  85. "env": {
  86. "VT_APIKEY": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
  87. }
  88. },
  89. "scc-mcp": {
  90. "command": "uvx",
  91. "args": [
  92. "scc_mcp"
  93. ],
  94. "env": {}
  95. },
  96. "secops-soar": {
  97. "command": "uvx",
  98. "args": [
  99. "secops_soar_mcp",
  100. "--integrations",
  101. "CSV,OKTA"
  102. ],
  103. "env": {
  104. "SOAR_URL": "https://yours-here.siemplify-soar.com:443",
  105. "SOAR_APP_KEY": "01234567-abcd-4321-1234-0123456789ab"
  106. }
  107. }
  108. }
  109. }
  110. ```
  111. You can also use environment files with uvx:
  112. ```json
  113. {
  114. "mcpServers": {
  115. "secops": {
  116. "command": "uvx",
  117. "args": [
  118. "--env-file",
  119. "/path/to/.env",
  120. "secops_mcp"
  121. ]
  122. }
  123. }
  124. }
  125. ```
  126. ## Client Configurations
  127. The MCP servers from this repo can be used with the following clients
  128. 1. Cline, Claude Desktop, and other MCP supported clients
  129. 2. [Google ADK(Agent Development Kit)](https://google.github.io/adk-docs/) Agents (a prebuilt agent is provided, details [below](#using-the-google-adk-autonomous-soc-agent))
  130. 3. [Google SecOps Extension](https://google.github.io/mcp-security/google_secops_extension.html) - Install our example extension for Gemini CLI to get specialized security skills (Triage, Investigate, Hunt).
  131. The configuration for Claude Desktop and Cline is the same (provided below for [uv](#using-uv-recommended) and [pip](#using-pip)). We use the stdio transport.
  132. ### Using the Google ADK Autonomous SOC Agent
  133. The repository includes a prebuilt Autonomous Security Operations Center (SOC) Agent powered by Google ADK v2 and the Model Context Protocol in [`run-with-google-adk`](./run-with-google-adk/README.md).
  134. It can be run locally via an interactive CLI REPL or launched as a FastAPI service for Google Cloud Run:
  135. ```bash
  136. cd run-with-google-adk
  137. cp .env.example .env
  138. # Interactive terminal investigation REPL
  139. uv run mcp-security-agent chat
  140. # Web UI and Cloud Run REST API server
  141. uv run mcp-security-agent serve --port 8080
  142. ```
  143. For full setup, architecture details, and Cloud Run deployment guides, see the [ADK Agent Guide](./run-with-google-adk/README.md).
  144. ## MCP Client Config Locations
  145. MCP clients all use the same JSON configuration format (see the [MCP Server Configuration Reference](https://google.github.io/mcp-security/usage_guide.html#mcp-server-configuration-reference)), but they expect the file in different locations.
  146. | Client Application | Scope | macOS / Linux Location | Windows Location | Notes |
  147. | ------------------------ | --------- | ------------------------------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  148. | **Gemini CLI** | Global | `~/.gemini/settings.json` | `%USERPROFILE%\.gemini\settings.json` | File must include `mcpServers`. Confirmed in [Google Security Ops post](https://security.googlecloudcommunity.com/google-security-operations-2/google-cloud-security-mcp-servers-in-gemini-cli-922). |
  149. | **Claude Desktop** | Global | `~/Claude/claude_desktop_config.json` | `%USERPROFILE%\Claude\claude_desktop_config.json` | Config accessible via *Claude > Settings > Developer > Edit Config*. |
  150. | **Claude Code** | Global | `~/.claude.json` | `%USERPROFILE%\.claude.json` | Primary config file for Claude Code CLI and extensions. |
  151. | **Cursor IDE (Global)** | Global | `~/.cursor/mcp.json` | `%USERPROFILE%\.cursor\mcp.json` | Enables MCP servers globally across all projects. |
  152. | **Cursor IDE (Project)** | Project | `<project-root>/.cursor/mcp.json` | `<project-root>/.cursor/mcp.json` | Workspace/project-specific config file. |
  153. | **VS Code (Workspace)** | Workspace | `<project-root>/.vscode/mcp.json` | `<project-root>/.vscode/mcp.json` | Workspace-level config used when an MCP extension (like **Cline**) is installed. Overrides global config if present. |
  154. | **Cline (VS Code Ext.)** | Global | Inside VS Code extension data | `%APPDATA%\Code\User\globalStorage\<extension-id>\settings\cline_mcp_settings.json` | Exact path varies by VS Code variant and platform. `<extension-id>` corresponds to the installed extension folder (e.g., `saoudrizwan.claude-dev`). |
  155. ### Additional Notes for Windows
  156. - `%USERPROFILE%` → `C:\Users\<username>`
  157. - `%APPDATA%` → `C:\Users\<username>\AppData\Roaming`
  158. - `<project-root>` → folder opened in VS Code or IDE for the project
  159. - `<extension-id>` → name of the installed extension folder (e.g., `saoudrizwan.claude-dev` for Claude/Cline)
  160. ### Tip: Single Config with Symlinks
  161. If you use multiple MCP clients, you can maintain a **single config file** and symlink it into each expected location. This avoids drift and keeps your server definitions consistent.
  162. ### Using uv (Recommended)
  163. ```json
  164. {
  165. "mcpServers": {
  166. "secops": {
  167. "command": "uv",
  168. "args": [
  169. "--directory",
  170. "/path/to/the/repo/server/secops/secops_mcp",
  171. "run",
  172. "server.py"
  173. ],
  174. "env": {
  175. "CHRONICLE_PROJECT_ID": "your-project-id",
  176. "CHRONICLE_CUSTOMER_ID": "01234567-abcd-4321-1234-0123456789ab",
  177. "CHRONICLE_REGION": "us"
  178. }
  179. },
  180. "secops-soar": {
  181. "command": "uv",
  182. "args": [
  183. "--directory",
  184. "/path/to/the/repo/server/secops-soar/secops_soar_mcp",
  185. "run",
  186. "server.py",
  187. "--integrations",
  188. "CSV,OKTA"
  189. ],
  190. "env": {
  191. "SOAR_URL": "https://yours-here.siemplify-soar.com:443",
  192. "SOAR_APP_KEY": "01234567-abcd-4321-1234-0123456789ab"
  193. }
  194. },
  195. "gti": {
  196. "command": "uv",
  197. "args": [
  198. "--directory",
  199. "/path/to/the/repo/server/gti/gti_mcp",
  200. "run",
  201. "server.py"
  202. ],
  203. "env": {
  204. "VT_APIKEY": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
  205. }
  206. },
  207. "scc-mcp": {
  208. "command": "uv",
  209. "args": [
  210. "--directory",
  211. "/path/to/the/repo/server/scc",
  212. "run",
  213. "scc_mcp.py"
  214. ],
  215. "env": {
  216. }
  217. }
  218. }
  219. }
  220. ```
  221. NOTE: `uv` also supports passing an `.env` file like so:
  222. ```
  223. "command": "uv",
  224. "args": [
  225. "--directory",
  226. "/path/to/the/repo/server/...",
  227. "run",
  228. "--env-file",
  229. "/path/to/the/repo/server/.env",
  230. "server.py"
  231. ]
  232. ```
  233. `SOAR_APP_KEY` and `VT_APIKEY` are good candidates for `.env`
  234. ### Using pip
  235. You can also use pip instead of uv to install and run the MCP servers. This approach uses a bash command to:
  236. 1. Change to the server directory
  237. 2. Install the package in development mode
  238. 3. Run the server binary
  239. ```json
  240. {
  241. "mcpServers": {
  242. "secops": {
  243. "command": "/bin/bash",
  244. "args": [
  245. "-c",
  246. "cd /path/to/the/repo/server/secops && pip install -e . && secops_mcp"
  247. ],
  248. "env": {
  249. "CHRONICLE_PROJECT_ID": "your-project-id",
  250. "CHRONICLE_CUSTOMER_ID": "01234567-abcd-4321-1234-0123456789ab",
  251. "CHRONICLE_REGION": "us"
  252. },
  253. "alwaysAllow": [
  254. ]
  255. },
  256. "gti": {
  257. "command": "/bin/bash",
  258. "args": [
  259. "-c",
  260. "cd /path/to/the/repo/server/gti && pip install -e . && gti_mcp"
  261. ],
  262. "env": {
  263. "VT_APIKEY": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
  264. },
  265. "alwaysAllow": [
  266. ]
  267. },
  268. "scc-mcp": {
  269. "command": "/bin/bash",
  270. "args": [
  271. "-c",
  272. "cd /path/to/the/repo/server/scc && pip install -e . && scc_mcp"
  273. ],
  274. "env": {
  275. },
  276. "alwaysAllow": []
  277. },
  278. "secops-soar": {
  279. "timeout": 60,
  280. "command": "/bin/bash",
  281. "args": [
  282. "-c",
  283. "cd /path/to/the/repo/server/secops-soar && pip install -e . && python secops_soar_mcp/server.py"
  284. ],
  285. "env": {
  286. "SOAR_URL": "https://yours-here.siemplify-soar.com:443",
  287. "SOAR_APP_KEY": "01234567-abcd-4321-1234-0123456789ab"
  288. },
  289. "transportType": "stdio"
  290. }
  291. }
  292. }
  293. ```
  294. ### When to use uv vs pip
  295. - **uv**: Recommended for most users because it offers faster package installation, better dependency resolution, and isolated environments. It also supports loading environment variables from a file.
  296. - **pip**: Use when you prefer the standard Python package manager or when you have specific environment setup requirements.
  297. #### `UV_ENV_FILE`
  298. The `--env-file` option allows `uv` to use a .env file for environment variables. You can create this file or use system environment variables as described in the usage guide.
  299. Alternatively, you can set `UV_ENV_FILE` to your `.env` file and omit the `--env-file` portion of the configuration.
  300. Refer to the [usage guide](docs/usage_guide.md#setting-up-environment-variables) for detailed instructions on how to set up these environment variables.
  301. ### Troubleshooting
  302. Running the MCP Server from the CLI (and outside of your MCP client) can reveal issues:
  303. ```
  304. uv --verbose \
  305. --directory "/Users/dandye/Projects/google-mcp-security/server/scc" \
  306. run \
  307. --env-file "/Users/dandye/Projects/google-mcp-security/.env" \
  308. scc_mcp.py
  309. ```
  310. Check your PATH(s):
  311. ```which uv``` # you may need to restart MCP Client after installing uv
  312. ```which python || which python3```
  313. ```python --version || python3 --version```
  314. ### Installing in Claude Desktop
  315. To use the MCP servers with Claude Desktop:
  316. 1. Install Claude Desktop
  317. 2. Open Claude Desktop and select "Settings" from the Claude menu
  318. 3. Click on "Developer" in the lefthand bar, then click "Edit Config"
  319. 4. Update your `claude_desktop_config.json` with the configuration (replace paths with your actual paths)
  320. 5. Save the file and restart Claude Desktop
  321. 6. You should now see the hammer icon in the Claude Desktop interface, indicating the MCP server is active
  322. ### Installing in cline (vscode extension)
  323. 1. Install cline.bot extension in VSCode
  324. 2. Update your `cline_mcp_settings.json` with the configuration (replace paths with your actual paths)
  325. 3. Save the file and restart VS Code
  326. ## License
  327. Apache 2.0

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.