Grok 4.6 API: จากการเรียกครั้งแรกสู่เอเจนต์ที่ใช้เครื่องมือได้

ตั้งค่า Grok 4.6 API บน Python อย่างไร?

เริ่มต้นจะต้องมีคีย์ API ของ SpaceXAI และติดตั้ง xai-sdk ก่อน

ขอคีย์ API จาก console.x.ai

ในการสร้างคีย์ API ของ Grok 4.6 ให้ไปที่ หน้าสร้างคีย์ API บนคอนโซล SpaceX AI จากนั้นคลิกปุ่ม Create API Key มุมขวาบน

แบบฟอร์มสร้างคีย์ API ใช้งานไม่ยาก ตั้งชื่อคีย์เพื่อให้รู้ว่าเป็นของโปรเจกต์ใด นอกจากนี้ แนะนำให้ตั้งวันหมดอายุของคีย์ API เสมอเพื่อป้องกันความเสี่ยงหากคีย์รั่วไหล

เมื่อสร้างคีย์แล้ว ให้คัดลอกไปวางลงในไฟล์ชื่อ .env ที่สร้างไว้ในโฟลเดอร์เดียวกับที่เขียนสคริปต์ Python วิธีนี้ช่วยให้โหลดคีย์ในสคริปต์ได้ง่าย โดยไม่ต้องเก็บคีย์ไว้ในไฟล์โค้ด ซึ่งอาจเผลอทำให้คีย์รั่วเมื่อแชร์หรืออัปโหลดโค้ดขึ้นคลาวด์

ไฟล์ .env ควรมีเนื้อหาดังนี้:

XAI_API_KEY=replace_with_the_api_key

ติดตั้ง xai-sdk และโหลดคีย์ API ของ SpaceXAI

ในการเชื่อมต่อกับ SpaceXAI ด้วยคีย์ API ให้ใช้แพ็กเกจ xai-sdk ควรสร้างสภาพแวดล้อมแยกต่อโปรเจกต์เพื่อป้องกันแพ็กเกจ Python ชนกับโปรเจกต์อื่น ๆ เราจะใช้ 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: ยูทิลิตีช่วยโหลดคีย์ API จากไฟล์ .env

ติดตั้งด้วยคำสั่ง:

pip install xai-sdk python-dotenv

โค้ดด้านล่างแสดงวิธีโหลดคีย์ API และสร้าง SpaceXAI Client ใน Python:

from dotenv import load_dotenv
from xai_sdk import Client

load_dotenv()

client = Client()

สังเกตว่าโค้ดนี้ยังไม่ส่งคำขอ เราจะเรียนรู้วิธีทำในหัวข้อต่อไป

ซื้อเครดิต API ของ SpaceXAI

ในการใช้ Grok 4.6 API ต้องซื้อเครดิตบนแพลตฟอร์ม API ของพวกเขาด้วย มิฉะนั้นคำขอจะถูกปฏิเสธ ให้ไปที่เมนู Credits ด้านล่างของแถบด้านข้าง คลิก Add credits แล้วเพิ่มจำนวนที่ต้องการ

Grok 4.6 ผ่าน API มีค่าใช้จ่ายเท่าไร?

การเรียกใช้ Grok 4.6 คิดค่าบริการตามจำนวนโทเค็น ราคาพื้นฐานคือ $2 ต่อโทเค็นอินพุตหนึ่งล้าน และ $6 ต่อโทเค็นเอาต์พุตหนึ่งล้าน

ควรทราบว่า Grok 4.6 เป็นโมเดลเชิงให้เหตุผล การให้เหตุผลทำในรูปแบบบทสนทนาภายในและใช้โทเค็นเช่นกัน ซึ่งคิดเป็นโทเค็นเอาต์พุต เราจะเรียนรู้ภายหลังถึงวิธีควบคุมปริมาณการให้เหตุผลของโมเดลในแต่ละคำขอ

โทเค็นที่แคชมีราคาถูกกว่ามาก เพียง $0.5 ต่อหนึ่งล้านโทเค็น

ดังที่เราจะเห็น Grok มีเครื่องมือในตัวสามอย่างที่คิดค่าบริการแยกจากโทเค็น ได้แก่ การค้นเว็บ การค้นหา X และการรันโค้ด ทั้งหมดราคา $5.00 ต่อ 1,000 ครั้งเรียก

สำหรับบริบทยาว โปรดทราบว่าโทเค็นทั้งหมดในพรอมต์ที่เกินเกณฑ์ 200K จะถูกคิดราคาสองเท่า

เรียก Grok 4.6 API ครั้งแรกอย่างไร?

มาสานต่อจากโค้ดก่อนหน้าเพื่อใช้ไคลเอนต์ SpaceXAI ส่งคำขอไปยัง Grok 4.6

ในการส่งคำขอไปยัง Grok 4.6 ให้เริ่มแชตที่กำหนดเป้าหมาย grok-4.6 ด้วย client.chat.create() และเพิ่มพรอมต์ของเราลงในประวัติการสนทนาด้วย 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 แบบนี้ เราจะได้รับคำตอบทีเดียวทั้งหมด จึงต้องรอจนกว่า 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 เพื่อสตรีมกระบวนการคิดทีละขั้นของ Grok ก่อน จากนั้นจึงพิมพ์ chunk.content เมื่อคำตอบสุดท้ายเริ่มต้น

ตั้งค่าระดับการให้เหตุผลใน Grok 4.6 ได้อย่างไร?

ดังที่เห็นข้างต้น เช่นเดียวกับโมเดล 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

