Skip to main content
Glama
BloodHound MCP Server

BloodHound MCP Server

by mwnickerson

BloodHound MCP

License: GPL v3

A Model Context Protocol (MCP) server that connects LLMs to BloodHound Community Edition and BloodHound Enterprise. Ask questions in natural language, get attack path analysis, run Cypher queries, and explore Active Directory, Azure/Entra ID, and OpenGraph environments — all from your AI assistant.

Demo

Watch the demonstration video


Related MCP server: BloodHound MCP

How It Works

The server exposes BloodHound CE's REST API and Neo4j graph through a set of 13 composite MCP tools, 10 reference resources, and a system prompt tuned for offensive security analysis.

Composite Tools

Each tool uses an info_type parameter to select what data is returned, keeping the tool surface small and token-efficient:

Tool

info_type Options

domain_info

list, info, users, groups, computers, ous, gpos, dc_syncers, foreign_admins, foreign_group_members, linked_gpos, search

user_info

info, sessions, memberships, admin_rights, rdp_rights, dcom_rights, ps_remote_rights, sql_admin_rights, constrained_delegation, controllables, controllers

group_info

info, members, memberships, admin_rights, rdp_rights, dcom_rights, ps_remote_rights, controllers, controllables

computer_info

info, sessions, local_admins, rdp_rights, dcom_rights, ps_remote_rights, sql_admins, constrained_delegation, controllables, controllers

ou_info

info, users, groups, computers, gpos

gpo_info

info, controllers

graph_analysis

shortest_path, edge_composition, search

adcs_info

templates, esc_paths

cypher_query

run, saved_list, saved_get

data_quality

stats, platform_list, platform_info

asset_groups

list, members, custom_selectors

custom_nodes

list, get, create, update, delete, validate_icon, extension_list, extension_upsert, extension_delete, extension_edges

file_upload

upload, start_job, upload_to_job, upload_bytes, upload_bytes_to_job, end_job

Resources

Reference material the LLM loads on demand — no extra API calls:

Resource URI

Contents

bloodhound://cypher/reference

Cypher syntax, schema, property names, patterns

bloodhound://cypher/offensive-queries

Battle-tested templates: DCSync, Kerberoasting, GPO abuse, delegation, ADCS, shadow credentials, NTLM relay, and more

bloodhound://guides/ad

AD node types and relationships quick reference

bloodhound://guides/ad-methodology

Full AD attack methodology and workflow

bloodhound://guides/azure

Azure/Entra ID analysis quick reference

bloodhound://guides/azure-methodology

Full Azure attack chains

bloodhound://guides/adcs

ADCS ESC1–ESC13 quick reference

bloodhound://guides/adcs-methodology

Detailed ESC analysis and exploitation

bloodhound://opengraph/guide

Custom node schema design and best practices

bloodhound://opengraph/examples

SQL Server and Web App OpenGraph examples

System Prompt

The bloodhound_assistant prompt includes behavioral rules that guide the LLM:

  • Load the offensive query library before writing Cypher for any attack scenario

  • Never draw privilege conclusions without checking group memberships and admincount

  • Respect BloodHound's property naming conventions (hasspn, enabled, admincount — all lowercase)

  • Handle uppercase name storage (DOMAIN ADMINS@CORP.LOCAL) correctly in filters

  • Follow proper DCSync and GPO edge traversal patterns


Prerequisites

  • Python 3.11+

  • uv

  • BloodHound Community Edition instance with data loaded

  • BloodHound API credentials (Token ID + Token Key)


Installation

Run the MCP server directly from Git without cloning it first:

export BLOODHOUND_DOMAIN=your-bloodhound-instance.domain.com
export BLOODHOUND_TOKEN_ID=your-token-id
export BLOODHOUND_TOKEN_KEY=your-token-key
uvx --from git+https://github.com/mwnickerson/bloodhound_mcp bloodhound-mcp

For a reproducible integration, append a commit after the repository URL, for example git+https://github.com/mwnickerson/bloodhound_mcp@<commit>. An uvx installation does not read the .env from a separate checkout, so the process that launches the MCP client must provide the credential variables.

For development, clone the repository and install its environment:

git clone https://github.com/mwnickerson/bloodhound_mcp.git
cd bloodhound-mcp
uv sync

Create a .env file in the project root:

BLOODHOUND_DOMAIN=your-bloodhound-instance.domain.com
BLOODHOUND_TOKEN_ID=your-token-id
BLOODHOUND_TOKEN_KEY=your-token-key

At startup, the MCP server makes a signed, read-only request to /api/v2/self. Invalid credentials, connectivity failures, and TLS failures stop the server before it accepts MCP tool calls. The startup request times out after 10 seconds.

