API do Grok 3: Um guia passo a passo com exemplos

O que é o Grok 3?

O Grok 3 é o modelo de linguagem grande mais recente da xAI, desenvolvido especificamente para raciocínio passo a passo, consistência lógica e resultados estruturados. Diferentemente dos modelos de bate-papo típicos que priorizam o fluxo da conversa, o Grok 3 pensa antes de responder, o que o torna ideal para tarefas que exigem lógica profunda, como tomada de decisões complexas, raciocínio matemático e análise quantitativa.

O Grok 3 vem em duas versões diferentes: o modelo normal e um modelo mini. Enquanto o minimodelo se concentra totalmente no aspecto de raciocínio e permite acessar seus traços de raciocínio, o modelo regular é anunciado como possuidor de um conhecimento de domínio significativo em áreas como finanças, saúde, direito e ciências.

Ambas as versões do modelo oferecem suporte a recursos avançados, como chamadas de funções nativas e geração de respostas estruturadas, ajudando os desenvolvedores a criar facilmente fluxos de trabalho de IA confiáveis e previsíveis.

Se você quiser saber mais sobre a arquitetura e o desempenho do Grok 3, não deixe de dar uma olhada nesta visão geral do Grok 3.

Preparação: Obtendo acesso à API do Grok 3

Nesta seção, explicarei como criar uma chave de API, configurar um ambiente Python para se conectar à API do Grok e fazer sua primeira solicitação de usuário.

Criando uma chave de API

Para autenticar o cliente Python com a API, precisamos criar uma chave de API. O processo é parecido com o seguinte:

1. Vá para a página de documentação do página de documentação do xAI.
2. Faça login com sua conta X, xAI ou Google - ou crie uma conta xAI.
3. Clique em "Create an API key" (Criar uma chave de API), dê um nome a ela e clique em "save" (salvar).
4. Quando a chave estiver visível, copie-a. Você não poderá vê-lo novamente mais tarde, mas sempre poderá criar um novo, caso o perca.
5. Crie um arquivo chamado .env no diretório do seu projeto e cole a chave no seguinte formato:

XAI_API_KEY=<your_api_key>

Preços da API do Grok 3

Embora o uso da API esteja frequentemente associado a custos mais baixos do que o uso de uma assinatura premium, ele não é gratuito. Em vez de uma conta fixa por mês, que começa em US$ 30 para a assinatura do SuperGrok, o custo depende totalmente da quantidade de uso. Para obter uma visão geral dos possíveis custos, visite a página de preços da xAI página de preços.

Os preços listados são por milhão de tokens, o que, de acordo com uma regra geral corresponde a cerca de 750.000 palavras de entrada ou saída em inglês.

O modelo mini é significativamente mais barato do que o modelo normal. As versões rápidas do Grok 3 e do Grok 3 mini usam exatamente os mesmos modelos subjacentes, mas são servidas em uma infraestrutura mais rápida, o que leva a melhores tempos de resposta.

Para usar a API, precisamos comprar créditos. No início, recomenda-se o uso de créditos pré-pagos em vez de faturamento automático de faturas, pois é uma boa proteção contra custos inesperados. Você pode comprar tokens e obter uma visão geral do seu uso no console xAI em Invoices > Credits (Faturas > Créditos).

Configurando o ambiente Python

Agora que você adquiriu uma chave de API e comprou créditos, é hora de configurar o cliente Python. Precisamos instalar duas dependências para que nossas solicitações de API sejam executadas com êxito:

• python-dotenv para carregar a chave da API como uma variável de ambiente do arquivo .env, e
• o cliente openai como a interface para enviar solicitações ao Grok 3.

Para configurar o ambiente do nosso projeto, recomendo que você use o Anaconda para evitar possíveis conflitos entre diferentes pacotes Python. Depois de instalar o Anaconda, criamos um ambiente chamado grok3 usando o Python 3.10 e o ativamos usando os seguintes comandos no terminal:

conda create -n grok3 python=3.10
conda activate grok3

Por fim, as dependências são instaladas:

