Kimi K2.6 API-tutorial: een AI-baanzoekassistent bouwen

2. Definieer de projectconfiguratie 

Start Jupyter Notebook, maak een nieuwe cel en voeg de vereiste imports en projectconfiguratie toe.

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

Definieer nu de modelnaam, API-eindpunten, maximale agentbeurten, cv-pad en baansvoorkeuren.

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)

De waarden KIMI_MODEL en KIMI_BASE_URL geven de app door om Kimi K2.6 te gebruiken via Moonshot AI's OpenAI-compatibele API-eindpunt. De Olostep-URL's worden gebruikt voor live baanzoekopdrachten en het scrapen van pagina's.

De variabele cv_path verwijst naar de PDF van het cv van de kandidaat. Zorg dat de PDF in dezelfde projectmap staat, of werk het pad bij als deze ergens anders staat opgeslagen.

De variabele preferences vertelt de agent naar welk type baan gezocht moet worden. Je kunt dit aanpassen op basis van doelfunctie, sector, locatie, senioriteitsniveau of voorkeurswerkstijl.

We schakelen tracing uit met set_tracing_disabled(True) omdat tracing een functie is van de OpenAI Agents SDK die standaard is ingeschakeld. Omdat dit project Kimi gebruikt via een OpenAI-compatibel eindpunt, houdt het uitschakelen van tracing de lokale setup eenvoudig en voorkomt het tracing-gerelateerde problemen met een externe modelprovider.

3. Verbind met de Kimi K2.6 API

Richt daarna de Kimi-client in met de API-sleutel die je eerder als omgevingsvariabele hebt opgeslagen.

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

Dit maakt de API-client voor Kimi aan. De api_key wordt geladen uit MOONSHOT_API_KEY en de base_url wijst naar Moonshot AI's OpenAI-compatibele eindpunt.

Wikkel vervolgens het Kimi-model in zodat het binnen de OpenAI Agents SDK kan worden gebruikt:

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

Definieer nu de modelinstellingen:

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

De instelling tool_choice="auto" laat de agent beslissen wanneer tools te gebruiken. Met parallel_tool_calls=True kan de agent meerdere tooloproepen tegelijk uitvoeren wanneer dat nodig is.

We schakelen Kimi's thinking-modus ook uit met extra_body={"thinking": {"type": "disabled"}}. Dit houdt de output compacter en beter geschikt voor een gestructureerd job-fitrapport.

Maak ten slotte de runconfiguratie aan:

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

De workflow_name geeft deze run een duidelijke label. We houden tracing hier ook uitgeschakeld omdat dit project Kimi gebruikt via een OpenAI-compatibel eindpunt, niet via OpenAI's tracing-backend.

4. Haal tekst uit het cv van de kandidaat

Gebruik vervolgens PdfReader om het cv van de kandidaat te laden en de tekst uit elke pagina te halen.

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

Deze code leest het PDF-bestand dat is gedefinieerd in cv_path, haalt de tekst van elke pagina en voegt die samen tot één string.

De limiet [:12000] houdt de cv-tekst kort genoeg om comfortabel in de agentprompt te passen, terwijl het model nog genoeg context krijgt over de ervaring, vaardigheden en voorkeuren van de kandidaat.

De output ziet er ongeveer zo uit, afhankelijk van de naam en lengte van je cv-bestand:

Loaded 2,946 characters from abid-resume.pdf

Dit bevestigt dat het cv succesvol is geladen en laat zien hoeveel tekens er uit de PDF zijn gehaald.

5. Maak de agentinstructies 

Definieer vervolgens de instructies die bepalen hoe de agent zoekt, tools gebruikt en het eindrapport opmaakt.

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

Deze instructies houden de agent gefocust. Ze beperken de workflow tot één baanzoekopdracht, maximaal drie gelezen vacaturepagina's en een vaste Markdown-rapportstructuur.

De rapportregels maken de output ook makkelijker te scannen door korte bullets, klikbare links, fitscores en een duidelijke sollicitatiebeslissing per rol te vereisen.

6. Bouw de runtimeprompt

Maak na het definiëren van de agentinstructies de prompttemplate die bij elke run aan de agent wordt doorgegeven.

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

Deze prompt combineert de cv-tekst en baansvoorkeuren van de kandidaat tijdens runtime.

De placeholder cv_text wordt gevuld met de geëxtraheerde cv-inhoud, terwijl de placeholder preferences wordt gevuld met de eerder gedefinieerde doelfunctievoorkeuren. Samen geven ze de agent genoeg context om relevante banen te zoeken en ze op geschiktheid te rangschikken.

7. Voeg live webzoekopdrachten toe met Olostep