The server defaults to https on port 443. Override if needed:

BLOODHOUND_PORT=8080
BLOODHOUND_SCHEME=http

TLS certificate verification remains enabled when no additional setting is provided. For a trusted lab deployment that uses a self-signed certificate, verification can be explicitly disabled:

BLOODHOUND_VERIFY_TLS=false

Disabling verification weakens transport security and logs a warning. Do not use this option on untrusted networks.


Configuration

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "bloodhound_mcp": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/mwnickerson/bloodhound_mcp",
        "bloodhound-mcp"
      ]
    }
  }
}

Claude Code

Add to ~/.claude/mcp.json:

{
  "mcpServers": {
    "bloodhound_mcp": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/mwnickerson/bloodhound_mcp",
        "bloodhound-mcp"
      ]
    }
  }
}

OpenAI Codex CLI

Add to ~/.codex/config.toml (or .codex/config.toml for project-scoped config):

[mcp_servers.bloodhound_mcp]
command = "uvx"
args = ["--from", "git+https://github.com/mwnickerson/bloodhound_mcp", "bloodhound-mcp"]

The server inherits credentials from the process that launches Codex. To keep them in the MCP configuration instead, pass them explicitly:

[mcp_servers.bloodhound_mcp]
command = "uvx"
args = ["--from", "git+https://github.com/mwnickerson/bloodhound_mcp", "bloodhound-mcp"]

[mcp_servers.bloodhound_mcp.env]
BLOODHOUND_DOMAIN = "your-bloodhound-instance.domain.com"
BLOODHOUND_TOKEN_ID = "your-token-id"
BLOODHOUND_TOKEN_KEY = "your-token-key"

MCP Inspector

  • Command: uvx

  • Args: --from git+https://github.com/mwnickerson/bloodhound_mcp bloodhound-mcp

BloodHound API Token

  1. Log into BloodHound CE or BloodHound Enterprise

  2. Navigate to Administration → API Tokens

  3. Create a new token and copy the Token ID and Token Key into your .env


Usage

Example Queries

Reconnaissance:

What domains are in BloodHound?
Show me all Domain Admins in CORP.LOCAL
Find all kerberoastable users
Which computers have unconstrained delegation?

User and Group Analysis:

What admin rights does jsmith@corp.local have?
Show me all sessions for the administrator account
What groups is this user a member of?
Who controls the IT ADMINS group?

Attack Path Analysis:

Find the shortest path from jsmith@corp.local to Domain Admins
Who has DCSync rights in the domain?
Show me all GPO abuse paths
Find ADCS ESC1 paths in the domain

Custom Cypher:

Run a Cypher query to find all users with SPN set and admincount=1
Find all computers where DOMAIN USERS can RDP

Collection Uploads:

Upload this SharpHound ZIP from /tmp/sharphound.zip into BloodHound
Upload these base64-encoded SharpHound ZIP bytes as sharphound.zip
Start an upload job, upload these base64 JSON bytes as users.json, then end the job

Agents that already hold a SharpHound or AzureHound collection in memory should base64-encode the collection bytes and call:

file_upload(
    info_type="upload_bytes",
    file_name="sharphound.zip",
    file_bytes_base64="<base64-encoded zip bytes>"
)

For multi-file jobs, call start_job, then upload_bytes_to_job for each base64 payload, then end_job.


OpenGraph Support

BloodHound 8.0+ supports custom node types via OpenGraph, letting you model non-AD infrastructure (cloud resources, databases, custom assets) in the same graph as Active Directory.

The custom_nodes tool handles legacy CRUD operations on node type display configurations through /api/v2/custom-nodes. For BloodHound v9.0.0+ instances with OpenGraph extension management enabled, the same composite tool also supports /api/v2/extensions and /api/v2/extensions-edges via extension_list, extension_upsert, extension_delete, and extension_edges.

Use the bloodhound://opengraph/guide and bloodhound://opengraph/examples resources for schema design and Cypher patterns. For structured OpenGraph schemas, upsert the extension schema first, then ingest collection data with file_upload.

Requires BloodHound Enterprise or BloodHound CE 8.0 or later. OpenGraph extension management requires BloodHound 9.0.0+ and the corresponding feature flag to be enabled.


Security Considerations

BloodHound data processed through this tool is transmitted to your LLM provider's servers. Do not use this with production AD data unless you have assessed that risk.

Recommended use cases:

  • Lab environments (GOAD, DetectionLab, custom ranges)

  • Training and certification prep

  • Research and tool development

  • Non-production domain analysis

Best practices:

  • Rotate BloodHound API tokens regularly

  • Use a read-only API token where possible

  • Consider a local LLM bridge for sensitive environments


Testing

# Full test suite
uv run pytest

