---
title: "Semantic Kernel : connecteur OpenAI et endpoint personnalisé"
description: "Connectez Microsoft Semantic Kernel à BroadNet Inference : en Python via un client AsyncOpenAI, en C# via un endpoint personnalisé, pour chat, plugins et agents."
url: https://broadrouter.com/fr/guides/semantic-kernel-openai-compatible/
lang: fr
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/guides/semantic-kernel-openai-compatible/) (mis à jour le 2026-11-16).

# Utiliser Semantic Kernel avec BroadNet Inference

Mis à jour 2026-11-16

En Python, créez un AsyncOpenAI avec base\_url https://inference.broadnet.ai/v1 et votre clé BroadNet, puis passez-le comme async\_client à OpenAIChatCompletion, avec ai\_model\_id réglé sur un ID BroadNet comme broadnet/glm-5.3. En C#, appelez AddOpenAIChatCompletion avec une Uri d’endpoint, que Microsoft marque comme expérimentale (SKEXP0010). Pour les plugins, utilisez GLM 5.3 ou Qwen3.8 27B.

Semantic Kernel est le SDK de Microsoft pour créer des applications et des agents d’IA en C#, Python et Java. Son connecteur OpenAI fonctionne avec d’autres services compatibles OpenAI : en Python, il accepte votre propre client OpenAI ; en C#, un endpoint personnalisé. BroadNet Inference sert des chat completions standard à l’adresse `https://inference.broadnet.ai/v1` : les deux voies fonctionnent. BroadRouter est le site de BroadNet ; ce guide suit la documentation Semantic Kernel de Microsoft et le code source Python 1.47.0.

## Python

```bash
pip install semantic-kernel
export BROADNET_API_KEY='your-broadnet-key'
```

```python
import asyncio, os
from openai import AsyncOpenAI
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion, OpenAIChatPromptExecutionSettings
from semantic_kernel.contents import ChatHistory

client = AsyncOpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
chat = OpenAIChatCompletion(ai_model_id="broadnet/glm-5.3", async_client=client, service_id="broadnet")

async def main():
    history = ChatHistory()
    history.add_user_message("Give me three names for a billing microservice.")
    settings = OpenAIChatPromptExecutionSettings(max_tokens=4000)
    print(await chat.get_chat_message_content(chat_history=history, settings=settings))

asyncio.run(main())
```

`ai_model_id` est envoyé tel quel : gardez le préfixe `broadnet/`. L’argument `api_key` de `OpenAIChatCompletion` est inutile quand vous passez un client.

### Plugins et appel de fonctions

```python
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
from semantic_kernel.functions import kernel_function

class Weather:
    @kernel_function(description="Get the weather for a city.")
    def get_weather(self, city: str) -> str:
        return f"21C in {city}"

kernel = Kernel()
kernel.add_service(chat)
kernel.add_plugin(Weather(), plugin_name="weather")
settings = OpenAIChatPromptExecutionSettings(
    max_tokens=4000,
    function_choice_behavior=FunctionChoiceBehavior.Auto(),
)
# await chat.get_chat_message_content(chat_history=history, settings=settings, kernel=kernel)
```

Semantic Kernel envoie le plugin comme un outil nommé `weather-get_weather`, l’exécute quand le modèle le demande et renvoie le résultat. Utilisez `broadnet/glm-5.3` ou `broadnet/qwen3.8-27b` ; la documentation de BroadNet n’indique les outils que pour ces deux modèles.

### Agents

```python
from semantic_kernel.agents import ChatCompletionAgent

agent = ChatCompletionAgent(service=chat, name="helper", instructions="Answer briefly.", plugins=[Weather()])
# response = await agent.get_response(messages="What's the weather in Dubai?")
```

## C# (.NET)

La documentation de Microsoft donne ce modèle pour les « other AI service providers that support the OpenAI chat completion API » (traduction : « autres fournisseurs de services d’IA qui prennent en charge l’API de chat completion d’OpenAI »). Nous n’avons pas exécuté la version C#.

```csharp
using Microsoft.SemanticKernel;

#pragma warning disable SKEXP0010
IKernelBuilder kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.AddOpenAIChatCompletion(
    modelId: "broadnet/glm-5.3",
    apiKey: Environment.GetEnvironmentVariable("BROADNET_API_KEY"),
    endpoint: new Uri("https://inference.broadnet.ai/v1")
);
Kernel kernel = kernelBuilder.Build();
```

Installez le connecteur avec `dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI`.

## Quel modèle choisir ?

| Usage | Modèle |
| --- | --- |
| Plugins, appel de fonctions, agents | `broadnet/glm-5.3` |
| Plugins avec entrée d’images ou texte arabe | `broadnet/qwen3.8-27b` |
| Chat et résumés sans outils, forfait à prix fixe | `broadnet/deepseek-v4.1-flash` |

