Skip to main content
Glama
Google Threat Intelligence MCP Server

Google Threat Intelligence MCP Server

by googleSandy

Google Threat Intelligence MCP Server (Standalone)

This is a standalone MCP (Model Context Protocol) server for interacting with Google's Threat Intelligence suite. It provides AI assistants like Claude with access to comprehensive threat intelligence capabilities through both local development and production cloud deployment modes.

GTI MCP Server Screenshot

Key Capabilities:

  • šŸ” Threat intelligence search (campaigns, threat actors, malware families)

  • šŸ“ File analysis and behavior reports

  • 🌐 Domain, IP, and URL reputation checking

  • šŸŽÆ IOC (Indicator of Compromise) search

  • šŸ“Š Threat profiles and hunting rulesets

Learn more about MCP

Architecture

Understanding how GTI MCP Server works in different deployment modes:

Component Overview

graph TB
    subgraph "MCP Clients"
        A1[Claude Desktop]
        A2[Cline]
        A3[Cursor]
        A4[Custom Frontend]
    end

    subgraph "Transport Layer"
        B1[stdio - Local]
        B2[SSE/HTTP - Remote]
    end

    subgraph "GTI MCP Server"
        C1[MCP Tools]
        C2[VT API Client]
    end

    D[VirusTotal/GTI API]

    A1 --> B1
    A2 --> B1
    A3 --> B1
    A4 --> B2

    B1 --> C1
    B2 --> C1

    C1 --> C2
    C2 --> D

    style C1 fill:#e1f5ff
    style C2 fill:#e1f5ff

Local Deployment Flow

For individual developers running the MCP server locally:

sequenceDiagram
    participant Client as MCP Client
    participant Server as GTI MCP Server
    participant Env as Environment
    participant VT as VirusTotal API

    Client->>Server: Launch via stdio
    Server->>Env: Read VT_APIKEY
    Env-->>Server: API Key
    Client->>Server: Call tool (e.g., get_file_report)
    Server->>VT: API Request with VT_APIKEY
    VT-->>Server: Response
    Server-->>Client: Tool Result

API Key Management: Server reads VT_APIKEY from environment variables at startup.

Cloud Deployment Flow

For teams deploying a centralized service:

sequenceDiagram
    participant Frontend as Frontend Client
    participant CloudRun as Cloud Run (SSE)
    participant Auth as Auth Middleware
    participant Server as GTI MCP Server
    participant VT as VirusTotal API

    Frontend->>CloudRun: Connect to /sse endpoint
    CloudRun->>Auth: Validate X-Mcp-Authorization header
    Auth-->>CloudRun: Authorized
    CloudRun-->>Frontend: SSE Connection Established

    Frontend->>CloudRun: Call tool with api_key parameter
    CloudRun->>Server: Execute tool
    Server->>VT: API Request with client-provided api_key
    VT-->>Server: Response
    Server-->>CloudRun: Tool Result
    CloudRun-->>Frontend: SSE Event with Result

API Key Management: Clients pass api_key parameter with each tool call. Server authenticates connection via MCP_AUTH_TOKEN but uses client-provided API keys for VirusTotal requests.

Security Note: This architecture allows teams to deploy a shared MCP server while maintaining individual user API quotas and access controls.

Related MCP server: Malware Analysis MCP Server

Features

Collections (Threats)

  • get_collection_report(id): Retrieves a specific collection report by its ID (e.g., report--<hash>, threat-actor--<hash>).

  • get_entities_related_to_a_collection(id, relationship_name, limit=10): Gets related entities (domains, files, IPs, URLs, other collections) for a given collection ID.

  • get_collection_timeline_events(id): Retrieves curated timeline events for a collection.

  • get_collection_rules(id): Gets detection rules (YARA and Sigma) associated with a collection.

  • get_collection_feature_matches(id): Retrieves feature matches for a collection.

  • get_collection_mitre_tree(id): Gets the MITRE ATT&CK framework tree for a collection.

  • get_collections_commonalities(ids): Finds commonalities between multiple collections.

  • create_collection(name, description): Creates a new threat collection.

  • update_collection_attributes(id, attributes): Updates metadata and attributes for a collection.

  • update_iocs_in_collection(id, iocs): Updates indicators of compromise in a collection.

  • search_threats(query, limit=5, order_by="relevance-"): Performs a general search for threats (collections) using GTI query syntax.

  • search_campaigns(query, limit=10, order_by="relevance-"): Searches specifically for collections of type campaign.

  • search_threat_actors(query, limit=10, order_by="relevance-"): Searches specifically for collections of type threat-actor.

  • search_malware_families(query, limit=10, order_by="relevance-"): Searches specifically for collections of type malware-family.

  • search_software_toolkits(query, limit=10, order_by="relevance-"): Searches specifically for collections of type software-toolkit.

  • search_threat_reports(query, limit=10, order_by="relevance-"): Searches specifically for collections of type report.

  • search_vulnerabilities(query, limit=10, order_by="relevance-"): Searches specifically for collections of type vulnerability.

Files

  • get_file_report(hash): Retrieves a comprehensive analysis report for a file based on its MD5, SHA1, or SHA256 hash.

  • get_entities_related_to_a_file(hash, relationship_name, limit=10): Gets related entities (domains, IPs, URLs, behaviours, etc.) for a given file hash.

  • get_file_behavior_report(file_behaviour_id): Retrieves a specific sandbox behavior report for a file.

  • get_file_behavior_summary(hash): Retrieves a summary of all sandbox behavior reports for a file hash.

  • analyse_file(file_path): Uploads and analyzes a file, returning a comprehensive threat intelligence report.

  • search_iocs(query, limit=10, order_by="last_submission_date-"): Searches for Indicators of Compromise (files, URLs, domains, IPs) using advanced GTI query syntax.

  • search_digital_threat_monitoring(query, limit=10): Searches digital threat monitoring data for brand protection, phishing, and impersonation threats.

Network Locations (Domains & IPs)

  • get_domain_report(domain): Retrieves a comprehensive analysis report for a domain.

  • get_entities_related_to_a_domain(domain, relationship_name, limit=10): Gets related entities for a given domain.

  • get_ip_address_report(ip_address): Retrieves a comprehensive analysis report for an IPv4 or IPv6 address.

  • get_entities_related_to_an_ip_address(ip_address, relationship_name, limit=10): Gets related entities for a given IP address.

