---
title: "Semantic Kernel: connettore OpenAI con endpoint custom"
description: "Collega Microsoft Semantic Kernel a BroadNet Inference: in Python con un client AsyncOpenAI, in C# con un endpoint personalizzato, per chat, plugin e agenti."
url: https://broadrouter.com/it/guides/semantic-kernel-openai-compatible/
lang: it
updated: 2026-11-16
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/guides/semantic-kernel-openai-compatible/) (aggiornato il 2026-11-16).

# Usare Semantic Kernel con BroadNet Inference

Aggiornato 2026-11-16

In Python crea AsyncOpenAI con base\_url https://inference.broadnet.ai/v1 e la tua chiave BroadNet, poi passalo come async\_client a OpenAIChatCompletion con ai\_model\_id impostato su un ID BroadNet come broadnet/glm-5.3. In C# chiama AddOpenAIChatCompletion con un endpoint Uri, che Microsoft segna come sperimentale (SKEXP0010). Per i plugin usa GLM 5.3 o Qwen3.8 27B.

Semantic Kernel è l’SDK di Microsoft per creare app e agenti di AI in C#, Python e Java. Il suo connettore OpenAI funziona con altri servizi compatibili con OpenAI: in Python accetta un tuo client OpenAI, in C# un endpoint personalizzato. BroadNet Inference serve chat completions standard su `https://inference.broadnet.ai/v1`, quindi funzionano entrambe le strade. BroadRouter è il sito di BroadNet; questa guida segue la documentazione di Semantic Kernel di Microsoft e il sorgente 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` viene inviato invariato, quindi mantieni il prefisso `broadnet/`. Quando passi un client, l’argomento `api_key` di `OpenAIChatCompletion` non serve.

### Plugin e function calling

```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 invia il plugin come tool chiamato `weather-get_weather`, lo esegue quando il modello lo richiede e rimanda indietro il risultato. Usa `broadnet/glm-5.3` o `broadnet/qwen3.8-27b`: la documentazione di BroadNet indica gli strumenti solo per questi due.

### Agenti

```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 documentazione di Microsoft propone questo schema per “other AI service providers that support the OpenAI chat completion API” (traduzione: altri fornitori di servizi di AI che supportano l’API OpenAI chat completion). La versione C# non l’abbiamo eseguita.

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

Installa il connettore con `dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI`.

## Quale modello scegliere

| Uso | Modello |
| --- | --- |
| Plugin, function calling, agenti | `broadnet/glm-5.3` |
| Plugin con input di immagini o testo in arabo | `broadnet/qwen3.8-27b` |
| Chat e riassunti senza strumenti, piano a prezzo fisso | `broadnet/deepseek-v4.1-flash` |