# Specific modules
uv run pytest tests/test_main_mcp_tools.py -v
uv run pytest tests/test_bloodhound_api.py -v

# Integration tests (requires a live BloodHound instance)
BLOODHOUND_INTEGRATION_TESTS=1 uv run pytest tests/test_integration.py -v

Roadmap

  • Direct Neo4j access mode (bypass REST API for complex graph traversal)

  • Enhanced Azure/Entra ID tooling

  • Improved ADCS attack path coverage

  • Additional OpenGraph examples and templates


Contributing

Contributions are welcome. Open an issue to discuss significant changes before submitting a PR.

  1. Fork the repo

  2. Create a feature branch

  3. Add tests for new functionality

  4. Run uv run pytest and confirm everything passes

  5. Submit a pull request


Acknowledgments

License

GNU General Public License v3.0 — see LICENSE for details.

Available Tools

79 tools
create_saved_queryB
Create a new saved Cypher query.

Args:
    name: Name for the saved query
    query: The Cypher query to save

Returns:
    JSON response with the created saved query data

Inputs: name (required), query (required).

get_aia_ca_controllersA
Retrieves the controllers of a specific AIA Certificate Authority.
AIA (Authority Information Access) CAs provide additional trust information.
Controllers of an AIA CA may be able to perform certificate-based attacks.

Args:
    ca_id: The ID of the AIA CA to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: ca_id (required), limit, skip.

get_cert_template_controllersA
Retrieves the controllers of a specific Certificate Template.
Controllers are security principals that can modify the Certificate Template or its properties.
This is critical for identifying ESC2 vulnerabilities (vulnerable Certificate Template access control).

Args:
    template_id: The ID of the Certificate Template to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: template_id (required), limit, skip.

get_cert_template_infoB
Retrieves information about a specific Certificate Template.
Certificate Templates define the properties and security settings for certificates that can be issued.
They can be abused for privilege escalation if misconfigured.

Args:
    template_id: The ID of the Certificate Template to query

Inputs: template_id (required).

get_computer_admin_rightsA
Retrieves the administrative rights of a specific computer in the domain.
Administrative rights are privileges that allow a computer to perform administrative tasks on a Security Principal (user, group, or computer) in Active Directory.
These rights can be abused in a variety of ways include lateral movement, persistence, and privilege escalation.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of administrative rights to return (default: 100)
    skip: Number of administrative rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_admin_usersA
Retrieves the administrative users of a specific computer in the domain.
Administrative users are the users that have administrative access to the specified computer.
These users can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of administrative users to return (default: 100)
    skip: Number of administrative users to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_constrained_delegation_rightsA
Retrieves the constrained delegation rights of a specific computer within the domain.
Constrained delegation rights allow a computer to impersonate another user or service when communicating with a service on another computer.
These rights can be abused for privilege escalation and lateral movement within the domain.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of constrained delegation rights to return (default: 100)
    skip: Number of constrained delegation rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_constrained_usersA
Retrieves the constrained users of a specific computer in the domain.
Constrained users are the users that have constrained delegation access to the specified computer.
These users can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of constrained users to return (default: 100)
    skip: Number of constrained users to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_controllablesA
Retrieves the Security Princiapls within the domain that a specific computer has administrative control over in the domain.
These are entities that the computer can control and manipulate within the domain.
These are potential targets for lateral movement, privilege escalation, and persistence.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of controllables to return (default: 100)
    skip: Number of controllables to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_controllersA
Retrieves the controllers of a specific computer in the domain.
Controllers are entities that have control over the specified computer
This can be used to help identify paths to gain access to a specific computer.
Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_dcom_rightsB

Retrieves the a list of security principals that a specific computer to execute COM on DCOM rights allow a computer to communicate with COM objects on another computer in the network. These rights can be abused for privilege escalation and lateral movement within the domain.

Inputs: computer_id (required), limit, skip.

get_computer_dcom_usersA
Retrieves the users that have DCOM rights to a specific computer in the domain.
DCOM rights allow a user to communicate with COM objects on another computer in the network.
These rights can be abused for privilege escalation and lateral movement within the domain.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of DCOM rights to return (default: 100)
    skip: Number of DCOM rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_infoB
Retrieves information about a specific computer in a specific domain.
This provides a general overview of a computer's information including their name, domain, and other attributes.
It can be used to conduct reconnaissance and start formulating and targeting computers within the domain
Args:
    computer_id: The ID of the computer to query

Inputs: computer_id (required).

get_computer_membershipsA
Retrieves the group memberships of a specific computer within the domain.
Group memberships are the groups that the specified computer is a member of within the domain.
These memberships can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of memberships to return (default: 100)
    skip: Number of memberships to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_ps_remote_rightsA