URLs

  • get_url_report(url): Retrieves a comprehensive analysis report for a URL.

  • get_entities_related_to_an_url(url, relationship_name, limit=10): Gets related entities for a given URL.

Hunting

  • get_hunting_ruleset: Get a Hunting Ruleset object from Google Threat Intelligence.

  • get_entities_related_to_a_hunting_ruleset: Retrieve entities related to the given Hunting Ruleset.

Threat Profiles

  • list_threat_profiles: List your Threat Profiles at Google Threat Intelligence.

  • get_threat_profile(profile_id): Get Threat Profile object.

  • get_threat_profile_recommendations(profile_id, limit=10): Returns the list of objects associated to the given Threat Profile.

  • get_threat_profile_associations_timeline(profile_id): Retrieves the associations timeline for the given Threat Profile.

Quick Start (Local Development)

For developers who want to use GTI MCP Server with Claude Desktop, Cline, Cursor, or other MCP clients.

Prerequisites

  • Python 3.11 or higher

  • uv package manager

  • VirusTotal API key (get one free)

Installation

# Clone the repository
git clone https://github.com/googleSandy/gti-mcp-standalone.git
cd gti-mcp-standalone

# Install with uv (recommended)
uv tool install -e .

# Or run directly without installation
uv run gti_mcp

API Key Setup

Set up the VT_APIKEY environment variable:

macOS/Linux:

export VT_APIKEY="your-virustotal-api-key"

Windows PowerShell:

$Env:VT_APIKEY = "your-virustotal-api-key"

Permanent setup (recommended):

Add the export command to your shell profile (~/.bashrc, ~/.zshrc, or ~/.bash_profile):

echo 'export VT_APIKEY="your-virustotal-api-key"' >> ~/.zshrc
source ~/.zshrc

MCP Client Configuration

Claude Desktop

Edit ~/.claude/claude_desktop_config.json:

{
  "mcpServers": {
    "gti": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/gti-mcp-standalone",
        "run",
        "gti_mcp"
      ],
      "env": {
        "VT_APIKEY": "${VT_APIKEY}"
      }
    }
  }
}

Note for macOS users: If you installed uv using the standalone installer, use the full path to the uv binary (e.g., /Users/yourusername/.local/bin/uv) instead of just uv.

Cline

Edit .cline/mcp.json or use the settings UI:

{
  "mcpServers": {
    "gti": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/gti-mcp-standalone",
        "run",
        "gti_mcp"
      ],
      "env": {
        "VT_APIKEY": "${VT_APIKEY}"
      }
    }
  }
}

Cursor

Edit .cursor/mcp.json:

{
  "mcpServers": {
    "gti": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/gti-mcp-standalone",
        "run",
        "gti_mcp"
      ],
      "env": {
        "VT_APIKEY": "${VT_APIKEY}"
      }
    }
  }
}

Verification

  1. Restart your MCP client (Claude Desktop, Cline, or Cursor)

  2. Check that the GTI server appears in the MCP tools list

  3. Try a simple query: "Check the reputation of google.com using GTI"

If everything is working, you should see results from Google Threat Intelligence!

Production Deployment (Cloud Run)

For teams who want to deploy a centralized GTI MCP service that multiple users or frontend applications can access via SSE (Server-Sent Events).

Why Cloud Deployment?

  • Centralized service: One deployment serves multiple users/applications

  • No local setup: Users connect via HTTP/SSE without installing Python or dependencies

  • Team sharing: Security teams can provide threat intelligence to multiple frontend apps

  • Scalability: Cloud Run automatically scales based on demand

Prerequisites

  • Google Cloud Platform account with billing enabled

  • gcloud CLI installed and configured

  • Project with Cloud Run API enabled

Deployment Steps

1. Clone the Repository

git clone https://github.com/googleSandy/gti-mcp-standalone.git
cd gti-mcp-standalone

2. Configure Deployment Script

Edit gti-remotemcp-deploy.sh and update the configuration section:

# Edit these three values:
PROJECT_ID="your-gcp-project-id"        # Find at console.cloud.google.com
SERVICE_NAME="gti-remotemcp-server"     # Name for your Cloud Run service
REGION="us-central1"                     # Your preferred region

3. Run Deployment

chmod +x gti-remotemcp-deploy.sh
./gti-remotemcp-deploy.sh

The script will:

  • Build the container using Google Cloud Buildpacks

  • Deploy to Cloud Run

  • Output the service URL and authentication token

4. Save Deployment Information

The script outputs:

  • Service URL: https://gti-remotemcp-server-xyz.a.run.app

  • SSE Endpoint: https://gti-remotemcp-server-xyz.a.run.app/sse

  • Auth Token: A randomly generated token for authentication

Important: Save the auth token securely! You'll need it to connect clients.

Architecture Details

Transport: SSE (Server-Sent Events) over HTTP

Authentication:

  • Server access: X-Mcp-Authorization header with MCP_AUTH_TOKEN

  • API calls: api_key parameter passed with each tool invocation

API Key Strategy:

  • Server does NOT store VirusTotal API keys

  • Each tool call must include api_key parameter

  • Allows per-user API quotas and access control

  • Client applications manage API key distribution

Security Considerations

  1. Protect the auth token: Store MCP_AUTH_TOKEN securely (environment variables, secrets manager)

  2. HTTPS only: Cloud Run enforces HTTPS by default

  3. API key handling: Client applications should never expose VT API keys in frontend code

  4. Access control: Consider adding additional authentication layers for production use

  5. Rate limiting: VirusTotal enforces rate limits per API key

Frontend Integration

For developers building custom frontend applications that connect to the deployed Cloud Run service.

Connection Overview

  • Protocol: SSE (Server-Sent Events) for events, HTTP POST for JSON-RPC messages

  • Transport: @modelcontextprotocol/sdk/client/sse

  • Authentication: Bearer-style token in X-Mcp-Authorization header

  • API Keys: Pass api_key parameter with each tool call

