Cortex REST API¶

A Cortex REST API oferece acesso a modelos de ponta da Anthropic, OpenAI, Meta, Mistral e outras empresas por meio do SDK ou ponto de extremidade preferido. Toda a inferência é executada dentro do perímetro do Snowflake, para que seus dados permaneçam seguros e dentro do seu limite de governança. Consulte abaixo como começar.

Escolher sua API¶

A Cortex REST API é compatível com duas especificações de API padrão do setor. Escolha a opção que melhor se adapta à sua pilha:


	Chat Completions API	API de mensagens
Compatibilidade	OpenAI Chat Completions API	Anthropic Messages API
Ponto de extremidade	`/api/v2/cortex/v1/chat/completions`	`/api/v2/cortex/v1/messages`
Modelos compatíveis	Todos os modelos (OpenAI, Claude, Llama, Mistral, DeepSeek, Snowflake)	Somente modelos Claude
Suporte para SDK	SDKs Python e JavaScript da OpenAI	SDK Python da Anthropic
Melhor para	Maioria dos casos de uso; flexibilidade multimodelo	Integrações existentes com o Anthropic; paridade com a Anthropic API

Ambas as APIs compartilham a mesma autenticação, catálogo de modelos e limites de taxa. A única diferença é o formato de solicitação/resposta e com quais modelos cada ponto de extremidade é compatível. Para obter preços, consulte a tabela de consumo de serviços do Snowflake.

Guia de início rápido¶

Pré-requisitos¶

Antes de começar, você precisa de:

URL da sua conta Snowflake (por exemplo, https://<account-identifier>.snowflakecomputing.com).
Um token de acesso programático (programmatic access token, PAT) do Snowflake para autenticação. Consulte Geração de um token de acesso programático.
Um nome de modelo para usar nas solicitações. Consulte Disponibilidade do modelo para obter os modelos disponíveis.

Guia rápido da Chat Completions¶

A Chat Completions API segue a especificação da OpenAI. Você pode usar diretamente o SDK da OpenAI.

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="claude-sonnet-4-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)

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: "claude-sonnet-4-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);

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",
    "messages": [
      {"role": "user", "content": "How does a snowflake get its unique pattern?"}
    ]
  }'

Nos exemplos anteriores, substitua o seguinte:

<account-identifier>: seu identificador de conta Snowflake.
<SNOWFLAKE_PAT>: um token de acesso programático (programmatic access token, PAT) do Snowflake.
model: o nome do modelo. Consulte Disponibilidade do modelo para obter os modelos compatíveis.

Guia rápido da Messages API¶

A Messages API segue a especificação da Anthropic e é compatível apenas com modelos Claude.

O SDK da Anthropic envia credenciais via x-api-key por padrão, mas o Snowflake espera um token Bearer. Use um cliente httpx para definir o cabeçalho de autorização correto.

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)

Assim como no Python, substitua o cabeçalho de autenticação padrão por um token Bearer via defaultHeaders.

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);

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?"}
    ]
  }'

Nos exemplos anteriores, substitua o seguinte:

<account-identifier>: seu identificador de conta Snowflake.
<SNOWFLAKE_PAT>: um token de acesso programático (programmatic access token, PAT) do Snowflake.
model: o nome do modelo Claude. Consulte Disponibilidade do modelo para obter os modelos compatíveis.

Configuração da autenticação¶

Para se autenticar na Cortex REST API, você pode usar os métodos descritos em Autenticando o Snowflake REST APIs com Snowflake.

Defina o cabeçalho Authorization para incluir seu token (por exemplo, um token da web JSON [JWT], um token OAuth ou um token de acesso programático).

Dica

Considere criar um usuário dedicado para solicitações da Cortex REST API.

Configuração da autorização¶

Para enviar uma solicitação REST API, sua função padrão deve ter a função de banco de dados SNOWFLAKE.CORTEX_USER concedida. Na maioria dos casos, os usuários já têm esse privilégio porque SNOWFLAKE.CORTEX_USER é concedido automaticamente à função PUBLIC, e todas as funções herdam PUBLIC.

Se o administrador do Snowflake revogou essa concessão, ele deve concedê-la novamente:

GRANT DATABASE ROLE SNOWFLAKE.CORTEX_USER TO ROLE my_role;
GRANT ROLE my_role TO USER my_user;

Importante