pip install python-dotenv openai

Envio da primeira solicitação de usuário

É hora de começar com nosso primeiro script! Primeiro, precisamos importar as funções que usaremos dos pacotes que instalamos anteriormente, bem como os para ler a chave da API.

import os
from dotenv import load_dotenv
from openai import OpenAI

A variável de ambiente variável de ambiente referente à chave de API é disponibilizada pela execução da função load_dotenv() importada do pacote dotenv.

# Load environment variables
load_dotenv()

A próxima etapa é inicializar o cliente. Chamamos a função OpenAI com nossa chave de API do arquivo .env e o URL do servidor Grok, e a atribuímos à variável client.

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)

Vamos pedir conselhos à Grok sobre o que fazer em São Francisco se estiver chovendo. O que precisamos fazer é especificar o model e o nosso messages e passá-los como argumentos para a função client.chat.completions.create. Opcionalmente, também podemos ajustar parâmetros como max_tokens para controlar o comprimento da resposta ou temperature para influenciar a aleatoriedade.

# Send a basic reasoning query
response = client.chat.completions.create(
    model="grok-3",
    messages=[
        {"role": "user", "content": "What kind of activity would you suggest, if it rains in San Francisco? Answer in one sentence."}
    ],
    max_tokens=1000,
    temperature=0.2,  # lower temperature for more deterministic answers
)

Para imprimir a resposta do Grok, temos que extraí-la do objeto resultante. Como chamamos a variável que armazena o resultado de response, a resposta pode ser encontrada em response.choices[0].message.content.

print(response.choices[0].message.content) # Print the response

If it rains in San Francisco, I suggest visiting indoor attractions like the San Francisco Museum of Modern Art or the California Academy of Sciences for an enriching and dry experience.

Raciocínio com o Grok 3 Mini

Para você ver o estilo de raciocínio da Grok, vamos fazer uma pergunta básica que requer algum raciocínio lógico. Usaremos o Grok 3 Mini para essa primeira solicitação porque ele garante um rastreamento completo do raciocínio em cada resposta da API, facilitando o acompanhamento passo a passo do processo de pensamento do modelo sem depender de engenharia de prompt especial.

O parâmetro que determina a profundidade do modelo é chamado reasoning_effort. Ele é exclusivo do Grok 3 Mini e está definido como a opção mais rápida ”low” por padrão. A configuração de reasoning_effort="high" ajuda o modelo a percorrer cuidadosamente o problema, passo a passo, antes de dar a resposta final, o que é perfeito para tarefas como planejamento, tomada de decisões ou raciocínio matemático.

Imagine que você queira usar o Grok para descobrir o que fazer em um dia de folga, dependendo do clima. Poderíamos passar as premissas do Grok definindo uma atividade para dias ensolarados e chuvosos, e uma premissa baseada no clima real.

response = client.chat.completions.create(
    model="grok-3-mini-beta",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": (
            "Premises:\n"
            "- If it is raining, the weather is suitable for indoor activities.\n"
        	"- Visiting a museum is an indoor activity.\n"
        	"- Today, it is raining.\n"
            "Question: What should we do today?"    	
        )}
    ],
    max_tokens=1000,
    temperature=0.2,
)

Para trabalhar com o rastreamento de raciocínio, primeiro precisamos analisar a resposta da API e extrair o atributo reasoning_content do objeto message. O código a seguir mostra como imprimir as etapas detalhadas do raciocínio e a resposta final, de modo semelhante ao que seria exibido em uma interface da Web.

# Print the reasoning trace if available
reasoning = getattr(response.choices[0].message, "reasoning_content", None)
 
if reasoning:
    print("Reasoning steps:\n")
    print(reasoning)
else:
    print("No detailed reasoning trace found.")
 
# Print the final answer
print("\nFinal Answer:\n")
print(response.choices[0].message.content)

O resultado é o seguinte:

Reasoning steps:
First, the premises are:
1. If it is raining, the weather is suitable for indoor activities.
2. Visiting a museum is an indoor activity.
3. Today, it is raining.
The question is: What should we do today?
I need to reason step by step based on the given premises.
From premise 3, today it is raining.
From premise 1, if it is raining, then the weather is suitable for indoor activities. Since it's raining today, the weather is suitable for indoor activities today.  	
From premise 2, visiting a museum is an indoor activity. So, if the weather is suitable for indoor activities, and visiting a museum is an indoor activity, it makes sense that visiting a museum would be a good choice today.
The conclusion should be that we should visit a museum or engage in some indoor activity. But the question is "What should we do today?" and the premises point towards indoor activities, with a specific example given.
Let me chain the logic:
- It is raining (premise 3).
- Therefore, weather is suitable for indoor activities (from premise 1).
- Visiting a museum is an indoor activity (premise 2).
- So, since the weather is suitable for indoor activities, and museum visiting is an indoor activity, it should be suitable to visit a museum.
The premises don't explicitly say that we should do the most suitable activity or anything like that. They just provide conditions and facts.
However, the question implies a recommendation based on the premises. Given that it's raining and indoor activities are suitable, and a museum is mentioned, it's logical to suggest visiting a museum.
I should stick to what's given. The premises don't suggest any other activities or constraints, so based on the information, visiting a museum is a reasonable suggestion.
Final answer should be something like: "We should visit a museum today."
To make it clear, I can phrase it as: "Since it is raining and the weather is suitable for indoor activities, and visiting a museum is an indoor activity, we should visit a museum today."
But since the instruction is to put the final answer in a box, probably a concise statement.
Looking back at the user's message, it's a reasoning exercise, so the answer should be direct.
Final Answer:
Based on the given premises:
- It is raining today (premise 3).
- If it is raining, the weather is suitable for indoor activities (premise 1).   	
- Therefore, the weather is suitable for indoor activities today.
- Visiting a museum is an indoor activity (premise 2).
A suitable activity for today would be an indoor one, such as visiting a museum. 	
**Recommendation:** We should visit a museum today.

Embora esse seja um exemplo bastante simples, podemos ver como o Grok-3-mini percorre cuidadosamente cada premissa, encadeando a lógica passo a passo antes de chegar a uma recomendação. Seu raciocínio é metódico e transparente, facilitando o rastreamento de como o modelo passa dos fatos para a sugestão final.

Chamada de função com o Grok 3

Um dos recursos que torna o Grok 3 interessante é a chamada de função, que permite que ele se conecte a ferramentas e sistemas externos. Isso permite que o modelo não apenas gere texto, mas também acione ações como a recuperação de previsões meteorológicas, a busca de programações de eventos, a análise de entradas de banco de dados ou até mesmo o controle de dispositivos inteligentes.

Quando enviamos uma solicitação de usuário, o Grok 3 pode reconhecer que precisa de informações adicionais e solicitar uma chamada de função com argumentos específicos. Em seguida, o cliente Python executa a função localmente, envia o resultado de volta ao Grok 3 e recebe a resposta final, totalmente fundamentada.

Fonte: xAI

Preparação

Precisaremos do pacote json para acessar a estrutura de argumentos de uma função que foi chamada pelo Grok, portanto, precisamos importá-lo.

import json

Para experimentar a chamada de função, precisamos definir uma função de retorno de chamada que é chamada quando o Grok a solicita em sua resposta. No nosso caso, a função get_weather_forecast é uma função simples do Python que retorna uma previsão do tempo codificada. Eu o codifiquei para fins de demonstração, a fim de manter a explicação simples e evitar que você dependa de serviços externos.

# Define the dummy function
def get_weather_forecast(location: str, date: str) -> dict:
    """Simulated function to always return rainy weather."""
    return {
        "location": location,
        "date": “this weekend”, # hardcoded for demo purposes
        "forecast": "rainy"  # hardcoded for demo purposes
    }

