Condividi tramite

Sviluppare applicazioni con kernel semantico e Microsoft Foundry (versione classica)

Annotazioni

Questo documento fa riferimento al portale di Microsoft Foundry (versione classica).

🔍Per informazioni sul nuovo portale, vedere la documentazione di Microsoft Foundry (nuova).

Questo articolo illustra come usare il kernel semantico con i modelli distribuiti dal catalogo dei modelli Foundry nel portale di Microsoft Foundry.

Importante

Azure AI Inference beta SDK è deprecato e verrà ritirato il 30 maggio 2026. Passare all'API OpenAI/v1 disponibile a livello generale con un SDK OpenAI stabile. Seguire la guida alla migrazione per passare a OpenAI/v1, usando l'SDK per il linguaggio di programmazione preferito.

Prerequisiti

Configurare l'ambiente

Per usare i modelli linguistici distribuiti nel portale foundry, sono necessarie l'endpoint e le credenziali per connettersi al progetto. Per ottenere le informazioni necessarie dal modello, seguire questa procedura:

Suggerimento

Poiché è possibile personalizzare il riquadro sinistro nel portale di Microsoft Foundry, è possibile che vengano visualizzati elementi diversi rispetto a quelli illustrati in questi passaggi. Se non viene visualizzato ciò che si sta cercando, selezionare ... Altro nella parte inferiore del riquadro sinistro.

  1. Accedere a Microsoft Foundry.

  2. Aprire il progetto in cui viene distribuito il modello, se non è già aperto.

  3. Passare a Modelli ed endpoint e selezionare il modello distribuito come indicato nei prerequisiti.

  4. Copiare l'URL dell'endpoint e la chiave.

    Suggerimento

    Se il modello è stato distribuito con il supporto di Microsoft Entra ID, non è necessaria una chiave.

Questo esempio usa le variabili di ambiente sia per l'URL dell'endpoint che per la chiave:

export AZURE_AI_INFERENCE_ENDPOINT="<your-model-endpoint-goes-here>"
export AZURE_AI_INFERENCE_API_KEY="<your-key-goes-here>"

Dopo aver configurato l'endpoint e la chiave, creare un client per connettersi all'endpoint:

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatCompletion

chat_completion_service = AzureAIInferenceChatCompletion(ai_model_id="<deployment-name>")

Suggerimento

Il client legge automaticamente le variabili di ambiente AZURE_AI_INFERENCE_ENDPOINT e AZURE_AI_INFERENCE_API_KEY per connettersi al modello. È invece possibile passare l'endpoint e la chiave direttamente al client usando i endpoint parametri e api_key nel costruttore.

In alternativa, se l'endpoint supporta l'ID Microsoft Entra, è possibile usare il codice seguente per creare il client:

export AZURE_AI_INFERENCE_ENDPOINT="<your-model-endpoint-goes-here>"

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatCompletion

chat_completion_service = AzureAIInferenceChatCompletion(ai_model_id="<deployment-name>")

Annotazioni

Se si usa Microsoft Entra ID, assicurarsi che l'endpoint sia stato distribuito con tale metodo di autenticazione e che si disponga delle autorizzazioni necessarie per richiamarlo.

Modelli di Azure OpenAI

Se si usa un modello OpenAI di Azure, usare il codice seguente per creare il client:

from azure.ai.inference.aio import ChatCompletionsClient
from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatCompletion

chat_completion_service = AzureAIInferenceChatCompletion(
    ai_model_id="<deployment-name>",
    client=ChatCompletionsClient(
        endpoint=f"{str(<your-azure-open-ai-endpoint>).strip('/')}/openai/deployments/{<deployment_name>}",
        credential=DefaultAzureCredential(),
        credential_scopes=["https://cognitiveservices.azure.com/.default"],
    ),
)

Parametri di inferenza

È possibile configurare come eseguire l'inferenza usando la AzureAIInferenceChatPromptExecutionSettings classe :

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatPromptExecutionSettings

execution_settings = AzureAIInferenceChatPromptExecutionSettings(
    max_tokens=100,
    temperature=0.5,
    top_p=0.9,
    # extra_parameters={...},    # model-specific parameters
)

Chiamata al servizio

Prima di tutto, chiamare il servizio di completamento della chat con una semplice cronologia chat:

Suggerimento

Il kernel semantico è una libreria asincrona, quindi è necessario usare la libreria asyncio per eseguire il codice.

import asyncio

async def main():
    ...

if __name__ == "__main__":
    asyncio.run(main())

from semantic_kernel.contents.chat_history import ChatHistory

chat_history = ChatHistory()
chat_history.add_user_message("Hello, how are you?")

response = await chat_completion_service.get_chat_message_content(
    chat_history=chat_history,
    settings=execution_settings,
)
print(response)

In alternativa, è possibile trasmettere la risposta dal servizio:

chat_history = ChatHistory()
chat_history.add_user_message("Hello, how are you?")

response = chat_completion_service.get_streaming_chat_message_content(
    chat_history=chat_history,
    settings=execution_settings,
)

chunks = []
async for chunk in response:
    chunks.append(chunk)
    print(chunk, end="")

full_response = sum(chunks[1:], chunks[0])

Creare una conversazione a esecuzione prolungata

È possibile creare una conversazione a esecuzione prolungata usando un ciclo:

while True:
    response = await chat_completion_service.get_chat_message_content(
        chat_history=chat_history,
        settings=execution_settings,
    )
    print(response)
    chat_history.add_message(response)
    chat_history.add_user_message(user_input = input("User:> "))

Se si trasmette la risposta, è possibile usare il codice seguente:

while True:
    response = chat_completion_service.get_streaming_chat_message_content(
        chat_history=chat_history,
        settings=execution_settings,
    )

    chunks = []
    async for chunk in response:
        chunks.append(chunk)
        print(chunk, end="")

    full_response = sum(chunks[1:], chunks[0])
    chat_history.add_message(full_response)
    chat_history.add_user_message(user_input = input("User:> "))

Usare i modelli di incorporamento

Configurare l'ambiente in modo analogo ai passaggi precedenti, ma usare la classe AzureAIInferenceEmbeddings:

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceTextEmbedding

embedding_generation_service = AzureAIInferenceTextEmbedding(ai_model_id="<deployment-name>")

Il codice seguente illustra come ottenere incorporamenti dal servizio:

embeddings = await embedding_generation_service.generate_embeddings(
    texts=["My favorite color is blue.", "I love to eat pizza."],
)

for embedding in embeddings:
    print(embedding)

Contenuti correlati

  • Last updated on