Grok 4.6 API: 첫 호출부터 도구 활용 에이전트까지

SpaceXAI의 최신 프런티어 모델을 활용해 지능형 도구형 에이전트를 처음부터 구축하세요. 기본 API 설정부터 프롬프트 캐싱과 커스텀 도구를 갖춘 완전 자율 루프 배포까지 모두 다룹니다.

업데이트됨 2026년 8월 24일 · 14분 읽다

AI로 탐색하기

이달 초 SpaceXAI가 최신 프런티어 AI 모델 Grok 4.6을 출시했습니다. 합리적인 가격대로 프런티어급 성능을 제공하며, 각 작업에 할당되는 추론 예산을 개발자가 제어할 수 있습니다.

이 가이드에서는 주식 포트폴리오 분석과 같은 실제 과제를 해결할 수 있는 Grok 4.6 AI 에이전트를 만드는 방법을 배웁니다. 이 에이전트는 웹 검색, 코드 실행, 파일 읽기/쓰기를 자율적으로 수행할 수 있습니다.

Grok 4.6의 벤치마크와 Grok 4.5 및 다른 프런티어 모델과의 비교에 대한 전체 분석은 우리의 Grok 4.6 가이드를 참고하세요.

Grok 4.6 API란?

Grok 4.6은 SpaceXAI의 최신 프런티어 모델로, 코딩, 지식 업무, 장시간 에이전트형 작업에 최적화되어 있습니다. 텍스트와 이미지 입력을 모두 지원하지만 출력은 텍스트만 지원합니다.

이 모델은 grok-4.6 식별자로 제공됩니다. 최대 500,000토큰의 컨텍스트 윈도우를 지원합니다. 다만 200,000토큰을 초과하는 요청의 경우, 프롬프트가 200,000토큰에 도달하면 해당 프롬프트의 모든 토큰이 표준 요금의 두 배로 청구됩니다. 이에 대해서는 뒤에서 더 자세히 다룹니다.

Grok 4.6 통합 시 SpaceXAI는 대화 이력을 처리하는 두 가지 방식을 제공합니다.

Responses API는 SpaceXAI가 권장하는 네이티브 아키텍처입니다. 이전 프롬프트, 추론, 모델 응답을 최대 30일 동안 SpaceXAI 서버에 저장해 상태 기반 상호작용을 선택적으로 활성화합니다. 매 요청마다 전체 대화 이력을 재전송하는 대신 진행 중인 response ID에 새 메시지만 추가하면 되므로, 장문맥 에이전트 루프가 크게 단순해집니다.
기존 애플리케이션을 마이그레이션하는 개발자를 위해, OpenAI SDK 호환을 통한 전통적인 Chat Completions도 상태 비저장 드롭인 대체재로 제공합니다.

Python에서 Grok 4.6 API를 어떻게 설정하나요?

시작하려면 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

환경을 활성화한 뒤, 필요한 패키지를 설치합니다. 우선 다음부터 시작해봅시다:

xai-sdk: SpaceXAI의 API 요청에 사용하는 공식 패키지입니다.
python-dotenv: .env 파일에서 API 키를 손쉽게 로드하도록 도와주는 유틸리티 패키지입니다.

설치는 다음 명령으로 진행합니다:

pip install xai-sdk python-dotenv

아래는 API 키를 로드하고 Python에서 SpaceXAI Client를 생성하는 방법입니다:

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를 클릭하고 원하는 금액을 추가하세요.

API로 사용하는 Grok 4.6의 비용은 어느 정도인가요?

Grok 4.6에 대한 청구는 토큰 단위입니다. 기본 요금은 입력 토큰 100만 개당 $2, 출력 토큰 100만 개당 $6입니다.

Usage	Price
Input tokens	$2 / 1M tokens
Output tokens (includes reasoning tokens)	$6 / 1M tokens
Cached input tokens	$0.50 / 1M tokens
Server-side tools (web search, X search, code execution)	$5 / 1,000 calls
Prompts above 200K tokens	표준 토큰 요금의 2배

