Kimi K2.6 API-Tutorial: Einen KI-Job-Suchassistenten bauen

2. Projektkonfiguration festlegen 

Starte Jupyter Notebook, erstelle eine neue Zelle und füge die benötigten Importe sowie die Projektkonfiguration hinzu.

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

Definiere jetzt Modellname, API-Endpunkte, maximale Agent-Turns, CV-Pfad und Jobpräferenzen.

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)

Die Werte KIMI_MODEL und KIMI_BASE_URL sagen der App, dass Kimi K2.6 über Moonshot AIs OpenAI-kompatiblen API-Endpunkt verwendet werden soll. Die Olostep-URLs dienen für die Live-Jobsuche und das Scrapen von Seiten.

Die Variable cv_path zeigt auf die PDF des Kandidaten. Speichere die PDF im Projektordner oder passe den Pfad entsprechend an.

Die Variable preferences gibt dem Agenten vor, nach welchen Rollen gesucht werden soll. Du kannst sie nach Zielrolle, Branche, Standort, Senioritätslevel oder bevorzugtem Arbeitsstil anpassen.

Wir deaktivieren Tracing mit set_tracing_disabled(True), da Tracing im OpenAI Agents SDK standardmäßig aktiv ist. Weil dieses Projekt Kimi über einen OpenAI-kompatiblen Endpunkt nutzt, hält das die lokale Einrichtung schlank und vermeidet Tracing-Probleme mit einem Drittanbieter-Modell.

3. Mit der Kimi K2.6 API verbinden

Richte dann den Kimi-Client mit dem zuvor als Umgebungsvariable gespeicherten API-Schlüssel ein.

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

Damit erstellst du den API-Client für Kimi. Der api_key wird aus MOONSHOT_API_KEY geladen und base_url zeigt auf Moonshot AIs OpenAI-kompatiblen Endpunkt.

Als Nächstes kapselst du das Kimi-Modell, damit es im OpenAI Agents SDK genutzt werden kann:

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

Lege nun die Modelleinstellungen fest:

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

Die Einstellung tool_choice="auto" überlässt dem Agenten, wann Tools aufgerufen werden. Mit parallel_tool_calls=True kann der Agent mehrere Toolaufrufe parallel ausführen.

Wir deaktivieren außerdem Kimis Thinking-Mode mit extra_body={"thinking": {"type": "disabled"}}. So bleibt die Ausgabe kompakt und besser geeignet für einen strukturierten Job-Fit-Report.

Erstelle abschließend die Run-Konfiguration:

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

Der workflow_name gibt diesem Lauf eine klare Bezeichnung. Wir lassen Tracing auch hier aus, da dieses Projekt Kimi über einen OpenAI-kompatiblen Endpunkt nutzt und nicht OpenAIs Tracing-Backend.

4. Text aus dem Lebenslauf extrahieren

Nutze als Nächstes PdfReader, um den Lebenslauf zu laden und den Text seitenweise zu extrahieren.

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

Dieser Code liest die in cv_path definierte PDF, extrahiert pro Seite den Text und führt alles zu einem String zusammen.

Die Begrenzung [:12000] hält den Lebenslauftext kurz genug für den Agenten-Prompt und liefert trotzdem ausreichend Kontext zu Erfahrung, Kompetenzen und Präferenzen.

Die Ausgabe sieht in etwa so aus, je nach Name und Länge deiner Datei:

Loaded 2,946 characters from abid-resume.pdf

Das bestätigt, dass der Lebenslauf erfolgreich geladen wurde, und zeigt, wie viele Zeichen extrahiert wurden.

5. Agenten-Instruktionen erstellen 

Definiere nun die Anweisungen, wie der Agent suchen, Tools nutzen und den finalen Report formatieren soll.

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

Diese Instruktionen halten den Agenten fokussiert. Sie begrenzen den Workflow auf eine Suche, bis zu drei Seitenlesevorgänge und eine feste Markdown-Reportstruktur.

Die Reportregeln machen die Ausgabe gut scanbar: kurze Bulletpoints, klickbare Links, Fit-Scores und eine klare Bewerbungsentscheidung pro Rolle.

6. Den Laufzeit-Prompt erstellen

Nachdem die Agenten-Instruktionen stehen, erstellst du die Prompt-Vorlage, die dem Agenten während jedes Laufs übergeben wird.

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

Dieser Prompt kombiniert zur Laufzeit den CV-Text und die Jobpräferenzen der kandidierenden Person.

Der Platzhalter cv_text wird mit dem extrahierten Lebenslauf gefüllt, während preferences die zuvor definierten Zielpräferenzen enthält. Zusammen liefern sie genug Kontext, um relevante Jobs zu finden und nach Passung zu ranken.

