datahub-agent-context 1.3.1.10rc1__tar.gz → 1.4.0rc1__tar.gz

{datahub_agent_context-1.3.1.10rc1 → datahub_agent_context-1.4.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datahub-agent-context
-Version: 1.3.1.10rc1
+Version: 1.4.0rc1
 Summary: DataHub Agent Context - MCP Tools for AI Agents
 Home-page: https://datahub.io/
 License: Apache License 2.0
@@ -28,27 +28,33 @@ Classifier: Environment :: MacOS X
 Classifier: Topic :: Software Development
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: jmespath<2.0.0,>=1.0.0
-Requires-Dist: cachetools<7.0.0,>=5.0.0
-Requires-Dist: acryl-datahub==1.3.1.10rc1
-Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: json-repair<1.0.0,>=0.25.0
+Requires-Dist: jmespath<2.0.0,>=1.0.0
+Requires-Dist: httpcore<2.0,>=1.0.9
 Requires-Dist: h11<1.0,>=0.16
+Requires-Dist: acryl-datahub==1.4.0rc1
+Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: cachetools<7.0.0,>=5.0.0
 Requires-Dist: google-re2<2.0,>=1.0
-Requires-Dist: httpcore<2.0,>=1.0.9
 Provides-Extra: dev
-Requires-Dist: types-jmespath<2.0.0,>=1.0.0; extra == "dev"
-Requires-Dist: types-PyYAML<7.0.0,>=6.0.0; extra == "dev"
-Requires-Dist: mypy==1.17.1; extra == "dev"
-Requires-Dist: types-toml<1.0.0,>=0.10.0; extra == "dev"
+Requires-Dist: snowflake-connector-python<4.0.0,>=3.0.0; extra == "dev"
 Requires-Dist: types-cachetools<7.0.0,>=5.0.0; extra == "dev"
-Requires-Dist: pytest<9.0.0,>=8.3.4; extra == "dev"
-Requires-Dist: pytest-cov<7.0.0,>=2.8.0; extra == "dev"
+Requires-Dist: types-toml<1.0.0,>=0.10.0; extra == "dev"
 Requires-Dist: types-requests<3.0.0,>=2.0.0; extra == "dev"
+Requires-Dist: click<9.0.0,>=8.0.0; extra == "dev"
 Requires-Dist: tox<5.0.0,>=4.0.0; extra == "dev"
+Requires-Dist: types-jmespath<2.0.0,>=1.0.0; extra == "dev"
 Requires-Dist: ruff==0.11.7; extra == "dev"
+Requires-Dist: langchain-core<2.0.0,>=1.2.7; extra == "dev"
+Requires-Dist: mypy==1.17.1; extra == "dev"
+Requires-Dist: pytest<9.0.0,>=8.3.4; extra == "dev"
+Requires-Dist: types-PyYAML<7.0.0,>=6.0.0; extra == "dev"
+Requires-Dist: pytest-cov<7.0.0,>=2.8.0; extra == "dev"
 Provides-Extra: langchain
 Requires-Dist: langchain-core<2.0.0,>=1.2.7; extra == "langchain"
+Provides-Extra: snowflake
+Requires-Dist: snowflake-connector-python<4.0.0,>=3.0.0; extra == "snowflake"
+Requires-Dist: click<9.0.0,>=8.0.0; extra == "snowflake"
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type

{datahub_agent_context-1.3.1.10rc1 → datahub_agent_context-1.4.0rc1}/setup.py

@@ -69,9 +69,16 @@ langchain_requirements = {
     "langchain-core>=1.2.7,<2.0.0",
 }
 
+snowflake_requirements = {
+    "click>=8.0.0,<9.0.0",
+    "snowflake-connector-python>=3.0.0,<4.0.0",
+}
+
 dev_requirements = {
     *lint_requirements,
     *mypy_stubs,
+    *snowflake_requirements,
+    *langchain_requirements,
     "pytest>=8.3.4,<9.0.0",
     "pytest-cov>=2.8.0,<7.0.0",
     "tox>=4.0.0,<5.0.0",
@@ -123,5 +130,6 @@ setuptools.setup(
     extras_require={
         "dev": list(dev_requirements),
         "langchain": list(langchain_requirements),
+        "snowflake": list(snowflake_requirements),
     },
 )

{datahub_agent_context-1.3.1.10rc1 → datahub_agent_context-1.4.0rc1}/src/datahub_agent_context/_version.py

@@ -13,4 +13,4 @@
 # limitations under the License.
 
 __package_name__ = "datahub-agent-context"
-__version__ = "1.3.1.10rc1"
+__version__ = "1.4.0rc1"

datahub_agent_context-1.4.0rc1/src/datahub_agent_context/cli.py

@@ -0,0 +1,152 @@
+import logging
+
+import click
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def agent() -> None:
+    """Helper commands for Creating and managing Agent on DataHub."""
+    pass
+
+
+@agent.group()
+def create() -> None:
+    """Create an agent on DataHub."""
+    pass
+
+
+@create.command(name="snowflake")
+@click.option(
+    "--sf-account",
+    default=None,
+    help="Snowflake account identifier (auto-detected if not provided)",
+)
+@click.option(
+    "--sf-user",
+    default=None,
+    help="Snowflake user name (auto-detected if not provided)",
+)
+@click.option(
+    "--sf-role",
+    default=None,
+    help="Snowflake role (auto-detected if not provided)",
+)
+@click.option(
+    "--sf-warehouse",
+    default=None,
+    help="Snowflake warehouse name (auto-detected if not provided)",
+)
+@click.option(
+    "--sf-database",
+    default=None,
+    help="Snowflake database name (auto-detected if not provided)",
+)
+@click.option(
+    "--sf-schema",
+    default=None,
+    help="Snowflake schema name (auto-detected if not provided)",
+)
+@click.option("--datahub-url", required=True, help="DataHub instance URL")
+@click.option("--datahub-token", required=True, help="DataHub Personal Access Token")
+@click.option(
+    "--agent-name", default="DATAHUB_SQL_AGENT", help="Agent name in Snowflake"
+)
+@click.option(
+    "--agent-display-name",
+    default="DataHub SQL Assistant",
+    help="Agent display name in Snowflake UI",
+)
+@click.option(
+    "--agent-color",
+    default="blue",
+    help="Agent color in Snowflake UI",
+    type=click.Choice(["blue", "red", "green", "yellow", "purple", "orange"]),
+)
+@click.option(
+    "--output-dir",
+    default="./snowflake_setup",
+    help="Output directory for generated SQL files",
+)
+@click.option(
+    "--execute",
+    is_flag=True,
+    default=False,
+    help="Connect to Snowflake and execute the SQL scripts directly",
+)
+@click.option(
+    "--sf-password",
+    help="Snowflake password (required if --execute is used with password authentication)",
+)
+@click.option(
+    "--sf-authenticator",
+    default="snowflake",
+    type=click.Choice(["snowflake", "externalbrowser", "oauth"], case_sensitive=False),
+    help="Authentication method: 'snowflake' (password), 'externalbrowser' (SSO), or 'oauth' (token-based). Default: snowflake",
+)
+@click.option(
+    "--enable-mutations/--no-enable-mutations",
+    default=True,
+    help="Include mutation/write tools (tags, descriptions, owners, etc.). Default: enabled",
+)
+def create_snowflake(
+    sf_account: str | None,
+    sf_user: str | None,
+    sf_role: str | None,
+    sf_warehouse: str | None,
+    sf_database: str | None,
+    sf_schema: str | None,
+    datahub_url: str,
+    datahub_token: str,
+    agent_name: str,
+    agent_display_name: str,
+    agent_color: str,
+    output_dir: str,
+    execute: bool,
+    sf_password: str | None,
+    sf_authenticator: str,
+    enable_mutations: bool,
+) -> None:
+    """Create a Snowflake agent on DataHub.
+
+    Snowflake connection parameters (account, user, role, warehouse, database, schema)
+    will be auto-detected from your current session if not provided explicitly.
+
+    Authentication methods:
+    - snowflake (default): Standard password authentication
+    - externalbrowser: SSO authentication via browser (no password required)
+    - oauth: OAuth token-based authentication
+
+    Examples:
+        # Generate SQL files only (default)
+        $ datahub agent create snowflake --datahub-url=... --datahub-token=...
+
+        # Execute with password authentication
+        $ datahub agent create snowflake --execute --sf-password=secret ...
+
+        # Execute with SSO authentication (browser-based)
+        $ datahub agent create snowflake --execute --sf-authenticator=externalbrowser ...
+    """
+    from datahub_agent_context.snowflake.snowflake import create_snowflake_agent
+
+    ctx = click.get_current_context()
+    ctx.invoke(
+        create_snowflake_agent,
+        sf_account=sf_account,
+        sf_user=sf_user,
+        sf_role=sf_role,
+        sf_warehouse=sf_warehouse,
+        sf_database=sf_database,
+        sf_schema=sf_schema,
+        datahub_url=datahub_url,
+        datahub_token=datahub_token,
+        agent_name=agent_name,
+        agent_display_name=agent_display_name,
+        agent_color=agent_color,
+        output_dir=output_dir,
+        execute=execute,
+        sf_password=sf_password,
+        sf_authenticator=sf_authenticator,
+        enable_mutations=enable_mutations,
+    )

{datahub_agent_context-1.3.1.10rc1 → datahub_agent_context-1.4.0rc1}/src/datahub_agent_context/mcp_tools/base.py

@@ -152,9 +152,12 @@ def _is_datahub_cloud(graph: DataHubGraph) -> bool:
         )
         return False
 
-    is_cloud = hasattr(graph, "frontend_base_url") and graph.frontend_base_url
-    logger.debug(f"Cloud detection: {is_cloud}")
-    return bool(is_cloud)
+    try:
+        is_cloud = hasattr(graph, "frontend_base_url") and graph.frontend_base_url
+        logger.debug(f"Cloud detection: {is_cloud}")
+        return bool(is_cloud)
+    except ValueError:
+        return False
 
 
 def _is_field_validation_error(error_msg: str) -> bool:

datahub_agent_context-1.4.0rc1/src/datahub_agent_context/snowflake/generate_udfs.py

@@ -0,0 +1,306 @@
+"""
+Generate Snowflake UDFs that use datahub-agent-context wrapper methods.
+
+This module generates Python UDF code that uses the datahub-agent-context package
+to interact with DataHub, instead of making direct HTTP API calls.
+"""
+
+import logging
+from pathlib import Path
+
+import click
+
+from datahub_agent_context.snowflake.udfs.add_glossary_terms import (
+    generate_add_glossary_terms_udf,
+)
+from datahub_agent_context.snowflake.udfs.add_owners import generate_add_owners_udf
+from datahub_agent_context.snowflake.udfs.add_structured_properties import (
+    generate_add_structured_properties_udf,
+)
+from datahub_agent_context.snowflake.udfs.add_tags import generate_add_tags_udf
+from datahub_agent_context.snowflake.udfs.get_dataset_queries import (
+    generate_get_dataset_queries_udf,
+)
+from datahub_agent_context.snowflake.udfs.get_entities import generate_get_entities_udf
+from datahub_agent_context.snowflake.udfs.get_lineage import generate_get_lineage_udf
+from datahub_agent_context.snowflake.udfs.get_lineage_paths_between import (
+    generate_get_lineage_paths_between_udf,
+)
+from datahub_agent_context.snowflake.udfs.get_me import generate_get_me_udf
+from datahub_agent_context.snowflake.udfs.grep_documents import (
+    generate_grep_documents_udf,
+)
+from datahub_agent_context.snowflake.udfs.list_schema_fields import (
+    generate_list_schema_fields_udf,
+)
+from datahub_agent_context.snowflake.udfs.remove_domains import (
+    generate_remove_domains_udf,
+)
+from datahub_agent_context.snowflake.udfs.remove_glossary_terms import (
+    generate_remove_glossary_terms_udf,
+)
+from datahub_agent_context.snowflake.udfs.remove_owners import (
+    generate_remove_owners_udf,
+)
+from datahub_agent_context.snowflake.udfs.remove_structured_properties import (
+    generate_remove_structured_properties_udf,
+)
+from datahub_agent_context.snowflake.udfs.remove_tags import generate_remove_tags_udf
+from datahub_agent_context.snowflake.udfs.search_datahub import (
+    generate_search_datahub_udf,
+)
+from datahub_agent_context.snowflake.udfs.search_documents import (
+    generate_search_documents_udf,
+)
+from datahub_agent_context.snowflake.udfs.set_domains import generate_set_domains_udf
+from datahub_agent_context.snowflake.udfs.update_description import (
+    generate_update_description_udf,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def extract_function_signature(udf_sql: str) -> str:
+    """Extract function parameter signature from UDF SQL.
+
+    Args:
+        udf_sql: The SQL CREATE FUNCTION statement
+
+    Returns:
+        String of Snowflake parameter types (e.g., "STRING, NUMBER")
+        Empty string if function has no parameters
+    """
+    import re
+
+    # Match the function parameters between parentheses
+    # The SQL format is: CREATE OR REPLACE FUNCTION name(params) RETURNS ...
+    match = re.search(r"FUNCTION\s+\w+\s*\((.*?)\)\s*RETURNS", udf_sql, re.DOTALL)
+    if not match:
+        return ""
+
+    params_str = match.group(1).strip()
+    if not params_str:
+        return ""
+
+    # Extract just the types (STRING, NUMBER, etc.)
+    # Parameter format is: param_name TYPE
+    param_types = []
+    for param in params_str.split(","):
+        param = param.strip()
+        if param:
+            # Split on whitespace and take the last part (the type)
+            parts = param.split()
+            if len(parts) >= 2:
+                param_types.append(parts[-1])
+
+    return ", ".join(param_types) if param_types else ""
+
+
+def generate_all_udfs(include_mutations: bool = True) -> dict[str, str]:
+    """Generate all DataHub UDFs from datahub-agent-context tools.
+
+    Returns all 20 tools from datahub-agent-context as Snowflake UDFs, including
+    both read operations (search, get_entities, etc.) and write operations (add_tags,
+    update_description, etc.).
+
+    Write operations enable automated governance workflows from Snowflake, such as:
+    - Tagging datasets based on query analysis
+    - Enriching metadata with descriptions and owners
+    - Bulk operations on multiple entities from SQL
+
+    Args:
+        include_mutations: Whether to include mutation/write tools (default: True)
+
+    Returns:
+        Dictionary mapping function names to their SQL definitions
+    """
+    udfs = {
+        # Core search and entity tools (read-only)
+        "SEARCH_DATAHUB": generate_search_datahub_udf(),
+        "GET_ENTITIES": generate_get_entities_udf(),
+        "LIST_SCHEMA_FIELDS": generate_list_schema_fields_udf(),
+        # Lineage tools (read-only)
+        "GET_LINEAGE": generate_get_lineage_udf(),
+        "GET_LINEAGE_PATHS_BETWEEN": generate_get_lineage_paths_between_udf(),
+        # Query analysis tools (read-only)
+        "GET_DATASET_QUERIES": generate_get_dataset_queries_udf(),
+        # Document search tools (read-only)
+        "SEARCH_DOCUMENTS": generate_search_documents_udf(),
+        "GREP_DOCUMENTS": generate_grep_documents_udf(),
+        # User info tool (read-only)
+        "GET_ME": generate_get_me_udf(),
+    }
+
+    if include_mutations:
+        # Mutation/write tools - only include if enabled
+        udfs.update(
+            {
+                # Tag management tools
+                "ADD_TAGS": generate_add_tags_udf(),
+                "REMOVE_TAGS": generate_remove_tags_udf(),
+                # Description management tool
+                "UPDATE_DESCRIPTION": generate_update_description_udf(),
+                # Domain management tools
+                "SET_DOMAINS": generate_set_domains_udf(),
+                "REMOVE_DOMAINS": generate_remove_domains_udf(),
+                # Owner management tools
+                "ADD_OWNERS": generate_add_owners_udf(),
+                "REMOVE_OWNERS": generate_remove_owners_udf(),
+                # Glossary term management tools
+                "ADD_GLOSSARY_TERMS": generate_add_glossary_terms_udf(),
+                "REMOVE_GLOSSARY_TERMS": generate_remove_glossary_terms_udf(),
+                # Structured property management tools
+                "ADD_STRUCTURED_PROPERTIES": generate_add_structured_properties_udf(),
+                "REMOVE_STRUCTURED_PROPERTIES": generate_remove_structured_properties_udf(),
+            }
+        )
+
+    return udfs
+
+
+def generate_datahub_udfs_sql(include_mutations: bool = True) -> str:
+    """Generate complete SQL script with DataHub UDFs using datahub-agent-context.
+
+    Args:
+        include_mutations: Whether to include mutation/write tools (default: True)
+    """
+    # Generate read-only UDFs first to get count
+    read_only_udfs = generate_all_udfs(include_mutations=False)
+    read_ops_count = len(read_only_udfs)
+
+    # Generate all UDFs (read + write if enabled)
+    all_udfs = generate_all_udfs(include_mutations=include_mutations)
+    total_udfs = len(all_udfs)
+    write_ops_count = total_udfs - read_ops_count
+
+    udf_sections = []
+    grant_statements = []
+    show_statements = []
+    function_list = []
+
+    for function_name, udf_sql in all_udfs.items():
+        udf_sections.append(f"""-- ============================================================================
+-- UDF: {function_name}
+-- ============================================================================
+{udf_sql}""")
+
+        # Generate GRANT statement based on function signature extracted from SQL
+        signature = extract_function_signature(udf_sql)
+        grant_statements.append(
+            f"GRANT USAGE ON FUNCTION {function_name}({signature}) TO ROLE IDENTIFIER($SF_ROLE);"
+        )
+
+        show_statements.append(f"SHOW FUNCTIONS LIKE '{function_name}';")
+        function_list.append(
+            f"    $SF_DATABASE || '.' || $SF_SCHEMA || '.{function_name}' AS {function_name.lower()}"
+        )
+
+    function_list_joined = ("," + chr(10)).join(function_list)
+
+    write_ops_section = (
+        f"""--
+-- Write Operations ({write_ops_count}):
+--   - ADD_TAGS, REMOVE_TAGS: Tag management
+--   - UPDATE_DESCRIPTION: Description management
+--   - SET_DOMAINS, REMOVE_DOMAINS: Domain management
+--   - ADD_OWNERS, REMOVE_OWNERS: Owner management
+--   - ADD_GLOSSARY_TERMS, REMOVE_GLOSSARY_TERMS: Glossary term management
+--   - ADD_STRUCTURED_PROPERTIES, REMOVE_STRUCTURED_PROPERTIES: Structured property management
+"""
+        if include_mutations
+        else ""
+    )
+
+    return f"""-- ============================================================================
+-- Step 2: DataHub API UDFs for Cortex Agent (using datahub-agent-context)
+-- ============================================================================
+-- This script creates {total_udfs} Python UDFs that enable Snowflake Intelligence to
+-- query DataHub for metadata{" and manage metadata programmatically" if include_mutations else ""}.
+--
+-- These UDFs use the datahub-agent-context package wrapper methods.
+--
+-- UDFs included:
+-- Read Operations ({read_ops_count}):
+--   - SEARCH_DATAHUB: Search for entities
+--   - GET_ENTITIES: Get entity details
+--   - LIST_SCHEMA_FIELDS: List schema fields with filtering
+--   - GET_LINEAGE: Get upstream/downstream lineage
+--   - GET_LINEAGE_PATHS_BETWEEN: Get detailed transformation paths
+--   - GET_DATASET_QUERIES: Get SQL queries using a dataset
+--   - SEARCH_DOCUMENTS: Search organization documents
+--   - GREP_DOCUMENTS: Regex search within documents
+--   - GET_ME: Get authenticated user information
+{write_ops_section}--
+-- Prerequisites:
+-- - Run 00_configuration.sql first to set variables
+-- - Run 01_network_rules.sql to create network rules and secrets
+-- - You must have appropriate privileges to create functions
+-- ============================================================================
+
+USE DATABASE IDENTIFIER($SF_DATABASE);
+USE SCHEMA IDENTIFIER($SF_SCHEMA);
+USE WAREHOUSE IDENTIFIER($SF_WAREHOUSE);
+
+{chr(10).join(udf_sections)}
+
+-- ============================================================================
+-- Grant Usage Permissions
+-- ============================================================================
+{chr(10).join(grant_statements)}
+
+-- ============================================================================
+-- Verify All UDFs Were Created
+-- ============================================================================
+{chr(10).join(show_statements)}
+
+SELECT
+    'All {total_udfs} DataHub UDFs created successfully!' AS status,
+{function_list_joined};
+"""
+
+
+@click.command()
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(dir_okay=False, writable=True),
+    help="Output file path for generated SQL (default: print to stdout)",
+)
+@click.option(
+    "--enable-mutations/--no-enable-mutations",
+    default=True,
+    help="Include mutation/write tools (tags, descriptions, owners, etc.). Default: enabled",
+)
+def main(output: str | None, enable_mutations: bool) -> None:
+    """Generate Snowflake UDF SQL for DataHub integration.
+
+    This command generates SQL scripts that create Snowflake User-Defined Functions (UDFs)
+    for interacting with DataHub metadata from Snowflake.
+
+    Generates all UDFs using the datahub-agent-context package.
+
+    Examples:
+        # Print SQL to stdout with all tools (read + write)
+        python -m datahub.ai.snowflake.generate_udfs
+
+        # Generate read-only tools (no mutations)
+        python -m datahub.ai.snowflake.generate_udfs --no-enable-mutations
+
+        # Save to file with mutations enabled
+        python -m datahub.ai.snowflake.generate_udfs -o datahub_udfs.sql
+    """
+    sql_content = generate_datahub_udfs_sql(include_mutations=enable_mutations)
+
+    if output:
+        output_path = Path(output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(sql_content)
+        udf_count = len(generate_all_udfs(include_mutations=enable_mutations))
+        click.echo(f"✓ Generated {udf_count} Snowflake UDF(s) to: {output_path}")
+        logger.info(f"Generated Snowflake UDF SQL to {output_path}")
+    else:
+        click.echo(sql_content)
+
+
+if __name__ == "__main__":
+    main()

datahub_agent_context-1.4.0rc1/src/datahub_agent_context/snowflake/generators/__init__.py

@@ -0,0 +1,21 @@
+"""SQL generators for Snowflake agent setup."""
+
+from datahub_agent_context.snowflake.generators.configuration import (
+    generate_configuration_sql,
+)
+from datahub_agent_context.snowflake.generators.cortex_agent import (
+    generate_cortex_agent_sql,
+)
+from datahub_agent_context.snowflake.generators.network_rules import (
+    generate_network_rules_sql,
+)
+from datahub_agent_context.snowflake.generators.stored_procedure import (
+    generate_stored_procedure_sql,
+)
+
+__all__ = [
+    "generate_configuration_sql",
+    "generate_network_rules_sql",
+    "generate_stored_procedure_sql",
+    "generate_cortex_agent_sql",
+]

datahub_agent_context-1.4.0rc1/src/datahub_agent_context/snowflake/generators/configuration.py

@@ -0,0 +1,104 @@
+"""Generate Snowflake configuration SQL."""
+
+
+def generate_configuration_sql(
+    sf_account: str | None,
+    sf_user: str | None,
+    sf_role: str | None,
+    sf_warehouse: str | None,
+    sf_database: str | None,
+    sf_schema: str | None,
+    datahub_url: str,
+    datahub_token: str,
+    agent_name: str,
+    agent_display_name: str,
+    agent_color: str,
+    execute: bool = False,
+) -> str:
+    """Generate configuration SQL based on provided parameters.
+
+    If parameters are None, uses Snowflake SQL functions to auto-detect values.
+    In non-execute mode, uses placeholder for token for security.
+
+    Args:
+        execute: If True, includes actual token. If False, uses placeholder.
+    """
+    # Use SQL functions for auto-detection when values are not provided
+    account_value = f"'{sf_account}'" if sf_account else "CURRENT_ACCOUNT()"
+    user_value = f"'{sf_user}'" if sf_user else "CURRENT_USER()"
+    role_value = f"'{sf_role}'" if sf_role else "CURRENT_ROLE()"
+    warehouse_value = f"'{sf_warehouse}'" if sf_warehouse else "CURRENT_WAREHOUSE()"
+    database_value = f"'{sf_database}'" if sf_database else "CURRENT_DATABASE()"
+    schema_value = f"'{sf_schema}'" if sf_schema else "CURRENT_SCHEMA()"
+
+    # Use placeholder for token in non-execute mode for security
+    token_value = datahub_token if execute else "<DATAHUB_TOKEN>"
+
+    return f"""-- ============================================================================
+-- CONFIGURATION FILE - Customize these values for your environment
+-- ============================================================================
+-- Values are auto-detected from your current session where possible
+-- Then run the numbered scripts in order (01, 02, 03, 04, 05)
+
+-- ============================================================================
+-- SNOWFLAKE CONFIGURATION
+-- ============================================================================
+
+-- Your Snowflake account identifier (e.g., 'xy12345' or 'xy12345.us-east-1')
+SET SF_ACCOUNT = {account_value};
+
+-- Your Snowflake user (the user who will run the agent)
+SET SF_USER = {user_value};
+
+-- Your Snowflake role (must have permissions to create objects)
+SET SF_ROLE = {role_value};
+
+-- Your Snowflake warehouse name
+SET SF_WAREHOUSE = {warehouse_value};
+
+-- Your Snowflake database name
+SET SF_DATABASE = {database_value};
+
+-- Your Snowflake schema name (where UDFs, procedures, and agent will be created)
+SET SF_SCHEMA = {schema_value};
+
+-- Set the database, schema, and warehouse context
+USE DATABASE IDENTIFIER($SF_DATABASE);
+USE SCHEMA IDENTIFIER($SF_SCHEMA);
+USE WAREHOUSE IDENTIFIER($SF_WAREHOUSE);
+
+-- ============================================================================
+-- DATAHUB CONFIGURATION
+-- ============================================================================
+
+-- Your DataHub instance URL (without /gms or trailing slash)
+-- Examples:
+--   https://fieldeng.acryl.io
+--   https://your-company.acryl.io
+--   https://datahub.your-company.com
+SET DATAHUB_URL = '{datahub_url}';
+
+-- Your DataHub Personal Access Token (PAT)
+-- Get this from DataHub UI: Settings > Access Tokens > Create Token
+-- Create Snowflake secrets to store credentials securely
+CREATE OR REPLACE SECRET datahub_url
+  TYPE = GENERIC_STRING
+  SECRET_STRING = '{datahub_url}';
+
+CREATE OR REPLACE SECRET datahub_token
+  TYPE = GENERIC_STRING
+  SECRET_STRING = '{token_value}';
+
+-- ============================================================================
+-- AGENT CONFIGURATION
+-- ============================================================================
+
+-- Agent name (will be created as: <DATABASE>.<SCHEMA>.<AGENT_NAME>)
+SET AGENT_NAME = '{agent_name}';
+
+-- Agent display name (shown in Snowflake Intelligence UI)
+SET AGENT_DISPLAY_NAME = '{agent_display_name}';
+
+-- Agent color (for UI display)
+SET AGENT_COLOR = '{agent_color}';
+"""