Snowflake

https://docs.snowflake.com/en/user-guide
Admin
Snowflake is a cloud data platform that provides a data warehouse as a service, enabling users to...
Tokens:4,542,058
Snippets:36,476
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example: start sfsql with user and password

Source: https://docs.snowflake.com/en/user-guide/sfsql-start-stop

Example of starting the client from /Users/user1/client with user 'user1' and password '1234567a' for account 'xy12345'. Shows the resulting HenPlus startup output and the prompt after successful login.

```bash
$ cd /Users/user1/client
$ ./sfsql -u user1 -c 1234567a

using GNU readline (Brian Fox, Chet Ramey), Java wrapper by Bernhard Bablok
henplus config at /Users/ybrenman/.henplus
----------------------------------------------------------------------------
 HenPlus II 0.9.8 "Yay Labor Day"
 Copyright(C) 1997..2009 Henner Zeller <H.Zeller@acm.org>
 HenPlus is provided AS IS and comes with ABSOLUTELY NO WARRANTY
 This is free software, and you are welcome to redistribute it under the
 conditions of the GNU Public License <http://www.gnu.org/licenses/gpl2.txt>
----------------------------------------------------------------------------
HenPlus II connecting
 url 'jdbc:snowflake://xy12345.snowflakecomputing.com:443/?account=xy12345&user=user1&ssl=on'
 driver version 2.3
 Snowflake - 1.0 (driver change version: 2.3.1, latest change version: 2.4.38)
no transactions.
 No Transaction *

user1@snowflake:xy12345.snowflakecomputing.com>

```

--------------------------------

### Prompt to install Databricks CLI and authenticate

Source: https://docs.snowflake.com/en/user-guide/cortex-code/data-platforms

Example prompt to start a CoCo session and set up the Databricks connection after enabling the plugin.

```text
Help me install the Databricks CLI and authenticate to my workspace

```

--------------------------------

### Messages API quickstart (Anthropic SDK and curl)

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Quickstart for the Messages API, which follows the Anthropic specification and supports Claude models only. The Anthropic SDK sends credentials via x-api-key by default, so the Python example uses an httpx client and the JavaScript example uses defaultHeaders to set a Bearer token. Replace <account-identifier> and <SNOWFLAKE_PAT> with your Snowflake account URL and programmatic access token.

```python
import httpx
import anthropic

PAT = "<SNOWFLAKE_PAT>"

http_client = httpx.Client(
  headers={"Authorization": f"Bearer {PAT}"},
)

client = anthropic.Anthropic(
  api_key="not-used",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex",
  http_client=http_client,
  default_headers={"Authorization": f"Bearer {PAT}"},
)

response = client.messages.create(
  model="claude-sonnet-4-5",
  max_tokens=1024,
  messages=[
    {"role": "user", "content": "How does a snowflake get its unique pattern?"}
  ],
)

print(response.content[0].text)

```

```javascript
import Anthropic from "@anthropic-ai/sdk";

const PAT = "<SNOWFLAKE_PAT>";

const client = new Anthropic({
  apiKey: "not-used",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex",
  defaultHeaders: {
    "Authorization": `Bearer ${PAT}`,
  },
});

const response = await client.messages.create({
  model: "claude-sonnet-4-5",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "How does a snowflake get its unique pattern?" }
  ],
});

console.log(response.content[0].text);

```

```bash
curl "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1/messages" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <SNOWFLAKE_PAT>" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-sonnet-4-5",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "How does a snowflake get its unique pattern?"}
    ]
  }'

```

--------------------------------

### Chat Completions quickstart (OpenAI SDK and curl)

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Quickstart for the Chat Completions API, which follows the OpenAI specification. Replace <account-identifier> and <SNOWFLAKE_PAT> with your Snowflake account URL and programmatic access token. The model name must be a supported model, such as openai-gpt-5.

```python
from openai import OpenAI

client = OpenAI(
  api_key="<SNOWFLAKE_PAT>",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
)

response = client.chat.completions.create(
  model="openai-gpt-5",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "How does a snowflake get its unique pattern?"}
  ]
)

print(response.choices[0].message.content)

```

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "<SNOWFLAKE_PAT>",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
});

