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 एंडपॉइंट, अधिकतम एजेंट टर्न, CV पथ, और जॉब प्राथमिकताएँ परिभाषित करें।

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 मान ऐप को Moonshot AI के OpenAI-संगत API एंडपॉइंट के माध्यम से Kimi K2.6 का उपयोग करने के लिए बताते हैं। Olostep URLs लाइव जॉब सर्च और पेज स्क्रैपिंग के लिए उपयोग होते हैं।

cv_path वेरिएबल उम्मीदवार के रेज़्यूमे PDF की ओर इशारा करता है। सुनिश्चित करें कि PDF उसी प्रोजेक्ट फ़ोल्डर में सेव हो, या यदि कहीं और है तो पथ अपडेट करें।

preferences वेरिएबल एजेंट को बताता है कि किस प्रकार की नौकरियाँ खोजनी हैं। आप इसे लक्ष्य भूमिका, उद्योग, स्थान, वरिष्ठता स्तर, या पसंदीदा कार्य शैली के आधार पर अपडेट कर सकते हैं।

हम set_tracing_disabled(True) के साथ ट्रेसिंग अक्षम करते हैं क्योंकि ट्रेसिंग OpenAI Agents SDK की एक सुविधा है जो डिफ़ॉल्ट रूप से सक्षम होती है। चूंकि यह प्रोजेक्ट Kimi को OpenAI-संगत एंडपॉइंट के माध्यम से उपयोग करता है, ट्रेसिंग अक्षम करना लोकल सेटअप को सरल रखता है और किसी थर्ड-पार्टी मॉडल प्रोवाइडर के साथ ट्रेसिंग-संबंधी समस्याओं से बचाता है।

3. Kimi K2.6 API से कनेक्ट करें

फिर, पहले से सेव की गई environment variable API कुंजी का उपयोग करके Kimi क्लाइंट सेट अप करें।

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

यह Kimi के लिए API क्लाइंट बनाता है। api_key MOONSHOT_API_KEY से लोड होती है, और base_url Moonshot AI के OpenAI-संगत एंडपॉइंट की ओर इशारा करता है।

अब 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 सेटिंग ज़रूरत पड़ने पर कई टूल कॉल्स को साथ-साथ चलने देती है।

हम extra_body={"thinking": {"type": "disabled"}} का उपयोग करके Kimi का थिंकिंग मोड भी अक्षम करते हैं। इससे आउटपुट अधिक स्वच्छ और स्ट्रक्चर्ड जॉब-फिट रिपोर्ट के लिए उपयुक्त रहता है।

अंत में, रन कॉन्फ़िगरेशन बनाएँ:

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

workflow_name इस रन को स्पष्ट लेबल देता है। हम यहाँ भी ट्रेसिंग अक्षम रखते हैं क्योंकि यह प्रोजेक्ट OpenAI की ट्रेसिंग बैकएंड के बजाय OpenAI-संगत एंडपॉइंट के माध्यम से Kimi का उपयोग करता है।

4. उम्मीदवार के CV से टेक्स्ट निकालें

अब PdfReader का उपयोग करके उम्मीदवार का CV लोड करें और प्रत्येक पेज से टेक्स्ट निकालें।

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

यह कोड cv_path में परिभाषित PDF फ़ाइल पढ़ता है, हर पेज से टेक्स्ट निकालता है, और उसे एक स्ट्रिंग में जोड़ता है।

[:12000] लिमिट CV टेक्स्ट को इतना छोटा रखती है कि वह एजेंट प्रॉम्प्ट में आराम से फिट हो जाए, जबकि मॉडल को उम्मीदवार के अनुभव, कौशल, और प्राथमिकताओं के बारे में पर्याप्त संदर्भ भी मिल जाए।

आउटपुट आपका फ़ाइल नाम और लंबाई के आधार पर कुछ यूँ दिखेगा:

Loaded 2,946 characters from abid-resume.pdf

यह पुष्टि करता है कि CV सफलतापूर्वक लोड हो गया और 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 रिपोर्ट संरचना तक सीमित करते हैं।

रिपोर्ट नियम आउटपुट को स्कैन करना आसान बनाते हैं—छोटे बुलेट, क्लिक करने योग्य लिंक, फिट स्कोर, और प्रत्येक भूमिका के लिए स्पष्ट apply निर्णय आवश्यक करते हुए।

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 टेक्स्ट और जॉब प्राथमिकताओं को संयोजित करता है।

cv_text प्लेसहोल्डर एक्सट्रैक्टेड CV कंटेंट से भरा जाता है, जबकि 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 सटीक सर्च और रिपोर्ट नियमों का पालन करने के लिए