As solicitações REST API usam a função padrão do usuário, portanto, essa função deve ter os privilégios necessários. Você pode alterar a função padrão de um usuário com :doc:`ALTER … USER SETDEFAULT_ROLE.

ALTER USER my_user SET DEFAULT_ROLE=my_role

Disponibilidade do modelo¶

As tabelas a seguir mostram os modelos disponíveis na Cortex REST API para cada região:


Modelo	Entre nuvens (Qualquer região)	AWS Global (Entre regiões)	AWS US (Entre regiões)	AWS EU (Entre regiões)	AWS APJ (Entre regiões)	Azure Global (Entre regiões)	Azure US (Entre regiões)
`claude-sonnet-4-6`	✔	✔	✔	✔
`claude-opus-4-6`	✔	✔
`claude-sonnet-4-5`	✔	✔	✔	✔
`claude-opus-4-5`	✔	✔
`claude-haiku-4-5`	✔	✔	✔
`claude-4-sonnet`	✔	✔	✔	✔
`claude-4-opus`	✔	✔
`claude-3-7-sonnet`	✔	✔
`claude-3-5-sonnet`	✔	✔
`openai-gpt-4.1`	✔				✔
`openai-gpt-5`	*				*	*	*
`openai-gpt-5-mini`	*					*
`openai-gpt-5-nano`	*					*
`openai-gpt-5-chat`	✔
`openai-gpt-oss-120b`	*
`llama4-maverick`	✔	✔
`llama3.1-8b`	✔	✔
`llama3.1-70b`	✔	✔
`llama3.1-405b`	✔	✔
`deepseek-r1`	✔	✔
`mistral-7b`	✔	✔
`mistral-large`	✔	✔
`mistral-large2`	✔	✔
`snowflake-llama-3.3-70b`	✔	✔


Modelo	AWS US West 2 (Oregon)	AWS US East 1 (N. Virginia)	Azure East US 2 (Virginia)
`claude-3-5-sonnet`	✔	✔
`llama4-maverick`	✔
`llama3.1-8b`	✔	✔	✔
`llama3.1-70b`	✔	✔	✔
`llama3.1-405b`	✔	✔	✔
`deepseek-r1`	✔
`mistral-7b`	✔	✔	✔
`mistral-large`	✔	✔	✔
`mistral-large2`	✔	✔	✔
`snowflake-llama-3.3-70b`	✔


Modelo	AWS Europe Central 1 (Frankfurt)	AWS Europe West 1 (Ireland)	Azure West Europe (Países Baixos)
`llama3.1-8b`	✔		✔
`llama3.1-70b`	✔	✔	✔
`mistral-7b`	✔		✔
`mistral-large`	✔		✔
`mistral-large2`	✔	✔	✔


Modelo	AWS AP Southeast 2 (Sidney)	AWS AP Northeast 1 (Tokyo)
`llama3.1-8b`	✔	✔
`llama3.1-70b`	✔	✔
`mistral-7b`		✔
`mistral-large`		✔
`mistral-large2`	✔	✔

* Indica uma função ou um modelo da versão preliminar. Os recursos em versão preliminar não são adequados para cargas de trabalho de produção.

Você também pode usar qualquer modelo com ajuste fino em qualquer região compatível.

Recursos¶

Streaming¶

Ambas as APIs são compatíveis com streaming de respostas usando eventos enviados pelo servidor.

Streaming da Chat Completions¶

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="claude-sonnet-4-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)

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: "claude-sonnet-4-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 || "");
}

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",
    "messages": [
      {"role": "user", "content": "How does a snowflake get its unique pattern?"}
    ],
    "stream": true,
    "stream_options": {
      "include_usage": true
    }
  }'

Streaming de API de mensagens¶

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}"},
)

with client.messages.stream(
  model="claude-sonnet-4-5",
  max_tokens=1024,
  messages=[
    {"role": "user", "content": "How does a snowflake get its unique pattern?"}
  ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

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 stream = client.messages.stream({
  model: "claude-sonnet-4-5",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "How does a snowflake get its unique pattern?" }
  ],
});

for await (const event of stream) {
  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
    process.stdout.write(event.delta.text);
  }
}

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,
    "stream": true,
    "messages": [
      {"role": "user", "content": "How does a snowflake get its unique pattern?"}
    ]
  }'

Chamada de ferramentas¶

A chamada de ferramentas permite que o modelo invoque funções externas durante uma conversa. O fluxo funciona em etapas:

Você envia uma solicitação com uma lista de ferramentas disponíveis.
O modelo decide chamar uma ou mais ferramentas e retorna o nome da ferramenta e os argumentos.
Você executa a ferramenta.
Você envia o resultado da ferramenta de volta e o modelo gera uma resposta final.

A chamada de ferramenta é compatível com modelos do OpenAI e do Claude.

Chamada da ferramenta Chat Completions¶

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="claude-sonnet-4-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="claude-sonnet-4-5",
      messages=messages,
      tools=tools,
    )

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

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: "claude-sonnet-4-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: "claude-sonnet-4-5",
    messages,
    tools,
  });

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

Etapa 1 – Enviar a solicitação com ferramentas:

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",
    "messages": [
      {"role": "user", "content": "What is the weather like in San Francisco?"}
    ],
    "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"]
          }
        }
      }
    ]
  }'

O modelo responde com uma matriz``tool_calls``:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"location\": \"San Francisco, CA\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ]
}

Etapa 2 – Executar a ferramenta e enviar o resultado de volta:

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",
    "messages": [
      {"role": "user", "content": "What is the weather like in San Francisco?"},
      {
        "role": "assistant",
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"location\": \"San Francisco, CA\"}"
            }
          }
        ]
      },
      {
        "role": "tool",
        "tool_call_id": "call_abc123",
        "content": "{\"temperature\": \"69°F\", \"condition\": \"sunny\"}"
      }
    ],
    "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"]
          }
        }
      }
    ]
  }'

Chamada da ferramenta Messages API¶

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)

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);
}

Etapa 1 – Enviar a solicitação com ferramentas:

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": "What is the weather like in San Francisco?"}
    ],
    "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"]
        }
      }
    ]
  }'

O modelo responde com um bloco de conteúdo tool_use:

{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll check the weather for you."
    },
    {
      "type": "tool_use",
      "id": "toolu_abc123",
      "name": "get_weather",
      "input": {"location": "San Francisco, CA"}
    }
  ],
  "stop_reason": "tool_use"
}

Etapa 2 – Executar a ferramenta e enviar o resultado de volta:

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": "What is the weather like in San Francisco?"},
      {
        "role": "assistant",
        "content": [
          {"type": "text", "text": "I'\''ll check the weather for you."},
          {
            "type": "tool_use",
            "id": "toolu_abc123",
            "name": "get_weather",
            "input": {"location": "San Francisco, CA"}
          }
        ]
      },
      {
        "role": "user",
        "content": [
          {
            "type": "tool_result",
            "tool_use_id": "toolu_abc123",
            "content": "{\"temperature\": \"69°F\", \"condition\": \"sunny\"}"
          }
        ]
      }
    ],
    "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"]
        }
      }
    ]
  }'

Saída estruturada¶

Você pode solicitar uma saída JSON estruturada que esteja em conformidade com um esquema específico. Isso é compatível com os modelos OpenAI e Claude por meio da Chat Completions API. Para o Messages API, use o padrão tool_use para impor a saída estruturada.

Saída estruturada da Chat Completions¶

Use o campo response_format com um esquema JSON para restringir a saída do modelo.

import json
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="claude-sonnet-4-5",
  messages=[
    {"role": "user", "content": "Create a dataset of 3 people with their names and ages."}
  ],
  response_format={
    "type": "json_schema",
    "json_schema": {
      "name": "people_data",
      "schema": {
        "type": "object",
        "properties": {
          "people": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": {"type": "string"},
                "age": {"type": "number"}
              },
              "required": ["name", "age"]
            }
          }
        },
        "required": ["people"]
      }
    }
  }
)

data = json.loads(response.choices[0].message.content)
print(data)

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: "claude-sonnet-4-5",
  messages: [
    { role: "user", content: "Create a dataset of 3 people with their names and ages." }
  ],
  response_format: {
    type: "json_schema",
    json_schema: {
      name: "people_data",
      schema: {
        type: "object",
        properties: {
          people: {
            type: "array",
            items: {
              type: "object",
              properties: {
                name: { type: "string" },
                age: { type: "number" }
              },
              required: ["name", "age"]
            }
          }
        },
        required: ["people"]
      }
    }
  }
});

const data = JSON.parse(response.choices[0].message.content);
console.log(data);

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",
    "messages": [
      {"role": "user", "content": "Create a dataset of 3 people with their names and ages."}
    ],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "people_data",
        "schema": {
          "type": "object",
          "properties": {
            "people": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "name": {"type": "string"},
                  "age": {"type": "number"}
                },
                "required": ["name", "age"]
              }
            }
          },
          "required": ["people"]
        }
      }
    }
  }'

Nota

Os modelos Claude são compatíveis apenas com json_schema como tipo de formato de resposta. Os modelos OpenAI são compatíveis com tipos de formato de resposta adicionais, conforme documentado na referência da OpenAI API.

Saída estruturada da Messages API¶

A Messages API não têm um campo response_format. Em vez disso, defina uma ferramenta com o esquema de saída desejado e instrua o modelo a usá-la. A resposta tool_use do modelo conterá JSON estruturado correspondente ao seu esquema.

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}"},
)

response = client.messages.create(
  model="claude-sonnet-4-5",
  max_tokens=1024,
  messages=[
    {"role": "user", "content": "Create a dataset of 3 people with their names and ages."}
  ],
  tools=[
    {
      "name": "people_data",
      "description": "Output a list of people with names and ages.",
      "input_schema": {
        "type": "object",
        "properties": {
          "people": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "name": {"type": "string"},
                "age": {"type": "number"}
              },
              "required": ["name", "age"]
            }
          }
        },
        "required": ["people"]
      }
    }
  ],
  tool_choice={"type": "tool", "name": "people_data"},
)

# Extract the structured data from the tool_use block
tool_use = next(b for b in response.content if b.type == "tool_use")
print(tool_use.input)

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: "Create a dataset of 3 people with their names and ages." }
  ],
  tools: [
    {
      name: "people_data",
      description: "Output a list of people with names and ages.",
      input_schema: {
        type: "object",
        properties: {
          people: {
            type: "array",
            items: {
              type: "object",
              properties: {
                name: { type: "string" },
                age: { type: "number" }
              },
              required: ["name", "age"]
            }
          }
        },
        required: ["people"]
      }
    }
  ],
  tool_choice: { type: "tool", name: "people_data" },
});

// Extract the structured data from the tool_use block
const toolUse = response.content.find(b => b.type === "tool_use");
console.log(toolUse.input);

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": "Create a dataset of 3 people with their names and ages."}
    ],
    "tools": [
      {
        "name": "people_data",
        "description": "Output a list of people with names and ages.",
        "input_schema": {
          "type": "object",
          "properties": {
            "people": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "name": {"type": "string"},
                  "age": {"type": "number"}
                },
                "required": ["name", "age"]
              }
            }
          },
          "required": ["people"]
        }
      }
    ],
    "tool_choice": {"type": "tool", "name": "people_data"}
  }'

Entrada de imagem¶

Você pode incluir imagens em suas solicitações para modelos que são compatíveis com visão. As imagens devem ser fornecidas como cadeias de caracteres codificadas em base64. As imagens são limitadas a 20 por conversação com um de tamanho máximo de solicitação de 20 MiB.

A entrada de imagem é compatível com:

Modelos Claude (claude-3-7-sonnet e mais recentes)
Modelos OpenAI (openai-gpt-4.1, openai-gpt-5, openai-gpt-5-chat, openai-gpt-5-mini, openai-gpt-5-nano)

Entrada de imagens da Chat Completions¶

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="claude-sonnet-4-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)

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: "claude-sonnet-4-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);

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",
    "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?"
          }
        ]
      }
    ]
  }'

Entrada de imagens da Messages API¶

O Messages API utiliza um formato de imagem diferente: um bloco source com campos type, media_type e data em vez do URL de dados.

import base64
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}"},
)

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

response = client.messages.create(
  model="claude-sonnet-4-5",
  max_tokens=1024,
  messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "base64",
            "media_type": "image/png",
            "data": image_data
          }
        },
        {
          "type": "text",
          "text": "What is in this image?"
        }
      ]
    }
  ],
)

print(response.content[0].text)

import Anthropic from "@anthropic-ai/sdk";
import fs from "fs";

const PAT = "<SNOWFLAKE_PAT>";

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

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

const response = await client.messages.create({
  model: "claude-sonnet-4-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "image",
          source: {
            type: "base64",
            media_type: "image/png",
            data: imageData
          }
        },
        {
          type: "text",
          text: "What is in this image?"
        }
      ]
    }
  ],
});

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

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": [
          {
            "type": "image",
            "source": {
              "type": "base64",
              "media_type": "image/png",
              "data": "<BASE64_IMAGE_DATA>"
            }
          },
          {
            "type": "text",
            "text": "What is in this image?"
          }
        ]
      }
    ]
  }'

Cache de prompts¶

O cache de prompts permite reutilizar o contexto processado anteriormente (como prompts extensos do sistema, documentos ou histórico de conversas) entre solicitações, reduzindo a latência e o custo.

Modelos OpenAI: o cache é implícito. Prompts com mais de 1.024 tokens são armazenados em cache automaticamente; nenhuma alteração na solicitação é necessária.
Modelos Claude: o cache é explícito. Adicione pontos de interrupção cache_control aos blocos de conteúdo que você deseja armazenar em cache. Somente o tipo de cache ephemeral é compatível, com um TTL de 5 minutos. No máximo 4 pontos de interrupção de cache por solicitação.

Cache de prompts da Chat Completions¶

Para modelos Claude via Chat Completions, adicione cache_control aos blocos de conteúdo. Os modelos OpenAI são armazenados em cache automaticamente e não exigem este campo.

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="claude-sonnet-4-5",
  messages=[
    {
      "role": "system",
      "content": [
        {
          "type": "text",
          "text": "<long system prompt to cache>",
          "cache_control": {"type": "ephemeral"}
        }
      ]
    },
    {"role": "user", "content": "Summarize the key points."}
  ]
)

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

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: "claude-sonnet-4-5",
  messages: [
    {
      role: "system",
      content: [
        {
          type: "text",
          text: "<long system prompt to cache>",
          cache_control: { type: "ephemeral" }
        }
      ]
    },
    { role: "user", content: "Summarize the key points." }
  ],
});

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

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",
    "messages": [
      {
        "role": "system",
        "content": [
          {
            "type": "text",
            "text": "<long system prompt to cache>",
            "cache_control": {"type": "ephemeral"}
          }
        ]
      },
      {"role": "user", "content": "Summarize the key points."}
    ]
  }'

Cache de prompts da Messages API¶

Use cache_control em blocos de conteúdo do sistema ou do usuário. Somente o tipo de cache ephemeral é compatível, com um TTL de 5 minutos. No máximo 4 pontos de interrupção de cache podem ser definidos por solicitação.

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,
  system=[
    {
      "type": "text",
      "text": "<long system prompt to cache>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  messages=[
    {"role": "user", "content": "Summarize the key points."}
  ],
)

print(response.content[0].text)

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,
  system: [
    {
      type: "text",
      text: "<long system prompt to cache>",
      cache_control: { type: "ephemeral" }
    }
  ],
  messages: [
    { role: "user", content: "Summarize the key points." }
  ],
});

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

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,
    "system": [
      {
        "type": "text",
        "text": "<long system prompt to cache>",
        "cache_control": {"type": "ephemeral"}
      }
    ],
    "messages": [
      {"role": "user", "content": "Summarize the key points."}
    ]
  }'

Nota

O cache de prompts da Anthropic tem um TTL de 5 minutos. O conteúdo em cache não acessado em 5 minutos é removido. O cache de prompts da OpenAI é implícito e gerenciado automaticamente; nenhum campo cache_control é necessário.

Raciocínio¶

Raciocínio da Chat Completions¶

Para modelos Claude, use o objeto reasoning. Para modelos de raciocínio OpenAI, use o campo reasoning_effort (valores: minimal, low, medium, high).

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",
  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)

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",
  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);

# 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",
    "messages": [
      {"role": "user", "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"}
    ],
    "reasoning": {
      "effort": "high"
    }
  }'

# 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"
  }'

Raciocínio da Messages API¶

Alguns modelos Claude são compatíveis com pensamento adaptativo, em que o modelo ajusta a quantidade de raciocínio que aplica com base na complexidade da tarefa. Os modelos a seguir são compatíveis com o pensamento adaptativo:

claude-opus-4-6

Para a Messages API, use o parâmetro thinking com type: "adaptive" para habilitar o raciocínio adaptativo. O parâmetro output_config.effort fornece um controle de alto nível sobre a profundidade do raciocínio e aceita os seguintes valores:


Nível de esforço	Comportamento
`max`	Sempre raciocina, sem restrições de profundidade. Apenas Claude Opus 4.6.
`high` (padrão)	Sempre raciocina. Fornece raciocínio profundo em tarefas complexas.
`medium`	Raciocínio moderado. Pode ignorar o raciocínio para consultas muito simples.
`low`	Minimiza o raciocínio. Ignora o raciocínio para tarefas simples em que a velocidade é mais importante.

Os exemplos a seguir demonstram como fazer uma chamada da Messages API com o raciocínio adaptativo habilitado:

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-opus-4-6",
  max_tokens=16384,
  thinking={
    "type": "adaptive"
  },
  messages=[
    {"role": "user", "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"}
  ],
)

# The response includes thinking blocks followed by text
for block in response.content:
    if block.type == "thinking":
        print(f"Thinking: {block.thinking[:100]}...")
    elif block.type == "text":
        print(f"Answer: {block.text}")

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-opus-4-6",
  max_tokens: 16384,
  thinking: {
    type: "adaptive"
  },
  messages: [
    { role: "user", content: "Are there an infinite number of prime numbers such that n mod 4 == 3?" }
  ],
});

// The response includes thinking blocks followed by text
for (const block of response.content) {
  if (block.type === "thinking") {
    console.log(`Thinking: ${block.thinking.slice(0, 100)}...`);
  } else if (block.type === "text") {
    console.log(`Answer: ${block.text}`);
  }
}

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-opus-4-6",
    "max_tokens": 16384,
    "thinking": {
      "type": "adaptive"
    },
    "messages": [
      {"role": "user", "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"}
    ]
  }'

A resposta inclui blocos de raciocínio com resumos e assinaturas de raciocínio. Passe esses blocos de volta em conversas com várias interações para manter o contexto do raciocínio:

{
  "role": "assistant",
  "content": [
    {"type": "thinking", "thinking": "<thinking>", "signature": "<signature>"},
    {"type": "text", "text": "Yes, there are infinitely many primes p where p ≡ 3 (mod 4)..."}
  ]
}

Para uma descrição completa do suporte da Messages API para raciocínio adaptativo, consulte Documentos da Claude API – raciocínio adaptativo.

Recursos beta (Messages API)¶

A Messages API é compatível com recursos beta da Anthropic pelo cabeçalho anthropic-beta. Passe um ou mais valores de cabeçalho beta como uma cadeia de caracteres separada por vírgulas.

Cabeçalhos beta compatíveis¶
Valor do cabeçalho beta	Recurso
`token-efficient-tools-2025-02-19`	Ferramentas com uso eficiente de tokens
`interleaved-thinking-2025-05-14`	Raciocínio intercalado
`output-128k-2025-02-19`	Permite até 128 mil tokens de saída
`dev-full-thinking-2025-05-14`	Modo desenvolvedor para raciocínio bruto em modelos Claude 4+
`context-1m-2025-08-07`	Janela de contexto com 1 milhão de tokens
`context-management-2025-06-27`	Gerenciamento de contexto
`effort-2025-11-24`	Parâmetro de esforço para raciocínio
`tool-search-tool-2025-10-19`	Ferramenta de pesquisa de ferramentas
`tool-examples-2025-10-29`	Exemplos de uso da ferramenta

O exemplo a seguir habilita a janela de contexto de 1 milhão de tokens com claude-sonnet-4-6:

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}",
    "anthropic-beta": "context-1m-2025-08-07",
  },
)

response = client.messages.create(
  model="claude-sonnet-4-6",
  max_tokens=8192,
  messages=[
    {"role": "user", "content": "<very long document text>... Summarize the key themes."}
  ],
)

print(response.content[0].text)

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}`,
    "anthropic-beta": "context-1m-2025-08-07",
  },
});

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 8192,
  messages: [
    { role: "user", content: "<very long document text>... Summarize the key themes." }
  ],
});

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

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: context-1m-2025-08-07" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 8192,
    "messages": [
      {"role": "user", "content": "<very long document text>... Summarize the key themes."}
    ]
  }'

