API Grok 3: Una guía paso a paso con ejemplos

¿Qué es Grok 3?

Grok 3 es el último gran modelo de lenguaje de xAI, creado específicamente para el razonamiento paso a paso, la coherencia lógica y los resultados estructurados. A diferencia de los modelos típicos de chat que priorizan el flujo de la conversación, Grok 3 piensa antes de responder, lo que lo hace ideal para tareas que requieren una lógica profunda, como la toma de decisiones complejas, el razonamiento matemático y el análisis cuantitativo.

Grok 3 se presenta en dos sabores diferentes: el modelo normal y un modelo mini. Mientras que el mini modelo se centra completamente en el aspecto del razonamiento y permite acceder a sus trazas de razonamiento, se anuncia que el modelo normal posee un importante conocimiento del dominio en campos como las finanzas, la sanidad, el derecho y la ciencia.

Ambas versiones del modelo admiten capacidades avanzadas como la llamada a funciones nativas y la generación de respuestas estructuradas, lo que ayuda a los programadores a crear fácilmente flujos de trabajo de IA fiables y predecibles.

Si quieres saber más sobre la arquitectura y el rendimiento de Grok 3, asegúrate de echar un vistazo a esta descripción general de Grok 3.

Preparación: Cómo acceder a la API Grok 3

En esta sección, te explicaré cómo crear una clave API, configurar un entorno Python para conectarte a la API de Grok y realizar tu primera solicitud de usuario.

Crear una clave API

Para autenticar al cliente Python con la API, necesitamos crear una clave API. El proceso es el siguiente:

1. Ir a la página página de documentación de xAI.
2. Inicia sesión con tu cuenta X, xAI o Google, o crea una cuenta xAI.
3. Haz clic en "Crear una clave API", dale un nombre y haz clic en "Guardar".
4. Cuando la clave esté visible, cópiala. No podrás volver a verlo después, pero siempre puedes crear uno nuevo, por si lo pierdes.
5. Crea un archivo llamado .env en el directorio de tu proyecto y pega la clave con el siguiente formato:

XAI_API_KEY=<your_api_key>

Precios de la API Grok 3

Aunque el uso de la API se asocia a menudo con costes más bajos que el uso de una suscripción premium, no es gratis. En lugar de una cuenta fija al mes, que comienza en 30 $ para la suscripción SuperGrok, el coste depende completamente de la cantidad de uso. Para obtener una visión general de los costes potenciales, visita la página de precios de xAI de xAI.

Los precios indicados son por millón de tokens, lo que, según una regla empírica corresponde a unas 750.000 palabras de entrada o salida en inglés.

El modelo mini es significativamente más barato que el modelo normal. Las versiones rápidas de Grok 3 y Grok 3 mini utilizan exactamente los mismos modelos subyacentes, pero se sirven en una infraestructura más rápida, lo que mejora los tiempos de respuesta.

Para utilizar la API, necesitamos comprar créditos. Al principio se recomienda utilizar créditos prepagados en lugar de la facturación automática, ya que es una buena salvaguarda contra los costes imprevistos. Puedes comprar fichas y obtener una visión general de su uso en la consola xAI, en Facturas > Créditos.

Configurar el entorno Python

Ahora que hemos adquirido una clave API y comprado créditos, es el momento de configurar el cliente Python. Necesitamos instalar dos dependencias para que nuestras peticiones a la API se ejecuten correctamente:

• python-dotenv para cargar la clave API como variable de entorno desde el archivo .env, y
• el cliente openai como interfaz para enviar solicitudes a Grok 3.

Para configurar el entorno de nuestro proyecto, recomiendo utilizar Anaconda para evitar posibles conflictos entre distintos paquetes de Python. Después de instalar Anaconda, creamos un entorno llamado grok3 utilizando Python 3.10 y lo activamos utilizando los siguientes comandos en el terminal:

conda create -n grok3 python=3.10
conda activate grok3