Configuration Parameters

  1. Service URL: Your Cloud Run service URL + /sse

    • Example: https://gti-remotemcp-server-xyz.a.run.app/sse

  2. Auth Token: The MCP_AUTH_TOKEN from deployment output

  3. VT API Key: VirusTotal API key (managed client-side, passed per tool call)

React/TypeScript Example

Complete implementation using the MCP SDK:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

// Configuration (use environment variables in production)
const MCP_SERVER_URL = process.env.REACT_APP_MCP_SERVER_URL || "https://your-service.a.run.app/sse";
const MCP_AUTH_TOKEN = process.env.REACT_APP_MCP_AUTH_TOKEN || "your-auth-token";
const VT_API_KEY = process.env.REACT_APP_VT_API_KEY || "your-vt-api-key";

// Create SSE transport with authentication
const transport = new SSEClientTransport(
  new URL(MCP_SERVER_URL),
  {
    // Headers for SSE connection (GET request)
    eventSourceInit: {
      headers: {
        "X-Mcp-Authorization": MCP_AUTH_TOKEN,
      }
    },
    // Headers for JSON-RPC messages (POST requests)
    requestInit: {
      headers: {
        "X-Mcp-Authorization": MCP_AUTH_TOKEN,
      }
    }
  }
);

// Create MCP client
const client = new Client(
  {
    name: "gti-frontend-client",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
      resources: {},
    },
  }
);

// Connect to server
async function connectToGTI() {
  try {
    await client.connect(transport);
    console.log("āœ… Connected to GTI MCP Server");
    return true;
  } catch (error) {
    console.error("āŒ Connection failed:", error);
    return false;
  }
}

// Example: Call a tool
async function checkFileReputation(fileHash: string) {
  try {
    const result = await client.callTool({
      name: "get_file_report",
      arguments: {
        hash: fileHash,
        api_key: VT_API_KEY  // āš ļø Required: Pass API key with each call
      }
    });

    console.log("File report:", result);
    return result;
  } catch (error) {
    console.error("Tool call failed:", error);
    throw error;
  }
}

// Example: Search for threats
async function searchThreats(query: string) {
  try {
    const result = await client.callTool({
      name: "search_threats",
      arguments: {
        query: query,
        limit: 10,
        api_key: VT_API_KEY  // āš ļø Required: Pass API key with each call
      }
    });

    console.log("Threat search results:", result);
    return result;
  } catch (error) {
    console.error("Search failed:", error);
    throw error;
  }
}

// Initialize
connectToGTI().then(success => {
  if (success) {
    // Example usage
    checkFileReputation("44d88612fea8a8f36de82e1278abb02f");
    searchThreats("APT28");
  }
});

Important: API Key Handling

Every tool call MUST include the api_key parameter:

const result = await client.callTool({
  name: "any_gti_tool",
  arguments: {
    // ... other tool-specific arguments ...
    api_key: VT_API_KEY  // āš ļø Always required
  }
});

Why? The Cloud Run deployment does not store API keys. This allows:

  • Per-user API quotas

  • Individual access control

  • Secure key management on client side

Security Best Practices:

  • Never hardcode API keys in frontend code

  • Use environment variables or secure configuration

  • Consider backend proxy for additional security

  • Implement proper key rotation policies

CORS Considerations

The server allows cross-origin requests by passing OPTIONS requests through authentication middleware. If you encounter CORS issues:

  1. Verify your request includes the X-Mcp-Authorization header

  2. Check browser console for specific CORS errors

  3. Ensure you're using HTTPS for the Cloud Run URL

  4. Consider adding Starlette's CORSMiddleware if strict CORS enforcement is needed

Troubleshooting

Connection fails:

  • Verify service URL is correct (must end with /sse)

  • Check MCP_AUTH_TOKEN matches deployment output

  • Ensure Cloud Run service is running (gcloud run services list)

Tool calls fail:

  • Verify api_key parameter is included in arguments

  • Check VirusTotal API key is valid

  • Review rate limits on your VirusTotal account

Authentication errors:

  • Confirm X-Mcp-Authorization header is set correctly

  • Check token hasn't been regenerated during redeployment

Development

Project Structure

.
ā”œā”€ā”€ gti_mcp/
│   ā”œā”€ā”€ __init__.py
│   ā”œā”€ā”€ server.py           # Main MCP server implementation
│   ā”œā”€ā”€ utils.py            # VirusTotal API utilities
│   └── tools/              # Tool implementations
│       ā”œā”€ā”€ __init__.py
│       ā”œā”€ā”€ collections.py  # Threat collections tools
│       ā”œā”€ā”€ files.py        # File analysis tools
│       ā”œā”€ā”€ intelligence.py # IOC search tools
│       ā”œā”€ā”€ netloc.py       # Domain/IP tools
│       ā”œā”€ā”€ threat_profiles.py
│       └── urls.py         # URL analysis tools
ā”œā”€ā”€ tests/                  # Test suite
│   ā”œā”€ā”€ conftest.py
│   ā”œā”€ā”€ test_tools.py
│   ā”œā”€ā”€ test_utils.py
│   └── test_files_errors.py
ā”œā”€ā”€ pyproject.toml          # Package configuration
ā”œā”€ā”€ Dockerfile              # Cloud Run container
ā”œā”€ā”€ gti-remotemcp-deploy.sh # Deployment script
└── README.md

Running Tests

# Install test dependencies
uv pip install -e ".[test]"

# Run all tests
pytest

# Run with coverage
pytest --cov=gti_mcp

# Run specific test file
pytest tests/test_tools.py -v

# Run specific test
pytest tests/test_tools.py::test_get_file_report -v

Contributing

To modify or extend this server:

  1. Fork and clone the repository

  2. Create a feature branch: git checkout -b feature/your-feature

  3. Make changes in gti_mcp/tools/ following existing patterns

  4. Add tests in tests/ for new functionality

  5. Run tests to verify: pytest

  6. Update README if adding new features or changing APIs

  7. Commit changes: Use clear, descriptive commit messages

  8. Push and create PR to the original repository

Adding New Tools

Example pattern for adding a new tool:

# In gti_mcp/tools/your_category.py

async def your_new_tool(param1: str, api_key: str) -> dict:
    """
    Tool description for MCP clients.

    Args:
        param1: Description of parameter
        api_key: VirusTotal API key (required for cloud deployment)

    Returns:
        Tool result as dictionary
    """
    import vt

    async with vt.Client(api_key) as client:
        result = await client.your_operation(param1)
        return result.to_dict()