É possível combinar vários recursos beta ao passar uma cadeia de caracteres separada por vírgulas:

-H "anthropic-beta: context-1m-2025-08-07,interleaved-thinking-2025-05-14"

Referência da Chat Completions API¶

POST /api/v2/cortex/v1/chat/completions¶

Gera uma complementação de bate-papo usando o modelo especificado. O formato da solicitação e da resposta segue a especificação da OpenAI Chat Completions API.

POST https://<account_identifier>.snowflakecomputing.com/api/v2/cortex/v1/chat/completions

Cabeçalhos obrigatórios¶

Authorization: Bearer token: Autorização para a solicitação. token é um token web JSON (JSON web token, JWT), token OAuth ou token de acesso programático. Para obter mais detalhes, consulte Autenticando o Snowflake REST APIs com Snowflake.
Content-Type: application/json: Especifica que o corpo da solicitação está no formato JSON.

Cabeçalhos opcionais¶

X-Snowflake-Authorization-Token-Type: type

Define o tipo de token de autorização.

Se você omitir o cabeçalho X-Snowflake-Authorization-Token-Type, o Snowflake determinará o tipo de token examinando o token.

Embora esse cabeçalho seja opcional, você pode optar por especificá-lo. Você pode definir o cabeçalho com um dos seguintes valores:

KEYPAIR_JWT (para autenticação de pares de chaves)
OAUTH (para OAuth)
PROGRAMMATIC_ACCESS_TOKEN (para tokens de acesso programático)

Accept: application/json, text/event-stream

Especifica que a resposta conterá JSON (caso de erro) ou eventos enviados pelo servidor.

Campos JSON obrigatórios¶


Campo	Tipo	Descrição
`model`	string	O modelo a ser utilizado (consulte Disponibilidade do modelo). Você também pode usar o nome totalmente qualificado de qualquer modelo ajustado no formato `database.schema.model`.
`messages`	matriz	Uma matriz de objetos de mensagem que representam a conversa. Cada mensagem deve ter um `role` (`system`, `user`, `assistant` ou `tool`) e `content` (cadeia de caracteres ou matriz de partes do conteúdo).

Campos JSON opcionais comumente utilizados¶


Campo	Tipo	Padrão	Descrição
`max_completion_tokens`	inteiro	4096	Número máximo de tokens na resposta. O máximo teórico é 131.072; cada modelo tem o próprio limite de saída.
`temperature`	number	Varia de acordo com o modelo	Controla a aleatoriedade. Valores de 0 a 2.
`top_p`	number	1.0	Controla a diversidade via amostragem de núcleo.
`stream`	booleano	falso	Indica se o progresso parcial deve ser transmitido como eventos enviados pelo servidor.
`tools`	matriz	null	Uma lista de ferramentas que o modelo pode chamar. Cada ferramenta deve ter `type: "function"` e um objeto `function` com `name`, `description` e `parameters`.
`tool_choice`	cadeia de caracteres ou objeto	`"auto"`	Controla como o modelo seleciona as ferramentas. Opções: `"auto"`, `"required"`, `"none"` ou um objeto especificando uma função específica.
`response_format`	objeto	null	Restringe o formato de saída. Use `{"type": "json_schema", "json_schema": {...}}` para a saída estruturada.
`reasoning_effort`	string	null	Para modelos de raciocínio da OpenAI. Valores: `"minimal"`, `"low"`, `"medium"`, `"high"`.
`reasoning`	objeto	null	Para modelos Claude. Defina `reasoning.effort` ou `reasoning.max_tokens` para habilitar o raciocínio.

