Grok 4.6 API：初回コールからツール駆動エージェントまで

Grok 4.6 API を Python でセットアップする方法は？

まず SpaceXAI の API キーを用意し、xai-sdk をインストールします。

console.x.ai で API キーを取得する

Grok 4.6 の API キーを作成するには、SpaceX AI コンソールの API キー作成ページに移動します。次に、右上の Create API Key ボタンをクリックします。

API キー作成フォームはシンプルです。どのプロジェクトのキーか分かるように名前を付けます。万一漏えいした場合に備え、API キーには常に有効期限を設定することをおすすめします。

キーが生成されたらコピーして、Python スクリプトを書くのと同じフォルダに .env という名前のファイルを作成し、そこに貼り付けます。こうしておけば、コードファイル内にキーを直書きせずに読み込めるため、コードを共有・クラウドへアップロードする際の誤露出を防げます。

.env ファイルの内容は次のとおりです。

XAI_API_KEY=replace_with_the_api_key

xai-sdk をインストールし SpaceXAI API キーを読み込む

API キーで SpaceXAI に接続するには xai-sdk パッケージを使います。各プロジェクトごとに環境を分け、他プロジェクトのパッケージと競合しないようにするのが良い実践です。ここでは Anaconda を使って次のコマンドを実行します。

conda create -yn grok-46 python=3.10
``` 
This creates an environment named grok-46 that we can activate using:
```bash
conda activate grok-46

環境を有効化したら、必要なパッケージをインストールします。まずは次の 2 つから始めます。

• xai-sdk：SpaceXAI の API にリクエストを送るための公式パッケージ。

• python-dotenv：.env ファイルから API キーを手軽に読み込むためのユーティリティ。

インストールは次のコマンドで行います。

pip install xai-sdk python-dotenv

Python で API キーを読み込み、SpaceXAI クライアントを作成する方法は次のとおりです。

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

このコードはまだリクエストを送っていません。次で学びます。

SpaceXAI の API クレジットを購入する

Grok 4.6 API を使うには、API プラットフォーム上でクレジットの購入も必要です。クレジットがないと API リクエストは拒否されます。サイドバー下部のCredits に移動し、Add credits をクリックして、希望額を追加してください。

Grok 4.6 の API 料金はどれくらい？

Grok 4.6 へのリクエストはトークン単位で課金されます。基本料金は入力 100 万トークンあたり $2、出力 100 万トークンあたり $6 です。

Grok 4.6 は推論モデルである点に注意が必要です。推論は自己対話として行われ、これもトークンを消費し、出力トークンとして課金されます。後ほど、リクエストごとにモデルの推論量を制御する方法を学びます。

キャッシュされたトークンは大幅に安く、100 万トークンあたり $0.5 のみです。

後述のとおり、Grok にはウェブ検索、X 検索、コード実行という 3 つの組み込みツールがあり、トークンとは別に課金されます。いずれも 1,000 コールあたり $5.00 です。

長い文脈では、プロンプトが 200K を超えると、プロンプト内のすべてのトークンが 2 倍レートで課金される点にも注意が必要です。

最初の Grok 4.6 API コールを行うには？

先ほどのコードを基に、SpaceXAI クライアントで Grok 4.6 にリクエストを送ってみます。

Grok 4.6 にリクエストを送るには、client.chat.create() で grok-4.6 を対象としたチャットセッションを初期化し、chat.append(user()) でプロンプトを会話履歴に追加します。

最後に chat.sample() を呼ぶと会話がモデルへ送信され、応答が生成されます。response.content を print して表示します。

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import user

load_dotenv()

client = Client()

chat = client.chat.create(model="grok-4.6")
chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

response = chat.sample()
print(response.content)

この使い方では、応答は一度にまとめて返って来ます。つまり、Grok が全出力を生成し終えるまで待つ必要があります。ストリーミングを使えば、単語ごとの返信を受け取れます。

レスポンスのストリーミング

chat.sample() で完全な応答を待つ代わりに、chat.stream() を使ってモデルの出力をリアルタイムで受け取れます。

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

