Tutorial API Kimi K2.6: Membangun Asisten Pencarian Kerja berbasis AI

2. Definisikan Konfigurasi Proyek 

Luncurkan Jupyter Notebook, buat sel baru, dan tambahkan impor yang diperlukan serta konfigurasi proyek.

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

Sekarang definisikan nama model, endpoint API, jumlah maksimum giliran agen, lokasi CV, dan preferensi pekerjaan.

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)

Nilai KIMI_MODEL dan KIMI_BASE_URL memberi tahu aplikasi untuk menggunakan Kimi K2.6 melalui endpoint API yang kompatibel dengan OpenAI milik Moonshot AI. URL Olostep digunakan untuk pencarian pekerjaan langsung dan scraping halaman.

Variabel cv_path menunjuk ke PDF resume kandidat. Pastikan PDF disimpan di folder proyek yang sama, atau perbarui path jika disimpan di lokasi lain.

Variabel preferences memberi tahu agen jenis pekerjaan apa yang harus dicari. Anda dapat memperbaruinya berdasarkan peran target, industri, lokasi, tingkat senioritas, atau gaya kerja pilihan.

Kami menonaktifkan tracing dengan set_tracing_disabled(True) karena tracing adalah fitur OpenAI Agents SDK yang aktif secara default. Karena proyek ini menggunakan Kimi melalui endpoint yang kompatibel dengan OpenAI, menonaktifkan tracing membuat penyiapan lokal tetap sederhana dan menghindari masalah terkait tracing dengan penyedia model pihak ketiga.

3. Sambungkan ke API Kimi K2.6

Kemudian, siapkan klien Kimi menggunakan kunci API yang Anda simpan sebelumnya sebagai variabel lingkungan.

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

Ini membuat klien API untuk Kimi. api_key dimuat dari MOONSHOT_API_KEY, dan base_url menunjuk ke endpoint yang kompatibel dengan OpenAI milik Moonshot AI.

Berikutnya, bungkus model Kimi agar dapat digunakan di dalam OpenAI Agents SDK:

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

Sekarang definisikan pengaturan model:

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

Pengaturan tool_choice="auto" memungkinkan agen memutuskan kapan memanggil tool. Pengaturan parallel_tool_calls=True memungkinkan agen menjalankan beberapa pemanggilan tool secara bersamaan saat diperlukan.

Kami juga menonaktifkan mode berpikir Kimi menggunakan extra_body={"thinking": {"type": "disabled"}}. Ini membuat keluaran lebih rapi dan lebih cocok untuk laporan kecocokan kerja yang terstruktur.

Terakhir, buat konfigurasi run:

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

Parameter workflow_name memberi label yang jelas untuk run ini. Kami juga tetap menonaktifkan tracing di sini karena proyek ini menggunakan Kimi melalui endpoint yang kompatibel dengan OpenAI, bukan backend tracing milik OpenAI.

4. Ekstrak Teks dari CV Kandidat

Selanjutnya, gunakan PdfReader untuk memuat CV kandidat dan mengekstrak teks dari setiap halaman.

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

Kode ini membaca file PDF yang didefinisikan di cv_path, mengekstrak teks dari setiap halaman, dan menggabungkannya menjadi satu string.

Batas [:12000] menjaga teks CV tetap cukup singkat untuk muat dengan nyaman di dalam prompt agen sambil tetap memberi model konteks yang cukup tentang pengalaman, keterampilan, dan preferensi kandidat.

Keluaran akan terlihat seperti ini, bergantung pada nama dan panjang file CV Anda:

Loaded 2,946 characters from abid-resume.pdf

Ini mengonfirmasi bahwa CV berhasil dimuat dan menunjukkan berapa banyak karakter yang diekstrak dari PDF.

5. Buat Instruksi Agen 

Selanjutnya, definisikan instruksi yang mengendalikan cara agen melakukan pencarian, menggunakan tool, dan memformat laporan akhir.

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()

Instruksi ini menjaga fokus agen. Instruksi membatasi alur kerja pada satu pencarian kerja, hingga tiga pembacaan halaman pekerjaan, dan struktur laporan Markdown yang tetap.

Aturan laporan juga membuat keluaran lebih mudah dipindai dengan mewajibkan bullet singkat, tautan yang dapat diklik, skor kecocokan, dan keputusan melamar yang jelas untuk setiap peran.

6. Bangun Prompt Runtime

Setelah mendefinisikan instruksi agen, buat templat prompt yang akan diteruskan ke agen pada setiap run.

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()

Prompt ini menggabungkan teks CV kandidat dan preferensi pekerjaan saat runtime.

Placeholder cv_text diisi dengan konten CV yang diekstrak, sementara placeholder preferences diisi dengan preferensi peran target yang didefinisikan sebelumnya. Keduanya memberikan konteks yang cukup bagi agen untuk mencari pekerjaan relevan dan memberi peringkat berdasarkan kecocokan.

7. Tambahkan Pencarian Web Langsung dengan Olostep