Consulte a tabela de compatibilidade detalhada para obter a lista completa de campos compatíveis por família de modelos.

Códigos de status¶

200 OK: Solicitação concluída com sucesso.
400 invalid options object: Os argumentos opcionais têm valores inválidos.
400 unknown model model_name: O modelo especificado não existe.
400 schema validation failed: A estrutura do esquema de resposta está incorreta.
400 max tokens of count exceeded: A solicitação excedeu o número máximo de tokens compatíveis com o modelo.
400 all requests were throttled by remote service: A solicitação foi limitada. Tente novamente mais tarde.
402 budget exceeded: O orçamento de consumo do modelo foi excedido.
403 Not Authorized: Conta não habilitada para REST API, ou a função padrão para o usuário que efetuou a chamada não tem a função de banco de dados snowflake.cortex_user.
429 too many requests: A cota de uso foi excedida. Tente novamente mais tarde.
503 inference timed out: A solicitação demorou muito.

Limitações¶

Se não for definido, max_completion_tokens assume o padrão de 4096. Cada modelo tem seu próprio limite de tokens de saída.
A chamada de ferramentas é compatível apenas com os modelos OpenAI e Claude.
O uso de áudio não é compatível.
A compreensão da imagem é compatível somente com modelos do OpenAI e do Claude. As imagens são limitadas a 20 por conversação com um de tamanho máximo de solicitação de 20 MiB.
Somente os modelos do Claude oferecem suporte a pontos de controle de cache efêmeros para cache de prompt. Os modelos do OpenAI oferecem suporte ao cache implícito.
Somente os modelos Claude são compatíveis com o retorno de detalhes de raciocínio na resposta.
max_tokens está obsoleto. Use max_completion_tokens em vez disso.
As mensagens de erro são geradas pela Snowflake, não pelo provedor do modelo.

