Google Threat Intelligence MCP Server
The Google Threat Intelligence MCP Server connects AI assistants to Google's Threat Intelligence platform (powered by VirusTotal), enabling comprehensive threat analysis, investigation, and monitoring.
Threat Intelligence Search & Collections
Search for threats (campaigns, threat actors, malware families, software toolkits, reports, vulnerabilities) using GTI query syntax
Retrieve collection reports, timeline events, MITRE ATT&CK trees, detection rules (YARA/Sigma), feature matches, and commonalities
Create and update threat collections, including attributes and IOCs (add/remove domains, files, IPs, URLs)
File Analysis
Get comprehensive file reports by MD5, SHA-1, or SHA-256 hash
Retrieve sandbox behavior reports and summaries
Upload and analyze new files directly
Explore file relationships (contacted domains/IPs/URLs, dropped files, parent files, etc.)
Domain, IP & URL Reputation
Get detailed analysis reports for domains (WHOIS, SSL, DNS), IP addresses, and URLs
Retrieve related entities (communicating files, campaigns, threat actors, historical data, etc.)
IOC Search & Digital Threat Monitoring
Search for files, URLs, domains, and IPs using advanced GTI query syntax with filters and ordering
Search surface, deep, and dark web sources (forums, paste sites, Telegram, etc.) using Lucene syntax for brand protection, phishing, and impersonation threats
Hunting Rulesets
Retrieve YARA hunting rulesets and find files matching those rules
Threat Profiles
List, retrieve, and get ML-powered recommendations from organizational threat profiles
View association timelines filtered by industries and regions of interest
Deployment Flexibility
Supports local (stdio) and cloud (SSE/HTTP) deployments with both environment-based and per-call API key management
Provides access to Google's Threat Intelligence suite, enabling searches for threat actors, campaigns, malware families, and vulnerability reports, as well as retrieval of threat profiles and hunting rulesets.
Leverages the VirusTotal API to provide comprehensive file analysis, sandbox behavior reports, and reputation checking for domains, IP addresses, and URLs.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Google Threat Intelligence MCP Server Search for recent threat intelligence on the actor group APT28"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.

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
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:#e1f5ffLocal 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 ResultAPI 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 ResultAPI 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 typecampaign.search_threat_actors(query, limit=10, order_by="relevance-"): Searches specifically for collections of typethreat-actor.search_malware_families(query, limit=10, order_by="relevance-"): Searches specifically for collections of typemalware-family.search_software_toolkits(query, limit=10, order_by="relevance-"): Searches specifically for collections of typesoftware-toolkit.search_threat_reports(query, limit=10, order_by="relevance-"): Searches specifically for collections of typereport.search_vulnerabilities(query, limit=10, order_by="relevance-"): Searches specifically for collections of typevulnerability.
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.
Intelligence Search
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_mcpAPI 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 ~/.zshrcMCP 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
Restart your MCP client (Claude Desktop, Cline, or Cursor)
Check that the GTI server appears in the MCP tools list
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-standalone2. 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 region3. Run Deployment
chmod +x gti-remotemcp-deploy.sh
./gti-remotemcp-deploy.shThe 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.appSSE Endpoint:
https://gti-remotemcp-server-xyz.a.run.app/sseAuth 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-Authorizationheader withMCP_AUTH_TOKENAPI calls:
api_keyparameter passed with each tool invocation
API Key Strategy:
Server does NOT store VirusTotal API keys
Each tool call must include
api_keyparameterAllows per-user API quotas and access control
Client applications manage API key distribution
Security Considerations
Protect the auth token: Store
MCP_AUTH_TOKENsecurely (environment variables, secrets manager)HTTPS only: Cloud Run enforces HTTPS by default
API key handling: Client applications should never expose VT API keys in frontend code
Access control: Consider adding additional authentication layers for production use
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/sseAuthentication: Bearer-style token in
X-Mcp-AuthorizationheaderAPI Keys: Pass
api_keyparameter with each tool call
Configuration Parameters
Service URL: Your Cloud Run service URL +
/sseExample:
https://gti-remotemcp-server-xyz.a.run.app/sse
Auth Token: The
MCP_AUTH_TOKENfrom deployment outputVT 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:
Verify your request includes the
X-Mcp-AuthorizationheaderCheck browser console for specific CORS errors
Ensure you're using HTTPS for the Cloud Run URL
Consider adding Starlette's
CORSMiddlewareif strict CORS enforcement is needed
Troubleshooting
Connection fails:
Verify service URL is correct (must end with
/sse)Check
MCP_AUTH_TOKENmatches deployment outputEnsure Cloud Run service is running (
gcloud run services list)
Tool calls fail:
Verify
api_keyparameter is included in argumentsCheck VirusTotal API key is valid
Review rate limits on your VirusTotal account
Authentication errors:
Confirm
X-Mcp-Authorizationheader is set correctlyCheck 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.mdRunning 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 -vContributing
To modify or extend this server:
Fork and clone the repository
Create a feature branch:
git checkout -b feature/your-featureMake changes in
gti_mcp/tools/following existing patternsAdd tests in
tests/for new functionalityRun tests to verify:
pytestUpdate README if adding new features or changing APIs
Commit changes: Use clear, descriptive commit messages
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__.pyLicense & 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
Documentation: This README and MCP Protocol Docs
Issues: Report issues at the original mcp-security repository
VirusTotal API: Official API documentation
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 toolsanalyse_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_typesis 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_reportto 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 (
sinceanduntil):Input parameters
sinceanduntilfilter 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
sizeresults (maximum 25).To retrieve more results, you must paginate:
Make your initial search request.
The response dictionary will contain a key named
page.If this
pagekey holds a non-empty string value, there are more results available.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
pageparameter set to the token value received in the previous response'spagefield.Continue this process, using the new
pagetoken from each response, until thepagefield 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
sinceanduntilparameters 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:
Files: https://gtidocs.virustotal.com/docs/file-search-modifiers
URLs: https://gtidocs.virustotal.com/docs/url-search-modifiers
Domains: https://gtidocs.virustotal.com/docs/domain-search-modifiers
IP Addresses: https://gtidocs.virustotal.com/docs/ip-address-search-modifiers
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
Scored across 36 tools
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.
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.
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.
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
Related MCP Connectors
Deltabridge brings an AI-native cyber threat intelligence platform into your AI agent. Search a knowledge graph of 200,000+ threat actors, malware families, vulnerabilities, indicators and campaigns, mapped to MITRE ATT&CK. Look up and enrich IOCs, trace links between entities and read living briefs built from 300+ open sources. Read-only, scoped to your organisation, with OAuth sign-in or an API key. Included on Researcher, Business and Enterprise plans.
AI-powered threat intelligence, smart contract auditing, and cybersecurity OSINT.
Real-time threat intel for AI agents: 890K+ IOCs incl. prompt-injection & AI-skill threats
Live threat intel for agents: incidents, actors, CVEs with KEV/EPSS, ransomware leak-site victims.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 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 PyPI40Apache 2.0
- AlicenseDqualityDmaintenanceEnables AI assistants to access real-time threat intelligence, malware sample metadata, and security analysis tools via integration with MalwareBazaar, VirusTotal, and Telegram.29MIT
- AlicenseBqualityDmaintenanceEnables LLM agents to access Google Threat Intelligence data, including IOC search, file/domain/IP/URL analysis, and threat hunting rulesets, for security investigations.36Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI assistants to query and manage OpenCTI threat intelligence data, including indicators, observables, reports, malware, and more, with read-only and optional write operations.1MIT