Samouczek API Kimi K2.6: Budowa asystenta AI do wyszukiwania ofert pracy

2. Zdefiniuj konfigurację projektu 

Uruchom Jupyter Notebook, utwórz nową komórkę i dodaj wymagane importy oraz konfigurację projektu.

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

Teraz proszę zdefiniować nazwę modelu, punkty końcowe API, maksymalną liczbę tur agenta, ścieżkę do CV i preferencje pracy.

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)

Wartości KIMI_MODEL i KIMI_BASE_URL wskazują aplikacji, aby używała Kimi K2.6 poprzez zgodny z OpenAI punkt końcowy Moonshot AI. Adresy URL Olostep służą do wyszukiwania aktualnych ofert i scrapowania stron.

Zmienna cv_path wskazuje na plik PDF z CV kandydata. Proszę upewnić się, że PDF jest zapisany w tym samym folderze projektu lub zaktualizować ścieżkę, jeśli znajduje się gdzie indziej.

Zmienna preferences informuje agenta, jakich typów ofert ma szukać. Można ją dostosować do docelowej roli, branży, lokalizacji, poziomu seniority lub preferowanego stylu pracy.

Wyłączamy śledzenie przy użyciu set_tracing_disabled(True), ponieważ tracing to funkcja OpenAI Agents SDK włączona domyślnie. Ponieważ projekt używa Kimi przez zgodny punkt końcowy OpenAI, wyłączenie śledzenia upraszcza lokalną konfigurację i unika problemów związanych ze śledzeniem u zewnętrznego dostawcy modelu.

3. Połącz się z API Kimi K2.6

Następnie proszę skonfigurować klienta Kimi, używając zapisanego wcześniej klucza API jako zmiennej środowiskowej.

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

Tworzy to klienta API dla Kimi. api_key jest ładowany z MOONSHOT_API_KEY, a base_url wskazuje na zgodny z OpenAI punkt końcowy Moonshot AI.

Następnie proszę „owinąć” model Kimi, aby można go było używać w OpenAI Agents SDK:

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

Teraz proszę zdefiniować ustawienia modelu:

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

Ustawienie tool_choice="auto" pozwala agentowi decydować, kiedy wywoływać narzędzia. parallel_tool_calls=True umożliwia równoległe wywołania narzędzi, gdy jest to potrzebne.

Wyłączamy też tryb „myślenia” Kimi przez extra_body={"thinking": {"type": "disabled"}}. Dzięki temu wynik jest czystszy i lepiej pasuje do ustrukturyzowanego raportu dopasowania.

Na koniec proszę utworzyć konfigurację uruchomienia:

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

Pole workflow_name nadaje temu uruchomieniu czytelną etykietę. Nadal wyłączamy tu tracing, ponieważ projekt używa Kimi przez zgodny punkt końcowy OpenAI, a nie zaplecze śledzenia OpenAI.

4. Wyodrębnij tekst z CV kandydata

Teraz proszę użyć PdfReader do załadowania CV kandydata i wyodrębnienia tekstu z każdej strony.

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

Ten kod czyta plik PDF wskazany w cv_path, wyodrębnia tekst z każdej strony i łączy go w jeden łańcuch znaków.

Limit [:12000] utrzymuje tekst CV na tyle krótki, by wygodnie zmieścił się w podpowiedzi agenta, a jednocześnie zapewnia modelowi dość kontekstu o doświadczeniu, umiejętnościach i preferencjach kandydata.

Wynik będzie wyglądał podobnie do tego — w zależności od nazwy i długości pliku CV:

Loaded 2,946 characters from abid-resume.pdf

To potwierdza, że CV zostało pomyślnie załadowane i pokazuje, ile znaków wyodrębniono z PDF.

5. Utwórz instrukcje dla agenta 

Następnie proszę zdefiniować instrukcje, które kontrolują sposób wyszukiwania, użycia narzędzi i formatowania końcowego raportu.

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

Te instrukcje utrzymują skupienie agenta. Ograniczają przepływ do jednego wyszukiwania, maksymalnie trzech odczytów stron ofert i stałej struktury raportu w Markdown.

Zasady raportu ułatwiają też jego skanowanie, wymagając krótkich wypunktowań, klikalnych linków, ocen dopasowania i jasnej decyzji o aplikowaniu dla każdej roli.

6. Zbuduj podpowiedź uruchomieniową

Po zdefiniowaniu instrukcji agenta proszę utworzyć szablon podpowiedzi, który będzie przekazywany agentowi przy każdym uruchomieniu.

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

Ta podpowiedź łączy tekst CV kandydata i preferencje pracy w czasie wykonania.

Symbol zastępczy cv_text jest wypełniany wyodrębnioną treścią CV, a preferences — zdefiniowanymi wcześniej preferencjami roli. Razem dają agentowi wystarczający kontekst, by wyszukać odpowiednie oferty i uszeregować je według dopasowania.

7. Dodaj wyszukiwanie w sieci z Olostep