Também devemos definir a ferramenta disponível especificando seu nome, finalidade e parâmetros necessários em um esquema JSON, que será enviado ao Grok com nossa solicitação posteriormente. Essa configuração permite que o Grok 3 saiba que pode chamar essa ferramenta sempre que precisar de informações meteorológicas para seu raciocínio.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                    },
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
            	    "required": ["location", "date"]
            }
        }
    }
]

Por fim, o site tools_map dictionary vincula os nomes das funções usadas pelo Grok 3 às funções locais reais do Python, permitindo que o cliente execute corretamente as chamadas de ferramentas solicitadas.

# Link the function names to the functions
tools_map = {
    "get_weather_forecast": get_weather_forecast
}

Embora a definição manual de esquemas de ferramentas seja perfeitamente adequada para projetos simples, o uso de um módulo de validação de dados como o Pydantic torna-se cada vez mais valioso à medida que os projetos aumentam em tamanho e complexidade. Ele permite a validação automática de entradas de funções, melhor tratamento de erros e um código mais limpo e de melhor manutenção.

Execução

Vamos ver se o Grok usa nossa função de previsão do tempo quando perguntado sobre uma atividade sugerida em São Francisco neste fim de semana. Seguimos a estrutura do fluxo de trabalho de chamada de função:

1. Primeiro, enviamos nossa solicitação inicial de usuário contendo nossa pergunta para o Grok junto com o tools disponível.
2. Verificamos a resposta do Grok para qualquer solicitação de chamada de ferramenta e, se for o caso, chamamos a função local correspondente usando o tools_map. Se o Grok não solicitar uma chamada de ferramenta, podemos lidar com isso retornando a resposta inicial do modelo.
3. Em seguida, adicionamos o resultado ao histórico de mensagens; e
4. Envie-o de volta ao Grok para que ele complete o raciocínio e gere a resposta final.

# Step 1: Send the initial user request
messages = [
    {"role": "user", "content": "What should I do this weekend in San Francisco?"}
]

response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
# Step 2: Check if a tool call was requested
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
 
        # Find and call the matching local function
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
            # Step 3: Add the function result back to the message history
            messages.append(response.choices[0].message)  # Grok's tool call message
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# Step 4: Send a new request including the tool response
            final_response = client.chat.completions.create(
                model="grok-3",
                messages=messages,
                tools=tools,
                tool_choice="auto"
        	)
 
        	# Print the final answer
            print("\nFinal Answer:")
            print(final_response.choices[0].message.content)
 
else:
    # No tool call: respond directly
    print("\nNo tool call was requested. Final Answer:")
    print(response.choices[0].message.content)

A função foi solicitada e executada com êxito, como indica a resposta de Grok:

Thanks for the weather update. Since it's going to be rainy this weekend in San Francisco, I’ll suggest some indoor activities to keep you entertained and dry. Here are a few ideas for your weekend: (...)

Você deve ter notado o argumento tool_choice na solicitação inicial do usuário, que se refere ao modo de chamada da função. Por padrão, o modo "auto" permite que o Grok 3 decida se e qual função chamar com base na conversa. Como alternativa, podemos controlar o comportamento forçando uma chamada de função com ”required”, especificando uma função exata a ser chamada ou desativando completamente a chamada de função com ”none”.

Saídas estruturadas com o Grok 3

As saídas estruturadas permitem que o Grok 3 retorne respostas em um formato estrito e predefinido, como JSON, em vez de texto livre. Isso facilita muito a análise automática, a validação e a integração das respostas do modelo em aplicativos ou fluxos de trabalho.

Ao definir um esquema antecipadamente, podemos garantir que os resultados do Grok sejam consistentes, legíveis por máquina e prontos para o processamento posterior. Portanto, é um recurso muito útil para casos de uso, como dados estruturados de documentos ou alimentação de insights gerados por IA em sistemas downstream, como bancos de dados, painéis ou pipelines de automação, sem a necessidade de análise de texto frágil.

Usamos o Pydantic para definir o esquema de saída porque ele oferece uma maneira mais limpa e legível de estruturar dados complexos. Tanto o BaseModel quanto o Field do pydantic precisam ser importados para que essa definição de esquema funcione corretamente. Como nossa saída inclui uma lista de etapas de raciocínio, também importamos List do módulo typing do Python para especificar o tipo de elemento com mais precisão.

