Skip to main content
Glama

Bazel MCP

A Model Context Protocol server that exposes Bazel build system capabilities to AI assistants.

Repo: github.com/saeid-rez/bazel-mcp

Tools

Tool

Description

bazel_query

Run arbitrary bazel query expressions

bazel_cquery

Run configured bazel cquery expressions (select() and platforms)

bazel_aquery

Run action bazel aquery expressions (compiler flags, commands)

list_targets

List targets in a package or subtree

get_deps

Direct or transitive dependencies of a target

get_rdeps

Reverse dependencies within a scope

get_dependency_path

Trace dependency chains (somepath/allpaths) between targets

show_target_info

Rule definition via query --output=build

find_affected_targets

Find targets affected by changed files

bazel_build

Run bazel build with structured failure diagnostics (omits raw logs by default to save tokens; use verbose=True for full logs)

bazel_test

Run bazel test with structured target and failed-case results (omits raw logs by default to save tokens; use verbose=True for full logs)

bazel_run

Run bazel run with arguments, environment variables, and working directory controls

explain_build_file

Read BUILD file contents for analysis

Related MCP server: mcp-cli-catalog

Usage

Requires uv. Configure the server with a Bazel workspace path if your MCP client does not start it from that workspace.

Antigravity (agy)

Add the following to ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "bazel": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/saeid-rez/bazel-mcp",
        "bazel-mcp-server"
      ]
    }
  }
}

Bazel commands run in your active workspace by default. If Antigravity does not start the server from your Bazel workspace, pass --workspace-root explicitly:

{
  "mcpServers": {
    "bazel": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/saeid-rez/bazel-mcp",
        "bazel-mcp-server",
        "--workspace-root",
        "/path/to/your/bazel/workspace"
      ]
    }
  }
}

OpenCode

Add the following to opencode.json or opencode.jsonc. Replace /path/to/your/bazel/workspace with the absolute path to your Bazel workspace.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "bazel": {
      "type": "local",
      "command": [
        "uvx",
        "--from",
        "git+https://github.com/saeid-rez/bazel-mcp",
        "bazel-mcp-server",
        "--workspace-root",
        "/path/to/your/bazel/workspace"
      ],
      "enabled": true
    }
  }
}

GitHub Copilot CLI

Add the following to ~/.copilot/mcp-servers.json. Replace /path/to/your/bazel/workspace with the absolute path to your Bazel workspace.

{
  "mcp": {
    "servers": {
      "bazel": {
        "command": "uvx",
        "args": [
          "--from",
          "git+https://github.com/saeid-rez/bazel-mcp",
          "bazel-mcp-server",
          "--workspace-root",
          "/path/to/your/bazel/workspace"
        ],
        "protocol": "stdio"
      }
    }
  }
}

Alternatively, run /mcp add bazel inside Copilot CLI and provide the same command and arguments.

Install With uv

To install the server persistently instead of running it from GitHub, run:

uv tool install bazel-mcp-server

Then use the following installed-server configuration in place of the GitHub-based command above. Include --workspace-root and its path when the client does not start the server from the Bazel workspace.

Antigravity (agy):

{
  "mcpServers": {
    "bazel": {
      "command": "bazel-mcp-server",
      "args": ["--workspace-root", "/path/to/your/bazel/workspace"]
    }
  }
}

OpenCode:

{
  "mcp": {
    "bazel": {
      "type": "local",
      "command": ["bazel-mcp-server", "--workspace-root", "/path/to/your/bazel/workspace"],
      "enabled": true
    }
  }
}

GitHub Copilot CLI:

{
  "mcp": {
    "servers": {
      "bazel": {
        "command": "bazel-mcp-server",
        "args": ["--workspace-root", "/path/to/your/bazel/workspace"],
        "protocol": "stdio"
      }
    }
  }
}

Cursor

Add this to .cursor/mcp.json in the Bazel workspace.

{
  "mcpServers": {
    "bazel": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/saeid-rez/bazel-mcp", "bazel-mcp-server"]
    }
  }
}

Bazel commands run in your open workspace by default.

If Cursor does not start the server from the Bazel workspace, pass the workspace explicitly:

{
  "mcpServers": {
    "bazel": {
      "command": "uvx",
      "args": [
        "bazel-mcp-server",
        "--workspace-root",
        "/path/to/your/bazel/workspace"
      ]
    }
  }
}

Other optional flags:

bazel-mcp-server --bazel-path bazelisk --timeout 600 --max-output-chars 64000

Development

Clone the repo and run tests locally:

git clone https://github.com/saeid-rez/bazel-mcp
cd bazel-mcp
uv sync --group dev
uv run pytest

Available Tools

8 tools
bazel_buildB

Run a Bazel build and return stdout, stderr, and exit code.

options are passed as extra bazel flags (e.g. --config=ci, -c opt).

Inputs: targets (required), options, timeout. Returns: result

bazel_queryA
Read-onlyIdempotent

Run an arbitrary Bazel query expression.

Query is read-only but can be expensive on broad patterns like //... output_format: label, build, xml, package, location, graph, etc.

Inputs: query (required), output_format. Returns: result

bazel_testB

Run Bazel tests and return structured pass/fail results with failure log excerpts.

Inputs: targets (required), options, timeout. Returns: exit_code, summary, targets, stdout, +1 more

explain_build_fileB
Read-onlyIdempotent

Return BUILD file contents for analysis by the host LLM.

path is relative to the workspace root (e.g. foo/bar/BUILD or foo/bar).

Inputs: path (required). Returns: result

get_depsA
Read-onlyIdempotent

Get dependencies of a target up to the given depth, excluding the target itself.

Inputs: target (required), depth. Returns: result

get_rdepsA
Read-onlyIdempotent

Find reverse dependencies of a target within scope, excluding the target itself.

Inputs: target (required), scope. Returns: result

list_targetsA
Read-onlyIdempotent

List all targets matching a package pattern.

Default //... lists targets across the entire workspace (can be slow). For a single package use //pkg or pkg (normalized to //pkg:all). For a subtree use //pkg/...

Inputs: package. Returns: result

show_target_infoA
Read-onlyIdempotent

Show the BUILD rule definition for a target (bazel query --output=build).

Macro-generated targets may differ from on-disk BUILD files.

Inputs: target (required). Returns: result

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 8 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: build, test, query, file explanation, dependency queries, target listing, and target info. No overlap or ambiguity.

    Naming Consistency3/5

    Three tools use the 'bazel_' prefix (bazel_build, bazel_test, bazel_query) while the rest use plain verb_noun (explain_build_file, get_deps, etc.). The inconsistency is noticeable but still readable.

    Tool Count5/5

    8 tools is well-scoped for a Bazel MCP server, covering the essential operations without unnecessary bloat.

    Completeness4/5

    Core workflows (build, test, query, dependency analysis, file inspection) are covered. Minor gaps like 'bazel run' or 'clean' are missing but not critical.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      A local MCP server that exposes Bazel build system functionality to AI agents, allowing them to build, test, query, and manage Bazel projects through natural language even in environments where Bazel can't be directly accessed.
      6
      9
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that publishes CLI tools on your machine for discoverability by LLMs
      7 npm
      1
      MIT