Skip to main content
Glama
enesjakozh
MammothGrowth

dbt CLI MCP Server

by MammothGrowth
OverviewSchemaRelated ServersScoreDiscussions
Python
Hybrid

dbt_deps

Install or update external package dependencies for a dbt project to ensure required modules, macros, and models are available before execution.

Instructions

Install dbt package dependencies. An AI agent should use this tool when it needs to install or update external packages that the dbt project depends on. This ensures that all required modules, macros, and models from other packages are available before running the project.

    Returns:
        Output from the dbt deps command as text (this command does not support JSON output format)

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
project_dirNoABSOLUTE PATH to the directory containing the dbt project (e.g. '/Users/username/projects/dbt_project' not '.').
profiles_dirNoDirectory containing the profiles.yml file (defaults to project_dir if not specified)

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • src/tools.py:285-309 (handler)
    The primary handler function for the 'dbt_deps' MCP tool. It defines the input schema with Pydantic Field descriptions, executes the 'dbt deps' command, and processes the result.
    @mcp.tool()
async def dbt_deps(
    project_dir: str = Field(
        default=".",
        description="ABSOLUTE PATH to the directory containing the dbt project (e.g. '/Users/username/projects/dbt_project' not '.')"
    ),
    profiles_dir: Optional[str] = Field(
        default=None,
        description="Directory containing the profiles.yml file (defaults to project_dir if not specified)"
    )
) -> str:
    """Install dbt package dependencies. An AI agent should use this tool when it needs to install or update external packages that the dbt project depends on. This ensures that all required modules, macros, and models from other packages are available before running the project.

    Returns:
        Output from the dbt deps command as text (this command does not support JSON output format)
    """
    command = ["deps"]

    # The --no-print flag is not supported by dbt Cloud CLI
    # We'll rely on proper parsing to handle any print macros

    result = await execute_dbt_command(command, project_dir, profiles_dir)

    # Use the centralized result processor
    return await process_command_result(result, command_name="deps")
  • src/server.py:88-90 (registration)
    Registers all MCP tools including 'dbt_deps' by calling register_tools(mcp) on the FastMCP server instance.
    # Register tools
register_tools(mcp)
  • src/tools.py:25-31 (registration)
    The register_tools function that defines and registers all MCP tools via @mcp.tool() decorators, including dbt_deps.
    def register_tools(mcp: FastMCP) -> None:
    """
    Register all tools with the MCP server.

    Args:
        mcp: The FastMCP server instance
    """

Tool Definition Quality

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's function (installing/updating dependencies) and output format (text from the dbt deps command, not JSON). However, it doesn't mention potential side effects like network dependencies, time requirements, or error conditions, which would be helpful for a mutation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is efficiently structured with two sentences: the first states the purpose and usage guidelines, and the second explains the output format. Every sentence adds value without redundancy, and the information is front-loaded with the core functionality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (installing dependencies), no annotations, and an output schema that exists (though the description clarifies it returns text, not JSON), the description is mostly complete. It covers purpose, usage, and output format, but could improve by mentioning behavioral aspects like idempotency or prerequisites.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the schema already documents both parameters (project_dir and profiles_dir) thoroughly. The description adds no additional parameter information beyond what's in the schema, maintaining the baseline score of 3 for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('install dbt package dependencies') and resource ('external packages'), distinguishing it from siblings like dbt_run or dbt_test that perform different operations. It explicitly mentions installing or updating dependencies, which is distinct from building, compiling, or testing the project.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool: 'when it needs to install or update external packages that the dbt project depends on.' It also explains the purpose ('ensures that all required modules, macros, and models from other packages are available before running the project'), which implicitly suggests using it as a prerequisite before other operations like dbt_run or dbt_test.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/MammothGrowth/dbt-cli-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server