Skip to main content
Glama
Google Threat Intelligence MCP Server

Google Threat Intelligence MCP Server

Google Threat Intelligence MCP Server

A production-ready, highly optimized Model Context Protocol (MCP) server for Google Threat Intelligence (GTI) (incorporating VirusTotal and Mandiant threat analytics). This server supports cloud-native network deployments via Stateless HTTP (streamable-http) or Server-Sent Events (SSE), making it fully compatible with Google Cloud Run or any other container-native environment.


Project Origin & Deployment Philosophy

This repository is 100% based on the official Google open-source implementation hosted in the google/mcp-security repository.

While the official project is designed as a broad, developer-focused, multi-tool mono-repo, this project was created specifically to empower non-technical users, security analysts, and IT administrators to deploy a secure, enterprise-grade Google Threat Intelligence (GTI) MCP server in minutes with zero friction.

๐Ÿ” How This Repository Differs from the Official Mono-Repo

Feature / Aspect

Official Google mcp-security Mono-Repo

This Dedicated GTI Project

Project Focus

Multi-server (SCC, SecOps, SOAR, GTI) developers workspace.

100% focused on Google Threat Intelligence (GTI). Completely stripped of unrelated bloat.

Nesting Structure

Nested deeply under /server/gti folders.

Flattened to the root. Clean git clone and run.

Secrets Security

Basic environment variables (risk of plaintext leak).

Strictly Enforced Google Secret Manager.

Cloud Deployment

Minimal developer deployment scaffolding.

Production-ready Google Cloud Run templates.

User Onboarding

Targeted at software developers and engineers.

Designed for non-technical users, complete with beginner-friendly command guides.

No-Agent Verification

Requires setting up and connecting an LLM desktop client.

Instant, zero-agent verification via a dynamic, automated verify.sh script.


IMPORTANT

Production Security Mandate: To ensure enterprise compliance and prevent credential leakage, this deployment strictly requires the use of Google Secret Manager to store and load your API key. Direct injection of plaintext credentials via environment variables is disabled/prohibited for cloud deployments.


Related MCP server: OpenCTI MCP Server

Table of Contents

  1. Project Origin & Deployment Philosophy

  2. Core Features

  3. Configuration & Customization (Optional)

  4. Getting Started

  5. Local Development & Setup

  6. Containerization & Docker

  7. Production Google Cloud Run Deployment (Strict Secret Manager)

  8. Gemini Enterprise Integration (Optional)


Core Features

This MCP server exposes high-performance threat intelligence endpoints to any compatible LLM agent.

๐Ÿ” Intelligence & Hunting

  • search_iocs(query, limit): Queries Indicators of Compromise (IOCs) using advanced search filters.

  • get_hunting_ruleset & get_entities_related_to_a_hunting_ruleset: Accesses and maps structured threat detection signatures.

๐Ÿ“ Files & Artifacts

  • get_file_report(hash): Inspects MD5, SHA1, or SHA256 hashes to check multi-engine detections and threat actor classifications.

  • get_file_behavior_report(id) & get_file_behavior_summary(hash): Retreives deep sandbox execution data.

๐ŸŒ Domains, IPs, and URLs

  • get_domain_report(domain) & get_entities_related_to_a_domain: Resolves passive DNS mappings, registrar details, and reputational classifications.

  • get_ip_address_report(ip_address): Retrieves geolocations, Autonomous System Numbers (ASN), and detections.

  • get_url_report(url) & get_entities_related_to_an_url: Inspects specific URLs.


Configuration & Customization (Optional)

This project is pre-configured and completely ready to run out-of-the-box. You do not need to modify any of these files to deploy. However, if you have specific network or architectural requirements, you can customize these configuration files:

File Path

Purpose

Modification Details

docker-compose.yml

Local Container Config

Change the container port mappings or local environment references if needed.

Dockerfile

Image Build Spec

Customize the base Python version or update build-stage packages.

IMPORTANT

Zero-Credential File Design: No secrets or API keys are written to disk in this repository. Local development utilizes memory-only shell environment variables, and production environments strictly load keys from cloud-managed secret vaults.