# Register in gti_mcp/tools/__init__.py

License & Attribution

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

Original Source

This is a standalone extraction of the Google Threat Intelligence MCP server from the official mcp-security repository.

Original Authors: Google SecOps Team Original Repository: https://github.com/google/mcp-security Original License: Apache 2.0

This standalone version is maintained independently but retains all original licensing and attribution.

Third-Party Libraries

  • mcp - Model Context Protocol SDK (MIT License)

  • vt-py - VirusTotal Python SDK (Apache 2.0)

  • Starlette - ASGI framework (BSD License)

  • uvicorn - ASGI server (BSD License)

Support

Getting Help

Frequently Asked Questions

Q: Do I need a paid VirusTotal account? A: No, a free VirusTotal account works. Note that free accounts have lower rate limits and not all MCP tools and features will work even though they will show as available.

Q: Can I use this with OpenAI or other LLM providers? A: Yes! This is an MCP server. Any MCP-compatible client can use it, not just Claude.

Q: Is my API key secure in cloud deployment? A: The server never stores API keys. Clients pass them per-call, allowing you to implement your own key management strategy.

Q: Can I deploy to platforms other than Cloud Run? A: Yes! The included Dockerfile works with any container platform (AWS ECS, Azure Container Instances, etc.). Cloud Run is just the default.

Q: What's the difference between this and the original mcp-security repo? A: This is a standalone extraction of just the GTI component, making it easier to deploy independently. The original repo contains multiple security tools.


Built with ā¤ļø using Model Context Protocol

Available Tools

36 tools
analyse_fileA

Upload and analyse the file in VirusTotal.

The file will be uploaded to VirusTotal and shared with the community.

Args: file_path (required): Path to the file for analysis. Use absolute path. Returns: The analysis report.

Inputs: file_path (required), api_key.

create_collectionA

Creates a new collection in Google Threat Intelligence. Ask for the collection's privacy (public or private) if the user doesn't specify.

Args: name (required): The name of the collection. description (required): A description of the collection. iocs (required): Indicators of Compromise (IOCs) to include in the collection. The items in the list can be domains, files, ip_addresses, or urls. At least one IOC must be provided. private: Indicates whether the collection should be private. Returns: A dictionary representing the newly created collection.

Inputs: name (required), description (required), iocs (required), private, +1 more. Returns: result

get_collection_feature_matchesB

Retrieves Indicators of Compromise (IOCs) from a collection that match a specific feature.

This tool allows pivoting from a commonality to the specific IOCs within a collection that exhibit that feature. Commonalities are shared characteristics and hidden relationships between various Indicators of Compromise (e.g., files, URLs, domains, IPs).

Available feature types by entity type: Files:

  • android_certificates, android_main_activities, android_package_names, attributions, behash, collections, compressed_parents, contacted_domains, contacted_ips, contacted_urls, crowdsourced_ids_results, crowdsourced_yara_results, elfhash, email_parents, embedded_domains, embedded_ips, embedded_urls, execution_parents, imphash, itw_domains, itw_urls, mutexes_created, mutexes_opened, pcap_parents, registry_keys_deleted, registry_keys_opened, registry_keys_set, tags, vhash, file_types, crowdsourced_sigma_results, deb_info_packages, debug_codeview_guids, debug_codeview_names, debug_timestamps, dropped_files_path, dropped_files_sha256, elfinfo_exports, elfinfo_imports, exiftool_authors, exiftool_companies, exiftool_create_dates, exiftool_creators, exiftool_last_modified, exiftool_last_printed, exiftool_producers, exiftool_subjects, exiftool_titles, filecondis_dhash, main_icon_dhash, main_icon_raw_md5, netassembly_mvid, nsrl_info_filenames, office_application_names, office_authors, office_creation_datetimes, office_last_saved, office_macro_names, permhash, pe_info_imports, pe_info_exports, pe_info_section_md5, pe_info_section_names, pwdinfo_values, sandbox_verdicts, signature_info_comments, signature_info_copyrights, signature_info_descriptions, signature_info_identifiers, signature_info_internal_names, signature_info_original_names, signature_info_products, symhash, trusted_verdict_filenames, rich_pe_header_hash, telfhash, tlshhash, email_senders, email_subjects, popular_threat_category, popular_threat_name, suggested_threat_label, attack_techniques, malware_config_family_name, malware_config_campaign_id, malware_config_campaign_group, malware_config_dga_seed, malware_config_dns_server, malware_config_service, malware_config_registry_key, malware_config_event, malware_config_pipe, malware_config_mutex, malware_config_folder, malware_config_file, malware_config_process_inject_target, malware_config_crypto_key, malware_config_displayed_message, malware_config_c2_url, malware_config_download_url, malware_config_misc_url, malware_config_decoy_url, malware_config_c2_user_agent, malware_config_download_user_agent, malware_config_misc_user_agent, malware_config_decoy_user_agent, malware_config_c2_password, malware_config_misc_username, malware_config_misc_password, malware_config_host_port, malware_config_dropped_file, malware_config_dropped_file_path, malware_config_registry_value, malware_config_download_password, malware_config_c2_username, malware_config_download_username, malware_config_exfiltration_username, malware_config_exfiltration_password, malware_config_exfiltration_url, malware_config_exfiltration_user_agent, malware_config_pivot_hash, memory_pattern_urls

Domains:

  • attributions, collections, communicating_files, downloaded_files, favicon_dhash, favicon_raw_md5, urls, registrant_names

IP Addresses:

  • attributions, collections, communicating_files, downloaded_files, urls

URLs:

  • attributions, http_response_contents, collections, contacted_domains, communicating_files, cookie_names, cookie_values, downloaded_files, domains, embedded_js, favicon_dhash, favicon_raw_md5, html_titles, ip_addresses, memory_patterns, outgoing_links, path, prefix_paths, suffix_paths, ports, users, passwords, user_passwords, query_strings, query_param_keys, query_param_values, query_param_key_values, referring_files, tags, tracker_ids

