Selecting a Unity Catalog Tool by Fit, Inputs, Outputs and Task Requirements

1.Functional fit: does the tool do the job the task describes?

The first criterion is whether the tool's purpose matches the kind of work the task asks for. Databricks is explicit about where Unity Catalog functions fit best. They are for structured data retrieval when the query is known ahead of time and the agent supplies the parameters. A function like lookup_customer_info(customer_name) fits that pattern. The SQL is fixed, and the agent only fills in a name.

Many agent tasks don't have a fixed query, so you have to recognise when a different tool is the better fit.

A Genie Agent covers up to 25 Unity Catalog tables and queries them in natural language. If the agent itself writes SQL and needs to run it through a SQL warehouse, the documentation points to the managed Databricks SQL MCP server instead of a custom tool. For unstructured documents, the AI Search MCP server queries an index. For arbitrary computation, there is the code interpreter.

Sources123

2.Input/output compatibility: can the agent call it, and use what comes back?

A tool can do the right job and still be the wrong choice if the agent can't supply its inputs. When an agent calls a Unity Catalog function, the DatabricksFunctionClient retrieves the function definition and validates the parameter names and types before execution. The call has to provide each declared argument by name, with a compatible value.

result = client.execute_function(
  function_name=f"{CATALOG}.{SCHEMA}.add_numbers",
   ? ={"number_1": 36939.0, "number_2": 8922.4}
)

This creates a practical test for selection: does the agent have, or can it get, every required input? The Databricks design-patterns guide uses a help desk agent that calls lookup_order(customer_id, order_id). If the user gives only a name, that tool can't be called yet, because nothing has produced a customer_id. The structured-retrieval version of lookup_customer_info closes that gap. Its COMMENT says it returns the customer's email and ID, and that the customer ID can be used for other queries. Read output descriptions this way. A tool is compatible when its output type and fields are what the next step consumes. In the example above, that means a STRING carrying an ID that feeds lookup_order.

Sources142

3.Task requirements: execution, permissions and context

The third criterion covers whatever else the task demands beyond what the tool does and what it accepts. Three requirements appear in the documentation.

Execution. Unity Catalog functions run as agent tools in serverless mode by default. That mode needs serverless generic compute (Spark Connect serverless), not serverless SQL warehouses. Without it, calls fail with errors like PERMISSION_DENIED: Cannot access Spark Connect.

Permissions. Access to the Unity Catalog functions MCP server is governed by Unity Catalog permissions. An agent deployed as an app must be granted EXECUTE on the function.

resources:
  apps:
    my_agent_app:
      resources:
        - name: 'my_uc_function'
          uc_securable:
            securable_full_name: '<catalog>.<schema>.<function-name>'
            securable_type: 'FUNCTION'
            permission: 'EXECUTE'

Authentication and flexibility. Outside structured retrieval with a known query, Databricks recommends MCP servers or logic written directly in agent code. The reasons given are faster execution, per-user authentication support and more flexibility. If a task requires acting with each user's own identity, that recommendation favours MCP or in-code tools over a UC function.

Conversation context. The managed Genie MCP server calls Genie as a tool, so conversation history isn't passed. If a task requires Genie to see the conversation so far, calling Genie as an agent in a multi-agent system can pass that context deterministically.

Sources152

Exam traps

Each one states something that sounds right. Open it to see what is actually true.

1. 1.Every agent tool that touches Unity Catalog should be a Unity Catalog function.Why is that wrong?

   Databricks recommends UC functions for structured retrieval with a known query. For other cases it recommends MCP servers or in-code logic, and for open-ended table questions it recommends Genie.

   Covered in Functional fit: does the tool do the job the task describes?

2. 2.A serverless SQL warehouse is enough compute to run Unity Catalog function tools.Why is that wrong?

   UC function tools run on serverless generic compute (Spark Connect serverless). Without it, calls fail with PERMISSION_DENIED.

   Covered in Task requirements: execution, permissions and context

3. 3.A tool is a fit as long as it returns the right kind of data, whether or not the agent has its inputs yet.Why is that wrong?

   The client validates parameter names and types before execution. If a required input such as customer_id isn't available, another tool must produce it first.

   Covered in Input/output compatibility: can the agent call it, and use what comes back?

Practise it for real

List the tools on a managed Unity Catalog functions MCP server and call one using the exact name and arguments from its schema.

1. 1.Run databricks auth login --host https://<workspace-hostname> and note the profile name (default DEFAULT).

   Why: The MCP client authenticates to your workspace with this OAuth profile.

   You should see: A saved profile you can pass to WorkspaceClient(profile=...).

2. 2.In Python 3.12 or above, run pip install -U "mcp>=1.9" "databricks-sdk[openai]" "mlflow>=3.1.0" "databricks-agents>=1.0.0" "databricks-mcp".

   Why: databricks-mcp provides DatabricksMCPClient.

   You should see: Packages install without errors.

3. 3.Create a DatabricksMCPClient for {host}/api/2.0/mcp/functions/system/ai and call list_tools().

   Why: This shows each tool's name, description and input schema, which is the contract you select from.

   You should see: A list of tool names that includes system__ai__python_exec.

4. 4.Call mcp_client.call_tool("system__ai__python_exec", {"code": "print('Hello, world!')"}) and print result.content.

   Why: This confirms that the call has to match the tool name and argument names in the listed schema.

   You should see: Output containing Hello, world!