Retrieves a list of hosts that this specific computer has the right to PS remote to
Remote PowerShell rights allow a computer to execute PowerShell commands on a remote computer.
These rights can be abused for lateral movement and privilege escalation within the domain.
Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of remote PowerShell rights to return (default: 100)
    skip: Number of remote PowerShell rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_ps_remote_usersA
This retieves the users that have PS remote rights to this specific computer in the domain.
Remote PowerShell rights allow a user to execute PowerShell commands on a remote computer.
These rights can be abused for lateral movement and privilege escalation within the domain.
Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of remote PowerShell rights to return (default: 100)
    skip: Number of remote PowerShell rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_rdp_rightsA
Retrieves a list of hosts that this specific computer has the right to RDP to
RDP rights allow a computer to remotely connect to another computer using the Remote Desktop Protocol.
These rights can be abused for lateral movement and privilege escalation within the domain.
Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of RDP rights to return (default: 100)
    skip: Number of RDP rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_rdp_usersA
This retieves the users that have RDP rights to this specific computer in the domain.
RDP rights allow a user to remotely connect to another computer using the Remote Desktop Protocol.
These rights can be abused for lateral movement and privilege escalation within the domain.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of RDP rights to return (default: 100)
    skip: Number of RDP rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computersB
Retrieves computers from a specific domain in the Bloodhound database.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of computers to return (default: 100)
    skip: Number of computers to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_computer_sessionsA
Retrieves the active sessions of a specific computer within the domain.
Active sessions are the current sessions that a computer has within the domain.
These sessions can be used to identify potential targets for lateral movement and privilege escalation.
These sessions can also be used to formulate and inform on attack paths because if a user has an active session on a host their credentials are cached in memory

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of sessions to return (default: 100)
    skip: Number of sessions to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_computer_sql_admin_rightsA
Retrieves the SQL administrative rights of a specific computer within the domain.
SQL administrative rights allow a computer to perform administrative tasks on a SQL Server.
These rights can be abused for lateral movement and privilege escalation within the domain.

Args:
    computer_id: The ID of the computer to query
    limit: Maximum number of SQL administrative rights to return (default: 100)
    skip: Number of SQL administrative rights to skip for pagination (default: 0)

Inputs: computer_id (required), limit, skip.

get_dc_syncersA
Retrieves security principals (users, groups, computers ) that are given the "GetChanges" and "GetChangesAll" permissions on the domain.
The security principals are therefore able to perform a DCSync attack.
They are are great targets for lateral movement or privilege escalation or domain compromise.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of DC Syncers to return (default: 100)
    skip: Number of DC Syncers to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_domainsD

Inputs: no named parameters.

get_edge_compositionA
Analyze the components of a complex edge between two nodes.
In Bloodhound, many high-level edges (like "HasPath" or "AdminTo") are composed of multiple
individual relationships. This function reveals those underlying components.
This is useful for understanding exactly how security principals are connected.

Args:
    source_node: ID of the source node
    target_node: ID of the target node
    edge_type: Type of edge to analyze (e.g., "MemberOf", "AdminTo", "CanRDP")

Inputs: source_node (required), target_node (required), edge_type (required).

get_enterprise_ca_controllersA
Retrieves the controllers of a specific Enterprise Certificate Authority.
Controllers of an Enterprise CA can issue arbitrary certificates and potentially compromise the domain.
This is critical for identifying ESC3 and ESC6 attack paths.

Args:
    ca_id: The ID of the Enterprise CA to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: ca_id (required), limit, skip.

get_enterprise_ca_infoB
Retrieves information about a specific Enterprise Certificate Authority.
Enterprise CAs issue certificates within the organization based on Certificate Templates.
They are critical components in the Active Directory PKI infrastructure.

Args:
    ca_id: The ID of the Enterprise CA to query

Inputs: ca_id (required).

get_foreign_adminsA
Retrieves foreign admins from a specific domain in the Bloodhound database.
 "Foreign Admins" are defined as security principals (users, groups, or computers) from one domain that have administrative privileges in another domain within the same forest.
These are potential targets for lateral movement and privilege escalation as well as cross domain compromise.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of foreign admins to return (default: 100)
    skip: Number of foreign admins to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_foreign_gpo_controllersA
Retrieves foreign GPO controllers from a specific domain in the Bloodhound database.
"Foreign GPO Controllers" are defined as security principals (users, groups, or computers) from one domain that have the ability to modify or control Group Policy Objects (GPOs) in another domain within the same forest
These are potential targets for lateral movement and privilege escalation as well as cross domain compromise.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of foreign GPO controllers to return (default: 100)
    skip: Number of foreign GPO controllers to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_foreign_groupsB