Sekarang setelah instruksi agen dan prompt runtime siap, tambahkan dua tool yang memungkinkan agen mencari web dan membaca halaman pekerjaan menggunakan Olostep.

Tool pertama mencari web untuk daftar pekerjaan dan mengembalikan daftar hasil yang ringkas.

@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)

Decorator @function_tool membuat fungsi Python ini tersedia bagi agen sebagai tool yang dapat dipanggil.

Saat agen membutuhkan daftar pekerjaan, agen akan memanggil search_jobs dengan kueri pencarian. Fungsi ini mengirim kueri ke endpoint pencarian Olostep, mengumpulkan hasil teratas, dan mengembalikannya sebagai JSON.

Setiap hasil mencakup:

• judul pekerjaan
• URL pekerjaan
• deskripsi singkat

Tool kedua memungkinkan agen membuka dan membaca halaman pekerjaan tertentu.

@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]

Fungsi ini mengirim URL pekerjaan ke endpoint scrape Olostep dan mengembalikan konten halaman dalam format Markdown.

Batas [:8000] menjaga halaman yang di-scrape tetap cukup singkat untuk diproses agen sambil tetap menangkap detail pekerjaan paling berguna, seperti tanggung jawab, persyaratan, dan informasi perusahaan.

8. Buat Agen JobFit AI

Sekarang buat agen dan hubungkan semua komponen yang Anda definisikan sebelumnya: model Kimi, pengaturan model, tool Olostep, dan instruksi agen.

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

Objek Agent adalah pengendali utama untuk alur kerja ini.

Agen ini menggunakan:

• kimi_model sebagai model penalaran
• model_settings untuk mengontrol penggunaan tool dan perilaku keluaran
• search_jobs untuk menemukan daftar pekerjaan langsung
• read_job_page untuk men-scrape halaman pekerjaan terpilih
• AGENT_INSTRUCTIONS untuk mengikuti aturan pencarian dan laporan secara tepat

Pada tahap ini, agen siap mencari pekerjaan, membandingkannya dengan CV kandidat, dan menghasilkan laporan JobFit AI yang terstruktur.

9. Jalankan Alur Kerja Agen

Sekarang jalankan agen JobFit AI menggunakan teks CV yang diekstrak dan preferensi pekerjaan yang telah ditetapkan sebelumnya.

Pertama, format prompt runtime:

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

Ini mengisi templat prompt dengan CV kandidat dan preferensi pekerjaan target.

Berikutnya, mulai run agen dengan streaming:

print("Starting agent run")


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

Metode Runner.run_streamed() memulai alur kerja agen dan melakukan streaming peristiwa saat terjadi. Ini memudahkan untuk melihat kapan agen memanggil tool, menerima keluaran tool, dan membuat pesan akhir.

Sekarang tambahkan loop streaming:

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

Loop ini mencetak pembaruan progres yang berguna saat agen berjalan. Misalnya, loop menampilkan saat agen mencari pekerjaan, membaca halaman pekerjaan, atau menyelesaikan pembuatan laporan.

Terakhir, simpan keluaran akhir ke variabel bernama 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")

Variabel report menyimpan laporan JobFit AI akhir, yang dapat Anda tampilkan, simpan, atau gunakan di dalam aplikasi Gradio.

Keluaran akan terlihat seperti ini:

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

Keluaran ini mengonfirmasi bahwa agen telah mencari pekerjaan, membaca halaman terpilih, dan berhasil menghasilkan laporan akhir.

10. Tampilkan Laporan JobFit yang Dihasilkan

Setelah run agen selesai, tampilkan laporan akhir dalam format Markdown.

display(Markdown(report))

Ini merender laporan JobFit AI yang dihasilkan langsung di dalam notebook, sehingga lebih mudah dibaca daripada teks biasa.

Laporan mencakup kecocokan terbaik, pekerjaan berperingkat, skor kecocokan, keputusan melamar, kekhawatiran, dan sudut pendekatan aplikasi.

11. Ubah Alur Kerja Menjadi Aplikasi Web Gradio

Setelah menguji alur kerja di notebook, Anda dapat mengubahnya menjadi aplikasi web Gradio sederhana. Buat file app.py, lalu salin kode dari file JobFit-AI/app.py di proyek GitHub dan tempelkan ke file lokal Anda.

Jalankan aplikasinya dengan:

python app.py

