บทช่วยสอน Kimi K2.6 API: สร้างผู้ช่วยค้นหางานด้วย AI

2. กำหนดค่าการตั้งค่าโปรเจ็กต์ 

เปิด Jupyter Notebook สร้างเซลล์ใหม่ และเพิ่มการอิมพอร์ตกับการตั้งค่าโปรเจ็กต์ที่ต้องใช้

import json
import os

import requests
from agents import Agent, AsyncOpenAI, ModelSettings, OpenAIChatCompletionsModel, RunConfig, Runner, function_tool, set_tracing_disabled
from IPython.display import Markdown, display
from pypdf import PdfReader

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

KIMI_MODEL = "kimi-k2.6"
KIMI_BASE_URL = "https://api.moonshot.ai/v1"
OLOSTEP_SEARCH_URL = "https://api.olostep.com/v1/searches"
OLOSTEP_SCRAPE_URL = "https://api.olostep.com/v1/scrapes"
MAX_AGENT_TURNS = 25


cv_path = "abid-resume.pdf"
preferences = """
Remote data science, AI writer, or technical writer roles in AI, machine learning, data science, or cloud.
Prefer technical content, tutorials, developer education, research writing, and AI product storytelling.
""".strip()


set_tracing_disabled(True)

ค่า KIMI_MODEL และ KIMI_BASE_URL บอกให้แอปใช้ Kimi K2.6 ผ่านเอ็นด์พอยต์ API ที่เข้ากันได้กับ OpenAI ของ Moonshot AI ส่วน URL ของ Olostep ใช้สำหรับค้นหางานสดและสกัดข้อมูลหน้ารายละเอียดงาน

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

ตัวแปร preferences ระบุประเภทงานที่เอเจนต์ควรค้นหา สามารถปรับให้เหมาะกับตำแหน่ง อุตสาหกรรม ทำเล ระดับอาวุโส หรือรูปแบบการทำงานที่ต้องการ

เราปิดการติดตาม (tracing) ด้วย set_tracing_disabled(True) เนื่องจาก tracing เป็นฟีเจอร์ของ OpenAI Agents SDK ที่เปิดใช้งานเป็นค่าเริ่มต้น โครงการนี้ใช้ Kimi ผ่านเอ็นด์พอยต์ที่เข้ากันได้กับ OpenAI จึงปิด tracing เพื่อให้การตั้งค่าโลคอลเรียบง่ายและหลีกเลี่ยงปัญหาที่เกี่ยวข้องกับผู้ให้บริการโมเดลภายนอก

3. เชื่อมต่อกับ Kimi K2.6 API

จากนั้นตั้งค่าไคลเอนต์ Kimi โดยใช้คีย์ API ที่บันทึกไว้ก่อนหน้าเป็นตัวแปรสภาพแวดล้อม

kimi_client = AsyncOpenAI(
   api_key=os.environ["MOONSHOT_API_KEY"],
   base_url=KIMI_BASE_URL,
)

โค้ดนี้สร้างไคลเอนต์ API สำหรับ Kimi โดยโหลด api_key จาก MOONSHOT_API_KEY และตั้งค่า base_url ให้ชี้ไปยังเอ็นด์พอยต์ที่เข้ากันได้กับ OpenAI ของ Moonshot AI

ต่อไป ห่อโมเดล Kimi เพื่อใช้งานภายใน OpenAI Agents SDK ได้:

kimi_model = OpenAIChatCompletionsModel(
   model=KIMI_MODEL,
   openai_client=kimi_client,
)

จากนั้นกำหนดค่าการตั้งค่าโมเดล:

model_settings = ModelSettings(
   tool_choice="auto",
   parallel_tool_calls=True,
   extra_body={"thinking": {"type": "disabled"}},
)

การตั้งค่า tool_choice="auto" อนุญาตให้เอเจนต์ตัดสินใจเองว่าจะเรียกใช้เครื่องมือเมื่อใด การตั้งค่า parallel_tool_calls=True อนุญาตให้เอเจนต์เรียกใช้เครื่องมือหลายตัวพร้อมกันเมื่อจำเป็น

เรายังปิดโหมดคิดของ Kimi ด้วย extra_body={"thinking": {"type": "disabled"}} เพื่อให้ออกผลลัพธ์ที่เรียบง่ายและเหมาะกับรายงานการจับคู่งานแบบมีโครงสร้าง

สุดท้าย สร้างการตั้งค่าการรัน:

run_config = RunConfig(
   workflow_name="JobFit AI Kimi Search",
   tracing_disabled=True,
)

พารามิเตอร์ workflow_name ให้ป้ายกำกับที่ชัดเจนกับการรันนี้ และยังคงปิดการติดตามไว้ เพราะโปรเจ็กต์นี้ใช้ Kimi ผ่านเอ็นด์พอยต์ที่เข้ากันได้กับ OpenAI ไม่ได้ใช้แบ็กเอนด์ tracing ของ OpenAI

4. ดึงข้อความจากเรซูเม่ของผู้สมัคร

ใช้ PdfReader เพื่อโหลดเรซูเม่และดึงข้อความจากแต่ละหน้า

reader = PdfReader(cv_path)
cv_text = "\n".join(page.extract_text() or "" for page in reader.pages)[:12000]
print(f"Loaded {len(cv_text):,} characters from {cv_path}")

โค้ดนี้อ่านไฟล์ PDF ตามที่กำหนดใน cv_path ดึงข้อความจากทุกหน้า และรวมเป็นสตริงเดียว

การจำกัด [:12000] ช่วยให้ข้อความเรซูเม่สั้นพอที่จะใส่ในพรอมป์ตของเอเจนต์ได้สะดวก ขณะเดียวกันก็ให้บริบทเพียงพอเกี่ยวกับประสบการณ์ ทักษะ และความชอบของผู้สมัคร

ผลลัพธ์จะมีหน้าตาคล้าย ๆ ดังนี้ ทั้งนี้ขึ้นอยู่กับชื่อไฟล์และความยาวเรซูเม่ของคุณ:

Loaded 2,946 characters from abid-resume.pdf

นี่เป็นการยืนยันว่าโหลดเรซูเม่สำเร็จและแสดงจำนวนอักขระที่ดึงได้จาก PDF

5. สร้างคำสั่งสำหรับเอเจนต์ 

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

AGENT_INSTRUCTIONS = """
You are JobFit AI, a focused job-search agent.

Tool plan:
- Call search_jobs exactly once with limit 8.
- Read at most 3 direct job pages with read_job_page.
- After reading up to 3 pages, stop using tools and write the report.
- Search again only if the first search returns zero usable jobs.
- Avoid broad search pages, expired jobs, and LinkedIn unless no better source exists.

Report rules:
- Keep the report simple, clear, and practical.
- Use short bullets.
- Do not use em dashes.
- Do not use contractions.
- Do not add text before or after the report.
- End after the final Job Notes entry.
- Include at least 5 ranked jobs if the search results contain at least 5 usable jobs.
- If only 3 pages were scraped, use backup jobs from search results when they look usable.
- Every job must include a clickable Markdown link.
- Every job must have one apply decision: Apply, Maybe, or Do not apply.

Use exactly this Markdown structure:

# JobFit AI Report

## Best Match

- **Role:** <job title>
- **Company:** <company>
- **Apply decision:** Apply / Maybe / Do not apply
- **Fit score:** <score>/100
- **Link:** [Apply here](<job url>)

**Why this is the best match:**

- <specific reason>
- <specific reason>
- <specific reason>

## Ranked Jobs

| Rank | Role | Company | Apply? | Fit | Link |
| --- | --- | --- | --- | --- | --- |
| 1 | <role> | <company> | Apply / Maybe / Do not apply | <score>/100 | [Apply here](<url>) |

## Job Notes

### 1. <Role> at <Company>

- **Apply decision:** Apply / Maybe / Do not apply
- **Fit score:** <score>/100
- **Link:** [Apply here](<job url>)

**Why it fits:**

- <bullet>
- <bullet>

**Concerns:**

- <bullet>
- <bullet>

**Application angle:**

- <how the person should position their CV/application>
""".strip()

คำสั่งเหล่านี้ทำให้เอเจนต์โฟกัสกับงาน โดยจำกัดเวิร์กโฟลว์ให้ค้นหางานหนึ่งครั้ง อ่านหน้ารายละเอียดงานได้สูงสุดสามหน้า และใช้โครงสร้างรายงาน Markdown แบบตายตัว

กติกาของรายงานยังช่วยให้อ่านง่าย โดยกำหนดให้ใช้หัวข้อย่อยสั้น ๆ ลิงก์ที่คลิกได้ คะแนนความเหมาะสม และการตัดสินใจสมัครที่ชัดเจนสำหรับแต่ละตำแหน่ง