Tabela de compatibilidade detalhada¶

As tabelas a seguir resumem quais campos de solicitação e resposta são compatíveis ao usar a Chat Completions API com diferentes famílias de modelos hospedadas no Snowflake.

Campos da solicitação¶
Campo	Modelos do OpenAI	Modelos do Claude	Outros modelos
`model`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`messages`	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`messages[].audio`	❌ Erro	❌ Ignorado	❌ Ignorado
`messages[].role`	Suporte para ✔	✔ Somente usuário/assistente/sistema	✔ Somente usuário/assistente/sistema
`messages[].content` (string)	Suporte para ✔	Suporte para ✔	Suporte para ✔
`messages[].content[]` (matriz)	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`messages[].content[].text`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`messages[].content[].type`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`messages[].content[].image_url`	Suporte para ✔	Suporte para ✔	❌ Erro
`messages[].content[].cache_control`	❌ Ignorado	✔ Compatível (somente efêmero)	❌ Ignorado
`messages[].content[].file`	❌ Erro	❌ Erro	❌ Ignorado
`messages[].content[].input_audio`	❌ Erro	❌ Ignorado	❌ Ignorado
`messages[].content[].refusal`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`messages[].function_call`	✔ Compatível (obsoleto)	❌ Ignorado	❌ Ignorado
`messages[].name`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`messages[].refusal`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`messages[].tool_call_id`	Suporte para ✔	Suporte para ✔	❌ Ignorado
`messages[].tool_calls`	Suporte para ✔	✔ Somente ferramentas `function`	❌ Ignorado
`messages[].reasoning_details`	❌ Ignorado	✔ Formato OpenRouter `reasoning.text`	❌ Ignorado
`audio`	❌ Erro	❌ Ignorado	❌ Ignorado
`frequency_penalty`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`logit_bias`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`logprobs`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`max_tokens`	❌ Erro (obsoleto)	❌ Erro (obsoleto)	❌ Erro (obsoleto)
`max_completion_tokens`	✔ Compatível (4096 padrão, 131072 máximo)	✔ Compatível (4096 padrão, 131072 máximo)	✔ Compatível (4096 padrão, 131072 máximo)
`metadata`	❌ Ignorado	❌ Ignorado	❌ Ignorado
`modalities`	❌ Ignorado	❌ Ignorado	❌ Ignorado
`n`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`parallel_tool_calls`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`prediction`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`presence_penalty`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`prompt_cache_key`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`reasoning_effort`	Suporte para ✔	❌ Ignorado (usar o objeto `reasoning`)	❌ Ignorado
`reasoning`	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`reasoning.effort`	✔ Compatível (substitui `reasoning_effort`)	✔ Convertido em `reasoning.max_tokens`	❌ Ignorado
`reasoning.max_tokens`	❌ Ignorado	Suporte para ✔	❌ Ignorado
`response_format`	Suporte para ✔	✔ Somente `json_schema`	❌ Ignorado
`safety_identifier`	❌ Ignorado	❌ Ignorado	❌ Ignorado
`service_tier`	❌ Erro	❌ Erro	❌ Erro
`stop`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`store`	❌ Erro	❌ Erro	❌ Erro
`stream`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`stream_options`	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`stream_options.include_obfuscation`	❌ Ignorado	❌ Ignorado	❌ Ignorado
`stream_options.include_usage`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`temperature`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`tool_choice`	Suporte para ✔	✔ Somente ferramentas `function`	❌ Ignorado
`tools`	Suporte para ✔	✔ Somente ferramentas `function`	❌ Erro
`top_logprobs`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`top_p`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`verbosity`	Suporte para ✔	❌ Ignorado	❌ Ignorado
`web_search_options`	❌ Erro	❌ Ignorado	❌ Ignorado