const response = await client.chat.completions.create({
  model: "openai-gpt-5",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "How does a snowflake get its unique pattern?" }
  ],
});

console.log(response.choices[0].message.content);

```

```bash
curl "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <SNOWFLAKE_PAT>" \
  -d '{
    "model": "openai-gpt-5",
    "messages": [
      {"role": "user", "content": "How does a snowflake get its unique pattern?"}
    ]
  }'

```

--------------------------------

### Chat Completions tool calling with OpenAI SDK (Python and JavaScript/TypeScript)

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Python and JavaScript/TypeScript examples for the Chat Completions tool calling workflow. Both use the OpenAI SDK with the Snowflake Cortex base URL and a Snowflake PAT. The code defines a get_weather tool, sends a request, handles the tool_calls response, executes the tool, and sends the result back to get the final answer.

```python
import json
from openai import OpenAI

client = OpenAI(
  api_key="<SNOWFLAKE_PAT>",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
)

tools = [
  {
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Get the current weather for a location",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "The city and state, e.g. San Francisco, CA"
          }
        },
        "required": ["location"]
      }
    }
  }
]

messages = [
  {"role": "user", "content": "What is the weather like in San Francisco?"}
]

# Step 1: Send the request with tools
response = client.chat.completions.create(
  model="openai-gpt-5",
  messages=messages,
  tools=tools,
)

# Step 2: The model responds with tool_calls
message = response.choices[0].message

if message.tool_calls:
    tool_call = message.tool_calls[0]

    # Step 3: Execute the tool (your implementation)
    result = json.dumps({"temperature": "69°F", "condition": "sunny"})

    # Step 4: Send the tool result back
    messages.append(message)
    messages.append({
      "role": "tool",
      "tool_call_id": tool_call.id,
      "content": result,
    })

    final_response = client.chat.completions.create(
      model="openai-gpt-5",
      messages=messages,
      tools=tools,
    )

    print(final_response.choices[0].message.content)

```

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "<SNOWFLAKE_PAT>",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
});

const tools = [
  {
    type: "function",
    function: {
      name: "get_weather",
      description: "Get the current weather for a location",
      parameters: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA"
          }
        },
        required: ["location"]
      }
    }
  }
];

const messages = [
  { role: "user", content: "What is the weather like in San Francisco?" }
];

// Step 1: Send the request with tools
const response = await client.chat.completions.create({
  model: "openai-gpt-5",
  messages,
  tools,
});

// Step 2: The model responds with tool_calls
const message = response.choices[0].message;

if (message.tool_calls) {
  const toolCall = message.tool_calls[0];

  // Step 3: Execute the tool (your implementation)
  const result = JSON.stringify({ temperature: "69°F", condition: "sunny" });

  // Step 4: Send the tool result back
  messages.push(message);
  messages.push({
    role: "tool",
    tool_call_id: toolCall.id,
    content: result,
  });

  const finalResponse = await client.chat.completions.create({
    model: "openai-gpt-5",
    messages,
    tools,
  });

  console.log(finalResponse.choices[0].message.content);
}

```

--------------------------------

### Use tool examples beta header with Messages API (Python, JavaScript, curl)

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Shows how to use the tool-examples-2025-10-29 beta header with the Messages API on Snowflake Cortex. The Python and JavaScript examples use the Anthropic SDK with a Snowflake PAT and base URL; the curl example sends the request directly. All three use the claude-sonnet-4-6 model and include a get_weather tool with an example input/output pair.