Args: collection_id (required): The ID of the collection to search within. feature_type (required): The type of feature to search for (e.g., 'attack_techniques'). feature_id (required): The specific value of the feature (e.g., 'T1497.001'). entity_type (required): search_space (required): The scope of the search. Use 'collection' to search only within the specified collection, or 'corpus' to search across the entire VirusTotal dataset. entity_type_plural (required): The plural of 'entity_type'. descriptors_only (optional): Returns only the descriptors. Returns: A dictionary containing the list of matching IOCs.

Inputs: collection_id (required), feature_type (required), feature_id (required), entity_type (required), +3 more. Returns: result

get_collection_mitre_treeC

Retrieves the Mitre tactics and techniques associated with a threat.

Args: id (required): Collection identifiers. Return: A dictionary including the tactics and techniques associated to the given threat.

Inputs: id (required), api_key. Returns: result

get_collection_reportC

At Google Threat Intelligence, threats are modeled as "collections". This tool retrieves them from the platform.

They have different collections types like:

  • "malware-family"

  • "threat-actor"

  • "campaign"

  • "report"

  • "collection".

You can find the collection type in the "collection_type" field.

Args: id (required): Google Threat Intelligence identifier. Returns: A collection object. Put attention to the collection type to correctly understand what it represents.

Inputs: id (required), api_key. Returns: result

get_collection_rulesA

Retrieve top N community rules and all curated hunting rules for a specific collection.

Note: The rule_types argument filters the types of rules returned. Available types are:

  • 'crowdsourced_ids'

  • 'crowdsourced_sigma'

  • 'crowdsourced_yara'

  • 'curated_yara_rule' If rule_types is not provided, all types are returned.

Example:

  • rule_types=['crowdsourced_yara']: Only crowdsourced YARA rules.

  • rule_types=['crowdsourced_ids', 'curated_yara_rule']: Crowdsourced IDS and curated YARA rules.

Args: collection_id (required): The ID of the collection. top_n (optional): The number of top community rules to return from each category. Defaults to 4. rule_types (optional): List of rule types to fetch.

Returns: A list of dictionaries, where each dictionary contains a rule and its metadata, or an error dictionary.

Inputs: collection_id (required), top_n, rule_types, api_key. Returns: result

get_collections_commonalitiesB

Retrieve the common characteristics or features (attributes / relationships) of the indicators of compromise (IoC) within a collection, identified by its ID. Args: collection_id (required): Collection identifier. Returns: Markdown-formatted string with the commonalities of the collection.

Inputs: collection_id (required), api_key. Returns: result

get_collection_timeline_eventsB

Retrieves timeline events from the given collection, when available.

This is super valuable curated information produced by security analysits at Google Threat Intelligence.

We should fetch this information for campaigns and threat actors always.

It's common to display the events grouped by the "event_category" field.

Args: id (required): Collection identifier Return: List of events related to the given collection.

Inputs: id (required), api_key.

get_domain_reportC

Get a comprehensive domain analysis report from Google Threat Intelligence.

Args: domain (required): Domain to analyse. Returns: Report with insights about the domain.

Inputs: domain (required), api_key. Returns: result

get_file_behavior_reportA

Retrieve the file behaviour report of the given file behaviour identifier.

You can get all the file behaviour of a given a file by calling get_entities_related_to_a_file as the file hash and the behaviours as relationship name.

The file behaviour ID is composed using the following pattern: "{file hash}_{sandbox name}".

Args: file_behaviour_id (required): File behaviour ID. Returns: The file behaviour report.

Inputs: file_behaviour_id (required), api_key. Returns: result

get_file_behavior_summaryB

Retrieve a summary of all the file behavior reports from all the sandboxes.

Args: hash (required): MD5/SHA1/SHA256) hash that identifies the file. Returns: The file behavior summary.

Inputs: hash (required), api_key. Returns: result

get_file_reportB

Get a comprehensive file analysis report using its hash (MD5/SHA-1/SHA-256).

Returns a concise summary of key threat details including detection stats, threat classification, and important indicators. Parameters: hash (required): The MD5, SHA-1, or SHA-256 hash of the file to analyze. Example: '8ab2cf...', 'e4d909c290d0...', etc.

Inputs: hash (required), api_key. Returns: result

get_hunting_rulesetB

Get a Hunting Ruleset object from Google Threat Intelligence.

A Hunting Ruleset object describes a user's hunting ruleset. It may contain multiple Yara rules.

The content of the Yara rules is in the rules attribute.

Some important object attributes:

  • creation_date: creation date as UTC timestamp.

  • modification_date (int): last modification date as UTC timestamp.

  • name (str): ruleset name.

  • rule_names (list[str]): contains the names of all rules in the ruleset.

  • number_of_rules (int): number of rules in the ruleset.

  • rules (str): rule file contents.

  • tags (list[str]): ruleset's custom tags.

Args: ruleset_id (required): Hunting ruleset identifier.

Returns: Hunting Ruleset object.

Inputs: ruleset_id (required), api_key. Returns: result

get_ip_address_reportB

Get a comprehensive IP Address analysis report from Google Threat Intelligence.

Args: ip_address (required): IP Address to analyze. It can be IPv4 or IPv6. Returns: Report with insights about the IP address.

Inputs: ip_address (required), api_key. Returns: result

get_threat_profileC

Get Threat Profile object.

A threat profile object contains the following attributes:

  • enable_recommendations (bool): whether or not Recommendations automatically generated by our ML are enabled.

  • interests (dict): Threat Profile's configured interests such as industries, target regions, source regions, malware roles and actor motivations to recommend the most relevant threats.

    • INTEREST_TYPE_TARGETED_INDUSTRY (list[str]): List of targeted industries.

    • INTEREST_TYPE_TARGETED_REGION (list[str]): list of targeted regions (ISO-3166 country code).

    • INTEREST_TYPE_SOURCE_REGION (list[str]): list of source regions (ISO-3166 country code).

    • INTEREST_TYPE_MALWARE_ROLE (list[str]): list of malware roles.

    • INTEREST_TYPE_ACTOR_MOTIVATION: (list[str]): list of threat actors motivations.

  • last_modification_date: Threat Profile's last modification date (UTC timestamp).

  • name (str): Threat Profile's name.

  • creation_date (int): Threat Profile's creation date (UTC timestamp).

  • aliases (list[str]): alternative names by which the threat actor is known.

  • description (str): description / context about the threat actor.

  • first_seen_date (int): estimated threat actor's first seen date of activity (UTC timestamp).

  • last_seen_date (int): estimated threat actor's last seen date of activity (UTC timestamp).

  • last_modification_date (int): last time when the threat actor was updated (UTC timestamp).

  • related_entities_count (int): estimated number of related IOCs to the threat actor.

  • source_region (str): threat actor's source region.

  • sponsor_region (str): region sponsoring the threat actor.

  • targeted_industries (list[str]): list of industries the threat actor has targeted.

  • targeted_regions (list[str]): list of regions the threat actor has targeted.