6. สร้างพรอมป์ตรันไทม์

หลังจากกำหนดคำสั่งเอเจนต์แล้ว ให้สร้างเทมเพลตพรอมป์ตที่จะส่งให้เอเจนต์ในทุกครั้งที่รัน

RUN_PROMPT_TEMPLATE = """
Find current job postings for this candidate and rank them by fit.

Keep the run simple:
- one search
- up to three page reads
- final report

The final report must follow AGENT_INSTRUCTIONS exactly.
Use simple wording. Do not use em dashes. Do not use contractions.

Candidate CV:
{cv_text}

Preferences:
{preferences}
""".strip()

พรอมป์ตนี้ผสานข้อความเรซูเม่และความต้องการงานของผู้สมัครในช่วงรันไทม์

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

7. เพิ่มการค้นหาเว็บแบบสดด้วย Olostep

เมื่อคำสั่งเอเจนต์และพรอมป์ตรันไทม์พร้อมแล้ว ให้เพิ่มเครื่องมือสองตัวเพื่อให้เอเจนต์ค้นเว็บและอ่านหน้ารายละเอียดงานด้วย Olostep

เครื่องมือแรกค้นหารายการงานบนเว็บและส่งคืนผลลัพธ์แบบย่อ

@function_tool
def search_jobs(query: str, limit: int = 8) -> str:
    """Search the web for job listings and return compact JSON results."""
    response = requests.post(
        OLOSTEP_SEARCH_URL,
        headers={"Authorization": f"Bearer {os.environ['OLOSTEP_API_KEY']}", "Content-Type": "application/json"},
        json={"query": query},
        timeout=60,
    )
    response.raise_for_status()
    links = response.json().get("result", {}).get("links", [])[:limit]
    results = [
        {"title": item.get("title", "Untitled"), "url": item.get("url"), "description": item.get("description", "")}
        for item in links
        if isinstance(item, dict) and item.get("url")
    ]
    return json.dumps(results, ensure_ascii=False)

ตัวตกแต่ง @function_tool ทำให้ฟังก์ชัน Python นี้พร้อมใช้งานในฐานะเครื่องมือที่เรียกใช้ได้โดยเอเจนต์

เมื่อเอเจนต์ต้องการรายการงาน จะเรียก search_jobs พร้อมคิวรีค้นหา ฟังก์ชันจะส่งคิวรีไปยังเอ็นด์พอยต์ค้นหาของ Olostep รวบรวมผลลัพธ์อันดับต้น ๆ และส่งคืนเป็น JSON

แต่ละผลลัพธ์ประกอบด้วย:

• ชื่อตำแหน่งงาน
• URL ของงาน
• คำอธิบายสั้น ๆ

เครื่องมือที่สองช่วยให้เอเจนต์เปิดและอ่านหน้ารายละเอียดงานเฉพาะ

@function_tool
def read_job_page(url: str) -> str:
    """Scrape one job listing URL and return markdown text."""
    response = requests.post(
        OLOSTEP_SCRAPE_URL,
        headers={"Authorization": f"Bearer {os.environ['OLOSTEP_API_KEY']}", "Content-Type": "application/json"},
        json={"url_to_scrape": url, "formats": ["markdown"]},
        timeout=120,
    )
    response.raise_for_status()
    markdown = response.json().get("result", {}).get("markdown_content") or ""
    return markdown[:8000]

ฟังก์ชันนี้ส่ง URL งานไปยังเอ็นด์พอยต์สกัดข้อมูลของ Olostep และส่งคืนเนื้อหาหน้าในรูปแบบ Markdown

การจำกัด [:8000] ช่วยให้เนื้อหาที่สกัดมาสั้นพอสำหรับเอเจนต์ในการประมวลผล ขณะเดียวกันยังเก็บรายละเอียดงานที่สำคัญ เช่น หน้าที่ ความต้องการ และข้อมูลบริษัท

8. สร้างเอเจนต์ JobFit AI

สร้างเอเจนต์และเชื่อมต่อทุกส่วนที่กำหนดไว้ก่อนหน้า: โมเดล Kimi การตั้งค่าโมเดล เครื่องมือ Olostep และคำสั่งเอเจนต์

agent = Agent(
   name="JobFit AI",
   model=kimi_model,
   model_settings=model_settings,
   tools=[search_jobs, read_job_page],
   instructions=AGENT_INSTRUCTIONS,
)

อ็อบเจ็กต์ Agent เป็นตัวควบคุมหลักของเวิร์กโฟลว์นี้