```python
import httpx
import anthropic

PAT = "<SNOWFLAKE_PAT>"

http_client = httpx.Client(
  headers={"Authorization": f"Bearer {PAT}"},
)

client = anthropic.Anthropic(
  api_key="not-used",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex",
  http_client=http_client,
  default_headers={
    "Authorization": f"Bearer {PAT}",
  },
)

response = client.beta.messages.create(
  model="claude-sonnet-4-6",
  max_tokens=8192,
  betas=["tool-examples-2025-10-29"],
  tools=[
    {
      "name": "get_weather",
      "description": "Get the current weather for a location",
      "input_schema": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "The city and state, e.g. San Francisco, CA"
          }
        },
        "required": ["location"]
      },
      "examples": [
        {
          "input": {"location": "San Francisco, CA"},
          "output": {"temperature": "65°F", "condition": "sunny"}
        }
      ]
    }
  ],
  messages=[
    {"role": "user", "content": "What's the weather in New York?"}
  ],
)

print(f"Stop reason: {response.stop_reason}")
if response.stop_reason == "tool_use":
  tool_use = next(b for b in response.content if b.type == "tool_use")
  print(f"Tool called: {tool_use.name}")
  print(f"Arguments: {tool_use.input}")
```

```javascript
import Anthropic from "@anthropic-ai/sdk";

const PAT = "<SNOWFLAKE_PAT>";

const client = new Anthropic({
  apiKey: "not-used",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex",
  defaultHeaders: {
    "Authorization": `Bearer ${PAT}`,
  },
});

const response = await client.beta.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 8192,
  betas: ["tool-examples-2025-10-29"],
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a location",
      input_schema: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA"
          }
        },
        required: ["location"]
      },
      examples: [
        {
          input: { location: "San Francisco, CA" },
          output: { temperature: "65°F", condition: "sunny" }
        }
      ]
    }
  ],
  messages: [
    { role: "user", content: "What's the weather in New York?" }
  ],
});

console.log(`Stop reason: ${response.stop_reason}`);
if (response.stop_reason === "tool_use") {
  const toolUse = response.content.find(b => b.type === "tool_use");
  console.log(`Tool called: ${toolUse.name}`);
  console.log(`Arguments: ${JSON.stringify(toolUse.input)}`);
}
```

```bash
curl "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1/messages" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <SNOWFLAKE_PAT>" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: tool-examples-2025-10-29" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 8192,
    "tools": [
      {
        "name": "get_weather",
        "description": "Get the current weather for a location",
        "input_schema": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            }
          },
          "required": ["location"]
        },
        "examples": [
          {
            "input": {"location": "San Francisco, CA"},
            "output": {"temperature": "65°F", "condition": "sunny"}
          }
        ]
      }
    ],
    "messages": [
      {"role": "user", "content": "What's the weather in New York?"}
    ]
  }'
```

--------------------------------

### Chat Completions with Claude reasoning object (Python, JavaScript, curl)

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Use the `reasoning` object with Claude models (e.g., claude-sonnet-4-5) to set reasoning effort to high. The Python and JavaScript examples use the OpenAI SDK with the Cortex base URL and a Snowflake PAT; the curl example sends the same request directly.

```python
from openai import OpenAI

client = OpenAI(
  api_key="<SNOWFLAKE_PAT>",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
)

# Claude models — use the reasoning object
response = client.chat.completions.create(
  model="claude-sonnet-4-5",
  temperature=1,
  messages=[
    {"role": "user", "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"}
  ],
  extra_body={
    "reasoning": {"effort": "high"}
  }
)

print(response.choices[0].message.content)
```

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "<SNOWFLAKE_PAT>",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
});

// Claude models — use the reasoning object
const response = await client.chat.completions.create({
  model: "claude-sonnet-4-5",
  temperature: 1,
  messages: [
    { role: "user", content: "Are there an infinite number of prime numbers such that n mod 4 == 3?" }
  ],
  reasoning: { effort: "high" },
});

console.log(response.choices[0].message.content);
```

```bash
# Claude models — use the reasoning object
curl "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <SNOWFLAKE_PAT>" \
  -d '{
    "model": "claude-sonnet-4-5",
    "temperature": 1,
    "messages": [
      {"role": "user", "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"}
    ],
    "reasoning": {
      "effort": "high"
    }
  }'
