Integrating .do with Your Data Warehouse for Smarter Automation

In today's data-centric world, the most valuable business insights are locked away in data warehouses like Snowflake, Google BigQuery, and Amazon Redshift. While your business runs on this data, traditional automation platforms often can't access it, leading to rigid, uninformed workflows. It's time to change that.

What if your automation could not only execute tasks but also make intelligent, data-driven decisions in real-time? With the .do Agentic Workflow Platform, you can build powerful agents that connect directly to your data sources. This post will demonstrate how to leverage the .do SDK to create agents that query your data warehouse, unlocking a new level of sophisticated, context-aware automation.

Why Connect an Agentic Workflow to Your Data Warehouse?

Integrating your automation layer with your data layer isn't just about convenience; it's a strategic advantage. When your workflows can read and react to the data in your warehouse, you move from simple, brittle scripts to intelligent, adaptive systems.

Here's what you unlock:

• True Data-Driven Decision Making: Go beyond static if-this-then-that rules. Your workflows can query real-time data to determine the next best action. For example, "Is this new user part of a high-value a ccount?" or "Does this customer's usage pattern warrant a proactive support ticket?"
• Hyper-Personalization at Scale: Enrich user profiles on the fly. When a customer signs up, a workflow can query your data warehouse to pull their entire history, segment information, and lifetime value, using that context to tailor the entire onboarding experience.
• Dynamic Resource Management: Automate operational tasks based on live metrics. A workflow could monitor product usage data in BigQuery and automatically scale resources, trigger maintenance alerts, or notify the product team of unusual trends.
• Intelligent Lead and Customer Routing: When a new lead comes in, an agent can query your data to enrich the lead with firmographic data, then route it to the most appropriate sales representative based on territory, industry, and account size.

The Core of the Integration: The Data Agent

The power of the .do platform lies in its "agentic" architecture. An agent is a specialized, reusable component designed to interact with a specific system or perform a focused task. Using our Software Development Kit (SDK), you can easily build your own custom agents.

A Data Warehouse Agent is a component you build whose sole purpose is to:

1. Securely connect to your data warehouse (e.g., Snowflake).
2. Receive a query as an input.
3. Execute the query.
4. Return the results to the workflow for the next step.

By building this logic once, you create a powerful, reusable developer tool that any workflow in your organization can use.

How to Build a Snowflake Agent with the .do SDK

Let's walk through a practical example of creating an agent that connects to Snowflake using the .do TypeScript SDK. The principles are nearly identical for BigQuery, Redshift, or any other SQL database.

Prerequisites

1. A .do account and an API key from your dashboard.
2. Snowflake account details: username, password, account identifier, etc.
3. Node.js and your favorite code editor.
4. The necessary NPM packages:

npm install @do-platform/sdk snowflake-sdk
# Or yarn add @do-platform/sdk snowflake-sdk

Step 1: Create the Agent Function

The agent is just a function that encapsulates the connection and query logic. We'll use environment variables to store our credentials securely—never hardcode them!

// src/agents/snowflake-agent.ts
import * as snowflake from 'snowflake-sdk';

interface QueryInput {
  query: string;
  params?: any[];
}

// This function is our reusable agent logic
export async function runSnowflakeQuery(input: QueryInput): Promise<any[]> {
  const connection = snowflake.createConnection({
    account: process.env.SNOWFLAKE_ACCOUNT!,
    username: process.env.SNOWFLAKE_USER!,
    password: process.env.SNOWFLAKE_PASSWORD!,
    warehouse: process.env.SNOWFLAKE_WAREHOUSE!,
    database: process.env.SNOWFLAKE_DATABASE!,
    schema: process.env.SNOWFLAKE_SCHEMA!,
  });

  try {
    // Attempt to connect to Snowflake
    await new Promise((resolve, reject) => {
      connection.connect((err, conn) => {
        if (err) {
          console.error('Unable to connect to Snowflake:', err.message);
          reject(err);
        } else {
          console.log('Successfully connected to Snowflake.');
          resolve(conn);
        }
      });
    });

    // Execute the query
    const statement = await new Promise<snowflake.Statement>((resolve, reject) => {
      connection.execute({
        sqlText: input.query,
        binds: input.params,
        complete: (err, stmt, rows) => {
          if (err) {
            console.error('Failed to execute statement:', err.message);
            reject(err);
          } else {
            console.log(`Query successful. Fetched ${rows?.length} rows.`);
            resolve(stmt);
          }
        },
      });
    });

    // Stream the results into an array
    const rows = await new Promise<any[]>((resolve, reject) => {
      const stream = statement.streamRows();
      const results: any[] = [];
      stream.on('error', (err) => reject(err));
      stream.on('data', (row) => results.push(row));
      stream.on('end', () => resolve(results));
    });

    return rows;

  } catch (error) {
    console.error('An error occurred during the Snowflake query:', error);
    throw error; // Re-throw to allow the workflow to handle the failure
  } finally {
    // Ensure the connection is always destroyed
    if (connection.isUp()) {
      connection.destroy((err) => {
        if (err) {
          console.error('Failed to disconnect from Snowflake:', err.message);
        }
      });
    }
  }
}