Getting Started

Regardless of whether you plan to run the server locally, package it in a container, or deploy it directly to Google Cloud Run, you must first clone the repository and navigate into the project directory:

# Clone this repository
git clone <your-repository-url>

# Enter the project directory
cd gti-mcp-server

๐Ÿš€ Choose Your Path

Once inside the directory, choose the section that matches your goal:


Local Development & Setup

Prerequisites

  • Python 3.11 or higher.

  • A valid Google Threat Intelligence (VirusTotal) API key.

Quick Start (Local Python)

  1. Configure your API Key (In-Memory Only): Export your Google Threat Intelligence API key directly in your terminal session. This key resides only in your shell's temporary RAM and is never written to disk:

    export VT_APIKEY="your_actual_gti_api_key_here"
  2. Install the package and dependencies:

    python3 -m venv .venv
    source .venv/bin/activate
    pip install --upgrade pip
    pip install -e .
  3. Run the server locally:

    Start the server in SSE/HTTP network mode. This boots the server as an HTTP service listening on port 8000 by default and outputs active startup logs once initialized:

    gti-mcp-server

๐Ÿงช Verifying Your Local SSE Server (No Agent Required)

Because Model Context Protocol (MCP) uses Server-Sent Events (SSE) under the hood, you can verify your local server using standard command-line tools without needing a desktop AI client or agent installed.

This test requires two additional terminal windows (or tabs), leaving your local server running in your current window from the previous step:

Step 1: Run the Server (Terminal Window 1)

This is the server you already started in the previous Quick Start step! (If you stopped it, simply open Terminal Window 1, activate your virtual environment, and run gti-mcp-server again). Leave this server running.

Step 2: Open the Event Stream (Terminal Window 2)

Establish a streaming SSE connection. Because SSE is a streaming protocol, this connection will stay open ("hanging") to capture real-time responses:

curl -i -N http://localhost:8000/sse

What you will see: It will connect instantly and output the initial dynamic connection endpoint along with a unique session ID:

HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

event: endpoint
data: /messages/?session_id=a1b2c3d4e5f6...

Leave this window running and copy your generated session_id.

Step 3: Perform the Handshake and Run Queries (Terminal Window 3)

In your third terminal window, run the following three requests sequentially (substituting your copied session_id) to complete the protocol handshake and list your tools:

  1. Initialize the MCP Session:

    curl -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 1,
        "method": "initialize",
        "params": {
          "protocolVersion": "2024-11-05",
          "capabilities": {},
          "clientInfo": {
            "name": "curl-test-client",
            "version": "1.0"
          }
        }
      }' \
      "http://localhost:8000/messages/?session_id=YOUR_ACTIVE_SESSION_ID"

    (Check Terminal Window 1: you will see a streamed message event containing the server's protocol capabilities).

  2. Confirm Handshake Completion:

    curl -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "method": "notifications/initialized"
      }' \
      "http://localhost:8000/messages/?session_id=YOUR_ACTIVE_SESSION_ID"
  3. List Available Threat Intelligence Tools:

    curl -X POST \
      -H "Content-Type: application/json" \
      -d '{
        "jsonrpc": "2.0",
        "id": 2,
        "method": "tools/list",
        "params": {}
      }' \
      "http://localhost:8000/messages/?session_id=YOUR_ACTIVE_SESSION_ID"

Look back at Terminal Window 1: You will see a complete, beautiful JSON-RPC stream containing all your Google Threat Intelligence capabilities (get_file_report, search_iocs, etc.)!


Containerization & Docker (Alternative)

This server is pre-configured with a secure, multi-stage Docker build spec and a companion Docker Compose layout.

Since docker-compose.yml is configured to build your container automatically, you do not need to run a separate build command! You can compile the image and launch the container on-the-fly with a single command:

# Make sure your API key is in your active terminal environment
export VT_APIKEY="your_actual_gti_api_key_here"

# Compile and start the server in the background
docker compose up -d