```

--------------------------------

### Combine multiple beta headers with comma-separated string

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Shows how to combine multiple beta features by passing a comma-separated string in the anthropic-beta header. This example combines tool-examples-2025-10-29 and tool-search-tool-2025-10-19.

```bash
-H "anthropic-beta: tool-examples-2025-10-29,tool-search-tool-2025-10-19"
```

--------------------------------

### Chat Completions streaming with OpenAI SDK and curl

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Streaming chat completions using the OpenAI SDK or curl against the Cortex API. The Python and JavaScript examples set the base URL to the Cortex v1 endpoint and enable stream mode; the curl example includes stream_options.include_usage to request usage information.

```python
from openai import OpenAI

client = OpenAI(
  api_key="<SNOWFLAKE_PAT>",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
)

response = client.chat.completions.create(
  model="openai-gpt-5",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "How does a snowflake get its unique pattern?"}
  ],
  stream=True
)

for chunk in response:
    print(chunk.choices[0].delta.content, end="", flush=True)

```

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "<SNOWFLAKE_PAT>",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
});

const stream = await client.chat.completions.create({
  model: "openai-gpt-5",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "How does a snowflake get its unique pattern?" }
  ],
  stream: true,
});

for await (const event of stream) {
  process.stdout.write(event.choices[0]?.delta?.content || "");
}

```

```bash
curl "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <SNOWFLAKE_PAT>" \
  -d '{
    "model": "openai-gpt-5",
    "messages": [
      {"role": "user", "content": "How does a snowflake get its unique pattern?"}
    ],
    "stream": true,
    "stream_options": {
      "include_usage": true
    }
  }'

```

--------------------------------

### Cortex Messages API tool calling with Python

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Python example using the Anthropic SDK to call the Cortex Messages API with tool calling. Requires the anthropic and httpx packages and a Snowflake PAT. The flow sends a request with tools, handles a tool_use response, executes the tool, and sends the result back.

```python
import json
import httpx
import anthropic

PAT = "<SNOWFLAKE_PAT>"

http_client = httpx.Client(
  headers={"Authorization": f"Bearer {PAT}"},
)

client = anthropic.Anthropic(
  api_key="not-used",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex",
  http_client=http_client,
  default_headers={"Authorization": f"Bearer {PAT}"},
)

tools = [
  {
    "name": "get_weather",
    "description": "Get the current weather for a location",
    "input_schema": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "The city and state, e.g. San Francisco, CA"
        }
      },
      "required": ["location"]
    }
  }
]

messages = [
  {"role": "user", "content": "What is the weather like in San Francisco?"}
]

# Step 1: Send the request with tools
response = client.messages.create(
  model="claude-sonnet-4-5",
  max_tokens=1024,
  messages=messages,
  tools=tools,
)

# Step 2: The model responds with a tool_use block
if response.stop_reason == "tool_use":
    tool_use = next(b for b in response.content if b.type == "tool_use")

    # Step 3: Execute the tool (your implementation)
    result = json.dumps({"temperature": "69°F", "condition": "sunny"})

    # Step 4: Send the tool result back
    messages.append({"role": "assistant", "content": response.content})
    messages.append({
      "role": "user",
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": tool_use.id,
          "content": result,
        }
      ],
    })

    final_response = client.messages.create(
      model="claude-sonnet-4-5",
      max_tokens=1024,
      messages=messages,
      tools=tools,
    )

    print(final_response.content[0].text)
```

--------------------------------

### Usage by user

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Aggregates usage by user and model for the last 30 days, joining with the USERS view to get user names, and breaking out input and output tokens.

```sql
SELECT
    u.NAME AS user_name,
    r.MODEL_NAME,
    COUNT(*) AS requests,
    SUM(r.TOKENS) AS total_tokens,
    SUM(r.TOKENS_GRANULAR:"input"::INT) AS input_tokens,
    SUM(r.TOKENS_GRANULAR:"output"::INT) AS output_tokens
FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_REST_API_USAGE_HISTORY r
JOIN SNOWFLAKE.ACCOUNT_USAGE.USERS u ON r.USER_ID = u.USER_ID
WHERE r.START_TIME >= DATEADD('day', -30, CURRENT_TIMESTAMP())
GROUP BY 1, 2
ORDER BY total_tokens DESC;

```