Por último, se instalan las dependencias:

pip install python-dotenv openai

Envío de la primera solicitud de usuario

¡Es hora de empezar con nuestro primer guión! En primer lugar, tenemos que importar las funciones que vamos a utilizar de los paquetes que instalamos anteriormente, así como os para leer la clave de la API.

import os
from dotenv import load_dotenv
from openai import OpenAI

La variable de entorno variable de entorno que hace referencia a la clave de la API está disponible al ejecutar la función load_dotenv() importada del paquete dotenv.

# Load environment variables
load_dotenv()

El siguiente paso es inicializar el cliente. Llamamos a la función OpenAI con nuestra clave API del archivo .env y la URL del servidor Grok, y la asignamos a la variable client.

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

Pidamos consejo a Grok sobre qué hacer en San Francisco si llueve. Lo que tenemos que hacer es especificar el model y nuestro messages, pasarlos como argumentos a la función client.chat.completions.create. Opcionalmente, también podemos ajustar parámetros como max_tokens para controlar la longitud de la respuesta o temperature para influir en la aleatoriedad.

# 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 la respuesta de Grok, tenemos que extraerla del objeto resultante. Como hemos llamado a la variable que almacena el resultado response, la respuesta puede encontrarse en 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.

Razonar con Grok 3 Mini

Para ver el estilo de razonamiento de Grok, hagamos una pregunta básica que requiera cierto razonamiento lógico. Utilizaremos Grok 3 Mini para esta primera petición porque garantiza una traza de razonamiento completa en cada respuesta de la API, lo que facilita seguir paso a paso el proceso de pensamiento del modelo sin depender de una ingeniería de instrucciones especial.

El parámetro que determina la profundidad de pensamiento del modelo se llama reasoning_effort. Es exclusivo de Grok 3 Mini y está configurado por defecto en la opción más rápida ”low”. Configurar reasoning_effort="high" ayuda al modelo a recorrer cuidadosamente el problema paso a paso antes de dar la respuesta final, perfecto para tareas como la planificación, la toma de decisiones o el razonamiento matemático.

Imagina que queremos utilizar Grok para averiguar qué hacer en un día libre, según el tiempo que haga. Podríamos pasar las premisas Grok definiendo una actividad para los días soleados y lluviosos, y una premisa basada en el tiempo 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 trabajar con el rastro de razonamiento, primero tenemos que analizar la respuesta de la API y extraer el atributo reasoning_content del objeto message. El código siguiente muestra cómo imprimir tanto los pasos detallados del razonamiento como la respuesta final, de forma similar a como aparecerían en una interfaz 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)

El resultado es el siguiente:

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.

Aunque se trata de un ejemplo bastante sencillo, podemos ver cómo Grok-3-mini recorre cuidadosamente cada premisa, encadenando la lógica paso a paso antes de llegar a una recomendación. Su razonamiento es metódico y transparente, por lo que resulta fácil rastrear cómo el modelo pasa de los hechos a la sugerencia final.

Llamada a funciones con Grok 3

Una de las características que hacen interesante a Grok 3 es la llamada a funciones, que le permite conectarse a herramientas y sistemas externos. Esto permite que el modelo no sólo genere texto, sino que también desencadene acciones como recuperar previsiones meteorológicas, buscar horarios de eventos, analizar entradas de bases de datos o incluso controlar dispositivos inteligentes.

Cuando enviamos una petición de usuario, Grok 3 puede reconocer que necesita información adicional y solicitar una llamada a una función con argumentos específicos. A continuación, el cliente Python ejecuta la función localmente, envía el resultado a Grok 3 y recibe la respuesta final, totalmente razonada.

Fuente: xAI

Preparación

Necesitaremos el paquete json para acceder a la estructura argumental de una función llamada por Grok, así que tenemos que importarlo.

import json