This starts the containerized server in the background, maps port 8000 to port 8000 on your host computer, and passes your terminal's ${VT_APIKEY} directly into the secure container memory.


Production Google Cloud Run Deployment (Strict Secret Manager)

This section provides a secure-by-default, step-by-step walkthrough for deploying to Google Cloud Run. It uses Google Secret Manager for credential storage and restricts invocations using GCP IAM OIDC Authentication (disallowing unauthenticated access).

Step 1: Set Your Deployment Variables

Replace the placeholder values below with your GCP details:

PROJECT_ID="your-gcp-project-id"   # Your GCP Project ID
REGION="us-central1"               # GCP Region to deploy to
REPO="mcp-servers"                 # Artifact Registry Repository name
IMAGE="gti-mcp-server"             # Container Image name

Step 2: Authenticate and Enable Required GCP Services

Authenticate your local shell session with Google Cloud and enable the APIs required for container hosting and secure secret storage:

# Authenticate your local shell session with Google Cloud
gcloud auth login

# Set your active gcloud project context
gcloud config set project ${PROJECT_ID}

# Enable Secret Manager, Artifact Registry, and Cloud Run APIs
gcloud services enable \
  secretmanager.googleapis.com \
  artifactregistry.googleapis.com \
  run.googleapis.com

Step 3: Secure your API Key in Google Secret Manager

Create a managed secret to host your Google Threat Intelligence (VirusTotal) API key securely:

  1. Create the Secret container:

    gcloud secrets create VT_APIKEY --replication-policy="automatic"
  2. Add your API key value as version 1 of the secret: Replace YOUR_ACTUAL_GTI_API_KEY with your actual token:

    echo -n "YOUR_ACTUAL_GTI_API_KEY" | gcloud secrets versions add VT_APIKEY --data-file=-

Step 4: Grant Access to the Cloud Run Service Account

Cloud Run services run under a designated service account. By default, Cloud Run uses the Compute Engine default service account to call other GCP APIs.

  1. Get your Project Number:

    PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
    echo "Your Project Number is: ${PROJECT_NUMBER}"
  2. Determine the Default Service Account Email: The default service account email follows the pattern: ${PROJECT_NUMBER}-compute@developer.gserviceaccount.com

  3. Grant Secret Accessor permission to this service account: This authorizes the Cloud Run container to fetch and decrypt the secret at startup:

    gcloud secrets add-iam-policy-binding VT_APIKEY \
      --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
      --role="roles/secretmanager.secretAccessor"

Step 5: Deploy to Cloud Run (Choose Your Path)

You can choose either of these two paths to compile and deploy your server. Option A is highly recommended for non-technical users as it does not require Docker or manual registry configurations!

๐Ÿš€ Option A: Direct Source-to-Cloud Deployment (No Local Docker Required)

This is the fastest, simplest method. Google Cloud will securely package your source directory, upload it, run Google Cloud Build in the background using your Dockerfile, automatically provision a private Artifact Registry under the hood, and deploy the service.

Simply run this single command from your repository root:

gcloud run deploy gti-mcp-server \
  --source . \
  --region=${REGION} \
  --platform=managed \
  --no-allow-unauthenticated \
  --set-secrets="VT_APIKEY=VT_APIKEY:latest" \
  --set-env-vars="TRANSPORT=http,STATELESS=1" \
  --port=8000 \
  --max-instances=5 \
  --cpu=1 \
  --memory=512Mi \
  --no-cpu-throttling

๐Ÿณ Option B: Traditional Docker Build, Push, & Deploy