इस बिंदु पर, एजेंट नौकरियाँ खोजने, उन्हें उम्मीदवार के CV के साथ तुलना करने, और एक संरचित JobFit AI रिपोर्ट जनरेट करने के लिए तैयार है।

9. एजेंट वर्कफ़्लो चलाएँ

अब एक्सट्रैक्ट किए गए CV टेक्स्ट और पहले परिभाषित जॉब प्राथमिकताओं का उपयोग करके JobFit AI एजेंट चलाएँ।

पहले, रनटाइम प्रॉम्प्ट फ़ॉर्मैट करें:

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

यह टेम्पलेट को उम्मीदवार के CV और लक्षित जॉब प्राथमिकताओं से भर देता है।

इसके बाद, स्ट्रीम्ड एजेंट रन शुरू करें:

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 रिपोर्ट को सीधे नोटबुक के अंदर रेंडर करता है, जिससे साधारण टेक्स्ट की तुलना में पढ़ना आसान हो जाता है।

रिपोर्ट में सर्वश्रेष्ठ जॉब मैच, रैंक की हुई नौकरियाँ, फिट स्कोर, apply निर्णय, चिंताएँ, और एप्लिकेशन एंगल शामिल होते हैं।

11. वर्कफ़्लो को Gradio वेब ऐप में बदलें

नोटबुक में वर्कफ़्लो टेस्ट करने के बाद, आप इसे एक साधारण Gradio वेब ऐप में बदल सकते हैं। एक app.py फ़ाइल बनाएँ, फिर GitHub प्रोजेक्ट में JobFit-AI/app.py फ़ाइल से कोड कॉपी करें और अपनी लोकल फ़ाइल में पेस्ट करें।

ऐप को इस प्रकार चलाएँ:

python app.py

