cortex-mcp
Summary: This MCP server lets an AI client operate a Cortex instance for observable analysis, job/artifact handling, gated response actions, and organization/user administration.
Browse, inspect, enable/disable, and run analyzers, including file submissions by path or base64.
Analyze observables with auto-detected types, explicit analyzer allowlists, or opt-in fan-out with taxonomy aggregation.
Track and manage jobs: list/filter, get status, wait for reports, retrieve reports and IOC artifacts, delete jobs, and clean up old/failed jobs.
List and execute responders against TheHive entities, with destructive operations gated by env permission and
confirm=true.Browse, enable, and disable responder definitions.
Check Cortex instance status, version, and configuration.
With superadmin credentials, manage organizations and users, including creating users and renewing API keys (schema also exposes key retrieval).
Use MCP resources/prompts for analyzer/responder/job context and guided workflows like observable analysis, IOC investigation, setup, and alert triage.
Allows for the submission of observables like IPs and hashes to VirusTotal through Cortex's analysis pipeline for security enrichment.
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., "@cortex-mcp Analyze the IP 185.220.101.42 and give me a summary of the findings"
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.
cortex-mcp is a Model Context Protocol (MCP) server for Cortex, the observable analysis and active-response engine from StrangeBee/TheHive Project. It exists because analysts already drive Cortex by hand through its web UI or raw REST API, and an AI client can do that work faster: detonate an indicator across every applicable analyzer, aggregate the taxonomy verdicts, and pull artifacts without anyone clicking through a dozen jobs. It differs from a generic HTTP bridge by exposing Cortex's real domain model as 30 typed MCP tools, auto-detecting observable data types, fanning out analysis with a cap, and gating every destructive action (responders, deletes, file reads) behind explicit confirmation.
What it does
cortex-mcp connects an MCP-capable AI client (Claude Desktop, Claude Code, Codex CLI, OpenClaw, Hermes, and others) to a running Cortex instance so the model can perform real observable analysis and threat-intelligence enrichment. Cortex is the analyzer/responder engine in the StrangeBee and TheHive SOAR stack: it runs analyzers against observables (IPs, domains, URLs, file hashes, emails, files) and executes responders against TheHive entities. This server speaks Cortex's REST API and projects the full pipeline as MCP tools, resources, and prompts, so an agent can browse analyzer definitions, enable and configure them, submit observables, wait for job reports, extract IOC artifacts, and triage alerts. Auto-detection classifies an observable's data type before analysis, bulk analysis fans out across applicable analyzers and aggregates the taxonomy results, and superadmin tools cover organization and user/API-key management. The result is conversational observable analysis: ask "what does Cortex think of 185.220.101.42?" and get an aggregated multi-analyzer verdict back.
Related MCP server: misp-mcp
Prerequisites
Node.js 20 or later
A running Cortex instance (v3.x recommended)
A Cortex API key with appropriate permissions
Installation from source
If you prefer to run from a checkout instead of npx:
git clone https://github.com/lidless-labs/cortex-mcp.git
cd cortex-mcp
npm install
npm run buildThen point your client at the built binary (see the per-client recipes below).
Try it (copy-paste MCP client config)
Add this to your MCP client config (this example is Claude Desktop's claude_desktop_config.json; the same command/args/env shape works for Claude Code, Codex, OpenClaw, and Hermes). It runs the published npm package directly with npx, no clone or build required:
{
"mcpServers": {
"cortex": {
"command": "npx",
"args": ["-y", "thehive-cortex-mcp"],
"env": {
"CORTEX_URL": "https://cortex.example.com:9001",
"CORTEX_API_KEY": "your-org-admin-key",
"CORTEX_SUPERADMIN_KEY": "your-superadmin-key"
}
}
}
}The npm package is named thehive-cortex-mcp; it installs a cortex-mcp binary. Set CORTEX_SUPERADMIN_KEY only if you want the organization and user management tools.
Usage
Claude Code
claude mcp add cortex \
--env CORTEX_URL=https://cortex.example.com:9001 \
--env CORTEX_API_KEY=your-org-admin-key \
--env CORTEX_SUPERADMIN_KEY=your-superadmin-key \
-- npx -y thehive-cortex-mcpAdd --scope user to make it available from any directory instead of only the current project.
OpenClaw
openclaw mcp set cortex '{
"command": "npx",
"args": ["-y", "thehive-cortex-mcp"],
"env": {
"CORTEX_URL": "https://cortex.example.com:9001",
"CORTEX_API_KEY": "your-org-admin-key",
"CORTEX_SUPERADMIN_KEY": "your-superadmin-key"
}
}'If you are running from a source checkout instead, point command/args at the built dist/index.js:
openclaw mcp set cortex '{
"command": "node",
"args": ["/absolute/path/to/cortex-mcp/dist/index.js"],
"env": {
"CORTEX_URL": "https://cortex.example.com:9001",
"CORTEX_API_KEY": "your-org-admin-key",
"CORTEX_SUPERADMIN_KEY": "your-superadmin-key"
}
}'Then restart the OpenClaw gateway so the new server is picked up:
systemctl --user restart openclaw-gateway
openclaw mcp list # confirm "cortex" is registeredHermes Agent
Hermes Agent reads MCP config from ~/.hermes/config.yaml under the mcp_servers key. Add an entry:
mcp_servers:
cortex:
command: "npx"
args: ["-y", "thehive-cortex-mcp"]
env:
CORTEX_URL: "https://cortex.example.com:9001"
CORTEX_API_KEY: "your-org-admin-key"
CORTEX_SUPERADMIN_KEY: "your-superadmin-key"Then reload MCP from inside a Hermes session:
/reload-mcpCodex CLI
Codex CLI registers MCP servers via codex mcp add:
codex mcp add cortex \
--env CORTEX_URL=https://cortex.example.com:9001 \
--env CORTEX_API_KEY=your-org-admin-key \
--env CORTEX_SUPERADMIN_KEY=your-superadmin-key \
-- npx -y thehive-cortex-mcpCodex writes the entry to ~/.codex/config.toml under [mcp_servers.cortex]. Verify with:
codex mcp listStandalone
export CORTEX_URL=https://cortex.example.com:9001
export CORTEX_API_KEY=your-org-admin-key
npx -y thehive-cortex-mcp # or `npm start` from a source checkoutMCP Tools (30)
Status
Tool | Description |
| Get Cortex instance health, version, and configuration |
Analyzer Tools
Tool | Description |
| List all enabled analyzers, optionally filtered by data type |
| Get details about a specific analyzer by ID |
| Submit an observable to a specific analyzer for analysis |
| Run an analyzer by name instead of ID (convenience wrapper) |
| Submit a file to an analyzer. |
Analyzer Definition Tools
Tool | Description |
| Browse all available analyzer definitions with filtering (by data type, free/no-config, search) |
| Enable an analyzer definition in the current org with configuration |
| Disable (remove) an enabled analyzer (destructive; requires |
Job Tools
Tool | Description |
| Get the status and details of an analysis job |
| Get the full report of a completed analysis job |
| Wait for a job to complete and return the report |
| List recent analysis jobs with optional filters |
| Get artifacts (extracted IOCs) from a completed job |
| Delete a specific job (destructive; requires |
| Bulk delete jobs by status or age (with dry-run) |
Responder Tools
Tool | Description |
| List all enabled responders, optionally filtered by data type |
| Execute a responder action against a TheHive entity (destructive; requires |
Responder Definition Tools
Tool | Description |
| Browse all available responder definitions with filtering |
| Enable a responder definition with configuration |
| Disable (remove) an enabled responder (requires |
Bulk Operations
Tool | Description |
| Run analyzers against an observable (auto-detected data type) and aggregate taxonomy results. Pass an |
Organization Management (superadmin)
Tool | Description |
| List all organizations |
| Get organization details |
| Create a new organization |
| Update organization description or status |
User Management (superadmin)
Tool | Description |
| List all users across organizations |
| Get user details |
| Create a new user in an organization |
| Rotate a key through an operator-configured credential store (requires |
MCP Resources (4)
URI | Description |
| Enabled analyzers with capabilities |
| All available analyzer definitions with config requirements |
| All available responder definitions with config requirements |
| Last 50 analysis jobs |
MCP Prompts (4)
Prompt | Description |
| Guided workflow for analyzing an observable through Cortex |
| Deep investigation workflow for a suspicious IOC |
| Guided setup wizard for fresh Cortex instances (enable free analyzers, configure API keys) |
| Structured alert triage workflow with multi-observable analysis and risk assessment |
Configuration
Variable | Required | Default | Description |
| Yes | - | HTTPS base URL without embedded credentials, query string or fragment (e.g., |
| Yes | - | API key for normal operations (org admin level) |
| No | - | Superadmin API key for org/user/definition management |
| No |
| Accepts |
| No |
| Accepts |
| No |
| Set to |
| No |
| Accepts |
| No |
| Request timeout as a positive integer from 1 to 300 seconds. Wait-report calls ( |
| No | - | Absolute base directory that |
| No |
| Set to |
| No |
| Positive safe integer from 1 to 9,007,199,254,740,991. Maximum number of analyzers |
Security and safety gates
This server can trigger real-world actions and submit observables to third-party services, so several capabilities are secured by default:
Arbitrary file reads are blocked.
cortex_run_analyzer_fileonly reads files insideCORTEX_FILE_BASE_DIR(realpath-confined to defeat symlink/..escapes). With no base dir configured, path-based reads are refused; usefileBase64to submit content explicitly.Writes are opt-in. Set
CORTEX_MODE=writebefore submitting analysis or changing configuration. POST job searches remain available in read-only mode.Responders are gated.
cortex_run_responderrequires bothCORTEX_ALLOW_DESTRUCTIVE=1in the environment andconfirm=truein the call.Changes require confirmation where indicated. User creation with roles, key rotation, organization locking, responder removal, job deletion, analyzer removal and cleanup with
dryRun=falserequireconfirm=true. Deletion and responder execution also requireCORTEX_ALLOW_DESTRUCTIVE=1.Bulk analysis is conservative.
cortex_analyze_observabledoes not fan out to every analyzer by default. Pass an explicitanalyzersallowlist, or setfanOut=trueto run all applicable analyzers (capped byCORTEX_MAX_FANOUT).API transport requires HTTPS. HTTP is allowed without an override only for literal dotted-decimal addresses in
127.0.0.0/8and IPv6::1(including expanded notation). DNS names, includinglocalhostand names ending in.localhost, IPv4-mapped IPv6, encoded addresses and legacy IPv4 forms require the explicit insecure HTTP override. No DNS lookup determines this exception. Prefer HTTPS with a trusted private CA throughNODE_EXTRA_CA_CERTS. The override does not disable certificate verification or permit URL userinfo.SSL verification is scoped. Disabling
CORTEX_VERIFY_SSLrelaxes TLS only for Cortex connections, never for the whole Node process.
Result and input limits
Responses are limited to 4 MiB while streaming. JSON request bodies are limited to
1 MiB, incoming MCP message lines to 16 MiB before parsing, and file uploads to 10 MiB. Path-based files must be regular files within
the configured base directory. Text arguments are limited to 65,536 characters,
with a separate encoded-file limit. Tool and resource data is JSON-quoted inside
escaped untrusted_cortex_data blocks, limited to 64 KiB with a truncation marker.
Resources use text/plain for that envelope. Upstream error bodies and status text
are omitted. Credential-bearing configuration and serialized parameters are omitted. Common
credential fields are redacted from structured results.
Credential delivery and worker networking
The Proxmox installer reads keys silently, sends credentials through stdin, and
stores them with owner-only permissions for systemd LoadCredential. The server
reads cortex-api-key and cortex-url from CREDENTIALS_DIRECTORY when their
respective environment variables are absent. Environment configuration still works.
The installed service runs as the dedicated cortex-mcp system account with no login shell. Application files under /opt/cortex-mcp remain root-owned and read-only to that account. Source credentials under /etc/cortex-mcp remain root-only. Systemd supplies private credential copies and owns the service's writable state and runtime directories (/var/lib/cortex-mcp and /run/cortex-mcp, mode 0700). The unit uses a read-only filesystem sandbox, a private temporary directory, no capabilities and NoNewPrivileges. Keep private CA certificates readable by the account when configuring NODE_EXTRA_CA_CERTS in a unit override.
For embedded use, pass an operator-approved CredentialStore adapter as the second
CortexClient constructor argument. Its put(userId, key) method must persist the
key without logging it and return a non-secret reference. Rotation returns only
that reference and a SHA-256 fingerprint. A failed store write is reported without
key material. If it fails after renewal, recover through Cortex administration.
Network-target validation covers IP, domain, FQDN and HTTP/HTTPS URL submissions. URL credentials and unsupported schemes are refused. DNS checks have a five-second budget and reject any private or special-purpose answer unless explicitly permitted. Configure the Cortex workers' network policy to enforce the same destination rules on every connection, including redirects and later DNS resolutions. Submission-time checks cannot enforce worker-side redirects or DNS changes. Cortex API redirects are refused by the client.
Examples
Set up analyzers from scratch
1. Use cortex_list_analyzer_definitions with freeOnly=true to find analyzers
that need no API keys.
2. Use cortex_enable_analyzer to enable "Abuse_Finder_3_0" with empty config.
3. Use cortex_analyze_observable with data "8.8.8.8" and fanOut=true to run
all applicable analyzers (or pass analyzers ["Abuse_Finder"] to scope it).Auto-detect observable type
Use cortex_analyze_observable with data "185.220.101.42" and fanOut=true
(no dataType needed - auto-detects as IP). Or pass an `analyzers` allowlist
to limit which analyzers run.Clean up old failed jobs
Use cortex_cleanup_jobs with status "Failure", dryRun true to preview,
then dryRun false and confirm true to delete (requires write mode and destructive permission).Analyze a file
Set CORTEX_FILE_BASE_DIR=/srv/cortex-uploads in the server environment, then:
Use cortex_run_analyzer_file with analyzerId "Yara_3_0",
filePath "/srv/cortex-uploads/suspicious.exe" to scan with YARA rules.
(Paths outside CORTEX_FILE_BASE_DIR are refused; alternatively pass fileBase64.)Manage API keys
Key retrieval is unavailable. Rotation requires write mode, confirm=true and an
operator-configured credential store adapter. The stock stdio server has no adapter
and refuses rotation before contacting Cortex. Manage keys through Cortex administration
until a store adapter is configured.Triage a security alert
Use the triage-alert prompt with alertDescription "Suspicious outbound traffic
detected" and observables "185.220.101.42, evil.example.com, 44d88612fea8a8f36de82e1278abb02f"Supported Data Types
Type | Examples | Auto-detected |
|
| yes |
|
| yes |
|
| yes |
| MD5, SHA1, SHA256, SHA512 | yes |
|
| yes |
|
| As domain |
|
| Manual |
|
| Manual |
| Binary file uploads | Manual |
| CVEs, custom types | Manual |
Deployment
Proxmox LXC
Before running the installer, review a local copy of the script and set these immutable inputs. There are no defaults:
CORTEX_SOURCE_COMMIT: the full 40-character hexadecimal commit reviewed for installation fromhttps://github.com/lidless-labs/cortex-mcp.git.NODE_VERSION: an exact Node 22 version at least22.12.0, without avprefix.NODE_ARCH:x64orarm64, matching the guest architecture.NODE_SHA256: the 64-character SHA-256 of that version'snode-v<VERSION>-linux-<ARCH>.tar.xzarchive.
Obtain the archive checksum from the official release's signed
SHASUMS256.txt.asc. Verify its signature with a separately trusted Node release
keyring using the official binary verification instructions
before supplying the checksum. Do not copy a checksum from the same unverified
download as the archive.
The installer rejects missing or malformed pins before any host command or LXC
creation. It downloads only from https://nodejs.org/dist/v<VERSION>/, checks the
archive against the supplied checksum before extraction, then fetches the reviewed
source commit from the canonical repository and checks its exact hash before
npm ci --ignore-scripts or the build. Node is installed in /usr/local, including
the service executable /usr/local/bin/node. Ubuntu template and apt prerequisites
still follow their upstream repositories. This does not freeze the whole OS or
provide a reproducible apt snapshot. An interrupted install leaves its guest for
operator inspection. A retry refuses an existing container ID.
Release publishing
The tag workflow uses npm trusted publishing and provenance. Configure the package's
trusted publisher for lidless-labs/cortex-mcp and .github/workflows/ci.yml on npm
before the next release. The workflow uses Node 24 and grants OIDC permission only
to the publish job. It does not use an npm token. Changing this workflow does not
publish a release or configure the npm account.
Why not something else?
The Cortex web UI is built for one analyst clicking through jobs by hand. cortex-mcp puts the same engine behind an AI client, so analysis, taxonomy aggregation, and artifact extraction happen conversationally instead of through a dozen page loads.
A raw REST wrapper or generic HTTP MCP bridge gives a model an untyped endpoint and no domain knowledge. cortex-mcp models analyzers, responders, jobs, definitions, organizations, and users as 31 typed tools with auto data-type detection, capped fan-out, and built-in safety gates, so the agent works in Cortex's vocabulary rather than reconstructing the API from scratch.
Wiring Cortex into a SOAR runbook or n8n flow is great for fixed, pre-authored pipelines. This server is for the open-ended path: ad hoc enrichment, investigation, and triage where the analyst (or the agent) decides the next step as results come in.
thehive-mcp (the companion server) drives case and alert management in TheHive. cortex-mcp is the analysis-and-response layer; the two are complementary, not substitutes.
What cortex-mcp is not
It is not a Cortex replacement or a reimplementation of analyzers. It calls a Cortex instance you already run; Cortex still does the analysis.
It is not a SIEM, a case manager, or a TheHive client. Case and alert workflows belong to TheHive (see thehive-mcp).
It is not an autonomous responder. Destructive actions (responders, job deletion, file reads by path) are off or confirmation-gated by default and never fire silently.
It is not a hosted service. It runs locally as a stdio MCP server next to your client; nothing is sent anywhere except the Cortex instance you configure.
Testing
npm test # Unit tests
npm run test:watch # Watch mode
npm run lint # Type check
# Integration tests (requires live Cortex instance)
CORTEX_URL=https://cortex.example.com:9001 \
CORTEX_API_KEY=your-key \
CORTEX_SUPERADMIN_KEY=your-superadmin-key \
npx vitest run tests/integration.test.tsLive lifecycle tests also require CORTEX_TEST_MUTATIONS=true, CORTEX_MODE=write
and CORTEX_ALLOW_DESTRUCTIVE=1. Use a disposable Cortex instance for these tests.
They remove the analyzers and responders they create and report cleanup failures.
Project Structure
cortex-mcp/
src/
index.ts # MCP server entry point
config.ts # Environment config + validation
client.ts # Cortex REST API client (full surface)
types.ts # Cortex API type definitions
resources.ts # MCP resources (4)
prompts.ts # MCP prompts (4)
tools/
analyzers.ts # Analyzer tools (list, get, run, run-by-name)
analyzer-definitions.ts # Definition browsing, enable, disable
jobs.ts # Job management + cleanup
responders.ts # Responder tools (list, run)
responder-definitions.ts # Definition browsing, enable, disable
bulk.ts # Bulk analysis with auto-detect
status.ts # Health/version check
organizations.ts # Org CRUD (superadmin)
users.ts # User CRUD + key management (superadmin)
tests/
client.test.ts # API client unit tests
tools.test.ts # Tool handler unit tests
integration.test.ts # Live instance integration tests
scripts/
proxmox_install.sh # Proxmox LXC deployment scriptContributing
Issues and pull requests are welcome. See CONTRIBUTING.md for the contribution path and SECURITY.md for reporting vulnerabilities. By participating you agree to the Code of Conduct.
Container root access
The installer creates no guest root password and locks password login after starting the container. Manage the guest from its Proxmox host with pct enter. Service API credentials continue to use protected stdin delivery and root-only storage.
License
MIT. See LICENSE.
Available Tools
31 toolscortex_analyze_observableA
Run applicable analyzers against an observable and collect aggregated results with taxonomy summary. Can auto-detect data type. By default only an explicit allowlist of analyzers runs; set fanOut=true to submit to every applicable analyzer (capped by CORTEX_MAX_FANOUT). Fanning out submits the observable to many third-party services (SSRF-by-proxy / IOC disclosure / quota burn), so it is opt-in.
Inputs: data (required), pap, tlp, fanOut, +4 more.
cortex_cleanup_jobsA
Delete multiple jobs by status or age. Useful for cleaning up failed or old jobs.
Inputs: limit, dryRun, status, olderThanDays.
cortex_create_organizationA
Create a new organization in Cortex (requires superadmin API key)
Inputs: name (required), description (required).
cortex_create_userA
Create a new user in an organization (requires superadmin API key)
Inputs: name (required), login (required), roles (required), organization (required), +1 more.
cortex_delete_jobA
Delete a specific analysis job by ID. DESTRUCTIVE: requires confirm=true.
Inputs: jobId (required), confirm.
cortex_disable_analyzerA
Disable (remove) an enabled analyzer from the current organization. DESTRUCTIVE: requires confirm=true.
Inputs: analyzerId (required), confirm.
cortex_disable_responderA
Disable (remove) an enabled responder from the current organization
Inputs: responderId (required).
cortex_enable_analyzerA
Enable an analyzer definition in the current organization. Provide configuration values for any required fields.
Inputs: definitionId (required), rate, jobCache, rateUnit, +1 more.
cortex_enable_responderC
Enable a responder definition in the current organization. Provide configuration values for any required fields.
Inputs: definitionId (required), rate, rateUnit, configuration.
cortex_get_analyzerA
Get details about a specific analyzer by ID
Inputs: analyzerId (required).
cortex_get_jobA
Get the status and details of an analysis job
Inputs: jobId (required).
cortex_get_job_artifactsA
Get artifacts (extracted observables/IOCs) from a completed analysis job
Inputs: jobId (required).
cortex_get_job_reportA
Get the full report of a completed analysis job
Inputs: jobId (required).
cortex_get_organizationA
Get details about a specific organization (requires superadmin API key)
Inputs: orgId (required).
cortex_get_statusA
Get Cortex instance health status, version info, and configuration
Inputs: no named parameters.
cortex_get_userA
Get details about a specific user (requires superadmin API key)
Inputs: userId (required).
cortex_get_user_keyA
Get the current API key for a user. Requires superadmin API key.
Inputs: userId (required).
cortex_list_analyzer_definitionsA
List all available analyzer definitions (installed but not necessarily enabled). Filter by data type or find analyzers that require no API keys.
Inputs: limit, search, dataType, freeOnly.
cortex_list_analyzersA
List all enabled analyzers, optionally filtered by data type
Inputs: dataType.
cortex_list_jobsC
List recent analysis jobs with optional filters
Inputs: limit, status, dataType, analyzerName.
cortex_list_organizationsA
List all organizations (requires superadmin API key via CORTEX_SUPERADMIN_KEY)
Inputs: no named parameters.
cortex_list_responder_definitionsA
List all available responder definitions (installed but not necessarily enabled). Filter by data type or find responders that require no API keys.
Inputs: limit, search, dataType, freeOnly.
cortex_list_respondersA
List all enabled responders, optionally filtered by data type
Inputs: dataType.
cortex_list_usersA
List all users across organizations (requires superadmin API key via CORTEX_SUPERADMIN_KEY)
Inputs: no named parameters.
cortex_renew_user_keyA
Generate a new API key for a user (invalidates the previous key). Requires superadmin API key.
Inputs: userId (required).
cortex_run_analyzerC
Submit an observable to a specific analyzer for analysis
Inputs: pap (required), tlp (required), data (required), dataType (required), +2 more.
cortex_run_analyzer_by_nameB
Run an analyzer by name instead of ID (convenience wrapper)
Inputs: data (required), dataType (required), analyzerName (required), pap, +1 more.
cortex_run_analyzer_fileB
Submit a file to a specific analyzer for analysis. Provide a file path or base64-encoded content.
Inputs: analyzerId (required), pap, tlp, message, +4 more.
cortex_run_responderA
Execute a responder action against a TheHive entity (case, task, artifact, alert). DESTRUCTIVE: responders perform real-world side effects (blocking IPs, sending mail, isolating hosts). Gated behind the CORTEX_ALLOW_DESTRUCTIVE env var AND confirm=true.
Inputs: objectId (required), objectType (required), responderId (required), confirm, +1 more.
cortex_update_organizationB
Update an organization's description or status (requires superadmin API key)
Inputs: orgId (required), status, description.
cortex_wait_and_get_reportB
Wait for a job to complete and return the full report (with polling timeout)
Inputs: jobId (required), timeout.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 31 tools
Each tool has a clearly distinct purpose: analyzers, responders, jobs, organizations, and users are separate domains. Within each, operations are unique (list, get, create, update, delete, enable, disable, run). Descriptions clarify any potential overlap, e.g., cortex_analyze_observable vs cortex_run_analyzer.
All tools follow a consistent `cortex_verb_noun` pattern with snake_case. Verbs like list, get, create, run are used uniformly. Even compound verbs like `wait_and_get` fit the pattern. No mixing of styles.
With 31 tools, this is a large set, but each tool corresponds to a specific operation in the Cortex security analysis platform. The count is slightly above the typical well-scoped range but justified by the platform's complexity and the need to cover analyzers, responders, jobs, organizations, and users.
The tool set covers core CRUD operations for analyzers, responders, jobs, organizations, and users. Notable gaps include missing delete tools for users and organizations, and no update for users besides key renewal. But the main analysis workflow is fully covered, and the gaps are minor.
Maintenance
Related MCP Connectors
The Cortex MCP server provides read-only access to real-time engineering context from the Cortex developer portal, allowing AI coding assistants to answer natural language questions about your organization's catalog (microservices, libraries, domains, teams, infrastructure), scorecards (engineering standards and best practices), initiatives (goals and deadlines), and Engineering Intelligence metrics. It includes tools for querying documentation, tracking personal entities, and accessing AI-assisted insights across the entire Cortex ecosystem.
MCP server for Pentest-Tools.com: run scans, manage findings and reports via your preffered LLM.
MCP server providing access to the Scorecard API to evaluate and optimize LLM systems.
An MCP server that provides an API to LLMs to manage their JumpCloud resources.
Related MCP Servers
- AlicenseAqualityBmaintenanceAn MCP server that extracts Indicators of Compromise (IoCs) from unstructured text and checks their reputation across multiple threat intelligence services. It enables real-time analysis of IPs, domains, hashes, and URLs, providing enriched context for security workflows within LLMs.539 PyPI19MIT
- AlicenseAqualityBmaintenanceAn MCP server that enables LLMs to interact with MISP for threat intelligence sharing, IOC lookups, and event management. It provides tools for investigating indicators, discovering correlations, and exporting intelligence in formats like STIX and Suricata.3633 npm2MIT
- FlicenseNot gradedqualityDmaintenanceA security-focused MCP server that enables automated log retrieval and threat analysis using LangGraph orchestration and RAG. It allows users to detect suspicious activity and generate structured security insights by integrating LLM reasoning with log data and runbook documentation.-
- AlicenseNot gradedqualityDmaintenanceMCP server that provides condensed and normalized data from OpenCTI to LLMs, enabling lookup of observables, adversaries, and reports with enriched context.16MIT