Grok 4.6은 추론 모델이라는 점이 중요합니다. 모델은 내부 자기 대화 형태로 추론을 수행하며, 이 과정에서도 토큰이 소비되고 출력 토큰으로 청구됩니다. 이후에 특정 요청에 대해 모델이 수행하는 추론 양을 제어하는 방법을 학습합니다.

캐시된 토큰은 훨씬 저렴하며, 100만 토큰당 $0.5만 청구됩니다.

앞서 보듯이, Grok에는 토큰과는 별도로 과금되는 기본 제공 도구가 세 가지 있습니다: 웹 검색, X 검색, 코드 실행. 모두 1,000회 호출당 $5.00입니다.

장문맥의 경우, 프롬프트가 200K를 초과하면 해당 프롬프트의 모든 토큰이 두 배 요금으로 청구된다는 점을 유의하세요.

첫 Grok 4.6 API 호출은 어떻게 하나요?

앞서 작성한 코드를 바탕으로 SpaceXAI 클라이언트를 사용해 Grok 4.6에 요청을 보내보겠습니다.

요청을 보내려면 client.chat.create()로 grok-4.6을 대상으로 채팅 세션을 초기화하고, chat.append(user())로 프롬프트를 대화 이력에 추가합니다.

마지막으로 chat.sample()을 호출하면 모델이 응답을 생성하고, response.content를 출력해 확인합니다.

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이 추론 모델이기 때문입니다. 기본적으로 최종 답변의 첫 단어를 생성하기 전에 내부적인 "chain-of-thought" 추론 단계를 거칩니다.

위 코드를 업데이트하여 모델의 추론 과정도 함께 표시할 수 있습니다:

# … 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 스트림은 두 종류의 토큰을 제공합니다:

모델의 내부 chain-of-thought 토큰
최종 답변

이 스크립트는 chunk.reasoning_content를 확인해 단계별 사고 과정을 먼저 스트리밍하고, 최종 응답이 시작되면 chunk.content를 출력하는 방식으로 둘을 구분합니다.

Grok 4.6에서 추론 노력(reasoning_effort)은 어떻게 설정하나요?

앞서 보았듯 다른 프런티어 AI 모델과 마찬가지로 Grok 4.6은 숨겨진 chain-of-thought에 의존합니다. 최종 답변의 첫 단어를 출력하기 전에, 해결 방안 탐색, 논리 재검토, 자체 오류 수정 등을 위해 수천 개의 추론 토큰을 생성합니다.

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 vs 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로 설정했을 때는 추론 예산이 작업 완료 전에 소진되어 불완전한 해를 반환했습니다. 높은 추론에서는 Grok 4.6이 264개 전체 해를 찾았습니다.

비교를 위해, low에서는 추론 토큰 16,422개를 사용했고, high에서는 56,455개를 사용했습니다.

xhigh는 언제 추가 토큰 값을 할 만한가요?

높은 설정만으로도 복잡한 논리 퍼즐이나 데이터 파싱 스크립트를 힘으로 밀어붙여 해결할 수 있는데, 왜 xhigh의 막대한 토큰 소모 비용을 지불해야 할까요?

일상적인 프로그래밍과 데이터 사이언스 작업의 99%에서는 xhigh는 과한 설정으로, API 예산만 빠르게 소모할 것입니다.

하지만 모델에 코딩 보조가 아닌 자율 에이전트 역할을 요구하는 순간 xhigh는 필수에 가깝습니다. 최종 출력을 보여주기 전에 모델이 자신의 작업을 강도 높게 검토하고, 막다른 길을 겪고, 논리를 다시 작성하도록 비용을 지불하는 셈입니다.

권장 사항은 low로 시작하고, 모델이 반복적으로 실패하는 작업에서만 점진적으로 높이는 것입니다. 경우에 따라 같은 문제에 여러 번 비용을 지불하게 될 수는 있지만, 대부분은 비용의 일부만 내고도 충분히 좋은 해법을 얻습니다.