[Prezzi di tutti i modelli](https://broadrouter.com/it/pricing/).

## Come l’abbiamo testato

Il 2026-11-15 abbiamo installato semantic-kernel 1.47.0 per Python in un ambiente virtuale pulito e abbiamo eseguito chat semplice, streaming, function calling automatico e un `ChatCompletionAgent` contro un server mock locale che parla il formato di chat completions di BroadNet. Abbiamo letto le richieste registrate. Sono andate tutte a `/v1/chat/completions` con l’ID del modello BroadNet invariato e una chiave Bearer. `max_tokens` è stato inviato con questo nome, lo streaming ha aggiunto `stream_options.include_usage` e il function calling ha inviato `tool_choice: "auto"`. Non avevamo una chiave BroadNet, quindi non abbiamo testato l’output reale del modello. Lo snippet C# viene dalla documentazione di Microsoft e non è stato eseguito.

## Risoluzione dei problemi

-   **401.** La chiave è sbagliata, scaduta o ha esaurito la quota.
-   **404.** Il `base_url` del client deve finire con `/v1`. Controlla l’ID del modello. I modelli a pagamento richiedono una ricarica; il credito di $5 copre solo `broadnet/gemma-4-26b-a4b` e i due modelli Transcribe.
-   **Risposte vuote.** Su DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B il ragionamento conta in `max_tokens`. Alzalo. [Perché le risposte arrivano vuote](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).
-   **Modelli di ragionamento e ruoli.** La documentazione di Microsoft suggerisce `instruction_role="developer"` per i modelli di ragionamento di OpenAI. Il riferimento API di BroadNet non menziona il ruolo `developer`, quindi lascia `instruction_role` al valore predefinito. Nel nostro test l’agente ha inviato le istruzioni in un messaggio `system`.
-   **429.** Una chiave a consumo consente 30 richieste al minuto e 4 in corso contemporaneamente. Vedi [errori e retry](https://broadrouter.com/it/guides/errors-and-retries/).

## Termini in questa guida

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

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

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

[Pagamento a consumo (pay-as-you-go)](https://broadrouter.com/it/glossary/pay-as-you-go/)

Il pagamento a consumo è un modello di prezzo in cui paghi solo ciò che usi, misurato per unità come token, richieste o minuti di audio, senza abbonamento né impegno minimo. La maggior parte delle API LLM fattura così, da un saldo prepagato o con una fattura periodica.

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

La Chat Completions API è l’endpoint HTTP di OpenAI, POST /v1/chat/completions, che riceve il nome di un modello e una lista di messaggi con un ruolo e restituisce il messaggio successivo del modello. La forma della sua richiesta e risposta è diventata il formato comune che riusano provider e SDK compatibili con OpenAI.

[Concorrenza (concurrency)](https://broadrouter.com/it/glossary/concurrency/)

La concorrenza è il numero di richieste che un client ha in corso nello stesso momento. Le API LLM spesso la limitano per chiave o per piano, separatamente dalle richieste al minuto, perché ogni richiesta aperta occupa capacità GPU finché la sua risposta non è terminata.

[Rate limit (limite di frequenza)](https://broadrouter.com/it/glossary/rate-limit/)

Un rate limit è un tetto che un’API pone a quanto un client può usarla in un intervallo di tempo, per esempio richieste al minuto o token al minuto. Le richieste oltre il limite vengono rifiutate, di solito con HTTP 429 Too Many Requests, finché l’uso non torna sotto la soglia.

[Credito prepagato (prepaid credit)](https://broadrouter.com/it/glossary/prepaid-credit/)

Il credito prepagato è denaro aggiunto a un account API prima dell’uso. Ogni richiesta scala il proprio costo dal saldo e, quando il saldo si esaurisce, le richieste a consumo si fermano finché non ricarichi. Limita la spesa a quanto hai versato.

## Domande frequenti

### Come imposto una base URL personalizzata in Semantic Kernel per Python?

Nella versione 1.47 OpenAIChatCompletion non ha un argomento base\_url. Crea un client openai.AsyncOpenAI con base\_url e api\_key e passalo come async\_client. Da quel momento il client invia ogni richiesta a BroadNet.

### Perché l’endpoint personalizzato in C# richiede un pragma?

La documentazione di Microsoft dice che usare endpoint personalizzati con il connettore OpenAI è sperimentale, quindi l’overload con endpoint richiede #pragma warning disable SKEXP0010.

### Il function calling automatico funziona con BroadNet?

Usa le normali tool call su chat completions, quindi scegli un modello che BroadNet indica con gli strumenti: GLM 5.3 o Qwen3.8 27B. Nel nostro test con un server mock, Semantic Kernel ha inviato il plugin come tool e ha restituito il risultato in un messaggio tool.

### Il ChatCompletionAgent di Semantic Kernel funziona su BroadNet?

Sì. Usa lo stesso servizio OpenAIChatCompletion. Nel nostro test in Python ha inviato le istruzioni dell’agente come messaggio di sistema e ha chiamato il plugin tramite chat completions.

## Guide correlate

-   [Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)
-   [Usare l’OpenAI Agents SDK con BroadNet Inference](https://broadrouter.com/it/guides/openai-agents-sdk-custom-provider/)
-   [Perché un modello di ragionamento restituisce una risposta vuota](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/)
-   [Codici di errore di BroadNet Inference e quando ritentare](https://broadrouter.com/it/guides/errors-and-retries/)
-   [Tutti gli strumenti che funzionano con BroadNet Inference (in inglese)](https://broadrouter.com/integrations/): SDK, agenti di coding, interfacce di chat e strumenti di automazione, con le impostazioni esatte per ciascuno

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Microsoft Learn, Add chat completion services to Semantic Kernel (aggiornato il 2026-05-26, verificato il 2026-11-15)](https://learn.microsoft.com/en-us/semantic-kernel/concepts/ai-services/chat-completion/)
-   [Sorgente di Semantic Kernel, OpenAIChatCompletion per Python a python-1.47.0 (verificato il 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 (verificato il 2026-11-15)](https://pypi.org/project/semantic-kernel/)
-   [Riferimento API di BroadNet Inference (verificato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-guides-semantic-kernel-openai-compatible&utm_content=sources)