--------------------------------

### Chat Completions with OpenAI reasoning_effort (curl)

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

For OpenAI reasoning models (e.g., openai-gpt-5), use the `reasoning_effort` field with values none, minimal, low, medium, or high. This curl example sets it to high.

```bash
# OpenAI reasoning models — use reasoning_effort
curl "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <SNOWFLAKE_PAT>" \
  -d '{
    "model": "openai-gpt-5",
    "messages": [
      {"role": "user", "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"}
    ],
    "reasoning_effort": "high"
  }'
```

--------------------------------

### Chat Completions image input with openai-gpt-5

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

Send an image to the Snowflake Cortex Chat Completions API using the openai-gpt-5 model. The Python and JavaScript examples read and base64-encode a local image file, while the curl example expects a pre-encoded <BASE64_IMAGE_DATA> placeholder. All three use the same endpoint and require a Snowflake PAT and account identifier.

```python
import base64
from openai import OpenAI

client = OpenAI(
  api_key="<SNOWFLAKE_PAT>",
  base_url="https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
)

# Read and encode an image file
with open("image.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
  model="openai-gpt-5",
  messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "image_url",
          "image_url": {
            "url": f"data:image/png;base64,{image_data}"
          }
        },
        {
          "type": "text",
          "text": "What is in this image?"
        }
      ]
    }
  ]
)

print(response.choices[0].message.content)
```

```javascript
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: "<SNOWFLAKE_PAT>",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1"
});

// Read and encode an image file
const imageData = fs.readFileSync("image.png").toString("base64");

const response = await client.chat.completions.create({
  model: "openai-gpt-5",
  messages: [
    {
      role: "user",
      content: [
        {
          type: "image_url",
          image_url: {
            url: `data:image/png;base64,${imageData}`
          }
        },
        {
          type: "text",
          text: "What is in this image?"
        }
      ]
    }
  ],
});

console.log(response.choices[0].message.content);
```

```bash
curl "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <SNOWFLAKE_PAT>" \
  -d '{
    "model": "openai-gpt-5",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image_url",
            "image_url": {
              "url": "data:image/png;base64,<BASE64_IMAGE_DATA>"
            }
          },
          {
            "type": "text",
            "text": "What is in this image?"
          }
        ]
      }
    ]
  }'
```

--------------------------------

### Cortex Messages API tool calling with JavaScript/TypeScript

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-rest-api

TypeScript example using the Anthropic SDK to call the Cortex Messages API with tool calling. Requires the @anthropic-ai/sdk package and a Snowflake PAT. The flow sends a request with tools, handles a tool_use response, executes the tool, and sends the result back.

```typescript
import Anthropic from "@anthropic-ai/sdk";

const PAT = "<SNOWFLAKE_PAT>";

const client = new Anthropic({
  apiKey: "not-used",
  baseURL: "https://<account-identifier>.snowflakecomputing.com/api/v2/cortex",
  defaultHeaders: {
    "Authorization": `Bearer ${PAT}`,
  },
});

const tools = [
  {
    name: "get_weather",
    description: "Get the current weather for a location",
    input_schema: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "The city and state, e.g. San Francisco, CA"
        }
      },
      required: ["location"]
    }
  }
];

const messages = [
  { role: "user", content: "What is the weather like in San Francisco?" }
];

// Step 1: Send the request with tools
const response = await client.messages.create({
  model: "claude-sonnet-4-5",
  max_tokens: 1024,
  messages,
  tools,
});

// Step 2: The model responds with a tool_use block
if (response.stop_reason === "tool_use") {
  const toolUse = response.content.find(b => b.type === "tool_use");

  // Step 3: Execute the tool (your implementation)
  const result = JSON.stringify({ temperature: "69°F", condition: "sunny" });

  // Step 4: Send the tool result back
  messages.push({ role: "assistant", content: response.content });
  messages.push({
    role: "user",
    content: [
      {
        type: "tool_result",
        tool_use_id: toolUse.id,
        content: result,
      }
    ],
  });

  const finalResponse = await client.messages.create({
    model: "claude-sonnet-4-5",
    max_tokens: 1024,
    messages,
    tools,
  });

  console.log(finalResponse.content[0].text);
}
```