Step 2: Use the Agent in a .do Workflow

Now that we have our agent logic, we can import and use it within a larger automated process defined with the .do SDK.

Let's imagine a workflow for qualifying new enterprise customers.

// src/workflows/customer-qualification.ts
import { Do } from '@do-platform/sdk';
import { runSnowflakeQuery } from '../agents/snowflake-agent';

const doClient = new Do({
  apiKey: process.env.DO_API_KEY,
});

async function qualifyNewCustomer(email: string) {
  try {
    // Step 1: Query Snowflake to get user data from our other products
    const customerDataRows = await runSnowflakeQuery({
      query: 'SELECT LIFETIME_VALUE, COMPANY_SIZE FROM dim_customers WHERE EMAIL = ?;',
      params: [email],
    });

    if (customerDataRows.length === 0) {
      console.log('New customer, no historical data found.');
      // Proceed with standard onboarding...
      return;
    }

    const customerData = customerDataRows[0];
    const isHighValue = customerData.LIFETIME_VALUE > 10000 && customerData.COMPANY_SIZE > 500;

    // Step 2: Run a .do workflow based on the data
    const result = await doClient.workflows.run({
      name: isHighValue
        ? 'enterprise-customer-onboarding'
        : 'standard-customer-onboarding',
      input: {
        email: email,
        source: 'DataWarehouseQualified',
      },
    });

    console.log(`Started workflow '${result.workflowName}' with Run ID: ${result.runId}`);
    return result;

  } catch (error) {
    console.error('Failed to run customer qualification workflow:', error);
  }
}

In this example, our script acts as the orchestrator. It calls our custom Snowflake agent, makes a decision based on the returned data, and then triggers the appropriate workflow using the .do SDK. This seamless API integration makes your code the single source of truth for your business logic.

Best Practices for Data Agents

• Security First: Always use read-only credentials for your agents. Never give your automation write access unless absolutely necessary. Store credentials in a secure secrets manager or as environment variables, not in your codebase.
• Performance is Key: Write efficient, targeted queries. Avoid SELECT *. The agent should only request the specific data fields needed for the workflow to make its decision.
• Design for Reusability: Build your agent to be generic. The runSnowflakeQuery function above can execute any query, making it a highly reusable tool for your team.
• Robust Error Handling: As shown in the example, wrap your database logic in try...catch blocks. A dropped connection or a faulty query shouldn't crash your entire system. The workflow should be able to catch the error and decide on a fallback action, like alerting an engineer.

Get Started with Smarter Automation

By bridging the gap between your applications and your data warehouse, you transform your automation from a simple task-doer into an intelligent decision-maker. The .do platform and our official SDKs provide all the developer tools you need to build, run, and scale these sophisticated agentic workflows.

Ready to unlock the power of your data?

• Explore our Developer Documentation for guides on our SDKs for TypeScript, Python, and more.
• Get your free API Key from your account dashboard and start building today.

Frequently Asked Questions

What is the .do SDK?
The .do Software Development Kit (SDK) is a set of tools, libraries, and documentation that allows developers to easily integrate the .do agentic workflow platform directly into their own applications.

Which programming languages are supported?
We provide official SDKs for popular languages like TypeScript/JavaScript, Python, and Go. Check our developer documentation for the most up-to-date list and community-supported libraries.

Is the SDK free to use?
Yes, our SDKs are free to download and use. Usage of the underlying .do platform is subject to our standard pricing plans, which are based on workflow executions and agent usage.