इसके बाद ब्राउज़र में लोकल URL खोलें जो दिखाया गया है (इस मामले में, http://127.0.0.1:7860/):

Gradio ऐप जॉब-फिट रिपोर्ट जनरेट करने के लिए एक सरल इंटरफ़ेस प्रदान करता है। इसमें शामिल हैं:

• CV PDF अपलोड फ़ील्ड जहाँ उपयोगकर्ता अपना रेज़्यूमे अपलोड कर सकते हैं।
• जॉब प्राथमिकताओं का टेक्स्ट बॉक्स जहाँ उपयोगकर्ता अपनी इच्छित भूमिकाएँ—भूमिका प्रकार, उद्योग, स्थान, वरिष्ठता, और पसंदीदा विषय—वर्णित कर सकते हैं।
• एजेंट वर्कफ़्लो शुरू करने के लिए Generate JobFit Report बटन।
• एक हिडन प्रोग्रेस लॉग जो रन के दौरान दिखाई देता है और दिखाता है कि ऐप क्या कर रहा है, जैसे CV पढ़ना, टूल कॉल करना, और टूल आउटपुट प्राप्त करना।
• अंतिम Markdown रिपोर्ट क्षेत्र जो एजेंट के समाप्त होते ही रैंक की हुई जॉब-फिट रिपोर्ट प्रदर्शित करता है।

पर्दे के पीछे, ऐप अपलोड किए गए CV को पढ़ता है, टेक्स्ट निकालता है, CV और प्राथमिकताएँ JobFit AI एजेंट को भेजता है, और Olostep के साथ लाइव जॉब लिस्टिंग्स खोजता है। यह अधिकतम तीन जॉब पेज पढ़ता है और रैंक की हुई भूमिकाओं, फिट स्कोर, apply निर्णय, चिंताओं, और एप्लिकेशन एंगल के साथ एक संरचित Markdown रिपोर्ट लौटाता है।

12. CV अपलोड करें और रिपोर्ट जनरेट करें

अब वेब ऐप को किसी CV या रेज़्यूमे PDF को अपलोड करके और Generate JobFit Report पर क्लिक करके टेस्ट करें।

इस उदाहरण में, मैंने लगभग तीन साल के अनुभव वाला CV अपलोड किया ताकि देखा जा सके कि ऐप उम्मीदवार की प्रोफ़ाइल और प्राथमिकताओं के आधार पर प्रासंगिक नौकरियाँ ढूँढ़ सकता है या नहीं। रिपोर्ट एक मिनट से कम समय में जनरेट हो गई।

ऐप के चलते समय, प्रोग्रेस लॉग वर्कफ़्लो के प्रत्येक चरण को दिखाता है, जिनमें शामिल हैं:

• CV पढ़ना
• प्रत्येक पेज से टेक्स्ट निकालना
• एजेंट रन शुरू करना
• जॉब सर्च टूल कॉल करना
• टूल आउटपुट लौटाना

रन पूरा होते ही, ऐप अंतिम रिपोर्ट को Markdown फ़ॉर्मैट में प्रदर्शित करता है।

रिपोर्ट सर्वश्रेष्ठ मैच से शुरू होती है, उसके बाद रैंक की हुई नौकरियों की तालिका आती है। फिर यह प्रत्येक भूमिका के लिए अधिक विस्तृत नोट्स देती है, जिनमें फिट स्कोर, apply निर्णय, भूमिका के फिट होने के कारण, संभावित चिंताएँ, और एक एप्लिकेशन एंगल शामिल होता है।

इस उदाहरण में, शीर्ष परिणाम NannyML में Senior Data Science Writer की भूमिका थी। चूँकि यह भूमिका उम्मीदवार के डेटा साइंस, तकनीकी लेखन, और AI कंटेंट पृष्ठभूमि से मेल खाती थी, यह एक मजबूत फिट लगी।

आप रिपोर्ट में Apply here लिंक पर क्लिक करके जॉब पेज खोल सकते हैं और आवेदन करने से पहले पूरी लिस्टिंग की समीक्षा कर सकते हैं।

नोट: यदि आपको प्रोजेक्ट लोकल रूप से चलाने में कोई समस्या आती है, तो GitHub रिपॉज़िटरी देखें: kingabzpro/JobFit-AI। इसमें नोटबुक, app.py फ़ाइल, और सेटअप निर्देश शामिल हैं जो आपको डिपेंडेंसी इंस्टॉल करने और प्रोजेक्ट को लोकल रूप से चलाने में मदद करेंगे। 

अंतिम विचार

JobFit AI, Kimi K2.6, Olostep, और OpenAI Agent SDK का उपयोग करके उन दो आम समस्याओं का समाधान करता है जिनका सामना रोल बदल रहे या सक्रिय रूप से नौकरियों के लिए आवेदन कर रहे लोगों को होता है।

पहली समस्या है यह जानना कि कहाँ आवेदन करें। बहुत सारे जॉब बोर्ड, प्लेटफ़ॉर्म, और कंपनी करियर पेज हैं, लेकिन हमेशा यह स्पष्ट नहीं होता कि कौन सी भूमिकाएँ आपके समय के लायक हैं। यह ऐप उम्मीदवार के CV और प्राथमिकताओं का उपयोग करके उन नौकरियों को ढूँढ़ने में मदद करता है जो उनके अनुभव से अधिक मेल खाती हैं।

दूसरी समस्या है बहुत अधिक जॉब लिस्टिंग्स को फ़िल्टर करना। हर जॉब बोर्ड को मैन्युअल रूप से जाँचने के बजाय, एजेंट लाइव लिस्टिंग्स खोजता है, चयनित जॉब पेज पढ़ता है, और सर्वश्रेष्ठ मैच, रैंक की हुई नौकरियाँ, फिट स्कोर, चिंताएँ, और एप्लिकेशन एंगल के साथ एक संरचित रिपोर्ट बनाता है। इससे उन भूमिकाओं पर ध्यान केंद्रित करना आसान हो जाता है जिनके लिए वास्तव में आवेदन करना सार्थक है।

Kimi K2.6 API ने इस एजेंट-आधारित वर्कफ़्लो में भी अच्छा प्रदर्शन किया। यह तेज़, विश्वसनीय, और संरचित निर्देशों का पालन करने में प्रभावी रहा। परीक्षण के दौरान, जब एजेंट को 25 टर्न तक की अनुमति थी, तो उसने अधिक गहराई से कई पेज खोजे और स्क्रैप किए, लेकिन रन में लगभग पाँच मिनट लगे। गुणवत्ता और स्पीड के बीच संतुलन के लिए, मैंने वर्कफ़्लो को एक सर्च और अधिकतम तीन पेज रीड तक सीमित रखा, जिससे रिपोर्ट एक मिनट से कम समय में जनरेट हुई।

आप अनुमत स्टेप्स, सर्च परिणाम, या पेज रीड की संख्या बढ़ाकर जॉब रिपोर्ट की गुणवत्ता में सुधार कर सकते हैं। उदाहरण के लिए, यदि आप एजेंट लिमिट को 30 टर्न तक बढ़ाते हैं और उसे अधिक जॉब पेज पढ़ने देते हैं, तो वह अधिक भूमिकाओं और मजबूत सिफारिशों के साथ एक गहरी रिपोर्ट बना सकता है। हालाँकि, इससे रनटाइम और API उपयोग भी बढ़ेगा।

यदि आप इसी तरह के एजेंटिक टूल बनाने में रुचि रखते हैं, तो हमारे अन्य API ट्यूटोरियल देखें: 

• DeepSeek V4 के साथ Thinking Mode Arena
• Claude Opus 4.7 के साथ Chart Digitizer
• Qwen 3.6 Plus के साथ Invoice Processing Pipeline
• Gemini 3 के साथ Data Analysis Automatizer