ซึ่งใช้:

• kimi_model เป็นโมเดลให้เหตุผล
• model_settings เพื่อควบคุมการใช้เครื่องมือและพฤติกรรมเอาต์พุต
• search_jobs เพื่อค้นหารายการงานสด
• read_job_page เพื่อสกัดข้อมูลจากหน้ารายละเอียดงานที่เลือก
• AGENT_INSTRUCTIONS เพื่อปฏิบัติตามกติกาการค้นหาและรายงานอย่างเคร่งครัด

ถึงจุดนี้ เอเจนต์พร้อมค้นหางาน เปรียบเทียบกับเรซูเม่ของผู้สมัคร และสร้างรายงาน JobFit AI แบบมีโครงสร้างแล้ว

9. รันเวิร์กโฟลว์ของเอเจนต์

รันเอเจนต์ JobFit AI โดยใช้ข้อความเรซูเม่ที่ดึงมาและความต้องการงานที่กำหนดไว้ก่อนหน้า

เริ่มจากจัดรูปแบบพรอมป์ตรันไทม์:

prompt = RUN_PROMPT_TEMPLATE.format(cv_text=cv_text, preferences=preferences)

คำสั่งนี้เติมเทมเพลตพรอมป์ตด้วยเรซูเม่และความต้องการงานของผู้สมัคร

จากนั้นเริ่มรันเอเจนต์แบบสตรีม:

print("Starting agent run")


result = Runner.run_streamed(
   agent,
   prompt,
   max_turns=MAX_AGENT_TURNS,
   run_config=run_config,
)

เมธอด Runner.run_streamed() เริ่มเวิร์กโฟลว์ของเอเจนต์และสตรีมเหตุการณ์แบบเรียลไทม์ ช่วยให้เห็นได้ง่ายว่าเมื่อใดที่เอเจนต์เรียกใช้เครื่องมือ รับผลลัพธ์ และสร้างข้อความสุดท้าย

ตอนนี้เพิ่มลูปสำหรับสตรีมมิง:

async for event in result.stream_events():
   if event.type == "agent_updated_stream_event":
       print(f"Agent: {event.new_agent.name}")
   elif event.type == "run_item_stream_event":
       item = event.item
       if event.name == "tool_called":
           raw = item.raw_item
           tool_name = raw.get("name") if isinstance(raw, dict) else getattr(raw, "name", "tool")
           arguments = raw.get("arguments") if isinstance(raw, dict) else getattr(raw, "arguments", "")
           arguments = str(arguments).replace(chr(10), " ")[:500]
           print(f"Tool call: {tool_name}")
           if arguments:
               print(f"Parameters: {arguments}")
       elif event.name == "tool_output":
           print(f"Tool output: {len(str(item.output)):,} chars")
       elif event.name == "message_output_created":
           print("Final message ready")

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

สุดท้าย บันทึกเอาต์พุตสุดท้ายไว้ในตัวแปรชื่อ report:

report = result.final_output
globals()["report"] = report


print("Run complete")
print(f"Model responses: {len(result.raw_responses)}")
print(f"Run items: {len(result.new_items)}")
print(f"Final output: {len(str(report)):,} chars")

ตัวแปร report เก็บรายงาน JobFit AI ฉบับสุดท้าย ซึ่งสามารถแสดง บันทึก หรือใช้ในแอป Gradio ได้

ผลลัพธ์จะมีลักษณะประมาณนี้:

Starting agent run
Agent: JobFit AI
Tool call: search_jobs
Parameters: {"query":"remote data science writer technical writer AI machine learning content editor","limit":8}
Tool output: 2,445 chars
Tool call: read_job_page
Parameters: {"url":"https://www.indeed.com/q-data-science-writer-jobs.html"}
Tool output: 8,000 chars
Tool call: read_job_page
Parameters: {"url":"https://www.builtinnyc.com/jobs/remote/data-analytics/data-science"}
Tool output: 8,000 chars
Tool call: read_job_page
Parameters: {"url":"https://www.virtualvocations.com/jobs/q-data+scientist+remote+jobs/c-writing/d-336"}
Tool output: 5,075 chars
Final message ready
Run complete
Model responses: 5
Run items: 13
Final output: 5,931 chars

เอาต์พุตนี้ยืนยันว่าเอเจนต์ค้นหางาน อ่านหน้าที่เลือก และสร้างรายงานสุดท้ายสำเร็จ