Grok 4.6 API로 이미지를 어떻게 보낼 수 있나요?

Grok 4.6은 멀티모달이며 이미지 데이터를 처리할 수 있습니다.

URL로 이미지 보내기

모델에 이미지를 제공하는 가장 쉬운 방법은 URL을 사용하는 것입니다. 사용자 메시지의 두 번째 인수로 제공할 수 있습니다:

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은 유용한 서버 측 도구 세 가지에 접근할 수 있으며, 커스텀 도구 생성도 지원합니다.

서버 측 도구 호출(웹 검색, X 검색, 코드 실행)

Grok 4.6에는 다음과 같은 서버 도구가 기본 탑재되어 있습니다:

웹 검색: 답변을 근거화하기 위해 웹 검색을 수행합니다.
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 에이전트에 커스텀 도구를 장착할 수 있습니다. 에이전트가 로컬 파일을 읽고 쓰게 하는 도구를 구현해 보겠습니다.

커스텀 도구 구현에는 두 가지가 필요합니다:

SpaceXAI SDK의 공식 tool() 객체를 사용한 도구 스펙
도구의 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 파일을 만들었습니다. 이 파일은 비교적 단순하며, 종목과 특히 매수일 및 매수가를 보여줍니다.

에이전트에게 아래 작업을 요청합니다:

CSV 파일을 불러온다.
웹 검색으로 각 종목의 현재가를 가져온다.
현재가 열을 새로 추가해 CSV를 업데이트한다.
해당 섹터의 최신 동향을 보여주는 포트폴리오 보고서를 작성한다.

아래는 1~3단계에 대한 에이전트와의 상호작용 스크린샷입니다.

웹 검색, 코드 실행, 우리가 만든 커스텀 도구(로컬 파일 읽기/쓰기)를 모두 사용했음을 확인할 수 있습니다. 최종적으로 현재 주가 열을 추가하여 CSV 파일이 업데이트되었습니다.

에이전트는 루프에서 동작하므로 대화를 이어갈 수 있습니다. 다음 상호작용에서는 해당 종목 관련 뉴스를 찾아보고 포트폴리오 다양성을 분석한 뒤, 마크다운 보고서를 작성하도록 요청했습니다.

생성된 보고서가 궁금하다면 GitHub 저장소에서 확인할 수 있습니다.

주식 포트폴리오 분석처럼 실제 과제에 에이전트를 적용해 보면 Grok 4.6의 역량이 분명히 드러납니다. 웹 검색, 코드 실행, 로컬 도구를 스스로 활용해 복잡한 요청도 수월하게 처리합니다.

프롬프트 캐싱과 200k 가격 절벽

멀티 턴 에이전트를 구현할 때는 매 상호작용마다 전체 이력을 다시 처리하지 않도록, 대화가 캐시되도록 해야 합니다. 이를 하지 않으면 비용이 크게 불어날 수 있습니다.

캐싱은 자동으로 이뤄지지만, 캐시 항목은 서버별로 저장되며 기본적으로 요청이 서로 다른 서버로 라우팅되어 캐시를 놓칠 수 있습니다. 캐시 적중률을 극대화하려면 안정적인 대화 식별자를 제공하여 동일 대화의 모든 요청이 같은 서버로 가도록 해야 합니다. 전달 방법은 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배 승수를 적용해 전체 요청을 표준 요금의 두 배로 청구합니다.

멀티 턴 루프가 200k 임계치를 넘지 않도록 하려면 컨텍스트 압축을 구현하는 것이 강력히 권장됩니다. 오래된 대화 턴을 주기적으로 요약하거나 컨텍스트 윈도우를 슬라이딩하는 방식입니다. 이렇게 하면 핵심 지침에 대해서는 저렴한 캐시 적중의 이점을 유지하면서, 끝없이 커지는 컨텍스트 윈도우로 인한 심각한 비용 패널티를 피할 수 있습니다.