Nu de agentinstructies en runtimeprompt klaar zijn, voeg je twee tools toe waarmee de agent met Olostep het web kan doorzoeken en vacaturepagina's kan lezen.

De eerste tool zoekt het web af naar vacatures en geeft een compacte lijst met resultaten terug.

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

De decorator @function_tool maakt deze Pythonfunctie beschikbaar voor de agent als aanroepbare tool.

Wanneer de agent vacatures nodig heeft, roept hij search_jobs aan met een zoekquery. De functie stuurt de query naar het Olostep-zoekeindpunt, verzamelt de toppresultaten en retourneert ze als JSON.

Elk resultaat bevat:

• functietitel
• vacature-URL
• korte beschrijving

De tweede tool laat de agent een specifieke vacaturepagina openen en lezen.

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

Deze functie stuurt een vacature-URL naar het Olostep-scrape-eindpunt en retourneert de paginacontent in Markdown-indeling.

De limiet [:8000] houdt de gescrapete pagina kort genoeg om door de agent verwerkt te worden, terwijl de meest bruikbare vacaturinformatie behouden blijft, zoals verantwoordelijkheden, vereisten en bedrijfsinformatie.

8. Maak de JobFit AI-agent

Maak nu de agent en verbind alle onderdelen die je eerder hebt gedefinieerd: het Kimi-model, modelinstellingen, Olostep-tools en agentinstructies.

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

Het object Agent is de hoofdcontroller voor deze workflow.

Het gebruikt:

• kimi_model als redeneermodel
• model_settings om toolgebruik en outputgedrag te sturen
• search_jobs om live vacatures te vinden
• read_job_page om geselecteerde vacaturepagina's te scrapen
• AGENT_INSTRUCTIONS om de exacte zoek- en rapportregels te volgen

Op dit punt is de agent klaar om naar banen te zoeken, ze te vergelijken met het cv van de kandidaat en een gestructureerd JobFit AI-rapport te genereren.

9. Voer de agentworkflow uit

Voer nu de JobFit AI-agent uit met de geëxtraheerde cv-tekst en de eerder gedefinieerde baansvoorkeuren.

Formatteer eerst de runtimeprompt:

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

Dit vult de prompttemplate met het cv van de kandidaat en de doelbaansvoorkeuren.

Start vervolgens de gestreamde agentrun:

print("Starting agent run")


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

De methode Runner.run_streamed() start de agentworkflow en streamt events terwijl ze plaatsvinden. Zo zie je makkelijker wanneer de agent een tool oproept, tooloutput ontvangt en het laatste bericht maakt.

Voeg nu de streaminglus toe:

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

Deze lus print nuttige voortgangsupdates terwijl de agent draait. Zo zie je bijvoorbeeld wanneer de agent naar banen zoekt, een vacaturepagina leest of het rapport afrondt.

Sla tot slot de uiteindelijke output op in een variabele genaamd 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")

De variabele report slaat het uiteindelijke JobFit AI-rapport op, dat je kunt tonen, opslaan of gebruiken in de Gradio-app.

De output ziet er ongeveer zo uit:

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

Deze output bevestigt dat de agent naar banen heeft gezocht, geselecteerde pagina's heeft gelezen en het eindrapport succesvol heeft gegenereerd.

10. Toon het gegenereerde JobFit-rapport

Toon na afloop van de agentrun het eindrapport in Markdown-indeling.

display(Markdown(report))

Dit rendert het gegenereerde JobFit AI-rapport direct in de notebook, wat prettiger leest dan platte tekst.

Het rapport bevat de beste match, gerangschikte banen, fitscores, sollicitatiebeslissingen, aandachtspunten en invalshoeken voor de sollicitatie.

11. Zet de workflow om in een Gradio-webapp

Nadat je de workflow in de notebook hebt getest, kun je deze omzetten in een eenvoudige Gradio-webapp. Maak een app.py-bestand en kopieer vervolgens de code uit het bestand JobFit-AI/app.py in het GitHub-project en plak die in je lokale bestand.

Start de app met:

python app.py