Para probar la llamada a funciones, tenemos que definir una función de llamada de retorno que se llame cuando Grok la solicite en su respuesta. En nuestro caso, la función get_weather_forecast es una simple función de Python que devuelve una previsión meteorológica codificada. Lo he codificado con fines de demostración para que la explicación sea sencilla y no dependa de servicios 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
    }

También debemos definir la herramienta disponible especificando su nombre, finalidad y parámetros necesarios en un esquema JSON, que se enviará a Grok con nuestra solicitud más adelante. Esta configuración permite a Grok 3 saber que puede llamar a esta herramienta siempre que necesite información meteorológica para su razonamiento.

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 último, la página tools_map dictionary vincula los nombres de las funciones utilizadas por Grok 3 a las funciones locales reales de Python, lo que permite al cliente ejecutar correctamente las llamadas a las herramientas solicitadas.

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

Aunque definir los esquemas de la herramienta manualmente está perfectamente bien para proyectos sencillos, utilizar un módulo de validación de datos como Pydantic resulta cada vez más valioso a medida que los proyectos crecen en tamaño y complejidad. Permite la validación automática de las entradas de las funciones, un mejor tratamiento de los errores y un código más limpio y fácil de mantener.

Ejecución

Veamos si Grok utiliza nuestra función de previsión meteorológica cuando se le pregunta por una actividad sugerida en San Francisco este fin de semana. Seguimos la estructura del flujo de trabajo de llamada a funciones:

1. En primer lugar, enviamos al Grok nuestra petición inicial de usuario que contiene nuestra pregunta junto con el tools disponible.
2. Comprobamos la respuesta de Grok para cualquier solicitud de llamada a la herramienta y, si procede, llamamos a la función local correspondiente utilizando la dirección tools_map. Si Grok no solicita una llamada a la herramienta, podemos manejarla devolviendo la respuesta inicial del modelo.
3. A continuación, añadimos el resultado al historial de mensajes; y
4. Devuélvelo a Grok para que complete el razonamiento y genere la respuesta 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)

La función se solicitó y ejecutó correctamente, como indica la respuesta 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: (...)

Puede que te hayas fijado en el argumento tool_choice de la petición inicial del usuario, que se refiere al modo de llamada a la función. Por defecto, el modo "auto" permite que Grok 3 decida si debe llamar a una función y a qué función, en función de la conversación. Alternativamente, podemos controlar el comportamiento forzando la llamada a una función con ”required”, especificando una función exacta a la que llamar, o desactivando completamente la llamada a una función con ”none”.

Salidas estructuradas con Grok 3

Las salidas estructuradas permiten a Grok 3 devolver respuestas en un formato estricto y predefinido, como JSON, en lugar de texto libre. Esto facilita mucho el análisis sintáctico automático, la validación y la integración de las respuestas del modelo en aplicaciones o flujos de trabajo.

Al definir un esquema por adelantado, podemos asegurarnos de que los resultados de Grok sean coherentes, legibles por máquina y estén listos para el procesamiento posterior. Por lo tanto, es una función muy útil para casos de uso como los datos estructurados de documentos o la alimentación de conocimientos generados por IA en sistemas posteriores como bases de datos, cuadros de mando o canalizaciones de automatización sin necesidad de un frágil análisis sintáctico del texto.

Utilizamos Pydantic para definir el esquema de salida porque ofrece una forma más limpia y legible de estructurar datos complejos. Es necesario importar tanto BaseModel como Field de pydantic para que esta definición de esquema funcione correctamente. Como nuestra salida incluye una lista de pasos de razonamiento, también importamos List del módulo typing de Python para especificar el tipo de elemento con mayor precisión.

Aunque también es posible definir el esquema utilizando JSON plano, en las pruebas he comprobado que Grok 3 a veces devolvía resultados que no coincidían exactamente con la estructura esperada. El JSON devuelto tenía un significado similar, pero seguía un esquema diferente, lo que podía romper las aplicaciones que esperaban una estructura específica. Debido a esta incoherencia, especialmente con elementos anidados como las listas, recomiendo encarecidamente utilizar Pydantic para garantizar que la salida estructurada se valida y analiza de forma fiable.