Args: profile_id (str): Threat Profile identifier at Google Threat Intelligence.

Returns: Threat Profile object.

Inputs: profile_id (required), api_key. Returns: result

get_threat_profile_associations_timelineC

Retrieves the associations timeline for the given Threat Profile.

Some important response attributes:

  • event_type (str): the type of the timeline association such as Alias, Motivation, Malware, Actor, Toolkit, Report, Campaign, etc.

  • event_entity (str): The name or value of the timeline association.

  • first_seen (int): Unix epoch UTC time (seconds) when the association between the object and the threat profile was made.

  • last_seen (int): Unix epoch UTC time (seconds) of most recent observed relationship between the object and the threat profile.

  • name (str): name of the object directly associated with the threat profile.

  • link (str): URL of the object directly associated with the threat profile

Returns: List of dictionaries containing timeline associations.

Inputs: profile_id (required), limit, api_key. Returns: result

get_threat_profile_recommendationsA

Returns the list of objects associated to a given Threat Profile.

Each of these objects has one of the following types:

  • Threat Actors

  • Malware Families

  • Software or Toolkits

  • Campaigns

  • IoC Collections

  • Reports

  • Vulnerabilities

We can distinguish between two other types of objects based on how they were associated with the Threat Profile:

  • Recommended objects are automatically recommended or assigned to a Threat Profile based on our proprietary ML that takes into account the Threat Profile's configured interests such as the targeted industries, target regions, source regions, malware roles and actor motivations to recommend the most relevant threats. These objects are identified by the presence of "source": "SOURCE_RECOMMENDATION" within the "context_attributes" response parameter below.

  • Added objects are assigned or added by users to a Threat Profile, when users find other relevant threats not automatically recommended by our ML module. These objects are identified by the presence of "source": "SOURCE_DIRECT_FOLLOW" within the "context_attributes" response parameter below.

    Args: profile_id (str): Threat Profile identifier at Google Threat Intelligence. limit: Limit the number of objects to retrieve. 10 by default.

    Returns: List of Threat (collection) objects identifiers associated to the Threat Profile. Use get_collection_report to retrieve the full objects.

Inputs: profile_id (required), limit, api_key. Returns: result

get_url_reportB

Get a comprehensive URL analysis report from Google Threat Intelligence.

Args: url (required): URL to analyse. Returns: Report with insights about the URL.

Inputs: url (required), api_key. Returns: result

list_threat_profilesB

List your Threat Profiles at Google Threat Intelligence.

Threat Profiles filter all of Google TI's threat intelligence so you can focus only on the threats that matter most to your organization.

Threat Profiles let you apply top-level filters for Target Industries and Target Regions to immediately provide a more focused view of relevant threats.

When searching for threats, we must use this tool first to check if there is any Threat Profile that matches the user query before peforming a general search using the search_threats tool.

Recommendations from Threat Profiles are more relevants to users than generic search threats. Use them as long as they match user's query.

Returns: List of Threat Profiles.

Inputs: limit, api_key. Returns: result

search_campaignsB

Search threat campaigns in the Google Threat Intelligence platform.

Campaigns are modeled as collections. Once you get collections from this tool, you can use get_collection_report to fetch the full reports and their relationships.

You can use order_by to sort the results by: "relevance", "creation_date". You can use the sign "+" to make it order ascending, or "-" to make it descending. By default is "relevance-"

Args: query (required): Search query to find threats. limit: Limit the number of threats to retrieve. 10 by default. order_by: Order results by the given order key. "relevance-" by default.

Returns: List of collections, aka threats.

Inputs: query (required), limit, order_by, api_key. Returns: result

search_digital_threat_monitoringA

Search for historical data in Digital Threat Monitoring (DTM) using Lucene syntax.

Digital theat monitoring is a collection of documents from surface, deep, and dark web sources.

To filter by document type or threat type, include the conditions within the query string using the fields __type and label_threat, respectively. Combine multiple conditions using Lucene boolean operators (AND, OR, NOT).

Examples of filtering in the query:

  • Single document type: (__type:forum_post) AND (body:security)

  • Multiple document types: (__type:(forum_post OR paste)) AND (body:security)

  • Single threat type: (label_threat:information-security/malware) AND (body:exploit)

  • Multiple threat types: (label_threat:(information-security/malware OR information-security/phishing)) AND (body:exploit)

  • Combined: (__type:document_analysis) AND (label_threat:information-security/information-leak/credentials) AND (body:password)

Important Considerations for Effective Querying:

  • Date/Time Filtering (since and until):

  • Input parameters since and until filter documents by their creation/modification time.

  • These must be strings in RFC3339 format, specifically ending with 'Z' to denote UTC.

  • Example: '2025-04-23T00:00:00Z'

  • Pagination for More Than 25 Results:

    • A single API call returns at most size results (maximum 25).

    • To retrieve more results, you must paginate:

      1. Make your initial search request.

      2. The response dictionary will contain a key named page.

      3. If this page key holds a non-empty string value, there are more results available.

      4. To fetch the next page, make a subsequent API call. This call MUST include the exact same parameters as your original request (query, size, since, until, doc_type, etc.), PLUS the page parameter set to the token value received in the previous response's page field.

      5. Continue this process, using the new page token from each response, until the page field is absent or empty in the response, indicating the end of the results.

Tokenization:

  • DTM breaks documents into tokens.

  • Example: "some-domain.com" -> "some", "domain", "com".

  • Wildcard/Regex queries match single tokens, not phrases.

Special Characters:

  • Escape with : + - & | ! ( ) { } [ ] ^ " ~ * ? : / and space.

  • Example: To find "(1+1):2", query (1+1):2