Choose this path if you prefer to compile, tag, and push your container image using Docker running locally on your laptop:

  1. Create the Docker repository in Artifact Registry:

    gcloud artifacts repositories create ${REPO} \
      --repository-format=docker \
      --location=${REGION} \
      --description="MCP Servers Repository"
  2. Authenticate Docker to push to your GCP registry:

    gcloud auth configure-docker ${REGION}-docker.pkg.dev
  3. Build and Tag the image (Intel/AMD64 target format):

    docker build --platform linux/amd64 -t ${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO}/${IMAGE}:latest .
  4. Push the image to GCP:

    docker push ${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO}/${IMAGE}:latest
  5. Deploy the pushed image to Cloud Run:

     gcloud run deploy gti-mcp-server \
       --image=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO}/${IMAGE}:latest \
       --region=${REGION} \
       --platform=managed \
       --no-allow-unauthenticated \
       --set-secrets="VT_APIKEY=VT_APIKEY:latest" \
       --set-env-vars="TRANSPORT=http,STATELESS=1" \
       --port=8000 \
       --max-instances=5 \
       --cpu=1 \
       --memory=512Mi \
       --no-cpu-throttling

Step 6: Retrieve and Save Your Cloud Run Service URL

Once successfully deployed, retrieve your Cloud Run live service URL and export it as an environment variable in your terminal session. This variable is required to register your server with Gemini Enterprise later:

SERVICE_URL=$(gcloud run services describe gti-mcp-server --region=${REGION} --format="value(status.url)")
echo "Your live Service URL is: ${SERVICE_URL}"

[NOTE] Setting host="0.0.0.0" in our server configuration ensures that the container is fully compatible with Cloud Run and can accept incoming production connections smoothly.

๐Ÿงช Verifying Your Cloud Run Stateless HTTP Server (No Agent Required)

Once your service is deployed, you can verify that the live production server is functioning, authenticated, and communicating properly over the network without needing to set up an AI agent first.

Using the official Google Cloud secure proxy is the simplest, safest, and most recommended method because it handles OAuth authentication and Host headers automatically.

This test requires two separate terminal windows (or tabs):

Step 1: Start the Cloud Run Proxy (Terminal Window 1)

Run this command to boot up a secure local authentication tunnel mapped to port 8000:

gcloud run services proxy gti-mcp-server --region=${REGION} --port 8000

Leave this terminal running. It will output a confirmation log indicating that port 8000 is proxying to your secure Cloud Run service.

Step 2: Query the Tools List (Terminal Window 2)

In your second terminal window, send a single JSON-RPC POST request to the proxied server at /mcp to list all available tools:

curl -X POST \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }' \
  "http://localhost:8000/mcp"

What you will see: It will connect instantly and output a beautiful JSON-RPC response containing your entire suite of Google Threat Intelligence tools (get_file_report, search_iocs, etc.) served directly from your secure Cloud Run deployment!


Gemini Enterprise Integration (Optional)

You can easily connect and register this secure Cloud Run MCP server directly with your Gemini Enterprise App (such as default-chat within Vertex AI Agent Builder) using a 100% command-line driven Discovery Engine custom MCP data store workflow.

Follow these command-driven steps to enable the required APIs, configure your OAuth identity provider, create your data store, authorize security, enable threat intelligence actions, and link them to Gemini:

Step 1: Enable Required APIs

Enable the advanced core APIs required for Discovery Engine custom datastores first, as initialization may take a minute:

gcloud services enable discoveryengine.googleapis.com \
  --project=${PROJECT_ID}

Step 2: Define Your OAuth Endpoints

Configure your session variables for your OAuth identity provider (required by Discovery Engine to federate and authenticate custom MCP servers):

# Default Google Cloud Identity OAuth 2.0 endpoints (change these if you are using a custom/external Identity Provider)
AUTH_URL="https://accounts.google.com/o/oauth2/v2/auth"
TOKEN_URL="https://oauth2.googleapis.com/token"

Step 3: Create an OAuth Client ID

Because OAuth Clients cannot be created programmatically via gcloud APIs, you must create one manually in the Google Cloud Console:

  1. Navigate to the Google Cloud Console API Credentials page.

  2. Click Create Credentials > OAuth client ID.

  3. Select Web application as the application type.

  4. Name your client (e.g., GTI MCP Server Client).

  5. Under Authorized redirect URIs, add any redirect URIs if required by your identity environment.

  6. Click Create and copy your Client ID and Client Secret.

Once you have your credentials, define them in your active terminal session:

CLIENT_ID="your-client-id"                      # Replace with your copied OAuth Client ID
CLIENT_SECRET="your-client-secret"              # Replace with your copied OAuth Client Secret
TIP