--------------------------------

### Create warehouse, database, and schemas

Source: https://docs.snowflake.com/en/user-guide/tutorials/dbt-projects-on-snowflake-ci-cd-tutorial

Run these SQL commands to create the warehouse, database, and schemas used by the tutorial. If you already completed the getting-started tutorial, these objects already exist and you can skip this step.

```sql
CREATE WAREHOUSE IF NOT EXISTS TASTY_BYTES_DBT_WH;
CREATE DATABASE IF NOT EXISTS tasty_bytes_dbt_db;
CREATE SCHEMA IF NOT EXISTS tasty_bytes_dbt_db.dev;
CREATE SCHEMA IF NOT EXISTS tasty_bytes_dbt_db.prod;

```

--------------------------------

### Customize feedback with Cortex provider and custom rubric

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/ai-observability/evaluate-applications-trulens

Defines a custom Metric using a Cortex provider feedback function with a custom rubric, guiding examples, and a custom score scale (0-3). The criteria and additional_instructions guide the judge, and examples provide scoring guidance.

```python
from trulens.core import Metric, Selector

f_relevance = Metric(
    implementation=provider.relevance_with_cot_reasons,
    name="Answer Relevance",
    selectors={
        "prompt": Selector.select_record_input(),
        "response": Selector.select_record_output(),
    },
    criteria="Score 3 only if the answer cites the policy section it used.",
    additional_instructions="A section number with no quote is partial credit.",
    examples=[
        ({"prompt": "Is water damage covered?",
          "response": "Yes, section 4.2 covers burst pipes."}, 3),
        ({"prompt": "Is water damage covered?",
          "response": "Yes, probably."}, 0),
    ],
    min_score_val=0,
    max_score_val=3,
)

run.compute_metrics(metrics=[
    f_relevance,
    "coherence",
    "groundedness",
])
```

--------------------------------

### Install CUSTOMERS_2 sample table

Source: https://docs.snowflake.com/en/user-guide/cleanrooms/installed-artifacts

Installs the CUSTOMERS_2 sample table. Requires the ACCOUNTADMIN role. Run this command if the SHOW TABLES LIKE 'CUSTOMERS_2' query returns no rows.

```sql
USE ROLE ACCOUNTADMIN;
EXECUTE IMMEDIATE FROM @SAMOOHA_BY_SNOWFLAKE.APP_SCHEMA.MOUNT_CODE_STAGE/dcr_loader.sql;

```

--------------------------------

### SHOW PARAMETERS example with output

Source: https://docs.snowflake.com/en/user-guide/admin-account-management

This example shows the command to view all account-level parameters and the resulting table with columns for key, value, default, level, and description.

```sql
SHOW PARAMETERS IN ACCOUNT;

+-------------------------------------+----------------------------------+----------------------------------+---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| key                                 | value                            | default                          | level   | description                                                                                                                                                                         |
|-------------------------------------+----------------------------------+----------------------------------+---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| ABORT_DETACHED_QUERY                | false                            | false                            |         | If true, Snowflake will automatically abort queries when it detects that the client has disappeared.                                                                                |
| AUTOCOMMIT                          | true                             | true                             |         | The autocommit property determines whether a statement should be implicitly                                                                                                     |
|                                     |                                  |                                  |         | wrapped within a transaction or not. If autocommit is set to true, then a                                                                                                           |
|                                     |                                  |                                  |         | statement that requires a transaction is executed within a transaction                                                                                                              |
|                                     |                                  |                                  |         | implicitly. If autocommit is off then an explicit commit or rollback is required                                                                                                    |
|                                     |                                  |                                  |         | to close a transaction. The default autocommit value is true.                                                                                                                       |
| AUTOCOMMIT_API_SUPPORTED            | true                             | true                             |         | Whether autocommit feature is enabled for this client. This parameter is for                                                                                                        |
|                                     |                                  |                                  |         | Snowflake use only.                                                                                                                                                                 |
| BINARY_INPUT_FORMAT                 | HEX                              | HEX                              |         | input format for binary                                                                                                                                                             |
| BINARY_OUTPUT_FORMAT                | HEX                              | HEX                              |         | display format for binary                                                                                                                                                           |

```