Skoro instrukcje agenta i podpowiedź uruchomieniowa są gotowe, proszę dodać dwa narzędzia pozwalające agentowi wyszukiwać w sieci i czytać strony z ofertami za pomocą Olostep.

Pierwsze narzędzie przeszukuje sieć pod kątem ofert pracy i zwraca zwięzłą listę wyników.

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

Dekorator @function_tool udostępnia tę funkcję Pythona agentowi jako wywoływalne narzędzie.

Gdy agent potrzebuje listy ofert, wywołuje search_jobs z zapytaniem. Funkcja wysyła zapytanie do punktu wyszukiwania Olostep, zbiera najlepsze wyniki i zwraca je jako JSON.

Każdy wynik obejmuje:

• stanowisko
• adres URL oferty
• krótki opis

Drugie narzędzie pozwala agentowi otworzyć i przeczytać konkretną stronę oferty.

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

Ta funkcja wysyła adres URL oferty do punktu scrapowania Olostep i zwraca treść strony w formacie Markdown.

Limit [:8000] utrzymuje zeskrapowaną stronę na tyle krótką, by agent mógł ją przetworzyć, a jednocześnie zawiera najważniejsze informacje: obowiązki, wymagania i dane o firmie.

8. Utwórz agenta JobFit AI

Teraz proszę utworzyć agenta i połączyć wszystkie wcześniej zdefiniowane elementy: model Kimi, ustawienia modelu, narzędzia Olostep i instrukcje agenta.

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

Obiekt Agent jest głównym kontrolerem tego przepływu pracy.

Wykorzystuje:

• kimi_model jako model rozumujący
• model_settings do kontroli użycia narzędzi i zachowania wyjścia
• search_jobs do znajdowania aktualnych ofert
• read_job_page do scrapowania wybranych stron ofert
• AGENT_INSTRUCTIONS do ścisłego przestrzegania zasad wyszukiwania i raportu

W tym momencie agent jest gotowy, by wyszukać oferty, porównać je z CV kandydata i wygenerować ustrukturyzowany raport JobFit AI.

9. Uruchom przepływ pracy agenta

Teraz proszę uruchomić agenta JobFit AI, używając wyodrębnionego tekstu CV i wcześniej zdefiniowanych preferencji pracy.

Najpierw proszę sformatować podpowiedź uruchomieniową:

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

Wypełnia to szablon podpowiedzi treścią CV kandydata i docelowymi preferencjami ról.

Następnie proszę rozpocząć strumieniowane uruchomienie agenta:

print("Starting agent run")


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

Metoda Runner.run_streamed() uruchamia przepływ agenta i strumieniuje zdarzenia na bieżąco. Dzięki temu łatwiej zobaczyć, kiedy agent wywołuje narzędzie, otrzymuje wynik z narzędzia i tworzy wiadomość końcową.

Teraz proszę dodać pętlę strumieniującą:

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

Ta pętla wypisuje przydatne aktualizacje postępu w trakcie działania agenta. Na przykład pokazuje, kiedy agent wyszukuje oferty, czyta stronę oferty lub kończy generowanie raportu.

Na koniec proszę zapisać wynik końcowy do zmiennej 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")

Zmienna report przechowuje końcowy raport JobFit AI, który można wyświetlić, zapisać lub użyć w aplikacji Gradio.

Wynik wygląda mniej więcej tak:

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

To potwierdza, że agent wyszukał oferty, odczytał wybrane strony i pomyślnie wygenerował raport końcowy.

10. Wyświetl wygenerowany raport JobFit

Po zakończeniu działania agenta proszę wyświetlić końcowy raport w formacie Markdown.

display(Markdown(report))

To renderuje wygenerowany raport JobFit AI bezpośrednio w notatniku, co ułatwia czytanie w porównaniu z czystym tekstem.

Raport zawiera najlepsze dopasowanie, ranking ofert, oceny dopasowania, decyzje o aplikowaniu, obawy i sugestie dotyczące aplikacji.

11. Zamień przepływ pracy w aplikację webową Gradio

Po przetestowaniu przepływu w notatniku można przekształcić go w prostą aplikację webową Gradio. Proszę utworzyć plik app.py, a następnie skopiować kod z pliku JobFit-AI/app.py w projekcie na GitHub i wkleić go do lokalnego pliku.

Uruchomienie aplikacji:

python app.py