このコードはストリームを反復し、到着したテキスト片（chunk.content）を逐次コンソールに出力します。トークン単位のストリーミングで、応答が即座に見える体験になります。

ただし、実行すると最初のトークンが出始めるまで少し時間がかかるのに気づきます。これは Grok 4.6 が推論モデルであるためです。既定では、最終回答の最初の語を出す前に、内部の「チェーン・オブ・ソート」推論段階を経ます。

上のコードを更新し、モデルの推論過程も表示するようにできます。

# … Same code as before

chat.append(user("Explain how the Transformer attention mechanism works using a simple analogy."))

print("--- Reasoning ---")
is_first_content = True

for response, chunk in chat.stream():
    if chunk.reasoning_content:
        print(chunk.reasoning_content, end="", flush=True)
    if chunk.content:
        if is_first_content:
            print("\n\n--- Response ---")
            is_first_content = False
        print(chunk.content, end="", flush=True)

print()

このスニペットに続く Grok 4.6 のストリームは 2 種類のトークンを返します。

• モデル内部のチェーン・オブ・ソートのトークン
• 最終回答

このスクリプトは、chunk.reasoning_content を確認して段階的な思考過程を先にストリームし、最終応答が始まったら chunk.content を出力することで両者を区別します。

Grok 4.6 の推論労力を設定するには？

前述のとおり、他のフロンティア AI モデル同様、Grok 4.6 は不可視のチェーン・オブ・ソートに依存します。最終回答の最初の語を出す前に、解法の探索、論理の再確認、自己修正のため何千もの推論トークンを生成します。

reasoning_effort パラメータで、この推論過程にどれだけ労力を割くかを制御できます。最終回答だけでなく推論トークンにも課金されるため、コスト削減の観点から重要なパラメータです。

Grok 3 mini ではすでに reasoning_effort の調整が可能でしたが、Grok 4 ではその制御が削除され、常に推論が有効で調整不可でした。SpaceXAI は Grok 4.x 系（4.3 と 4.5）で制御を再導入し、Grok 4.6 でも low、medium、high（既定）、xhigh をサポートします。

推論労力を設定するには、client.chat.create() でチャットを初期化する際に reasoning_effort パラメータを指定します。値は希望する労力を表す文字列です。既定値は "high"。以下は "low" に設定する例です。

chat = client.chat.create(
    model="grok-4.6",
    reasoning_effort="low"
)

同一プロンプトで low と high を比較

low と high の両方で多数のタスクを試しました。たとえば簡単なゲームの作成、通貨表記が不揃いな給与データの分析スクリプト作成、論理パズルの解答などです。

いずれの場合も、モデルは low／high どちらでも同程度の解法を提示できました。

差が出るのは、推論の途中で打ち切ると失敗するタスクです。そこで多数の解があるパズルに切り替えました。使用したプロンプトは次のとおりです。

Solve the following alphametic puzzle, in which each letter represents a unique digit from 0 to 9. The leading digits cannot be zero.

GROK + DATA = CAMP

Provide a list of all solutions. For each solution, show a single line with the final addition to prove it works.

両方の推論レベルで Grok 4.6 は正しい解を見つけました。しかし low では推論予算が途中で尽き、タスク完了前に応答が切れて不完全な結果になりました。high では 264 通りすべての解を見つけました。

比較として、low では推論トークンを 16,422 個使用、high では 56,455 個使用しました。

xhigh はいつ追加トークンの価値があるか？

high 設定で複雑な論理パズルやデータ解析スクリプトを総当りで解けるなら、xhigh の大量トークンを支払う必要があるでしょうか？

日常のプログラミングやデータサイエンスの 99% では、xhigh は過剰で API 予算を浪費するだけだと考えます。

ただし、コーディング支援としてではなく自律エージェントとして動かす場合は xhigh が不可欠になります。最終出力を見せる前に、自己レビューや行き止まりの探索、ロジックの書き直しを積極的に行わせるためのコストを支払うイメージです。

まずは low で始め、モデルが系統的に失敗する場合のみ段階的に上げるのがよいでしょう。同じ課題に複数回分の費用がかかるケースもありますが、たいていはコストの一部で十分な解に到達できます。