Campos de resposta:¶
Campo	Modelos do OpenAI	Modelos do Claude	Outros modelos
`id`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`object`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`created`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`model`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`choices`	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`choices[].index`	Suporte para ✔	✔ Somente escolha única	✔ Somente escolha única
`choices[].finish_reason`	Suporte para ✔	❌ Sem suporte	✔ Somente `stop`
`choices[].logprobs`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`choices[].message` (sem streaming)	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`choices[].message.content`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`choices[].message.role`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`choices[].message.refusal`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`choices[].message.annotations`	❌ Sem suporte	❌ Sem suporte	❌ Sem suporte
`choices[].message.audio`	❌ Sem suporte	❌ Sem suporte	❌ Sem suporte
`choices[].message.function_call`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`choices[].message.tool_calls`	Suporte para ✔	✔ Somente ferramentas `function`	❌ Sem suporte
`choices[].message.reasoning`	❌ Sem suporte	✔ Formato OpenRouter	❌ Sem suporte
`choices[].delta` (streaming)	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`choices[].delta.content`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`choices[].delta.role`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`choices[].delta.refusal`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`choices[].delta.function_call`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`choices[].delta.tool_calls`	Suporte para ✔	✔ Somente ferramentas `function`	❌ Sem suporte
`choices[].delta.reasoning`	❌ Sem suporte	✔ Formato OpenRouter	❌ Sem suporte
`usage`	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`usage.prompt_tokens`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`usage.completion_tokens`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`usage.total_tokens`	Suporte para ✔	Suporte para ✔	Suporte para ✔
`usage.prompt_tokens_details`	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`usage.prompt_tokens_details.audio_tokens`	❌ Sem suporte	❌ Sem suporte	❌ Sem suporte
`usage.prompt_tokens_details.cached_tokens`	✔ Somente leituras de cache	✔ Leitura + gravação de cache	❌ Sem suporte
`usage.completion_tokens_details`	Consulte os subcampos	Consulte os subcampos	Consulte os subcampos
`usage.completion_tokens_details.accepted_prediction_tokens`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`usage.completion_tokens_details.audio_tokens`	❌ Sem suporte	❌ Sem suporte	❌ Sem suporte
`usage.completion_tokens_details.reasoning_tokens`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`usage.completion_tokens_details.rejected_prediction_tokens`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`service_tier`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte
`system_fingerprint`	Suporte para ✔	❌ Sem suporte	❌ Sem suporte

Cabeçalhos de solicitação¶
Cabeçalho	Suporte
`Authorization`	✔ Obrigatório
`Content-Type`	✔ Compatível (`application/json`)
`Accept`	✔ Compatível (`application/json`, `text/event-stream`)

Cabeçalhos de resposta¶
Cabeçalho	Suporte
`openai-organization`	❌ Sem suporte
`openai-version`	❌ Sem suporte
`openai-processing-ms`	❌ Sem suporte
`x-ratelimit-limit-requests`	❌ Sem suporte
`x-ratelimit-limit-tokens`	❌ Sem suporte
`x-ratelimit-remaining-requests`	❌ Sem suporte
`x-ratelimit-remaining-tokens`	❌ Sem suporte
`x-ratelimit-reset-requests`	❌ Sem suporte
`x-ratelimit-reset-tokens`	❌ Sem suporte
`retry-after`	❌ Sem suporte

Saiba mais¶

Para exemplos de uso adicionais, consulte a referência da OpenAI Chat Completions API ou o OpenAI Cookbook.

Além de oferecer compatibilidade com a API Chat Completions, o Snowflake oferece suporte a recursos compatíveis com OpenRouter para modelos do Claude. Esses recursos são expostos como campos extras na solicitação:

Para cache de prompt, use o campo cache_control. Consulte a documentação de cache de prompts OpenRouter.
Para tokens de raciocínio, use o campo reasoning. Consulte a documentação de raciocínio do OpenRouter.

Referência da Messages API¶

POST /api/v2/cortex/v1/messages¶

Gera uma resposta usando um modelo Claude. O formato de solicitação e resposta segue a especificação da Anthropic Messages API.

POST https://<account_identifier>.snowflakecomputing.com/api/v2/cortex/v1/messages

Nota

A Messages API é compatível apenas com modelos Claude. Para outros modelos, use a Chat Completions API.

Cabeçalhos obrigatórios¶

Authorization: Bearer token: Autorização para a solicitação. token é um token web JSON (JSON web token, JWT), token OAuth ou token de acesso programático. Para obter mais detalhes, consulte Autenticando o Snowflake REST APIs com Snowflake.
Content-Type: application/json: Especifica que o corpo da solicitação está no formato JSON.
anthropic-version: 2023-06-01: Cabeçalho de versão Anthropic API obrigatório.

Cabeçalhos opcionais¶

X-Snowflake-Authorization-Token-Type: type

Define o tipo de token de autorização.

Se você omitir o cabeçalho X-Snowflake-Authorization-Token-Type, o Snowflake determinará o tipo de token examinando o token.

Embora esse cabeçalho seja opcional, você pode optar por especificá-lo. Você pode definir o cabeçalho com um dos seguintes valores:

KEYPAIR_JWT (para autenticação de pares de chaves)
OAUTH (para OAuth)
PROGRAMMATIC_ACCESS_TOKEN (para tokens de acesso programático)

anthropic-beta: feature

Habilita os recursos beta. Somente cabeçalhos beta compatíveis com Bedrock são aceitos.

Campos JSON obrigatórios¶


Campo	Tipo	Descrição
`model`	string	O modelo Claude a ser utilizado (consulte Disponibilidade do modelo).
`max_tokens`	inteiro	o número máximo de tokens a serem gerados.
`messages`	matriz	Uma matriz de objetos de mensagem. Cada mensagem tem um `role` (`user` ou `assistant`) e um `content` (cadeia de caracteres ou matriz de blocos de conteúdo).

Recursos aceitos¶

A Messages API é compatível com o conjunto de recursos padrão do Anthropic Messages API para modelos Claude, incluindo:

Geração de texto e conversas com várias interações
Streaming ("stream": true)
Mensagens do sistema (via campo system de nível superior)
Chamada de ferramentas (formato Anthropic com name, description, input_schema)
Entrada de imagem (blocos de origem base64)
Cache de prompts (cache_control em blocos de conteúdo)
Raciocínio estendido (parâmetro thinking com budget_tokens)

Para obter detalhes completos sobre o esquema de solicitação e resposta, consulte a documentação da Anthropic Messages API.

Limitações¶

Somente modelos Claude. OpenAI, Llama, Mistral e outros modelos não estão disponíveis por meio desse ponto de extremidade.
Sem processamento flexível ou nível de prioridade. O campo service_tier não é compatível.
Apenas cabeçalhos beta do Bedrock. Somente valores de cabeçalho anthropic-beta compatíveis com o Bedrock são compatíveis.
As mensagens de erro são geradas pela Snowflake, não pela Anthropic.