Retrieves foreign groups from a specific domain in the Bloodhound database.
"Foreign Groups" are defined as security groups from one domain that have members from another domain within the same forest. They represent cross-domain group memberships in Active Directory.
These are potential targets for lateral movement and privilege escalation as well as cross domain compromise.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of foreign groups to return (default: 100)
    skip: Number of foreign groups to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_foreign_usersA
Retrieves foreign users from a specific domain in the Bloodhound database.
"Foreign Users" are defined as user accounts from one domain that are referenced in another domain within the same forest. These represent user accounts that have some form of relationship or access across domain boundaries.
These are potential targets for lateral movement and privilege escalation as well as cross domain compromise.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of foreign users to return (default: 100)
    skip: Number of foreign users to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_gpo_computersB
Retrieves the computers within a specific GPO in the domain.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    gpo_id: The ID of the GPO to query
    limit: Maximum number of computers to return (default: 100)
    skip: Number of computers to skip for pagination (default: 0)

Inputs: gpo_id (required), limit, skip.

get_gpo_controllersA
Retrieves the controllers of a specific GPO in the domain.
Controllers are entities that have control over the specified GPO
This can be used to help identify paths to gain access to a specific GPO.

Args:
    gpo_id: The ID of the GPO to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: gpo_id (required), limit, skip.

get_gpo_infoC
Retrieves information about a specific GPO in a specific domain.
This provides a general overview of a GPO's information including their name, domain, and other attributes.
It can be used to conduct reconnaissance and start formulating and targeting GPOs within the domain
Args:
    gpo_id: The ID of the GPO to query

Inputs: gpo_id (required).

get_gpo_ousA
Retrieves the OUs that are linked to a specific GPO in the domain.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    gpo_id: The ID of the GPO to query
    limit: Maximum number of OUs to return (default: 100)
    skip: Number of OUs to skip for pagination (default: 0)

Inputs: gpo_id (required), limit, skip.

get_gposA
Retrieves Group Policy Objects (GPOs) from a specific domain in the Bloodhound database.
GPOs are containers for policy settings that can be applied to users and computers in Active Directory.
These can be abused for persistence and privilege escalation and are key in idenitfying GPO related edges.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of GPOs to return (default: 100)
    skip: Number of GPOs to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_gpo_tier_zerosA
Retrieves the Tier 0 groups that are linked to a specific GPO in the domain.
Tier 0 groups are the highest privileged groups in the domain and have access to all resources.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    gpo_id: The ID of the GPO to query
    limit: Maximum number of Tier 0 groups to return (default: 100)
    skip: Number of Tier 0 groups to skip for pagination (default: 0)

Inputs: gpo_id (required), limit, skip.

get_gpo_usersB
Retrieves the users within a specific GPO in the domain.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    gpo_id: The ID of the GPO to query
    limit: Maximum number of users to return (default: 100)
    skip: Number of users to skip for pagination (default: 0)

Inputs: gpo_id (required), limit, skip.

get_group_admin_rightsB
Retrieves the administrative rights of a specific group in the domain.
Administrative rights are privileges that allow a group to perform administrative tasks on a Security Principal (user, group, or computer) in Active Directory.
These rights can be abused in a variety of ways include lateral movement, persistence, and privilege escalation.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of administrative rights to return (default: 100)
    skip: Number of administrative rights to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_group_controllablesA
Retrieves the Security Princiapls within the domain that a specific group has administrative control over in the domain.
These are entities that the group can control and manipulate within the domain.
These are potential targets for lateral movement, privilege escalation, and persistence.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of controllables to return (default: 100)
    skip: Number of controllables to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_group_controllersA
Retrieves the controllers of a specific group in the domain.
Controllers are entities that have control over the specified group
This can be used to help identify paths to gain access to a specific group.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_group_dcom_rightsA
Retrieves the DCOM rights of a specific group within the domain.
DCOM rights allow a group to communicate with COM objects on another computer in the network.
These rights can be abused for privilege escalation and lateral movement within the domain.
Args:
    group_id: The ID of the group to query
    limit: Maximum number of DCOM rights to return (default: 100)
    skip: Number of DCOM rights to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_group_infoB
Retrieves information about a specific group in a specific domain.
This provides a general overview of a group's information including their name, domain, and other attributes.
It can be used to conduct reconnaissance and start formulating and targeting groups within the domain
Args:
    group_id: The ID of the group to query

Inputs: group_id (required).

get_group_membersB
Retrieves the members of a specific group within the domain.
Group members are the users and groups that are members of the specified group.
These memberships can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of members to return (default: 100)
    skip: Number of members to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_group_membershipsB
Retrieves the group memberships of a specific group within the domain.
Group memberships are the groups that the specified group is a member of within the domain.
These memberships can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of memberships to return (default: 100)
    skip: Number of memberships to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_group_ps_remote_rightsA