For more details on Google's OAuth 2.0 implementation and general concepts, refer to theOfficial Google Identity OAuth 2.0 Documentation.

Step 4: Create the Custom MCP Data Store (via setUpDataConnector REST API)

Because the discoveryengine command group is not standard in the public gcloud SDK, use curl to invoke the Discovery Engine custom MCP setup API directly.

First, define your Discovery Engine settings:

LOCATION="us"                           # Discovery Engine location (e.g., us, global)
COLLECTION_ID="gti-mcp-server-collection"  # Your unique collection identifier
DISPLAY_NAME="Google Threat Intelligence Tools"

Now, execute the API call to establish a federated custom MCP connector:

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "X-Goog-User-Project: ${PROJECT_ID}" \
  -H "Content-Type: application/json" \
  -d '{
    "collectionDisplayName": "'"${DISPLAY_NAME}"'",
    "dataConnector": {
      "dataSource": "custom_mcp",
      "connectorSourceId": "custom_mcp",
      "params": {
        "oauth_access_token": "unused",
        "auth_type": "AUTHORIZATION_TYPE_UNDEFINED"
      },
      "refreshInterval": "86400s",
      "entities": [
        {
          "entityName": "mcp_data"
        }
      ],
      "dataSourceVersion": 1,
      "staticIpEnabled": false,
      "actionConfig": {
        "actionParams": {
          "instance_uri": "'"${SERVICE_URL}"'/mcp",
          "auth_uri": "'"${AUTH_URL}"'",
          "token_uri": "'"${TOKEN_URL}"'",
          "client_id": "'"${CLIENT_ID}"'",
          "client_secret": "'"${CLIENT_SECRET}"'",
          "scopes": "openid",
          "auth_type": "OAUTH",
          "mcp_server_description": "Google Threat Intelligence (GTI) MCP server. Exposes tools to query Indicators of Compromise (IOCs), threat analytics, domain and IP address intelligence, and file/artifact reputation or sandbox analysis.",
          "mcp_agent_instructions": "You are a security analyst assistant. Use this Google Threat Intelligence (GTI) MCP server to analyze security threats, investigate network artifacts (domains, IPs, URLs), and query file reports or execution behaviors. Always validate hash formats (MD5, SHA1, SHA256) and ensure domain inputs are stripped of protocol schemas before querying.",
          "mcp_server_source": "BYO_MCP"
        },
        "createBapConnection": true,
        "isActionConfigured": false
      },
      "connectorModes": [
        "FEDERATED"
      ]
    }
  }' \
  "https://${LOCATION}-discoveryengine.googleapis.com/v1alpha/projects/${PROJECT_ID}/locations/${LOCATION}:setUpDataConnector?collectionId=${COLLECTION_ID}"

Step 5: Authorize the Gemini Enterprise Service Account (IAM)

Because your Cloud Run service is locked down securely (--no-allow-unauthenticated), you must explicitly authorize the Gemini Enterprise Discovery Engine system service account to call and invoke your Cloud Run endpoint.

Run these commands to bind the Cloud Run Invoker role:

# Retrieve your active Discovery Engine system service account email
DISCOVERY_ENGINE_SA="service-${PROJECT_NUMBER}@gcp-sa-discoveryengine.iam.gserviceaccount.com"

# Grant it invoker rights to your Cloud Run service
gcloud run services add-iam-policy-binding gti-mcp-server \
    --member="serviceAccount:${DISCOVERY_ENGINE_SA}" \
    --role="roles/run.invoker" \
    --region=${REGION} \
    --project=${PROJECT_ID}

Step 6: Reload and Enable Your Actions (GCP Console UI)

Because the custom actions discovery and OAuth consent handshake are handled securely by Google Cloud Console's frontend, you must perform a one-time manual reload to authorize and activate your threat intelligence tools:

  1. Open the Google Cloud Agent Builder Data Stores Console.

  2. Select your newly created Google Threat Intelligence Tools data store.

  3. Click on the Actions tab on the left-hand navigation pane.

  4. If prompted, click Re-authenticate to sign in and complete the OAuth connection.

  5. Click the Reload custom actions button. This will connect to your Cloud Run service's /mcp endpoint and dynamically populate all 45+ GTI tools.

  6. Select the tools you want to enable, and click Enable actions.