Embora também seja possível definir o esquema usando JSON simples, descobri em testes que o Grok 3 às vezes retornava resultados que não correspondiam exatamente à estrutura esperada. O JSON retornado era semelhante em significado, mas seguia um esquema diferente, o que poderia prejudicar os aplicativos que esperavam uma estrutura específica. Devido a essa inconsistência, especialmente com elementos aninhados como listas, recomendo enfaticamente que você use o site Pydantic para garantir que a saída estruturada seja validada e analisada de forma confiável.

from pydantic import BaseModel, Field
from typing import List

Nosso esquema, chamado DecisionPlan, consiste em nosso situation inicial e em uma lista de DecisionSteps, que são definidos por seu número step, o reasoning por trás deles e um action sugerido.

# Define the schema for the structured output
class DecisionStep(BaseModel):
    step: int = Field(description="Step number in the decision process")
    reasoning: str = Field(description="Reasoning behind this step")
    action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
    situation: str = Field(description="The initial situation to consider")
    steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")

Há alguns aspectos a serem considerados com relação à solicitação em si. Em primeiro lugar, precisamos usar client.beta.chat.completions.parse() em vez de create(), para que o Grok saiba que queremos que a saída tenha um formato específico. Esse é o esquema que acabamos de definir e, portanto, passamos nosso DecisionPlan como o argumento response_format.

Pode ser útil incluir todas as instruções importantes para uma tarefa específica no prompt do sistema, pois isso ajuda o Grok 3 a manter o foco na tarefa durante toda a conversa. Em combinação com o esquema definido separadamente, o prompt do usuário não precisa especificar os campos obrigatórios no JSON de saída, mas pode se concentrar na tarefa em si.

Poderíamos, por exemplo, dividir facilmente o processo de planejamento de atividades em três etapas bem definidas:

# Send a prompt and request structured output
completion = client.beta.chat.completions.parse(
    model="grok-3",
    messages=[
        {"role": "system", "content": (
        "You are an expert travel planner."
        "When asked about activities, always break down the decision process into exactly 3 logical reasoning steps."
        "Return the output in structured JSON format following the provided schema, without any extra text."
        )},
        {"role": "user", "content": (
        "It's raining today in San Francisco. What indoor activity would you recommend?"
        )}
    ],
    response_format=DecisionPlan,
)

Depois de analisar a saída estruturada do Grok 3, podemos agir com base nos resultados, resumindo as principais recomendações, acionando fluxos de trabalho automatizados ou até mesmo tomando decisões adicionais de forma programática.

Vamos usar o primeiro exemplo e exibir apenas a nossa situação e a recomendação final do nosso especialista em viagens, Grok. Como nossa saída está em nosso formato JSON predefinido, podemos acessar facilmente a recomendação da etapa final:

# Access the parsed result
plan = completion.choices[0].message.parsed
 
# Use the final action to create a summary message
final_step = plan.steps[-1]
 
print(f"\nSummary:")
print(f"Situation: {plan.situation}")
print(f"Recommended Action: {final_step.action}")

Summary:
Situation: It's raining today in San Francisco, and an indoor activity is needed to make the most of the day.
Recommended Action: Visiting the California Academy of Sciences in Golden Gate Park for an educational and entertaining indoor experience.

Colocando tudo junto: Criando um aplicativo de raciocínio simples com o Grok 3

Podemos combinar a chamada de função e as saídas estruturadas para criar um aplicativo simples que use o raciocínio do Grok. Você pode copiar e colar o código para:

• Importação de todos os pacotes e funções mencionados anteriormente;
• Inicialização do cliente;
• Definir o esquema de função, a função fictícia e tools_map; e
• Definição do esquema de saída.

Começamos com uma chamada de API usando a função create() para acionar a chamada da ferramenta. Para permitir que o usuário insira a pergunta no terminal, basta substituir nossa pergunta sobre a atividade em São Francisco por input("> ").