Następnie proszę otworzyć lokalną aplikację w przeglądarce pod wyświetlonym adresem (w tym przypadku http://127.0.0.1:7860/):

Aplikacja Gradio zapewnia prosty interfejs do generowania raportów dopasowania do ofert pracy. Obejmuje:

• Pole przesyłania pliku PDF z CV, w którym użytkownicy mogą załadować swoje CV.
• Pole tekstowe preferencji pracy, w którym użytkownicy mogą opisać typ poszukiwanych ról, w tym rodzaj stanowiska, branżę, lokalizację, poziom seniority i preferowane tematy.
• Przycisk Generate JobFit Report do uruchomienia przepływu agenta.
• Ukryty dziennik postępu, który pojawia się w trakcie działania i pokazuje, co robi aplikacja — np. czytanie CV, wywoływanie narzędzi i odbieranie wyników.
• Końcowy obszar raportu Markdown, w którym wyświetlany jest rankingowy raport po zakończeniu pracy agenta.

W tle aplikacja czyta przesłane CV, wyodrębnia tekst, przekazuje CV i preferencje do agenta JobFit AI oraz wyszukuje aktualne oferty z Olostep. Czyta do trzech stron ofert i zwraca ustrukturyzowany raport Markdown z uszeregowanymi rolami, ocenami dopasowania, decyzjami o aplikowaniu, obawami i sugestiami dotyczącymi aplikacji.

12. Prześlij CV i wygeneruj raport

Teraz proszę przetestować aplikację webową, przesyłając PDF z CV/życiorysem i klikając Generate JobFit Report.

W tym przykładzie przesłałem CV z około trzyletnim doświadczeniem, aby sprawdzić, czy aplikacja potrafi znaleźć odpowiednie oferty na podstawie profilu i preferencji kandydata. Raport został wygenerowany w mniej niż minutę.

Podczas działania aplikacji dziennik postępu pokazuje każdy krok przepływu, w tym:

• czytanie CV
• wyodrębnianie tekstu z każdej strony
• rozpoczęcie działania agenta
• wywołanie narzędzia wyszukiwania ofert
• zwrócenie wyniku narzędzia

Po zakończeniu działania aplikacja wyświetla raport końcowy w formacie Markdown.

Raport zaczyna się od najlepszego dopasowania, po którym następuje tabela z rankingiem ofert. Następnie zawiera bardziej szczegółowe notatki dla każdej roli, w tym ocenę dopasowania, decyzję o aplikowaniu, powody dopasowania, możliwe obawy i sugestię dotyczącą sposobu aplikowania.

W tym przykładzie najlepszym wynikiem było stanowisko Senior Data Science Writer w NannyML. Ponieważ rola odpowiadała doświadczeniu kandydata w data science, pisaniu technicznym i treściach AI, wydawała się mocno dopasowana.

Można kliknąć link Apply here w raporcie, aby otworzyć stronę oferty i przejrzeć pełne ogłoszenie przed podjęciem decyzji o aplikowaniu.

Uwaga: Jeśli napotkają Państwo problemy podczas lokalnego uruchamiania projektu, proszę sprawdzić repozytorium GitHub: kingabzpro/JobFit-AI. Zawiera notatnik, plik app.py i instrukcje konfiguracji, które pomogą zainstalować zależności i uruchomić projekt lokalnie. 

Podsumowanie

JobFit AI wykorzystuje Kimi K2.6, Olostep i OpenAI Agent SDK, aby rozwiązać dwa powszechne problemy osób zmieniających role lub aktywnie aplikujących o pracę.

Pierwszym problemem jest wiedza, gdzie aplikować. Istnieje wiele job boardów, platform i stron karier firm, ale nie zawsze wiadomo, które role są warte poświęcenia czasu. Ta aplikacja zawęża wybór, korzystając z CV i preferencji kandydata, aby znaleźć oferty bardziej odpowiednie do jego doświadczenia.

Drugim problemem jest filtrowanie nadmiaru ogłoszeń. Zamiast ręcznie sprawdzać każdy job board, agent wyszukuje aktualne ogłoszenia, czyta wybrane strony i tworzy ustrukturyzowany raport z najlepszym dopasowaniem, rankingiem ofert, ocenami dopasowania, obawami i sugestiami aplikacyjnymi. To ułatwia skupienie się na rolach, na które rzeczywiście warto aplikować.

API Kimi K2.6 również sprawdziło się w tym przepływie opartym na agencie — było szybkie, niezawodne i skutecznie podążało za ustrukturyzowanymi instrukcjami. W testach, gdy agent miał do 25 tur, przeszukiwał i scrapował wiele stron bardziej dogłębnie, ale uruchomienie trwało około pięciu minut. Aby zrównoważyć jakość i szybkość, ograniczyłem przepływ do jednego wyszukiwania i maksymalnie trzech odczytów stron, co pozwoliło wygenerować raport w mniej niż minutę.

Jakość raportu można poprawić, zwiększając liczbę dozwolonych kroków, wyników wyszukiwania lub odczytów stron. Na przykład, jeśli zwiększą Państwo limit agenta do 30 tur i pozwolą mu czytać więcej stron z ofertami, może on przygotować głębszy raport z większą liczbą ról i mocniejszymi rekomendacjami. Zwiększy to jednak czas działania i zużycie API.

Jeśli są Państwo zainteresowani tworzeniem podobnych narzędzi agentowych, proszę sprawdzić inne nasze samouczki API dotyczące budowy: 

• Thinking Mode Arena z DeepSeek V4
• Chart Digitizer z Claude Opus 4.7
• Pipeline przetwarzania faktur z Qwen 3.6 Plus
• Automatyzator analizy danych z Gemini 3