Retrieves the remote PowerShell rights of a specific group within the domain.
Remote PowerShell rights allow a group to execute PowerShell commands on a remote computer.
These rights can be abused for lateral movement and privilege escalation within the domain.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of remote PowerShell rights to return (default: 100)
    skip: Number of remote PowerShell rights to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_group_rdp_rightsA
Retrieves the RDP rights of a specific group within the domain.
RDP rights allow a group to remotely connect to another computer using the Remote Desktop Protocol.
These rights can be abused for lateral movement and privilege escalation within the domain.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of RDP rights to return (default: 100)
    skip: Number of RDP rights to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_groupsB
Retrieves groups from a specific domain in the Bloodhound database.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of groups to return (default: 100)
    skip: Number of groups to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_group_sessionsA
Retrieves the active sessions of the members of a specific group within the domain.
Active sessions are the current sessions that hte members of this group have within the domain.
These sessions can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    group_id: The ID of the group to query
    limit: Maximum number of sessions to return (default: 100)
    skip: Number of sessions to skip for pagination (default: 0)

Inputs: group_id (required), limit, skip.

get_inbound_trustsA
Retrieves inbound trusts from a specific domain in the Bloodhound database.
"Inbound Trusts" are defined as trust relationships where the domain is the trusted domain and other domains trust it.
These are potential targets for moving to other external domains or other domains within the forest

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of inbound trusts to return (default: 100)
    skip: Number of inbound trusts to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_linked_gposA
Retrieves linked GPOs from a specific domain in the Bloodhound database.
"Linked GPOs" are defined as Group Policy Objects that have been linked to or associated with specific Active Directory containers such as domains, organizational units (OUs), or sites
These are potential targets for moving laterally, elevating privileges, or maintaining persistence in the domain.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of linked GPOs to return (default: 100)
    skip: Number of linked GPOs to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_ou_computersB
Retrieves the computers within a specific OU in the domain.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    ou_id: The ID of the OU to query
    limit: Maximum number of computers to return (default: 100)
    skip: Number of computers to skip for pagination (default: 0)

Inputs: ou_id (required), limit, skip.

get_ou_gposB
Retrieves the GPOs within a specific OU in the domain.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    ou_id: The ID of the OU to query
    limit: Maximum number of GPOs to return (default: 100)
    skip: Number of GPOs to skip for pagination (default: 0)

Inputs: ou_id (required), limit, skip.

get_ou_groupsA
Retrieves the groups within a specific OU in the domain.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    ou_id: The ID of the OU to query
    limit: Maximum number of groups to return (default: 100)
    skip: Number of groups to skip for pagination (default: 0)

Inputs: ou_id (required), limit, skip.

get_ou_infoB
Retrieves information about a specific OU in a specific domain.
This provides a general overview of an OU's information including their name, domain, and other attributes.
It can be used to conduct reconnaissance and start formulating and targeting OUs within the domain
Args:
    ou_id: The ID of the OU to query

Inputs: ou_id (required).