10. แสดงรายงาน JobFit ที่สร้างขึ้น

เมื่อการรันของเอเจนต์เสร็จสิ้น ให้แสดงรายงานสุดท้ายในรูปแบบ Markdown

display(Markdown(report))

คำสั่งนี้เรนเดอร์รายงาน JobFit AI โดยตรงในโน้ตบุ๊ก ซึ่งอ่านง่ายกว่าข้อความล้วน

รายงานประกอบด้วยงานที่เหมาะที่สุด งานแบบจัดอันดับ คะแนนความเหมาะสม การตัดสินใจสมัคร ข้อกังวล และแนวทางการสมัคร

11. แปลงเวิร์กโฟลว์เป็นเว็บแอป Gradio

หลังทดสอบเวิร์กโฟลว์ในโน้ตบุ๊กแล้ว สามารถแปลงเป็นเว็บแอป Gradio แบบง่าย สร้างไฟล์ app.py แล้วคัดลอกโค้ดจากไฟล์ JobFit-AI/app.py ในโปรเจ็กต์ GitHub มาวางในไฟล์โลคอลของคุณ

รันแอปด้วย:

python app.py

จากนั้นเปิดแอปโลคอลในเบราว์เซอร์ที่ URL ที่แสดง (ในตัวอย่างนี้คือ http://127.0.0.1:7860/):

แอป Gradio มอบอินเทอร์เฟซง่าย ๆ สำหรับสร้างรายงานการจับคู่งาน โดยมี:

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

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

12. อัปโหลดเรซูเม่และสร้างรายงาน

ทดสอบเว็บแอปโดยอัปโหลดไฟล์เรซูเม่หรือ CV แบบ PDF และคลิก Generate JobFit Report

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

ขณะรันแอป บันทึกความคืบหน้าจะแสดงทุกขั้นตอนของเวิร์กโฟลว์ ได้แก่:

• อ่านเรซูเม่
• ดึงข้อความจากแต่ละหน้า
• เริ่มรันเอเจนต์
• เรียกใช้เครื่องมือค้นหางาน
• ส่งคืนเอาต์พุตจากเครื่องมือ

เมื่อการรันเสร็จสิ้น แอปจะแสดงรายงานสุดท้ายในรูปแบบ Markdown

รายงานเริ่มด้วยงานที่เหมาะที่สุด ตามด้วยตารางงานแบบจัดอันดับ จากนั้นให้บันทึกรายละเอียดสำหรับแต่ละตำแหน่ง รวมถึงคะแนนความเหมาะสม การตัดสินใจสมัคร เหตุผลที่ตำแหน่งเหมาะสม ข้อกังวลที่อาจมี และแนวทางการสมัคร

ในตัวอย่างนี้ ผลลัพธ์อันดับต้นเป็นตำแหน่ง Senior Data Science Writer ที่ NannyML ซึ่งดูเหมาะสมอย่างยิ่งเพราะสอดคล้องกับพื้นหลังด้าน data science งานเขียนเชิงเทคนิค และคอนเทนต์ AI ของผู้สมัคร

สามารถคลิกลิงก์ Apply here ในรายงานเพื่อเปิดหน้ารายละเอียดงานและตรวจสอบประกาศฉบับเต็มก่อนตัดสินใจสมัคร

หมายเหตุ: หากพบปัญหาในการรันโปรเจ็กต์บนเครื่อง โปรดตรวจสอบที่ GitHub repository: kingabzpro/JobFit-AI มีโน้ตบุ๊ก ไฟล์ app.py และคำแนะนำในการตั้งค่าเพื่อช่วยติดตั้ง dependencies และรันโปรเจ็กต์บนเครื่อง

สรุปท้ายบท

JobFit AI ใช้ Kimi K2.6, Olostep และ OpenAI Agent SDK เพื่อแก้สองปัญหาหลักของผู้ที่กำลังเปลี่ยนสายงานหรือสมัครงานอย่างจริงจัง

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

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

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

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

หากสนใจสร้างเครื่องมือแบบเอเจนต์ลักษณะคล้ายกัน ลองดูบทช่วยสอน API อื่น ๆ ของเราว่าด้วยการสร้าง: 

• Thinking Mode Arena ด้วย DeepSeek V4
• Chart Digitizer ด้วย Claude Opus 4.7
• Invoice Processing Pipeline ด้วย Qwen 3.6 Plus
• Data Analysis Automatizer ด้วย Gemini 3