Grok 4.6 API に画像を送る方法は？

Grok 4.6 はマルチモーダルで、画像データを扱えます。

URL で画像を送る

最も手軽なのは URL を使う方法です。ユーザーメッセージの第 2 引数として渡せます。

from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import image, user

load_dotenv()
client = Client()

chat = client.chat.create(model="grok-4.6")

image_url = "https://images.pexels.com/photos/25810993/pexels-photo-25810993.jpeg"

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=image_url),
    )
)

for response, chunk in chat.stream():
    print(chunk.content, end="", flush=True)

print()

ファイルアップロードで画像を送る

URL ではなくローカルの画像を使いたい場面もよくあります。これは画像を base64 文字列として読み込むことで可能です。encode_image() 関数がその処理を行えます。

import base64
import mimetypes

def encode_image(image_path: str) -> str:
    mime_type, _ = mimetypes.guess_type(image_path)
    if not mime_type:
        mime_type = "image/jpeg"
    with open(image_path, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
    return f"data:{mime_type};base64,{encoded_string}"

画像をエンコードしたら、先ほどと同じ方法でモデルに渡します。

chat.append(
    user(
        "Describe what you see in this image in detail.",
        image(image_url=encode_image("image.png")),
    )
)

画像入力に対応していても、Grok 4.6 の出力はテキストのみです。SpaceXAI の画像生成について詳しく知るには、Grok Imagine API のチュートリアルをご覧ください。

Grok 4.6 のエージェントでツールを有効化するには？

Grok 4.6 は 3 つの有用なサーバーサイドツールへアクセスでき、カスタムツールの作成も可能です。

サーバーサイドツールを呼び出す（ウェブ検索、X 検索、コード実行）

Grok 4.6 には 3 つのサーバーツールが組み込まれています。

• ウェブ検索：回答の裏付けのためにウェブ検索を実行。
• X 検索：X のリアルタイムなプラットフォームデータを照会。
• コード実行：サンドボックスでコードを実行し、質問への回答を支援。

これらのツールは SpaceXAI のサーバー上で実行され、各ツールコールはトークンとは独立して課金されます。

有効化するには、インポートして client.chat.create() でチャットを作成する際に渡します。

from xai_sdk.tools import code_execution, web_search, x_search
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution()],
)

レスポンスをストリームする際、chunk.tool_calls フラグを確認するとエージェントがツールを使用しているか分かります。

ストリーミング応答を処理し、エージェントがツールを使っているタイミングをユーザーに示すコードは次のとおりです。

for response, chunk in chat.stream():
    for tool_call in chunk.tool_calls:
        print(f"\n--> Agent is calling tool: {tool_call.function.name}\n", flush=True)
    if chunk.content:
        print(chunk.content, end="", flush=True)

サーバーツールの完全なサンプルスクリプトは、併設の GitHub リポジトリにあります。

カスタムのローカルツールを実装する

上記のサーバーツールに加えて、カスタムツール を使って Grok 4.6 エージェントを拡張できます。ここではローカルファイルの読み書きを可能にするツールの実装方法を見ていきます。

カスタムツールの実装には次の 2 点が必要です。

1. SpaceXAI SDK の公式 tool() オブジェクトを使ったツール仕様。

2. ツールの Python 実装。すなわちツール呼び出し時に実行したいコード。

ツール仕様は以下から構成されます。

• 呼び出す Python 関数の名前
• ツールの動作を説明する説明。これは重要で、エージェントがツールを呼ぶ判断に影響します。
• 関数のパラメータ仕様

次はローカルファイルを読み取るツールを実装する関数です。

def execute_read_file(file_path: str) -> str:
    print(f"\n🔒 [Permission Request] Grok wants to read local file: '{file_path}'")
    confirm = input("Allow access? [y/N]: ").strip().lower()
    if confirm not in ("y", "yes"):
        print(f"❌ Denied access to '{file_path}'")
        return f"Permission denied by user. Access to file '{file_path}' was not granted."

    if not os.path.exists(file_path):
        return f"Error: File '{file_path}' does not exist."

    try:
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()
        print(f"✅ Read {len(content)} characters from '{file_path}'\n")
        return content
    except Exception as e:
        return f"Error reading file '{file_path}': {e}"

