Cours
Travailler avec l'API OpenAI
3 h
139.9K
Introduction aux agents d'intelligence artificielle
Apprenez les principes fondamentaux des agents d'intelligence artificielle, leurs composants et leur utilisation dans le monde réel - aucun codage n'est nécessaire.
2. Définissez la configuration du projet
Lancez Jupyter Notebook, créez une nouvelle cellule et ajoutez les imports nécessaires ainsi que la configuration du projet.
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 PdfReaderDéfinissez maintenant le nom du modèle, les endpoints d’API, le nombre maximal de tours de l’agent, le chemin du CV et les préférences de poste.
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)Les valeurs KIMI_MODEL et KIMI_BASE_URL indiquent à l’application d’utiliser Kimi K2.6 via l’endpoint compatible OpenAI de Moonshot AI. Les URLs Olostep servent à la recherche d’offres en direct et au scraping des pages.
La variable cv_path pointe vers le fichier PDF du CV. Assurez-vous que le PDF est enregistré dans le même dossier de projet, ou mettez à jour le chemin s’il est stocké ailleurs.
La variable preferences indique à l’agent le type de postes à rechercher. Adaptez-la selon le rôle visé, le secteur, la localisation, le niveau de séniorité ou le mode de travail souhaité.
Nous désactivons le tracing avec set_tracing_disabled(True) car cette fonctionnalité du SDK OpenAI Agents est activée par défaut. Comme ce projet utilise Kimi via un endpoint compatible OpenAI, la désactiver simplifie la configuration locale et évite les problèmes de tracing avec un fournisseur tiers.
3. Connectez-vous à l’API Kimi K2.6
Configurez ensuite le client Kimi en utilisant la clé API précédemment enregistrée comme variable d’environnement.
kimi_client = AsyncOpenAI(
api_key=os.environ["MOONSHOT_API_KEY"],
base_url=KIMI_BASE_URL,
)Cela crée le client API pour Kimi. La api_key est chargée depuis MOONSHOT_API_KEY et le base_url pointe vers l’endpoint compatible OpenAI de Moonshot AI.
Enveloppez ensuite le modèle Kimi pour l’utiliser dans le SDK OpenAI Agents :
kimi_model = OpenAIChatCompletionsModel(
model=KIMI_MODEL,
openai_client=kimi_client,
)Définissez maintenant les paramètres du modèle :
model_settings = ModelSettings(
tool_choice="auto",
parallel_tool_calls=True,
extra_body={"thinking": {"type": "disabled"}},
)Le paramètre tool_choice="auto" laisse l’agent décider quand appeler des outils. parallel_tool_calls=True autorise l’exécution simultanée de plusieurs appels d’outils lorsque nécessaire.
Nous désactivons également le mode « thinking » de Kimi avec extra_body={"thinking": {"type": "disabled"}}. Cela rend la sortie plus épurée et mieux adaptée à un rapport de pertinence structuré.
Enfin, créez la configuration d’exécution :
run_config = RunConfig(
workflow_name="JobFit AI Kimi Search",
tracing_disabled=True,
)Le workflow_name donne un libellé clair à cette exécution. Nous conservons également le tracing désactivé ici car ce projet utilise Kimi via un endpoint compatible OpenAI, et non l’infrastructure de tracing d’OpenAI.
4. Extrayez le texte du CV du ou de la candidat·e
Utilisez ensuite PdfReader pour charger le CV et extraire le texte de chaque page.
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}")Ce code lit le fichier PDF défini dans cv_path, extrait le texte de chaque page et le combine en une chaîne unique.
La limite [:12000] garde le texte du CV suffisamment court pour tenir confortablement dans l’invite de l’agent, tout en donnant au modèle assez de contexte sur l’expérience, les compétences et les préférences du ou de la candidat·e.
La sortie ressemblera à ceci, selon le nom et la longueur de votre fichier CV :
Loaded 2,946 characters from abid-resume.pdfCela confirme que le CV a été chargé avec succès et indique le nombre de caractères extraits du PDF.
5. Créez les instructions de l’agent
Définissez ensuite les instructions qui pilotent la recherche, l’usage des outils et le format du rapport final.
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()Ces instructions maintiennent l’agent concentré. Elles limitent le workflow à une seule recherche d’offres, jusqu’à trois lectures de pages d’annonce et un format de rapport Markdown fixe.
Les règles du rapport facilitent également la lecture, en imposant des puces courtes, des liens cliquables, des scores d’adéquation et une décision claire pour chaque poste.
6. Construisez l’invite d’exécution
Après avoir défini les instructions, créez le modèle d’invite qui sera transmis à l’agent à chaque exécution.
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()Cette invite combine le texte du CV du ou de la candidat·e et ses préférences de postes à l’exécution.
Le placeholder cv_text est rempli avec le contenu extrait du CV, tandis que preferences reprend les préférences de rôle définies plus haut. Ensemble, ils fournissent à l’agent le contexte nécessaire pour rechercher des offres pertinentes et les classer par adéquation.
7. Ajoutez la recherche web en direct avec Olostep
Maintenant que les instructions et l’invite d’exécution sont prêtes, ajoutez deux outils permettant à l’agent de rechercher sur le web et de lire des pages d’offres via Olostep.
Le premier outil recherche des listes d’offres et renvoie une liste de résultats compacte.
@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)Le décorateur @function_tool rend cette fonction Python disponible pour l’agent en tant qu’outil appelable.
Quand l’agent a besoin de listes d’offres, il appelle search_jobs avec une requête. La fonction envoie la requête à l’endpoint de recherche Olostep, récupère les meilleurs résultats et les renvoie en JSON.
Chaque résultat inclut :
- intitulé du poste
- URL de l’offre
- courte description
Le second outil permet à l’agent d’ouvrir et de lire une page d’offre précise.
@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]Cette fonction envoie l’URL d’une offre à l’endpoint de scraping d’Olostep et renvoie le contenu de la page au format Markdown.
La limite [:8000] garde la page scrapée assez courte pour que l’agent la traite, tout en capturant les informations clés : missions, prérequis et informations sur l’entreprise.
8. Créez l’agent JobFit AI
Créez maintenant l’agent et reliez tous les éléments définis : le modèle Kimi, ses paramètres, les outils Olostep et les instructions.
agent = Agent(
name="JobFit AI",
model=kimi_model,
model_settings=model_settings,
tools=[search_jobs, read_job_page],
instructions=AGENT_INSTRUCTIONS,
)L’objet Agent est le contrôleur principal de ce workflow.
Il utilise :
kimi_modelcomme modèle de raisonnementmodel_settingspour piloter l’usage des outils et le comportement de sortiesearch_jobspour trouver des offres en directread_job_pagepour scraper des pages d’offres sélectionnéesAGENT_INSTRUCTIONSpour suivre précisément les règles de recherche et de rapport
À ce stade, l’agent est prêt à rechercher des offres, les comparer au CV et générer un rapport structuré JobFit AI.
9. Exécutez le workflow de l’agent
Lancez maintenant l’agent JobFit AI en utilisant le texte extrait du CV et les préférences définies.
Commencez par formater l’invite d’exécution :
prompt = RUN_PROMPT_TEMPLATE.format(cv_text=cv_text, preferences=preferences)Cela complète le modèle d’invite avec le CV et les préférences cibles.
Démarrez ensuite l’exécution streamée de l’agent :
print("Starting agent run")
result = Runner.run_streamed(
agent,
prompt,
max_turns=MAX_AGENT_TURNS,
run_config=run_config,
)La méthode Runner.run_streamed() lance le workflow et diffuse les événements au fil de l’eau. Cela permet de voir quand l’agent appelle un outil, reçoit une sortie et produit le message final.
Ajoutez maintenant la boucle de 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")Cette boucle affiche des informations de progression utiles durant l’exécution. Par exemple, elle signale quand l’agent recherche des offres, lit une page d’annonce ou termine la génération du rapport.
Enfin, enregistrez la sortie finale dans une variable appelée 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")La variable report stocke le rapport JobFit AI final, que vous pouvez afficher, enregistrer ou intégrer dans l’application Gradio.
La sortie ressemble à ceci :
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 charsCette sortie confirme que l’agent a recherché des offres, lu des pages sélectionnées et généré le rapport final avec succès.
10. Affichez le rapport JobFit généré
Une fois l’exécution terminée, affichez le rapport final en Markdown.
display(Markdown(report))Cela rend le rapport JobFit AI directement dans le notebook, plus lisible qu’un simple texte brut.
Le rapport inclut la meilleure correspondance, des postes classés, des scores d’adéquation, des décisions de candidature, des points de vigilance et des angles de candidature.
11. Transformez le workflow en application web Gradio
Après avoir testé le workflow dans le notebook, vous pouvez le transformer en application web Gradio. Créez un fichier app.py, puis copiez le code depuis le fichier JobFit-AI/app.py du projet GitHub et collez-le dans votre fichier local.
Lancez l’application avec :
python app.py
Ouvrez ensuite l’application locale dans votre navigateur à l’URL affichée (ici, http://127.0.0.1:7860/) :
L’application Gradio propose une interface simple pour générer des rapports de pertinence. Elle inclut :
- Un champ de téléversement de CV PDF pour importer son CV.
- Une zone de texte pour décrire le type de postes recherchés : rôle, secteur, localisation, niveau de séniorité et thématiques préférées.
- Un bouton Generate JobFit Report pour lancer le workflow de l’agent.
- Un journal de progression masqué qui apparaît pendant l’exécution et affiche les actions en cours : lecture du CV, appels d’outils, retours d’outils.
- Une zone de rapport Markdown final qui affiche le classement une fois l’agent terminé.
En arrière-plan, l’application lit le CV téléversé, en extrait le texte, envoie le CV et les préférences à l’agent JobFit AI et recherche des offres en direct avec Olostep. Elle lit jusqu’à trois pages d’offres et renvoie un rapport Markdown structuré avec postes classés, scores d’adéquation, décisions de candidature, points de vigilance et angles de candidature.
12. Téléversez un CV et générez un rapport
Testez maintenant l’application web en téléversant un CV au format PDF puis en cliquant sur Generate JobFit Report.
Pour cet exemple, j’ai téléversé un CV avec environ trois ans d’expérience afin de voir si l’application pouvait trouver des offres pertinentes selon le profil et les préférences de la personne. Le rapport a été généré en moins d’une minute.
Pendant l’exécution, le journal de progression montre chaque étape du workflow, notamment :
- lecture du CV
- extraction du texte de chaque page
- début de l’exécution de l’agent
- appel de l’outil de recherche d’offres
- retour de la sortie de l’outil
Une fois l’exécution terminée, l’application affiche le rapport final en Markdown.
Le rapport commence par la meilleure correspondance, suivi d’un tableau de postes classés. Il fournit ensuite des notes détaillées pour chaque rôle : score d’adéquation, décision de candidature, raisons de l’adéquation, points de vigilance et angle de candidature.
Dans cet exemple, le premier résultat était un poste de Senior Data Science Writer chez NannyML. Comme le poste correspondait au parcours du ou de la candidat·e en data science, rédaction technique et contenu IA, il semblait être un très bon choix.
Vous pouvez cliquer sur le lien Apply here dans le rapport pour ouvrir la page de l’offre et examiner la fiche complète avant de décider de postuler.
Remarque : si vous rencontrez des problèmes en local, consultez le dépôt GitHub : kingabzpro/JobFit-AI. Il inclut le notebook, le fichier app.py et des instructions d’installation pour configurer les dépendances et exécuter le projet en local.
Conclusion
JobFit AI utilise Kimi K2.6, Olostep et le SDK OpenAI Agents pour résoudre deux problèmes fréquents chez les personnes en reconversion ou en recherche active.
Le premier est de savoir où postuler. Entre les job boards, plateformes et pages « Carrières » des entreprises, il n’est pas toujours évident de cibler les bons postes. L’application réduit ce champ en s’appuyant sur le CV et les préférences du ou de la candidat·e pour trouver des offres plus pertinentes.
Le second est de filtrer l’abondance d’offres. Au lieu de consulter manuellement chaque site, l’agent recherche des annonces en direct, lit des pages sélectionnées et génère un rapport structuré avec meilleure correspondance, postes classés, scores d’adéquation, points de vigilance et angles de candidature. Vous vous concentrez ainsi sur les rôles qui valent réellement la peine de postuler.
L’API Kimi K2.6 s’est également très bien comportée dans ce workflow piloté par agent : rapide, fiable et efficace pour suivre des consignes structurées. Lors des tests, avec jusqu’à 25 tours autorisés, l’agent explorait davantage de pages mais l’exécution prenait environ cinq minutes. Pour équilibrer qualité et vitesse, nous avons limité le workflow à une recherche et jusqu’à trois lectures de pages, ce qui permet de générer le rapport en moins d’une minute.
Vous pouvez améliorer la qualité du rapport en augmentant le nombre d’étapes autorisées, de résultats de recherche ou de pages lues. Par exemple, en passant la limite d’agent à 30 tours et en autorisant davantage de lectures de pages, l’agent produit un rapport plus approfondi avec plus de rôles et des recommandations plus solides. En contrepartie, le temps d’exécution et l’usage d’API augmenteront.
Si vous êtes intéressé·e par la création d’outils agentiques similaires, consultez nos autres tutoriels API :