--------------------------------

### Download SnowSQL 1.5.2 installer from AWS endpoint

Source: https://docs.snowflake.com/en/user-guide/snowsql-install-config

Example download of the SnowSQL installer from the AWS endpoint for bootstrap version 1.5 and version 1.5.2.

```bash
curl -O https://sfc-repo.snowflakecomputing.com/snowsql/bootstrap/1.5/darwin_x86_64/snowsql-1.5.2-darwin_x86_64.pkg

```

--------------------------------

### metadata event example

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-agents-run

Example of a metadata event sent when a message is added to the thread. Useful for getting the parent_message_id for following requests to the Agents API.

```json
{
  "metadata": {
    "role": "user",
    "message_id": 83472,
    "run_id": "4264-83472"
  }
}
```

--------------------------------

### Create database and warehouse for Cortex Search tutorial

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-search/tutorials/cortex-search-tutorial-3-chat-advanced

Creates the tutorial database and an initially suspended X-SMALL warehouse, then sets the warehouse as active. Use this setup before creating tables or Cortex Search services.

```sql
CREATE DATABASE IF NOT EXISTS cortex_search_tutorial_db;

CREATE OR REPLACE WAREHOUSE cortex_search_tutorial_wh WITH
     WAREHOUSE_SIZE='X-SMALL'
     AUTO_SUSPEND = 120
     AUTO_RESUME = TRUE
     INITIALLY_SUSPENDED=TRUE;

 USE WAREHOUSE cortex_search_tutorial_wh;

```

--------------------------------

### Download SnowSQL 1.5.2 installer from Azure endpoint

Source: https://docs.snowflake.com/en/user-guide/snowsql-install-config

Example download of the SnowSQL installer from the Microsoft Azure endpoint for bootstrap version 1.5 and version 1.5.2.

```bash
curl -O https://sfc-repo.azure.snowflakecomputing.com/snowsql/bootstrap/1.5/darwin_x86_64/snowsql-1.5.2-darwin_x86_64.pkg

```

--------------------------------

### Start upgrade immediately with ./create.sh

Source: https://docs.snowflake.com/en/user-guide/data-integration/openflow/manage

Run this command to start the upgrade immediately instead of waiting for the automatic upgrade (which occurs within approximately 10 minutes).

```bash
./create.sh
```

--------------------------------

### Set up database, warehouse, and schema for Cortex Search

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-search/cortex-search-overview

Sets up the database, warehouse, and schema for the Cortex Search example. Run these commands first to create the required environment.

```sql
CREATE DATABASE IF NOT EXISTS cortex_search_db;

CREATE OR REPLACE WAREHOUSE cortex_search_wh WITH
   WAREHOUSE_SIZE='X-SMALL';

CREATE OR REPLACE SCHEMA cortex_search_db.services;

```

```sql
CREATE OR REPLACE TABLE support_transcripts (
    transcript_text VARCHAR,
    region VARCHAR,
    agent_id VARCHAR
);

INSERT INTO support_transcripts VALUES
    ('My internet has been down since yesterday, can you help?', 'North America', 'AG1001'),
    ('I was overcharged for my last bill, need an explanation.', 'Europe', 'AG1002'),
    ('How do I reset my password? The email link is not working.', 'Asia', 'AG1003'),
    ('I received a faulty router, can I get it replaced?', 'North America', 'AG1004');

```

--------------------------------

### Complete example with ^

Source: https://docs.snowflake.com/en/user-guide/match-recognize-introduction

Complete example using ^ to match the first row of a partition. Only the row at the start of the partition is considered a match, even if other rows also satisfy the condition.