安全のため、読み取り前に必ずユーザーへ許可を求める実装にしています。これにより、機密データを誤ってエージェントに提供することを防げます。

この関数のツール仕様は次のとおりです。

from xai_sdk.chat import tool
read_file_tool = tool(
    name="read_local_file",
    description="Reads the text contents of a local file given its relative or absolute path. Use this whenever the user asks to inspect, summarize, or analyze a local file.",
    parameters={
        "type": "object",
        "properties": {
            "file_path": {
                "type": "string",
                "description": "The path to the local file to read.",
            }
        },
        "required": ["file_path"],
    },
)

ファイルへの書き込みコードは類似で、リポジトリ内の tools.py にあります。

Grok 4.6 でツールを使うエージェントループを動かすには？

ここではこれまで学んだことを組み合わせ、オンライン検索で裏取りをしつつローカルファイルに対して実作業を行える Grok 4.6 のエージェントループを構築します。

エージェントの動作は下図のとおりです。ユーザーがプロンプトを送ると、必要に応じてツールを使って応答します。回答はユーザーへ返り、ユーザーは引き続きエージェントとやり取りできます。

エージェントは chat.append() でユーザープロンプト、応答、ツール結果を会話に追加し、全体の会話を保持します。ツール結果は tool_result() のインスタンスでラップする必要があります。

エージェントの完全な実装は次のとおりです。

import json
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user
from xai_sdk.tools import code_execution, web_search, x_search
from tools import (
    execute_read_file,
    execute_write_file,
    read_file_tool,
    write_file_tool,
)

load_dotenv()

# 1. Initialize the chat client with both server-side and client-side tools
client = Client()
chat = client.chat.create(
    model="grok-4.6",
    tools=[web_search(), x_search(), code_execution(), read_file_tool, write_file_tool],
)

# 2. Interactive chat loop
while True:
    try:
        prompt = input("> ")
    except (EOFError, KeyboardInterrupt):
        print()
        break

    if not prompt.strip():
        continue
    if prompt.strip().lower() in ("exit", "quit"):
        break

    # Append the user prompt to the conversation
    chat.append(user(prompt))

    # Agent loop: keeps running until Grok finishes (no further client tool calls)
    print("How can I help you?\n")
    while True:
        response = None
        announced_tools = set()
        started_content = False

        for response, chunk in chat.stream():
            # Announce tool calls
            if chunk.tool_calls:
                for tc in chunk.tool_calls:
                    name = getattr(tc.function, "name", "")
                    tc_id = getattr(tc, "id", None) or name
                    if tc_id and tc_id not in announced_tools:
                        announced_tools.add(tc_id)
                        display_name = name or "tool"
                        print(f"\n⚙️  [Agent Tool] Calling: {display_name}...", flush=True)

            # Stream generated content
            if chunk.content:
                if not started_content:
                    print("\nGrok > ", end="", flush=True)
                    started_content = True
                print(chunk.content, end="", flush=True)

        if response:
            chat.append(response)

        # Check if Grok triggered client-side tools
        client_tool_executed = False
        if response and response.tool_calls:
            for tool_call in response.tool_calls:
                fn_name = tool_call.function.name
                if fn_name == "read_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                    except Exception:
                        file_path = tool_call.function.arguments or ""
                    
                    result = execute_read_file(file_path)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

                elif fn_name == "write_local_file":
                    client_tool_executed = True
                    try:
                        args = json.loads(tool_call.function.arguments)
                        file_path = args.get("file_path", "")
                        content = args.get("content", "")
                    except Exception:
                        file_path = ""
                        content = ""
                    
                    result = execute_write_file(file_path, content)
                    chat.append(tool_result(result, tool_call_id=tool_call.id))

        # If Grok called a client-side tool, re-enter the loop so Grok processes the tool result
        if client_tool_executed:
            continue
        
        break

    print("\n")