Open vervolgens de lokale app in je browser via de weergegeven lokale URL (in dit geval http://127.0.0.1:7860/):

De Gradio-app biedt een eenvoudige interface voor het genereren van job-fitrapporten. Deze bevat:

• Een uploadveld voor cv's in PDF waarin gebruikers hun cv kunnen uploaden.
• Een tekstvak voor baansvoorkeuren waarin gebruikers het type rollen kunnen beschrijven dat ze willen, inclusief functietype, sector, locatie, senioriteit en voorkeursonderwerpen.
• Een knop Generate JobFit Report om de agentworkflow te starten.
• Een verborgen voortgangslog die tijdens de run verschijnt en toont wat de app doet, zoals het lezen van het cv, tools aanroepen en tooloutput ontvangen.
• Een eindrapportgebied in Markdown waar het gerangschikte job-fitrapport wordt weergegeven zodra de agent klaar is.

Onder de motorkap leest de app het geüploade cv, extraheert de tekst, stuurt het cv en de voorkeuren naar de JobFit AI-agent en zoekt live vacatures met Olostep. Hij leest tot drie vacaturepagina's en retourneert een gestructureerd Markdown-rapport met gerangschikte rollen, fitscores, sollicitatiebeslissingen, aandachtspunten en invalshoeken voor de sollicitatie.

12. Upload een cv en genereer een rapport

Test nu de webapp door een cv- of resume-PDF te uploaden en op Generate JobFit Report te klikken.

Voor dit voorbeeld heb ik een cv met ongeveer drie jaar ervaring geüpload om te zien of de app relevante banen kon vinden op basis van het profiel en de voorkeuren van de kandidaat. Het rapport werd in minder dan een minuut gegenereerd.

Terwijl de app draait, toont het voortgangslog elke stap van de workflow, waaronder:

• het cv lezen
• tekst uit elke pagina halen
• de agentrun starten
• de tool voor baanzoekopdrachten aanroepen
• de tooloutput retourneren

Zodra de run is voltooid, toont de app het eindrapport in Markdown-indeling.

Het rapport begint met de beste match, gevolgd door een tabel met gerangschikte banen. Daarna volgen meer gedetailleerde notities per rol, inclusief de fitscore, sollicitatiebeslissing, redenen waarom de rol past, mogelijke aandachtspunten en een invalshoek voor de sollicitatie.

In dit voorbeeld was het toppositie een Senior Data Science Writer-rol bij NannyML. Omdat de rol aansloot op de achtergrond van de kandidaat in data science, technisch schrijven en AI-content, leek het een sterke match.

Je kunt in het rapport op de link Apply here klikken om de vacaturepagina te openen en de volledige beschrijving te bekijken voordat je beslist of je solliciteert.

Opmerking: als je problemen ondervindt bij het lokaal draaien van het project, bekijk dan de GitHub-repository: kingabzpro/JobFit-AI. Deze bevat de notebook, het app.py-bestand en installatie-instructies om je te helpen de dependencies te installeren en het project lokaal te draaien. 

Tot slot

JobFit AI gebruikt Kimi K2.6, Olostep en de OpenAI Agent SDK om twee veelvoorkomende problemen op te lossen voor mensen die van rol wisselen of actief solliciteren.

Het eerste probleem is weten waar je moet solliciteren. Er zijn veel vacaturebanken, platforms en bedrijfswebsites, maar het is niet altijd duidelijk welke rollen de moeite waard zijn. Deze app helpt dat te versmallen door het cv en de voorkeuren van de kandidaat te gebruiken om banen te vinden die beter aansluiten op hun ervaring.

Het tweede probleem is het filteren door te veel vacatures. In plaats van elk vacatureplatform handmatig te controleren, zoekt de agent live listings, leest geselecteerde vacaturepagina's en maakt een gestructureerd rapport met de beste match, gerangschikte banen, fitscores, aandachtspunten en invalshoeken voor de sollicitatie. Zo kun je je makkelijker richten op rollen die echt de moeite waard zijn om op te solliciteren.

De Kimi K2.6 API presteerde ook goed in deze agentgebaseerde workflow. Hij was snel, betrouwbaar en effectief in het volgen van gestructureerde instructies. Tijdens het testen, wanneer de agent tot 25 beurten mocht gebruiken, zocht en scrapte hij meerdere pagina's dieper, maar duurde de run ongeveer vijf minuten. Om kwaliteit en snelheid te balanceren, heb ik de workflow beperkt tot één zoekopdracht en maximaal drie paginalezen, wat hielp om het rapport in minder dan een minuut te genereren.

Je kunt de kwaliteit van het baanrapport verbeteren door het aantal toegestane stappen, zoekresultaten of paginalezen te verhogen. Als je bijvoorbeeld de agentlimiet verhoogt naar 30 beurten en hem meer pagina's laat lezen, kan hij een dieper rapport produceren met meer rollen en sterkere aanbevelingen. Dit verhoogt echter ook de runtijd en het API-gebruik.

Als je geïnteresseerd bent in het maken van vergelijkbare agentic tools, bekijk dan onze andere API-tutorials over het bouwen van: 

• Thinking Mode Arena met DeepSeek V4
• Chart Digitizer met Claude Opus 4.7
• Factuurverwerkingspijplijn met Qwen 3.6 Plus
• Geautomatiseerde data-analyse met Gemini 3