Códigos de status¶

200 OK: Solicitação concluída com sucesso.
400 invalid_request_error: O corpo da solicitação está malformado ou contém valores inválidos.
400 unknown model model_name: O modelo especificado não existe ou não é um modelo Claude.
402 budget exceeded: O orçamento de consumo do modelo foi excedido.
403 Not Authorized: A conta não está habilitada para REST API ou a função padrão não tem a função de banco de dados snowflake.cortex_user.
429 too many requests: A cota de uso foi excedida. Tente novamente mais tarde.
503 inference timed out: A solicitação demorou muito.

Limites de taxa¶

Para garantir alto desempenho para todos os clientes Snowflake, as solicitações Cortex REST API estão sujeitas a limites de taxa. As solicitações que excederem os limites poderão receber uma resposta HTTP 429. Ocasionalmente, a Snowflake pode ajustar esses limites.

Os limites padrão nas tabelas a seguir são aplicados por conta e de maneira independente para cada modelo. Certifique-se de que seu aplicativo trate respostas 429 de maneira adequada, tentando novamente com espera exponencial.

Se você precisa aumentar os limites, entre em contato com o suporte Snowflake.

Limites de taxa da Cortex REST API¶
Modelo	Tokens processados por minuto (TPM)	Solicitações por Minuto (RPM)	Saída máxima (tokens)
`claude-3-5-sonnet`	300,000	300	16.384
`claude-3-7-sonnet`	300,000	300	16.384
`claude-sonnet-4-5`	600.000	600	16.384
`claude-haiku-4-5`	600.000	600	16.384
`claude-4-sonnet`	300,000	300	16.384
`claude-4-opus`	75.000	75	16.384
`deepseek-r1`	100,000	100	16.384
`llama3.1-8b`	400,000	400	16.384
`llama3.1-70b`	200,000	200	16.384
`llama3.1-405b`	100,000	100	16.384
`mistral-7b`	400,000	400	16.384
`mistral-large2`	200,000	200	16.384
`openai-gpt-4.1`	300,000	300	16.384
`openai-gpt-5`	300,000	300	16.384
`openai-gpt-5-chat`	300,000	300	16.384
`openai-gpt-5-mini`	1.000.000	1.000	16.384
`openai-gpt-5-nano`	5.000.000	5.000	16.384

Aumento dos limites de taxa com inferência entre regiões¶

Se você configurar a inferência entre regiões em sua conta Snowflake, os limites de taxa serão maiores para os seguintes modelos:

Limites de taxa da Cortex REST API com inferência entre regiões¶
Modelo	Tokens processados por minuto (TPM)	Solicitações por Minuto (RPM)	Saída máxima (tokens)
`claude-3-7-sonnet`	600.000	600	16.384
`claude-haiku-4-5`	600.000	600	16.384
`claude-sonnet-4-5`	600.000	600	16.384
`claude-4-sonnet`	1.200.000	1.200	16.384
`claude-4-opus`	150.000	150	16.384
`llama3.1-8b`	800.000	400	16.384
`llama3.1-70b`	400,000	200	16.384
`llama3.1-405b`	200,000	100	16.384

Solução de problemas de eventos de limite de taxa¶

Exceder um dos limites de TPM ou RPM resulta no código de resposta 429. Se o seu uso da REST API está abaixo do limite de taxa de solicitação por minuto, mas ainda assim recebeu o código de resposta 429, verifique novamente a taxa de uso de token.

A Cortex REST API implementa limites de taxa usando o padrão Contador de janelas deslizantes. Os contadores são armazenados em um cluster Redis de alta disponibilidade, acessível apenas pelo Snowflake Cortex, dentro da rede privada do Snowflake.

O contador de janelas deslizantes considera que o tráfego do cliente para a API na janela de tempo anterior esteja uniformemente distribuído. Quando o pico de tráfego está elevado, essa suposição pode superestimar a taxa de solicitações, mas se recupera rapidamente, já que janela é breve. Entre em contato com o suporte Snowflake se você está sujeito à superestimativa e quer aumentar os limites.

Problemas conhecidos¶

Expiração do token de sessão¶

Recomendamos a autenticação com um dos três métodos definidos em Autenticando o Snowflake REST APIs com Snowflake. Entretanto, se você autenticar com um token de sessão do Snowflake, deverá cuidar da atualização do token para garantir o acesso ininterrupto à API.

Os tokens de sessão expiram periodicamente. Se uma solicitação for executada com um token de sessão expirado, a API REST retornará uma resposta 200 OK que inclui o código de erro 390112. Quando isso ocorre, a operação não é realizada.

Para resolver esse comportamento, seu aplicativo deve:

Verificar em cada resposta da API se há o código de erro 390112, mesmo quando o código de status HTTP é 200 OK.
Quando o código de erro 390112 for detectado, atualize o token de sessão e repita a solicitação.

Nota

Esse comportamento afeta apenas aplicativos que usam tokens de sessão do Snowflake. Se você se autentica usando autenticação de par de chaves, OAuth ou tokens de acesso programático (Programmatic Access Tokens, PATs), não precisa implementar esse tratamento de erros.

Considerações sobre custo¶

As solicitações da REST API do Snowflake Cortex incorrem em custos de computação com base no número de tokens processados. Consulte a tabela de consumo de serviços do Snowflake para obter o custo de cada modelo em dólares por milhão de tokens.

Um token é a menor unidade de texto processada pelas funções de LLM do Snowflake Cortex, aproximadamente igual a quatro caracteres de texto. A equivalência do texto bruto de entrada ou saída com tokens pode variar de acordo com o modelo.

Tanto os tokens de entrada quanto os de saída incorrem em custo de computação. Se você usa a API para fornecer uma experiência de usuário de conversação ou de bate-papo, todos os prompts e respostas anteriores serão processados para gerar cada nova resposta, com os custos correspondentes.