[Les prix de chaque modèle](https://broadrouter.com/fr/pricing/).

## Comment nous l’avons testé

Le 15 novembre 2026, nous avons installé semantic-kernel 1.47.0 pour Python dans un environnement virtuel vierge et exécuté un chat simple, du streaming, l’appel automatique de fonctions et un `ChatCompletionAgent` contre un serveur fictif local qui parle le format chat completions de BroadNet. Nous avons lu les requêtes journalisées. Toutes sont allées vers `/v1/chat/completions`, avec l’ID de modèle BroadNet inchangé et une clé Bearer. `max_tokens` a été envoyé sous ce nom, le streaming a ajouté `stream_options.include_usage`, et l’appel de fonctions a envoyé `tool_choice: "auto"`. Faute de clé BroadNet, nous n’avons pas testé de vraie sortie de modèle. L’extrait C# provient de la documentation de Microsoft et n’a pas été exécuté.

## Dépannage

-   **401.** La clé est erronée, a expiré ou a épuisé son allocation.
-   **404.** La `base_url` du client doit se terminer par `/v1`. Vérifiez l’ID du modèle. Les modèles payants nécessitent une recharge ; le crédit de $5 ne couvre que `broadnet/gemma-4-26b-a4b` et les deux modèles Transcribe.
-   **Réponses vides.** Sur DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B, le raisonnement compte dans `max_tokens`. Augmentez-le. [Pourquoi les réponses reviennent vides](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **Modèles de raisonnement et rôles.** La documentation de Microsoft suggère `instruction_role="developer"` pour les modèles de raisonnement d’OpenAI. La référence de l’API de BroadNet ne mentionne pas le rôle `developer` : laissez donc `instruction_role` à sa valeur par défaut. Notre test d’agent a envoyé les instructions dans un message `system`.
-   **429.** Une clé à l’usage autorise 30 requêtes par minute et 4 requêtes en cours. Voir [codes d’erreur et nouvelles tentatives](https://broadrouter.com/fr/guides/errors-and-retries/).

## Termes de ce guide

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Streaming](https://broadrouter.com/fr/glossary/streaming/)

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

[Concurrence (requêtes simultanées)](https://broadrouter.com/fr/glossary/concurrency/)

La concurrence est le nombre de requêtes qu’un client a en cours au même moment. Les API de LLM la plafonnent souvent par clé ou par forfait, indépendamment des requêtes par minute, car chaque requête ouverte occupe de la capacité GPU jusqu’à la fin de sa réponse.

[API Chat Completions](https://broadrouter.com/fr/glossary/chat-completions-api/)

L’API Chat Completions est l’endpoint HTTP d’OpenAI, POST /v1/chat/completions, qui reçoit un nom de modèle et une liste de messages associés à un rôle, et renvoie le message suivant du modèle. Sa forme de requête et de réponse est devenue le format commun que reprennent les fournisseurs et SDK compatibles OpenAI.

[Limite de débit (rate limit)](https://broadrouter.com/fr/glossary/rate-limit/)

Une limite de débit (rate limit) est un plafond qu’une API impose à l’usage d’un client sur une période, par exemple en requêtes ou en tokens par minute. Les requêtes au-delà sont refusées, généralement avec HTTP 429 Too Many Requests, jusqu’à ce que l’usage repasse sous la limite.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

[Crédit prépayé (prepaid credit)](https://broadrouter.com/fr/glossary/prepaid-credit/)

Le crédit prépayé est de l’argent versé sur un compte API avant utilisation. Chaque requête déduit son coût du solde, et quand le solde est épuisé, les requêtes facturées s’arrêtent jusqu’à la prochaine recharge. Les dépenses sont ainsi plafonnées à ce que vous avez versé.

## Questions fréquentes

### Comment définir une base URL personnalisée dans Semantic Kernel pour Python ?

OpenAIChatCompletion n’a pas d’argument base\_url dans la version 1.47. Créez un client openai.AsyncOpenAI avec base\_url et api\_key, et passez-le comme async\_client. Ce client envoie alors chaque requête à BroadNet.

### Pourquoi l’endpoint personnalisé en C# exige-t-il un pragma ?

La documentation de Microsoft indique que l’utilisation d’endpoints personnalisés avec le connecteur OpenAI est expérimentale : la surcharge avec endpoint nécessite donc #pragma warning disable SKEXP0010.

### L’appel automatique de fonctions fonctionne-t-il avec BroadNet ?

Il repose sur des appels d’outils standard via les chat completions : utilisez donc un modèle que BroadNet indique avec outils, GLM 5.3 ou Qwen3.8 27B. Dans notre test sur serveur fictif, Semantic Kernel a envoyé le plugin comme outil et renvoyé le résultat dans un message d’outil.

### Le ChatCompletionAgent de Semantic Kernel fonctionne-t-il avec BroadNet ?

Oui. Il prend le même service OpenAIChatCompletion. Dans notre test Python, il a envoyé les instructions de l’agent dans un message système et appelé le plugin via les chat completions.

## Guides associés

-   [Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Faire tourner l’OpenAI Agents SDK sur BroadNet Inference](https://broadrouter.com/fr/guides/openai-agents-sdk-custom-provider/)
-   [Pourquoi un modèle de raisonnement renvoie une réponse vide](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/)
-   [Codes d’erreur de BroadNet Inference : quand réessayer ?](https://broadrouter.com/fr/guides/errors-and-retries/)
-   [Tous les outils compatibles avec BroadNet Inference (en anglais)](https://broadrouter.com/integrations/) : SDK, agents de code, interfaces de chat et outils d’automatisation, avec les réglages exacts pour chacun

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-semantic-kernel-openai-compatible&utm_content=page-cta) ·

**Sources**

-   [Microsoft Learn, ajouter des services de chat completion à Semantic Kernel (mis à jour le 2026-05-26, consulté le 2026-11-15)](https://learn.microsoft.com/en-us/semantic-kernel/concepts/ai-services/chat-completion/)
-   [Code source de Semantic Kernel, OpenAIChatCompletion Python en python-1.47.0 (consulté le 2026-11-15)](https://github.com/microsoft/semantic-kernel/blob/python-1.47.0/python/semantic_kernel/connectors/ai/open_ai/services/open_ai_chat_completion.py)
-   [PyPI, semantic-kernel 1.47.0 (consulté le 2026-11-15)](https://pypi.org/project/semantic-kernel/)
-   [Référence de l’API de BroadNet Inference (consultée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-guides-semantic-kernel-openai-compatible&utm_content=sources)