株式ポートフォリオ分析で Grok 4.6 エージェントをテストする

テスト用にサンプルの株式ポートフォリオ CSV を用意しました。銘柄名、購入日、購入価格などを記載したシンプルなファイルです。

エージェントへの依頼内容は以下のとおりです。

1. CSV ファイルを読み込む。
2. 各銘柄の現在価格を取得するためにウェブ検索を行う。
3. 現在価格の新しい列を追加して CSV を更新する。
4. セクターの最新動向を示すポートフォリオレポートを作成してもらう。

以下はステップ 1〜3 におけるエージェントとのやり取りのスクリーンショットです。

ウェブ検索、コード実行、作成したカスタムツール（ローカルファイルの読み書き）を用いたことが分かります。最終的に、現在の株価列を追加して CSV ファイルを更新できました。

ループで動作するため、会話は継続できます。次のやり取りでは、該当銘柄のニュース調査、ポートフォリオの分散分析、Markdown レポートの作成を依頼しました。

作成されたレポートに興味があれば、GitHub リポジトリをご覧ください。

株式ポートフォリオの分析といった実務的なタスクでエージェントを試すと、Grok 4.6 の実力がよく分かります。ウェブ検索、コード実行、ローカルツールの自動活用により、複雑な依頼も難なくこなします。

プロンプトキャッシュと 200k 価格の断崖

マルチターンのエージェントを実装する際は、会話がキャッシュされ、各ターンで履歴すべてを再処理しなくて済むようにする必要があります。これを怠ると巨大なコストが発生し得ます。

キャッシュは自動で行われますが、キャッシュ項目はサーバー単位で保存され、既定ではリクエストが異なるサーバーへルーティングされてキャッシュミスが起きる可能性があります。キャッシュヒットを最大化するには、会話を一意に識別できる安定した ID を付与し、会話内のすべてのリクエストが同一サーバーに届くようにします。指定方法は API によって異なります。

• xai-sdk（gRPC）：クライアント初期化時の gRPC メタデータで x-grok-conv-id を渡す

• OpenAI Responses API：リクエストボディで prompt_cache_key を設定

以下のスニペットで方法を示します。

import uuid
from dotenv import load_dotenv
from xai_sdk import Client
from xai_sdk.chat import tool_result, user

load_dotenv()

# 1. Generate a unique ID for the conversation loop
conv_id = str(uuid.uuid4()) 

# 2. Pass the ID when initializing the Client
client = Client(
    metadata=(("x-grok-conv-id", conv_id),)
)

# ... [the rest of the code remains the same]

重要な注意点として、会話が長くなるほど金銭的な影響が深刻になります。合計プロンプト長が 200k トークンに到達・超過すると、API は 2 倍係数を適用し、そのリクエスト全体を標準レートの 2 倍で課金します。

この 200k のしきい値をマルチターンで越えないように、コンテキストの圧縮を実装することを強く推奨します。具体的には、古いターンを定期的に要約する、あるいはコンテキストウィンドウをスライドさせます。これにより、主要な指示に対する安価なキャッシュヒットの恩恵を維持しつつ、際限なく肥大化するコンテキストウィンドウによる高額課金を回避できます。

まとめ

本チュートリアルでは、Python から SpaceXAI API を使って Grok 4.6 と対話する方法を学びました。テキストと画像のプロンプト送信の基本、モデルが何をしているかをユーザーに示すための出力処理も扱いました。

さらに、AI モデルへツールを提供する方法を学び、それらを組み合わせて、Grok 4.6 を使って株式ポートフォリオの分析といった実タスクを解ける AI エージェントを構築しました。最後に、長いコンテキストのタスクはキャッシュを使わないと非常に高価になり得ることも確認しました。

演習として、本稿で学んだ内容を踏まえ、エージェントにキャッシュを実装し、推論トークンも表示するよう出力を更新してみてください。

API を用いた AI エージェント構築をさらに深めたい場合は、Working with the OpenAI API コース をおすすめします。AI エージェントを体系的に学ぶなら AI Agent Fundamentals スキルトラック が最適です。