Finally, link your newly configured threat intelligence data store to your active Gemini App configuration (e.g., your chat or search application):

  1. Open the Gemini Enterprise Console.

  2. In the left-hand navigation pane, click on Apps

  3. Click on your Gemini Enterprise application

  4. In the left-hand navigation pane, click on Connected data stores.

  5. Click Add existing data store

  6. Select your newly created Google Threat Intelligence Tools data store from the list.

  7. Click Connect (or Save) to confirm.

Your Gemini Enterprise conversational app is now fully integrated with real-time Google Threat Intelligence capabilities, securely authorized, and ready to assist your security operations team! ๐Ÿš€

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).

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: iocs (required), name (required), description (required), private. 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: feature_id (required), entity_type (required), feature_type (required), search_space (required), +3 more. Returns: result

get_collection_mitre_treeB

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). Returns: result

get_collection_reportB

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). 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. 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). Returns: result

get_collection_timeline_eventsA

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).

get_domain_reportB

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). 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). 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). Returns: result

get_file_reportA

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). Returns: result

get_hunting_rulesetA

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). Returns: result

get_ip_address_reportA

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). Returns: result

get_threat_profileA

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). 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. 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. 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). Returns: result

list_threat_profilesA

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. Returns: result

search_campaignsA

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. 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), page, size, since, +3 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. 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. 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. 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. 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. 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), limit, order_by, collection_type. 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. Returns: result

update_collection_attributesA

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. Returns: result

update_iocs_in_collectionB

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), iocs (required), operation (required), relationship (required). Returns: result

Tool Schema Changelog

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

Loading tool schema changelogโ€ฆ

    TDQS

    B3.4/5.0

    Scored across 36 tools

    Disambiguation4/5

    Most tools have distinct purposes, e.g., searching different entity types (search_campaigns, search_malware_families) and retrieving reports (get_file_report, get_domain_report). However, search_threats can filter by collection_type, causing slight overlap with the specific search tools. Overall clear differentiation.

    Naming Consistency4/5

    Predominantly follows verb_noun pattern (e.g., create_collection, get_collection_report). Inconsistencies include 'analyse_file' (British spelling) versus American spelling used elsewhere, and verbose names like get_entities_related_to_a_collection. Still largely predictable.

    Tool Count3/5

    With 36 tools, the count is on the high side. The server covers a broad threat intelligence domain, but multiple similar tools (e.g., seven search tools, five get_entities_related_to_* tools) add redundancy. Could be streamlined without losing functionality.

    Completeness4/5

    The tool set covers CRUD operations for collections, detailed reports for various IOC types, and specialized searches. Notable gap: no tool to delete a collection entirely (only update). Digital threat monitoring and hunting rulesets are well-integrated. Minor missing features prevent a perfect score.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      B
      quality
      D
      maintenance
      Enables AI assistants to access Google's Threat Intelligence suite for file analysis, indicator of compromise searches, and reputation checking. It supports both local and cloud-based deployments for investigating campaigns, threat actors, and malware families.
      36
      4
      -
    • 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
    • F
      license
      Not graded
      quality
      D
      maintenance
      Provides real-time threat intelligence for AI agents, enabling checks on IPs, domains, URLs, hashes, CVEs, prompt-injection payloads, and malicious AI-skill/MCP-tool definitions against a free database of 890K+ IOCs.
      -
    • A
      license
      A
      quality
      C
      maintenance
      Gives AI agents threat-intelligence verdicts for IPs, domains, URLs and hashes, CVE lookups with EPSS and CISA KEV data, and a prompt-injection gate that scans untrusted text before the agent acts on it. Agents can also batch-check up to 100 indicators, hunt brand-lookalike domains, and track scan and request quotas.
      1
      203 npm
      1
      MIT