7. Live-Websuche mit Olostep hinzufügen

Da die Instruktionen und der Laufzeit-Prompt bereit sind, fügst du zwei Tools hinzu, mit denen der Agent über Olostep das Web durchsuchen und Jobseiten lesen kann.

Das erste Tool durchsucht das Web nach Stellen und liefert eine kompakte Ergebnisliste.

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

Der @function_tool-Decorator macht diese Python-Funktion als aufrufbares Tool für den Agenten verfügbar.

Wenn der Agent Joblisten benötigt, ruft er search_jobs mit einer Suchanfrage auf. Die Funktion sendet die Query an den Olostep-Suchendpunkt, sammelt die Top-Ergebnisse und gibt sie als JSON zurück.

Jedes Ergebnis enthält:

• Jobtitel
• Job-URL
• kurze Beschreibung

Das zweite Tool lässt den Agenten eine konkrete Jobseite öffnen und lesen.

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

Diese Funktion sendet eine Job-URL an den Olostep-Scrape-Endpunkt und gibt den Seiteninhalt als Markdown zurück.

Die Begrenzung [:8000] hält die gescrapte Seite kompakt genug, um sie zu verarbeiten, und enthält dennoch die wichtigsten Details wie Aufgaben, Anforderungen und Firmeninfos.

8. Den JobFit-AI-Agenten erstellen

Erstelle nun den Agenten und verbinde alle zuvor definierten Bausteine: Kimi-Modell, Modelleinstellungen, Olostep-Tools und Agenten-Instruktionen.

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

Das Agent-Objekt ist der Haupt-Controller dieses Workflows.

Es nutzt:

• kimi_model als Reasoning-Modell
• model_settings zur Steuerung von Toolnutzung und Ausgabe
• search_jobs für Live-Jobsuchen
• read_job_page zum Scrapen ausgewählter Seiten
• AGENT_INSTRUCTIONS zur exakten Einhaltung von Such- und Reportregeln

Damit ist der Agent bereit, nach Jobs zu suchen, sie gegen den Lebenslauf der Person zu prüfen und einen strukturierten JobFit-AI-Report zu erzeugen.

9. Den Agent-Workflow ausführen

Führe den JobFit-AI-Agenten jetzt mit dem extrahierten CV-Text und den zuvor definierten Präferenzen aus.

Formatiere zuerst den Laufzeit-Prompt:

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

Damit füllst du die Vorlage mit Lebenslauf und Zielpräferenzen.

Starte als Nächstes den gestreamten Agentenlauf:

print("Starting agent run")


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

Die Methode Runner.run_streamed() startet den Workflow und streamt Ereignisse in Echtzeit. So siehst du, wann der Agent ein Tool aufruft, Ausgaben erhält und die finale Nachricht erzeugt.

Füge nun die Streaming-Schleife hinzu:

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

Diese Schleife gibt hilfreiche Fortschrittsupdates aus — z. B. wenn der Agent sucht, eine Seite liest oder den Report fertigstellt.

Speichere abschließend die finale Ausgabe in einer Variablen namens 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")

Die Variable report enthält den finalen JobFit-AI-Report, den du anzeigen, speichern oder in der Gradio-App nutzen kannst.

Die Ausgabe könnte so aussehen:

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

Das bestätigt, dass der Agent gesucht, Seiten gelesen und den finalen Report erfolgreich erzeugt hat.

10. Den erzeugten JobFit-Report anzeigen

Zeige nach Abschluss des Laufs den finalen Report in Markdown an.

display(Markdown(report))

So wird der generierte JobFit-AI-Report direkt im Notebook gerendert — deutlich lesbarer als Plain-Text.

Der Report enthält den Best Match, eine Rangliste, Fit-Scores, Bewerbungsentscheidungen, Bedenken und Vorschläge für die Bewerbung.

11. Den Workflow in eine Gradio-Web-App verwandeln

Nachdem du den Workflow im Notebook getestet hast, kannst du ihn in eine einfache Gradio-Web-App überführen. Erstelle eine Datei app.py und kopiere den Code aus der JobFit-AI/app.py-Datei im GitHub-Projekt in deine lokale Datei.

Starte die App mit:

python app.py