Case Sensitivity:

  • DTM entity values are often lowercased.

  • Boolean operators (AND, OR, NOT) MUST be UPPERCASE.

Domain Search Nuances:

  • Use wildcards/regex on fields like doc.domain.

  • Example: doc.domain:google.*.dev

  • Avoid pattern searches on group_network.

Performance Limit:

  • Searches timeout after 60 seconds.

  • For broad or complex queries, it is highly recommended to use the since and until parameters to add time delimiters. This narrows the search scope and helps prevent timeouts.

Noise Reduction:

  • Use typed entities for higher precision.

  • Example: organization:"Acme Corp"

  • Prefer typed entities over free text searches.

The following fields and their meanings can be used to compose a query using Lucene syntax (including combining them with AND, OR, and NOT operators along with parentheses):

  • author.identity.name - The handle used by the forum post author

  • subject - The subject line of the forum post

  • body - The body text of the content

  • inet_location.url - What URL content was found

  • language - The content language

  • title - The title of the web page

  • channel.name - The Telegram channel name

  • domain - A DNS domain name

  • cve - A CVE entry by ID

__type: one of the following

  • web_content_publish - General website content

  • domain_discovery - Newly discovered domain names

  • forum_post - Darkweb forum posts

  • message - Chat messages like Telegram

  • paste - Paste site content like Pastebin

  • shop_listing - Items for sale on the dark web

  • email_analysis - Suspicious emails

  • tweet - Tweets from Twitter on cybersecurity topics.

  • document_analysis - Documents (PDF, Office, text) from VirusTotal, including malicious and corporate confidential files.

label_threat: one of the following

  • information-security/anonymization - Anonymization

  • information-security/apt - Advanced Persistent Threat

  • information-security/botnet - Botnet

  • information-security/compromised - Compromised Infrastructure

  • information-security/doxing - Personal Information Disclosure

  • information-security/exploit - Exploits

  • information-security/phishing - Phishing

  • information-security/information-leak - Information Leak

  • information-security/information-leak/confidential - Confidential Information Leak

  • information-security/information-leak/credentials - Credential Leak

  • information-security/information-leak/payment-cards - Credit Card Leak

  • information-security/malicious-activity - Malicious Activity

  • information-security/malicious-infrastructure - Malicious Infrastructure

  • information-security/malware - Malware

  • information-security/malware/ransomware - Ransomware

  • information-security/malware/ransomware-victim-listing - Ransomware Victim Listing

  • information-security/security-research - Security Research

  • information-security/spam - Spam

Args: query (required): The Lucene-like query string for your document search. size (optional): The number of results to return in each page (0 to 25). Defaults to 10. since (optional): The timestamp to search for documents since (RFC3339 format). until (optional): The timestamp to search for documents from (RFC3339 format). page (optional): The page ID to fetch the page for. This is only used when paginating through pages greater than the first page of results. truncate (optional): The number of characters (as a string) to truncate all documents fields in the response (e.g., '500'). sanitize (optional): If true (default), any HTML content in the document fields are sanitized to remove links, scripts, etc.

Returns: A dictionary containing the list of documents found and search metadata.

Inputs: query (required), size, since, until, +4 more.

search_iocsA

Search Indicators of Compromise (IOC) in the Google Threat Intelligence platform.

You can search by for different IOC types using the entity modifier. Below, the different IOC types and the supported orders:

Entity type

Supported orders

Default order

file

first_submission_date, last_submission_date, positives, times_submitted, size

last_submission_date-

url

first_submission_date, last_submission_date, positives, times_submitted, status

last_submission_date-

domain

creation_date, last_modification_date, last_update_date, positives

last_modification_date-

ip

ip, last_modification_date, positives

last_modification_date-

Note: The entity modifier can only be used ONCE per query.

You can find all available modifers at:

With integer modifers, use the - and + characters to indicate:

  • Greater than: p:60+

  • Less than: p:60-

  • Equal to: p:60

Args query (required): Search query to find IOCs. limit: Limit the number of IoCs to retrieve. 10 by default. order_by: Order the results. "last_submission_date-" by default.

Returns: List of Indicators of Compromise (IoCs).

Inputs: query (required), limit, order_by, api_key. Returns: result

search_malware_familiesA

Search malware families in the Google Threat Intelligence platform.

Malware families are modeled as collections. Once you get collections from this tool, you can use get_collection_report to fetch the full reports and their relationships.

You can use order_by to sort the results by: "relevance", "creation_date". You can use the sign "+" to make it order ascending, or "-" to make it descending. By default is "relevance-"

Args: query (required): Search query to find threats. limit: Limit the number of threats to retrieve. 10 by default. order_by: Order results by the given order key. "relevance-" by default.

Returns: List of collections, aka threats.

Inputs: query (required), limit, order_by, api_key. Returns: result

search_software_toolkitsA

Search software toolkits (or just tools) in the Google Threat Intelligence platform.

Software toolkits are modeled as collections. Once you get collections from this tool, you can use get_collection_report to fetch the full reports and their relationships.

You can use order_by to sort the results by: "relevance", "creation_date". You can use the sign "+" to make it order ascending, or "-" to make it descending. By default is "relevance-"

Args: query (required): Search query to find threats. limit: Limit the number of threats to retrieve. 10 by default. order_by: Order results by the given order key. "relevance-" by default.

Returns: List of collections, aka threats.

Inputs: query (required), limit, order_by, api_key. Returns: result

search_threat_actorsA

Search threat actors in the Google Threat Intelligence platform.

Threat actors are modeled as collections. Once you get collections from this tool, you can use get_collection_report to fetch the full reports and their relationships.

You can use order_by to sort the results by: "relevance", "creation_date". You can use the sign "+" to make it order ascending, or "-" to make it descending. By default is "relevance-"

Args: query (required): Search query to find threats. limit: Limit the number of threats to retrieve. 10 by default. order_by: Order results by the given order key. "relevance-" by default.

Returns: List of collections, aka threats.

Inputs: query (required), limit, order_by, api_key. Returns: result

search_threat_reportsA

Search threat reports in the Google Threat Intelligence platform.

Google Threat Intelligence provides continuously updated reports and analysis of threat actors, campaigns, vulnerabilities, malware, and tools