from pydantic import BaseModel, Field
from typing import List

Nuestro esquema, denominado DecisionPlan, consta de nuestro situation inicial y una lista de DecisionSteps, que se definen por su número step, el reasoning que hay detrás de ellos y un 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")

Hay que tener en cuenta algunas cosas en relación con la solicitud en sí. En primer lugar, tenemos que utilizar client.beta.chat.completions.parse() en lugar de create(), para que Grok sepa que queremos que la salida tenga un formato específico. Este es el esquema que acabamos de definir y, en consecuencia, pasamos nuestro DecisionPlan como argumento response_format.

Puede ser útil incluir todas las instrucciones importantes para una tarea concreta en el aviso del sistema, ya que ayuda a Grok 3 a mantenerse centrado en la tarea durante toda la conversación. En combinación con el esquema definido por separado, el usuario no tiene que especificar los campos obligatorios en el JSON de salida, sino que puede centrarse en la tarea en sí.

Por ejemplo, podríamos desglosar fácilmente el proceso de planificación de actividades en tres pasos bien definidos:

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

Tras analizar la salida estructurada de Grok 3, podemos actuar sobre los resultados resumiendo las recomendaciones clave, activando flujos de trabajo automatizados, o incluso tomando otras decisiones mediante programación.

Sigamos con el primer ejemplo y mostremos sólo nuestra situación y la recomendación final de nuestro experto en viajes, Grok. Como nuestra salida está en nuestro formato JSON predefinido, podemos acceder fácilmente a la recomendación del paso 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.

Ponerlo todo junto: Construir una aplicación de razonamiento simple con Grok 3

Podemos combinar la llamada a funciones y las salidas estructuradas para crear una aplicación sencilla que utilice el razonamiento de Grok. Podemos copiar y pegar el código para:

• Importa todos los paquetes y funciones mencionados anteriormente;
• Inicializar el cliente;
• Definir el esquema de la función, la función ficticia y tools_map; y
• Definir el esquema de salida.

Empezamos con una llamada a la API utilizando la función create() para activar la llamada a la herramienta. Para que el usuario introduzca la pregunta en el terminal, sólo tenemos que sustituir nuestra pregunta sobre la actividad en San Francisco por input("> ").

Después de añadir el function_result a la lista messages viene el giro: en lugar de crear otra llamada a la API que utilice create(), we parse() and pass our DecisionPlan as the response_format`.

Aquí tienes el código completo de nuestra pequeña aplicación:

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

Ejemplo de ejecución

Para probar la aplicación, navegamos hasta el directorio de nuestro proyecto, cargamos nuestro entorno y ejecutamos el script:

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

Si pedimos algún consejo para Helsinki, nuestra aplicación Grok responde:

Es una sugerencia decente, ¡lo digo por experiencia!

Conclusión

Hemos hablado mucho, terminemos. Exploramos cómo trabajar con la API de Grok 3 para ejecutar consultas sencillas, gestionar trazas de razonamiento y utilizar funciones avanzadas como la llamada a funciones y los resultados estructurados.

Combinamos estas capacidades en un pequeño proyecto que mostraba cómo Grok puede utilizar herramientas externas y devolver respuestas estructuradas y procesables. En combinación con API -en nuestro caso, una API meteorológica- se pueden crear potentes aplicaciones que aprovechen al máximo los puntos fuertes de Grok 3.

Si has llegado hasta aquí, probablemente estés interesado en saber más sobre los LLM. No dudes en consultar también estos recursos:

• GPT-Image-1 API: Una guía paso a paso con ejemplos
• Cómo configurar y ejecutar Qwen3 localmente con Ollama
• Puesta a punto de Qwen3: Guía paso a paso