get_ousB
Retrieves Organizational Units (OUs) from a specific domain in the Bloodhound database.
OUs are containers within a domain that can hold users, groups, computers, and other OUs.
These are key in understanding the structure of the domain.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of OUs to return (default: 100)
    skip: Number of OUs to skip for pagination (default

Inputs: domain_id (required), limit, skip.

get_outbound_trustsB
Retrieves outbound trusts from a specific domain in the Bloodhound database.
"Outbound Trusts" are defined as trust relationships where the domain trusts other domains.
These are potential targets for accessing resources within another domain and may provide a path into the domain if the external one has weaker security.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of outbound trusts to return (default: 100)
    skip: Number of outbound trusts to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_ou_usersA
Retrieves the users within a specific OU in the domain.
This can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    ou_id: The ID of the OU to query
    limit: Maximum number of users to return (default: 100)
    skip: Number of users to skip for pagination (default: 0)

Inputs: ou_id (required), limit, skip.

get_relay_targetsA
Find valid relay targets for a given edge in the Bloodhound graph.
Relay targets represent potential nodes that could be used to relay an attack or
privilege escalation between two nodes. This is critical for advanced attack path planning.

Args:
    source_node: ID of the source node
    target_node: ID of the target node
    edge_type: Type of edge (relationship) between the nodes

Inputs: source_node (required), target_node (required), edge_type (required).

get_root_ca_controllersA
Retrieves the controllers of a specific Root Certificate Authority.
Controllers of a Root CA can compromise the entire PKI infrastructure.
This is critical for identifying ESC4 and ESC5 attack paths.

Args:
    ca_id: The ID of the Root CA to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: ca_id (required), limit, skip.

get_root_ca_infoB
Retrieves information about a specific Root Certificate Authority.
Root CAs are the foundation of trust in a PKI infrastructure.
Controlling a Root CA allows an attacker to issue trusted certificates.

Args:
    ca_id: The ID of the Root CA to query

Inputs: ca_id (required).

get_security_controllersA
Retrieves security principals that have control relationships over other objects in the domain.

In Bloodhound terminology, a "controller" is any security principal (user, group, computer)
that has some form of control relationship (like AdminTo, WriteOwner, GenericAll, etc.)
over another security object in the domain. These are NOT domain controllers (AD servers),
but rather represent control edges in the graph.

These control relationships are key for identifying potential attack paths in the domain.

Example controllers might include:
- A user with AdminTo rights on a computer
- A group with GenericAll rights over another group
- A user with WriteOwner rights over another user

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of control relationships to return (default: 100)
    skip: Number of control relationships to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_shortest_pathA
Find the shortest path between two nodes in the Bloodhound graph.
This is useful for attack path analysis, showing the most direct route between two security principals.
The path will show all the intermediary nodes and the types of relationships connecting them.
If this returns a 500 or 404 error it is likely that the path does not exist within bloodhound

Args:
    start_node: Object ID of the starting node (source)
    end_node: Object ID of the ending node (target)
    relationship_kinds: Optional comma-separated list of relationship types to include in the path

Inputs: start_node (required), end_node (required), relationship_kinds.

get_user_admin_rightsA
Retrieves the administrative rights of a specific user in the domain.
Administrative rights are privileges that allow a user to perform administrative tasks on a Security Principal (user, group, or computer) in Active Directory.
These rights can be abused in a variety of ways include lateral movement, persistence, and privilege escalation.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of administrative rights to return (default: 100)
    skip: Number of administrative rights to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_user_constrained_delegation_rightsA
Retrieves the constrained delegation rights of a specific user within the domain.
Constrained delegation rights allow a user to impersonate another user or service when communicating with a service on another computer.
These rights can be abused for privilege escalation and lateral movement within the domain.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of constrained delegation rights to return (default: 100)
    skip: Number of constrained delegation rights to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_user_controllablesA
Retrieves the Security Princiapls within the domain that a specific user has administrative control over in the domain.
These are entities that the user can control and manipulate within the domain.
These are potential targets for lateral movement, privilege escalation, and persistence.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of controllables to return (default: 100)
    skip: Number of controllables to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_user_controllersA
Retrieves the controllers of a specific user in the domain.
Controllers are entities that have control over the specified user
This can be used to help identify paths to gain access to a specific user.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of controllers to return (default: 100)
    skip: Number of controllers to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_user_dcom_rightsA
Retrieves the DCOM rights of a specific user within the domain.
DCOM rights allow a user to communicate with COM objects on another computer in the network.
These rights can be abused for privilege escalation and lateral movement within the domain.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of DCOM rights to return (default: 100)
    skip: Number of DCOM rights to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_user_infoC
Retrieves information about a specific user in a specific domain.
This provides a general overview of a user's information including their name, domain, and other attributes.
It can be used to conduct reconnaissance and start formulating and targeting users within the domain

Args:
    user_id: The ID of the user to query

Inputs: user_id (required).

get_user_membershipsA
Retrieves the group memberships of a specific user within the domain.
Group memberships are the groups that a user is a member of within the domain.
These memberships can be used to identify potential targets for lateral movement and privilege escalation.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of memberships to return (default: 100)
    skip: Number of memberships to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_user_ps_remote_rightsA
Retrieves the remote PowerShell rights of a specific user within the domain.
Remote PowerShell rights allow a user to execute PowerShell commands on a remote computer.
These rights can be abused for lateral movement and privilege escalation within the domain.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of remote PowerShell rights to return (default: 100)
    skip: Number of remote PowerShell rights to skip for pagination

Inputs: user_id (required), limit, skip.

get_user_rdp_rightsB
Retrieves the RDP rights of a specific user within the domain.
RDP rights allow a user to remotely connect to another computer using the Remote Desktop Protocol.
These rights can be abused for lateral movement and privilege escalation within the domain.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of RDP rights to return (default: 100)
    skip: Number of RDP rights to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_usersB
Retrieves users from a specific domain in the Bloodhound database.

Args:
    domain_id: The ID of the domain to query
    limit: Maximum number of users to return (default: 100)
    skip: Number of users to skip for pagination (default: 0)

Inputs: domain_id (required), limit, skip.

get_user_sessionsC
Retrieves the active sessions of a specific user within the domain.
Active sessions are the current sessions that a user has within the domain.
These sessions can be used to identify potential targets for lateral movement and privilege escalation.
It can also be used to indentify and plan attack paths within the domain.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of sessions to return (default: 100)
    skip: Number of sessions to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

get_user_sql_admin_rightsA
Retrieves the SQL administrative rights of a specific user within the domain.
SQL administrative rights allow a user to perform administrative tasks on a SQL Server.
These rights can be abused for lateral movement and privilege escalation within the domain.

Args:
    user_id: The ID of the user to query
    limit: Maximum number of SQL administrative rights to return (default: 100)
    skip: Number of SQL administrative rights to skip for pagination (default: 0)

Inputs: user_id (required), limit, skip.

interpret_cypher_resultB
Help interpret the results of a Cypher query for offensive security analysis.

Args:
    query: The original Cypher query that was executed
    result_json: The JSON result from run_cypher_query
    
Returns:
    Human-readable interpretation of what the results mean for security analysis

Inputs: query (required), result_json (required).

list_saved_queriesC
List saved Cypher queries.

Args:
    skip: Number of queries to skip for pagination
    limit: Maximum number of queries to return
    name: Filter by query name

Returns:
    JSON response with list of saved queries

Inputs: skip, limit, name.

run_cypher_queryA
Run a custom Cypher query on the BloodHound Neo4j database.

This tool properly interprets BloodHound's HTTP response codes:
- 200: Query successful with results
- 404: Query successful but no results found (NOT an error!)
- 400: Query syntax error
- 401/403: Authentication/permission issues
- 5xx: Server errors

Args:
    query: The Cypher query to execute
    include_properties: Whether to include node/edge properties in the response

Returns:
    JSON response with graph data (nodes and edges) and execution metadata

Inputs: query (required), include_properties.

search_graphA
Search for nodes in the Bloodhound graph by name.
This function lets you find specific nodes in the graph based on a search query.
Results are typically returned as matches on node names.

Args:
    query: Search text to find nodes by name
    search_type: Type of search to perform - "fuzzy" (default) for approximate matches, "exact" for exact matches

Inputs: query (required), search_type.

search_objectsA
Search for objects in the BloodHound database by name or Object ID.
This is useful for finding specific objects when you don't know their exact ID.

Args:
    query: Search text - can be a partial name, full name, or Object ID
    object_type: Optional filter by object type:
        - For Active Directory: User, Computer, Group, GPO, OU, Domain
        - For Azure: AZUser, AZGroup, AZDevice, etc.
    limit: Maximum number of results to return (default: 100)
    skip: Number of results to skip for pagination (default: 0)

Inputs: query (required), object_type, limit, skip.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 79 tools

    Disambiguation4/5

    The tools are highly specialized with distinct purposes, such as get_computer_admin_rights vs get_computer_admin_users, which target different aspects of computer administration. However, some tools like get_computer_rdp_rights and get_computer_rdp_users have overlapping domains that could cause minor confusion, but descriptions clarify the differences. Overall, the set is well-differentiated with minimal ambiguity.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern using snake_case, such as get_computer_info, list_saved_queries, and run_cypher_query. There are no deviations in naming conventions, making the set predictable and easy to navigate. This uniformity enhances usability and reduces cognitive load for agents.

    Tool Count2/5

    With 79 tools, the count is excessive for a single server, likely overwhelming for agents and increasing the risk of misselection. While the domain of BloodHound (Active Directory security analysis) is complex, this many tools suggests poor scoping or fragmentation, as many functions could be consolidated into more generic queries or parameters. It far exceeds the typical well-scoped range of 3-15 tools.

    Completeness5/5

    The tool set provides comprehensive coverage for BloodHound's domain, including CRUD operations for saved queries, detailed queries for various Active Directory objects (users, computers, groups, GPOs, OUs, domains, certificates), and advanced analysis tools like get_shortest_path and get_edge_composition. There are no obvious gaps; agents can perform reconnaissance, attack path analysis, and security assessments effectively.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      C
      quality
      D
      maintenance
      An extension that allows Large Language Models to interact with and analyze Active Directory environments through natural language queries instead of manual Cypher queries.
      100
      165
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      BloodHound-MCP-AI is integration that connects BloodHound with AI through Model Context Protocol, allowing security professionals to analyze Active Directory attack paths using natural language instead of complex Cypher queries.
      385
      -
    • A
      license
      A
      quality
      D
      maintenance
      Connects LLMs to BloodHound Enterprise for natural language attack path analysis, Cypher queries, and exploration of Active Directory, Azure/Entra ID, and OpenGraph environments.
      20
      GPL 3.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that enables LLMs to query and reason over Active Directory attack graphs collected by BloodHound, providing attack paths, blast radius analysis, choke points, and defender remediation advice.
      MIT