Depois de anexar o function_result à lista messages, você terá uma reviravolta: em vez de criar outra chamada de API que usa create(), we parse() and pass our DecisionPlan as the response_format`.

Aqui está o código completo do nosso pequeno aplicativo:

import os
import json
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import List
 
# Load environment variables
load_dotenv()
 
# Initialize the client
client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
)
 
# 1. Define the function schema (tool definition)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather_forecast",
            "description": "Get a simulated weather forecast for a given location and date.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city where the activity will take place."
                	},
                    "date": {
                        "type": "string",
                        "description": "The date for which the weather is needed, in YYYY-MM-DD format."
                    }
            	    },
                "required": ["location", "date"]
        	}
        }
    }
]
 
# 2. Dummy weather function (hardcoded)
def get_weather_forecast(location: str, date: str) -> dict:
    return {
        "location": location,
        "date": "this weekend",
        "forecast": "rainy"
    }
 
# 3. Tool mapping
tools_map = {
    "get_weather_forecast": get_weather_forecast
}
 
# 4. Define structured output schema using Pydantic
class DecisionStep(BaseModel):
	step: int = Field(description="Step number in the decision process")
	reasoning: str = Field(description="Reasoning behind this step")
	action: str = Field(description="Suggested action at this step")
 
class DecisionPlan(BaseModel):
	situation: str = Field(description="The initial situation to consider")
	steps: List[DecisionStep] = Field(description="List of reasoning steps leading to the final action")
 
# 5. Defining messages: system prompt and input
messages = [
    {"role": "system", "content": (
        "You are an expert travel planner. When asked about weekend plans, "
        "first get the weather forecast via the tool provided. Then, based on the result, "
        "break down your reasoning into exactly 3 steps and return structured JSON only."
    )},
    {"role": "user", "content": input("> ")} # enter the question in the terminal
]
 
# 6. First API call to trigger the tool call
response = client.chat.completions.create(
    model="grok-3",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = getattr(response.choices[0].message, "tool_calls", [])
 
if tool_calls:
    for tool_call in tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        if function_name in tools_map:
            function_result = tools_map[function_name](**function_args)
 
        	# Add the assistant's tool call message and the tool result to the message history
            messages.append(response.choices[0].message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(function_result)
        	})
 
        	# 7. Second API call with parse() to get structured output
            final_response = client.beta.chat.completions.parse(
                model="grok-3",
                messages=messages,
                response_format=DecisionPlan
        	)
 
        	plan = final_response.choices[0].message.parsed
 
        	# 8. Use the output
            final_action = plan.steps[-1].action
 
            print(f"\nSummary:")
            print(f"Situation: {plan.situation}")
            print(f"Recommended Action: {final_action}")
 
else:
    print("No tool call was requested.")

Exemplo de execução

Para testar o aplicativo, navegamos até o diretório do projeto, carregamos nosso ambiente e executamos o script:

cd <your/working/directory>
conda activate grok3
python app.py

Se pedirmos conselhos para Helsinque, nosso aplicativo Grok responderá:

Essa é uma boa sugestão, posso dizer por experiência própria!

Conclusão

Falamos muito sobre o assunto, vamos encerrar. Exploramos como trabalhar com a API do Grok 3 para executar consultas simples, lidar com traços de raciocínio e utilizar recursos avançados, como chamadas de função e saídas estruturadas.

Combinamos esses recursos em um pequeno projeto que mostrou como o Grok pode usar ferramentas externas e retornar respostas estruturadas e acionáveis. Em combinação com APIs - no nosso caso, uma API meteorológica -, você pode criar aplicativos poderosos que utilizam totalmente os pontos fortes do Grok 3.

Se você chegou até aqui, provavelmente está interessado em saber mais sobre os LLMs. Fique à vontade para conferir esses recursos também:

• API GPT-Image-1: Um guia passo a passo com exemplos
• Como configurar e executar o Qwen3 localmente com o Ollama
• Fine-Tuning Qwen3: Um guia passo a passo