```sql
SELECT *
    FROM stock_price_history
       MATCH_RECOGNIZE (
           PARTITION BY company
           ORDER BY price_date
           MEASURES
               MATCH_NUMBER() AS "Match #",
               MATCH_SEQUENCE_NUMBER() AS "Match Sequence #"
           ALL ROWS PER MATCH
           PATTERN (^ GT60)
           DEFINE
               GT60 AS price > 60.00
           )
    ORDER BY "Match #", "Match Sequence #";
+---------+------------+-------+---------+------------------+
| COMPANY | PRICE_DATE | PRICE | Match # | Match Sequence # |
|---------+------------+-------+---------+------------------|
| XYZ     | 2020-10-01 |    89 |       1 |                1 |
+---------+------------+-------+---------+------------------+

```

--------------------------------

### Create and use a warehouse for the tutorial

Source: https://docs.snowflake.com/en/user-guide/tutorials/tables-iceberg-set-up-bidirectional-access-to-unity-catalog

Creates a standard XSMALL warehouse named catalog_linked_database_tutorial_wh and then sets it as the active warehouse for the session. Run these statements before creating the catalog integration.

```sql
CREATE WAREHOUSE catalog_linked_database_tutorial_wh
  WAREHOUSE_TYPE = STANDARD
  WAREHOUSE_SIZE = XSMALL;

USE WAREHOUSE catalog_linked_database_tutorial_wh;

```

--------------------------------

### Retrieve, describe, invoke, and manage runs

Source: https://docs.snowflake.com/en/user-guide/snowflake-cortex/ai-observability/evaluate-applications-trulens

Shows how to get a run by name, describe it, and start it. For TABLE source, start() takes no arguments; for DATAFRAME source, pass the input dataframe. start() blocks until invocation and ingestion complete or time out.

```python
run = tru_app.get_run(run_name=run_name)
run.describe()
run.start()  # TABLE source
run.start(input_df=user_input_df)  # DATAFRAME source
```

--------------------------------

### Query rows by start date with DATEADD

Source: https://docs.snowflake.com/en/user-guide/tutorials/snowflake-in-20minutes

Calculate potential benefit start dates by adding 90 days to employee start dates using the DATEADD function. The query filters for employees whose start date is on or before January 1, 2017, and the example result shows four rows.

```bash
snow sql -q "SELECT first_name, last_name, DATEADD('day',90,start_date) FROM emp_basic WHERE start_date <= '2017-01-01';" --database sf_tuts --warehouse sf_tuts_wh

```

```text
+------------+-----------+------------------------------+
| FIRST_NAME | LAST_NAME | DATEADD('DAY',90,START_DATE) |
|------------+-----------+------------------------------|
| Granger    | Bassford  | 2017-03-30                   |
| Catherin   | Devereu   | 2017-03-17                   |
| Cesar      | Hovie     | 2017-03-21                   |
| Wallis     | Sizey     | 2017-03-30                   |
+------------+-----------+------------------------------+

```

--------------------------------

### Create warehouse and database for Iceberg tutorial

Source: https://docs.snowflake.com/en/user-guide/tutorials/create-your-first-iceberg-table

Creates a standard XSMALL warehouse and a database for the tutorial, then sets them as active.

```sql
CREATE WAREHOUSE iceberg_tutorial_wh
  WAREHOUSE_TYPE = STANDARD
  WAREHOUSE_SIZE = XSMALL;

USE WAREHOUSE iceberg_tutorial_wh;

CREATE OR REPLACE DATABASE iceberg_tutorial_db;
USE DATABASE iceberg_tutorial_db;

```

--------------------------------

### Download SnowSQL 1.5.2 installer from Azure endpoint

Source: https://docs.snowflake.com/en/user-guide/snowsql-install-config

Example curl command to download the SnowSQL installer for version 1.5.2 from the Azure endpoint, using bootstrap version 1.5.

```bash
$ curl -O https://sfc-repo.azure.snowflakecomputing.com/snowsql/bootstrap/1.5/linux_x86_64/snowsql-1.5.2-linux_x86_64.bash

```
Tokens:
Raw