Rufe die lokale App dann im Browser über die angezeigte URL auf (hier http://127.0.0.1:7860/):

Die Gradio-App bietet ein unkompliziertes Interface zur Erstellung von Job-Fit-Reports. Enthalten sind:

• Ein Upload-Feld für CV-PDFs, um den Lebenslauf hochzuladen.
• Ein Textfeld für Jobpräferenzen (Rolle, Branche, Standort, Seniorität, bevorzugte Themen).
• Ein Button Generate JobFit Report, um den Agenten-Workflow zu starten.
• Ein verstecktes Fortschrittsprotokoll, das während des Laufs erscheint und zeigt, was die App gerade tut (CV lesen, Tools aufrufen, Toolausgaben empfangen).
• Ein Markdown-Bereich, der nach Abschluss den priorisierten Job-Fit-Report anzeigt.

Im Hintergrund liest die App den hochgeladenen Lebenslauf, extrahiert den Text, übergibt CV und Präferenzen an den JobFit-AI-Agenten und sucht mit Olostep Live-Stellen. Sie liest bis zu drei Jobseiten und liefert einen strukturierten Markdown-Report mit Rangliste, Fit-Scores, Bewerbungsentscheidungen, Bedenken und Anwendungstipps.

12. Lebenslauf hochladen und Report erzeugen

Teste die Web-App, indem du eine CV- bzw. Resume-PDF hochlädst und auf Generate JobFit Report klickst.

In diesem Beispiel habe ich einen Lebenslauf mit rund drei Jahren Erfahrung hochgeladen, um zu sehen, ob die App auf Basis von Profil und Präferenzen passende Rollen findet. Der Report wurde in unter einer Minute erzeugt.

Während die App läuft, zeigt das Protokoll jeden Schritt des Workflows, darunter:

• Lesen des Lebenslaufs
• Textextraktion pro Seite
• Start des Agentenlaufs
• Aufruf des Jobsuche-Tools
• Rückgabe der Toolausgabe

Nach Abschluss zeigt die App den finalen Report im Markdown-Format.

Der Report beginnt mit dem Best Match, gefolgt von einer Rangtabelle. Danach folgen detaillierte Notizen pro Rolle mit Fit-Score, Bewerbungsentscheidung, Gründen für die Passung, möglichen Bedenken und einer Bewerbungsperspektive.

In diesem Beispiel war das Top-Ergebnis eine Senior Data Science Writer Rolle bei NannyML. Da die Rolle zum Hintergrund der Kandidatin bzw. des Kandidaten in Data Science, Technical Writing und KI-Content passt, wirkt sie sehr stimmig.

Du kannst im Report auf Apply here klicken, um die Jobseite zu öffnen und die volle Ausschreibung zu prüfen, bevor du dich entscheidest.

Hinweis: Wenn du lokal auf Probleme stößt, sieh dir das GitHub-Repository an: kingabzpro/JobFit-AI. Dort findest du Notebook, app.py und Setup-Anweisungen, um die Abhängigkeiten zu installieren und das Projekt lokal auszuführen. 

Abschließende Gedanken

JobFit AI nutzt Kimi K2.6, Olostep und das OpenAI Agent SDK, um zwei häufige Probleme für Menschen zu lösen, die sich beruflich umorientieren oder aktiv bewerben.

Das erste Problem ist zu wissen, wo man sich bewerben sollte. Es gibt viele Jobbörsen, Plattformen und Karriereseiten von Firmen, aber nicht immer ist klar, welche Rollen sich lohnen. Die App engt das ein, indem sie mit Lebenslauf und Präferenzen gezielter passende Jobs findet.

Das zweite Problem ist die Flut an Listings. Statt jede Plattform manuell zu prüfen, sucht der Agent Live-Stellen, liest ausgewählte Seiten und erstellt einen strukturierten Report mit Best Match, Rangliste, Fit-Scores, Bedenken und Bewerbungsperspektiven. So fokussierst du dich schneller auf wirklich passende Rollen.

Die Kimi K2.6 API hat sich in diesem agentenbasierten Workflow zudem bewährt: schnell, zuverlässig und gut in der Befolgung strukturierter Instruktionen. In Tests konnte der Agent mit bis zu 25 Turns mehrere Seiten tiefgreifender durchsuchen und scrapen, der Lauf dauerte dann jedoch rund fünf Minuten. Für ein gutes Verhältnis aus Qualität und Geschwindigkeit habe ich auf eine Suche und bis zu drei Seitenlesevorgänge begrenzt — so entsteht der Report in unter einer Minute.

Du kannst die Qualität des Reports steigern, indem du die erlaubten Schritte, Suchergebnisse oder Seitenlesungen erhöhst. Erlaubst du z. B. 30 Turns und mehr Seitenaufrufe, fällt der Report tiefer und die Empfehlungen klarer aus — allerdings auf Kosten von Laufzeit und API-Nutzung.

Wenn du interessiert bist, ähnliche agentische Tools zu bauen, sieh dir unsere weiteren API-Tutorials an zu: 

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