Threat reports are modeled as collections. Once you get collections from this tool, you can use get_collection_report to fetch the full reports and their relationships.

You can use order_by to sort the results by: "relevance", "creation_date". You can use the sign "+" to make it order ascending, or "-" to make it descending. By default is "relevance-"

Args: query (required): Search query to find threats. limit: Limit the number of threats to retrieve. 10 by default. order_by: Order results by the given order key. "relevance-" by default.

Returns: List of collections, aka threats.

Inputs: query (required), limit, order_by, api_key. Returns: result

search_threatsA

Search threats in the Google Threat Intelligence platform.

Threats are modeled as collections. Once you get collections from this tool, you can use get_collection_report to fetch the full reports and their relationships.

IMPORTANT CONTEXT CLUE: Pay close attention to the user's request. If their request mentions specific kinds of threats such as "threat actor", "malware family", "campaign", "report", or "vulnerability", treat this as a strong signal that you must use the collection_type filter in your query to ensure relevant results. Using this filter significantly improves search precision.

Filtering by Type: To filter your search results to a specific type of threat, include the collection_type modifier within your query string. Syntax: collection_type:"<type>" Available <type> values:

  • "threat-actor": Use when the user asks about specific actors, groups, or APTs.

  • "malware-family": Use when the user asks about malware, trojans, viruses, ransomware families.

  • "software-toolkit": Use when the user asks about legit tools usually related to malware.

  • "campaign": Use when the user asks about specific attack campaigns.

  • "report": Use when the user is looking for analysis reports.

  • "vulnerability": Use when the user asks about specific CVEs or vulnerabilities.

  • "collection": A generic type, use only if no other type fits or if the user explicitly asks for generic "collections".

You can use order_by to sort the results by: "relevance", "creation_date". You can use the sign "+" to make it order ascending, or "-" to make it descending. By default is "relevance-"

When asked for latest threats, prioritize campaigns or vulnerabilities over reports.

Args: query (required): Search query to find threats. collection_type: Filter your search results to a specific type of threat limit: Limit the number of threats to retrieve. 5 by default. order_by: Order results by the given order key. "relevance-" by default.

Returns: List of collections, aka threats. They are full collection objects, you do not need to retrieve themusing the get_collection_reporttool. You may need to extend with relationships usingget_entities_related_to_a_collection` tool.

Inputs: query (required), collection_type, limit, order_by, +1 more. Returns: result

search_vulnerabilitiesA

Search vulnerabilities (CVEs) in the Google Threat Intelligence platform.

Vulnerabilities are modeled as collections. Once you get collections from this tool, you can use get_collection_report to fetch the full reports and their relationships.

You can use order_by to sort the results by: "relevance", "creation_date". You can use the sign "+" to make it order ascending, or "-" to make it descending. By default is "relevance-"

Args: query (required): Search query to find threats. limit: Limit the number of threats to retrieve. 10 by default. order_by: Order results by the given order key. "relevance-" by default.

Returns: List of collections, aka threats.

Inputs: query (required), limit, order_by, api_key. Returns: result

update_collection_attributesB

Allows updating a collection's attributes (such as name or description) Args: id (required): The ID of the collection to update. attributes: Available attributes in a collection: * name: string * description: string * private: boolean * tags: array of strings * alt_names: array of strings Returns: A dictionary representing the updated collection.

Inputs: id (required), attributes, api_key. Returns: result

update_iocs_in_collectionA

Updates (add or remove) Indicators of Compromise (IOCs) to a collection. Args: id (required): The ID of the collection to update. relationship (required): The type of relationship to add. Can be "domains", "files", "ip_addresses", or "urls". iocs (required): List of IOCs to add to the collection. For "urls", these are the full URLs. For other types, they are the identifiers (hashes for files, domain names for domains, etc.). operation (required): The operation to perform. Can be "add" or "remove".

Returns: A string indicating the success or failure of the operation.

Inputs: id (required), relationship (required), iocs (required), operation (required), +1 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 36 tools

    Disambiguation3/5

    Tools like search_threats, search_campaigns, search_threat_actors, search_malware_families, search_software_toolkits, search_threat_reports, and search_vulnerabilities overlap heavily; the latter six are essentially wrappers around the first with a collection_type filter. While descriptions clarify the differences, the generic search_threats can also do the same, which may lead to confusion about which to use for a specific request.

    Naming Consistency4/5

    The naming pattern is mostly consistent: 'get_*_report', 'get_entities_related_to_*', 'search_*'. However, there are slight deviations like 'analyse_file' (British spelling) versus 'analyze' elsewhere, and 'create_collection' vs 'update_collection_attributes' but these are minor and the overall convention is clear.

    Tool Count2/5

    With 36 tools, the server is on the heavier side, reflecting a broad threat intelligence API. The many search_* wrapper tools (7 variants) contribute bloat; they could be consolidated into a single search with a type parameter. The get_entities_related_* tools also repeat the same pattern for each entity type, adding to the count. While the scope is large, the number feels excessive and could be trimmed.

    Completeness4/5

    The tool surface covers major threat intelligence capabilities: searching and retrieving collections, entities, reports, timelines, MITRE attribution, collection management (CRUD), and IOC pivoting. However, there are gaps like no direct creation/update for IOCs beyond collections, and no functions for managing threat profiles (only retrieval). Overall, the domain is well covered, but some advanced operational features are missing.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI-powered threat intelligence analysis of IPs, domains, URLs, and file hashes across multiple threat intelligence platforms (VirusTotal, AlienVault OTX, AbuseIPDB, IPinfo) with APT attribution and interactive reporting through natural language queries.
      25 PyPI
      40
      Apache 2.0
    • A
      license
      D
      quality
      D
      maintenance
      Enables AI assistants to access real-time threat intelligence, malware sample metadata, and security analysis tools via integration with MalwareBazaar, VirusTotal, and Telegram.
      29
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables LLM agents to access Google Threat Intelligence data, including IOC search, file/domain/IP/URL analysis, and threat hunting rulesets, for security investigations.
      36
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants to query and manage OpenCTI threat intelligence data, including indicators, observables, reports, malware, and more, with read-only and optional write operations.
      1
      MIT