Lalu buka aplikasi lokal di browser pada URL lokal yang ditampilkan (dalam kasus ini, http://127.0.0.1:7860/):

Aplikasi Gradio menyediakan antarmuka sederhana untuk menghasilkan laporan kecocokan kerja. Ini mencakup:

• Kolom unggah CV PDF tempat pengguna dapat mengunggah resume mereka.
• Kotak teks preferensi pekerjaan tempat pengguna dapat mendeskripsikan jenis peran yang diinginkan, termasuk jenis peran, industri, lokasi, senioritas, dan topik yang disukai.
• Tombol Generate JobFit Report untuk memulai alur kerja agen.
• Log progres tersembunyi yang muncul selama run dan menunjukkan apa yang dilakukan aplikasi, seperti membaca CV, memanggil tool, dan menerima keluaran tool.
• Area laporan Markdown akhir yang menampilkan laporan kecocokan kerja berperingkat setelah agen selesai.

Di balik layar, aplikasi membaca CV yang diunggah, mengekstrak teks, mengirim CV dan preferensi ke agen JobFit AI, dan mencari daftar pekerjaan langsung dengan Olostep. Aplikasi membaca hingga tiga halaman pekerjaan dan mengembalikan laporan Markdown terstruktur dengan peran berperingkat, skor kecocokan, keputusan melamar, kekhawatiran, dan sudut pendekatan aplikasi.

12. Unggah CV dan Hasilkan Laporan

Sekarang uji aplikasi web dengan mengunggah CV atau resume PDF dan mengklik Generate JobFit Report.

Untuk contoh ini, saya mengunggah CV dengan sekitar tiga tahun pengalaman untuk melihat apakah aplikasi dapat menemukan pekerjaan yang relevan berdasarkan profil dan preferensi kandidat. Laporan dihasilkan dalam waktu kurang dari satu menit.

Saat aplikasi berjalan, log progres menampilkan setiap langkah alur kerja, termasuk:

• membaca CV
• mengekstrak teks dari setiap halaman
• memulai run agen
• memanggil tool pencarian pekerjaan
• mengembalikan keluaran tool

Setelah run selesai, aplikasi menampilkan laporan akhir dalam format Markdown.

Laporan dimulai dengan kecocokan terbaik, diikuti tabel pekerjaan berperingkat. Kemudian memberikan catatan yang lebih detail untuk setiap peran, termasuk skor kecocokan, keputusan melamar, alasan kecocokan, kemungkinan kekhawatiran, dan sudut pendekatan aplikasi.

Pada contoh ini, hasil teratas adalah peran Senior Data Science Writer di NannyML. Karena peran tersebut sesuai dengan latar belakang kandidat di bidang data science, penulisan teknis, dan konten AI, peran ini tampak sangat cocok.

Anda dapat mengeklik tautan Apply here dalam laporan untuk membuka halaman pekerjaan dan meninjau listing lengkap sebelum memutuskan untuk melamar.

Catatan: Jika Anda mengalami masalah saat menjalankan proyek secara lokal, periksa repositori GitHub: kingabzpro/JobFit-AI. Repositori ini mencakup notebook, file app.py, dan petunjuk penyiapan untuk membantu Anda memasang dependensi dan menjalankan proyek secara lokal. 

Pemikiran Akhir

JobFit AI menggunakan Kimi K2.6, Olostep, dan OpenAI Agent SDK untuk menyelesaikan dua masalah umum bagi orang yang berpindah peran atau aktif melamar pekerjaan.

Masalah pertama adalah mengetahui tempat untuk melamar. Ada banyak papan lowongan, platform, dan halaman karier perusahaan, tetapi tidak selalu jelas peran mana yang layak waktu Anda. Aplikasi ini membantu mempersempit pilihan dengan menggunakan CV dan preferensi kandidat untuk menemukan pekerjaan yang lebih relevan dengan pengalaman mereka.

Masalah kedua adalah menyaring terlalu banyak listing pekerjaan. Alih-alih memeriksa setiap papan lowongan secara manual, agen mencari listing langsung, membaca halaman pekerjaan terpilih, dan membuat laporan terstruktur dengan kecocokan terbaik, pekerjaan berperingkat, skor kecocokan, kekhawatiran, dan sudut pendekatan aplikasi. Ini memudahkan untuk fokus pada peran yang benar-benar layak untuk dilamar.

API Kimi K2.6 juga berkinerja baik dalam alur kerja berbasis agen ini. API cepat, andal, dan efektif dalam mengikuti instruksi terstruktur. Selama pengujian, ketika agen diizinkan hingga 25 giliran, agen mencari dan men-scrape beberapa halaman lebih mendalam, tetapi run memakan waktu sekitar lima menit. Untuk menyeimbangkan kualitas dan kecepatan, saya membatasi alur kerja menjadi satu pencarian dan hingga tiga pembacaan halaman, yang membantu menghasilkan laporan dalam waktu kurang dari satu menit.

Anda dapat meningkatkan kualitas laporan pekerjaan dengan menambah jumlah langkah yang diizinkan, hasil pencarian, atau pembacaan halaman. Misalnya, jika Anda meningkatkan batas agen menjadi 30 giliran dan mengizinkannya membaca lebih banyak halaman pekerjaan, agen dapat menghasilkan laporan yang lebih mendalam dengan lebih banyak peran dan rekomendasi yang lebih kuat. Namun, ini juga akan meningkatkan waktu run dan penggunaan API.

Jika Anda tertarik membuat tool agentik serupa, lihat tutorial API kami yang lain tentang membangun: 

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