การตั้งค่าระดับการให้เหตุผลทำได้โดยระบุพารามิเตอร์ reasoning_effort ตอนเริ่มแชตด้วย client.chat.create() ค่านี้เป็นสตริงที่ระบุระดับที่ต้องการ ค่าเริ่มต้นคือ "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 Grok 4.6 พบครบทั้ง 264 วิธีแก้

เพื่อเปรียบเทียบ ระดับ low ใช้โทเค็นการให้เหตุผล 16,422 โทเค็น ในขณะที่ระดับ high ใช้ 56,455 โทเค็น

เมื่อใดที่ xhigh คุ้มกับโทเค็นที่ใช้เพิ่ม?

หากการตั้งค่า high สามารถบุกตะลุยปริศนาตรรกะซับซ้อนและสคริปต์แยกข้อมูลได้สำเร็จ เหตุใดจึงต้องยอมจ่ายกับการใช้โทเค็นจำนวนมากของ 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 repo ที่แนบมา

สร้างเครื่องมือโลคัลแบบกำหนดเอง

นอกเหนือจากเครื่องมือฝั่งเซิร์ฟเวอร์ เราสามารถติดตั้ง เครื่องมือแบบกำหนดเอง ให้เอเจนต์ Grok 4.6 ได้ มาดูวิธีสร้างเครื่องมือที่ให้อ่านและเขียนไฟล์โลคัล

การสร้างเครื่องมือแบบกำหนดเองต้องมีสองส่วน:

1. สเปกของเครื่องมือโดยใช้วัตถุ tool() อย่างเป็นทางการจาก SpaceXAI SDK

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 จาก repository

รันลูปเอเจนต์ที่ใช้เครื่องมือกับ 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 โดยเพิ่มคอลัมน์ราคาหุ้นล่าสุด

เนื่องจากเอเจนต์ทำงานเป็นลูป เราจึงสนทนาต่อได้ ในการโต้ตอบถัดมา ฉันให้ค้นหาข่าวที่เกี่ยวข้องกับหุ้นเหล่านี้ วิเคราะห์ความหลากหลายของพอร์ต และสร้างรายงานแบบมาร์กดาวน์

หากอยากดูรายงานที่สร้างไว้ อยู่ใน GitHub repository

การทดสอบเอเจนต์กับงานในโลกจริงอย่างการวิเคราะห์พอร์ตหุ้น ทำให้เห็นศักยภาพของ Grok 4.6 อย่างแท้จริง ด้วยการค้นเว็บ รันโค้ด และใช้เครื่องมือโลคัลได้เอง โมเดลจึงรับมือคำขอซับซ้อนได้อย่างง่ายดาย

การแคชพรอมต์และหน้าผาราคา 200k

เมื่อสร้างเอเจนต์แบบหลายรอบสนทนา ควรทำให้การสนทนาถูกแคช เพื่อที่โมเดลจะไม่ต้องประมวลผลประวัติทั้งหมดซ้ำทุกรอบ มิฉะนั้นค่าใช้จ่ายอาจสูงมาก

การแคชเกิดขึ้นอัตโนมัติ แต่เอนทรีแคชถูกเก็บแยกตามเซิร์ฟเวอร์ และโดยปริยายคำขออาจถูกส่งไปคนละเซิร์ฟเวอร์และพลาดแคช เพื่อเพิ่มอัตราการถูกแคช เราควรระบุตัวตนการสนทนาที่คงที่ เพื่อให้คำขอทั้งหมดในบทสนทนาไปถึงเซิร์ฟเวอร์เดียวกัน วิธีส่งค่าขึ้นกับ API ที่ใช้:

• xai-sdk (gRPC): x-grok-conv-id ส่งเป็นเมทาดาทา gRPC ตอนเริ่มต้นไคลเอนต์

• 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 ควรทำการย่อบริบทอย่างสม่ำเสมอ โดยสรุปบทสนทนารอบเก่าเป็นระยะ หรือเลื่อนหน้าต่างบริบท วิธีนี้ช่วยให้ได้ประโยชน์จากแคชราคาถูกบนคำสั่งหลัก ขณะหลีกเลี่ยงค่าปรับรุนแรงจาก หน้าต่างบริบท ที่โตไม่หยุด

สรุป

ในบทความสอนนี้ เราได้เรียนรู้การใช้ SpaceXAI API กับ Python เพื่อโต้ตอบกับ Grok 4.6 เราได้เรียนรู้พื้นฐานการส่งพรอมต์ข้อความและรูปภาพ และจัดการเอาต์พุตเพื่อให้ผู้ใช้ทราบว่าโมเดลกำลังทำอะไรอยู่

เมื่อเรียนรู้การให้เครื่องมือกับโมเดล AI เราก็นำทั้งหมดมารวมกันเพื่อสร้างเอเจนต์ AI ที่ใช้ Grok 4.6 แก้งานจริงได้ เช่น การวิเคราะห์พอร์ตหุ้น สุดท้ายเราได้เรียนรู้ว่างานบริบทยาวอาจมีค่าใช้จ่ายสูงมาก โดยเฉพาะหากไม่ใช้แคช

แบบฝึกหัดหนึ่งเพื่อทดสอบสิ่งที่เรียนมาคือ ลองเพิ่มการแคชในเอเจนต์ และอัปเดตเอาต์พุตให้แสดงโทเค็นการให้เหตุผลด้วย

หากต้องการ เพิ่มพูนความรู้เรื่องการสร้างเอเจนต์ AI ด้วย API แนะนำ คอร์ส Working with the OpenAI API จุดที่ดีที่สุดในการเจาะลึกเอเจนต์ AI คือ เส้นทางทักษะ AI Agent Fundamentals