Partilhar via

Desenvolver aplicações com Semantic Kernel e Microsoft Foundry (clássico)

Aplica-se apenas a:Foundry (clássico) portal. Este artigo não está disponível para o novo portal da Foundry. Saiba mais sobre o novo portal.

Observação

Alguns links neste artigo podem abrir conteúdo na nova documentação do Microsoft Foundry em vez da documentação do Foundry (clássico) que está a ver agora.

Neste artigo, aprende a usar Semantic Kernel com modelos implementados a partir do catálogo de modelos Foundry no portal Microsoft Foundry.

Importante

O Azure AI Inference beta SDK está obsoleto e será retirado a 30 de maio de 2026. Mude para a API OpenAI/v1 geralmente disponível com um SDK OpenAI estável. Siga o guia de migração para mudar para OpenAI/v1, usando o SDK da sua linguagem de programação preferida.

Pré-requisitos

  • Uma conta no Azure com uma subscrição ativa. Se não tiveres uma, cria uma conta Azure free, que inclui uma subscrição de teste gratuita.

  • Um projeto da Foundry conforme explicado no portal Criar um projeto na Foundry.

  • Um modelo implementado que suporta a API de Inferência de Modelos de IA Azure. Este artigo usa uma Mistral-Large implementação. Você pode usar qualquer modelo. Para usar funcionalidades de embeddings no LlamaIndex, precisa de um modelo de embeddings como cohere-embed-v3-multilingual.

  • Python 3.10 ou posterior instalado, incluindo pip.

  • Semantic Kernel instalado. Você pode usar o seguinte comando:

    pip install semantic-kernel

  • Este artigo utiliza a Model Inference API, por isso instale as dependências relevantes do Azure. Você pode usar o seguinte comando:

    pip install semantic-kernel[azure]

Configurar o ambiente

Para usar modelos de linguagem implementados no portal Foundry, precisa do endpoint e das credenciais para se ligar ao seu projeto. Siga estas etapas para obter as informações necessárias do modelo:

Sugestão

Como pode personalizar o painel esquerdo no portal Microsoft Foundry, pode ver itens diferentes dos mostrados nestes passos. Se não encontrar o que procura, selecione ... Mais informações na parte inferior do painel esquerdo.

  1. Inicie sessão no Microsoft Foundry.

  2. Abra o projeto onde o modelo está implantado, se ainda não estiver aberto.

  3. Vá para Modelos + endpoints e selecione o modelo que implantou como indicado nos pré-requisitos.

  4. Copie o URL do ponto de extremidade e a chave.

    Sugestão

    Se implementaste o teu modelo com suporte ao Microsoft Entra ID, não precisas de uma chave.

Este exemplo usa variáveis de ambiente para a URL do ponto de extremidade e a chave.

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

Depois de configurar o ponto de extremidade e a chave, crie um cliente para se conectar ao ponto de extremidade:

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceChatCompletion

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

Sugestão

O cliente lê automaticamente as variáveis de ambiente AZURE_AI_INFERENCE_ENDPOINT e AZURE_AI_INFERENCE_API_KEY para se conectar ao modelo. Pode, em vez disso, passar o endpoint e a chave diretamente ao cliente, usando os parâmetros endpoint e api_key no construtor.

Alternativamente, se o seu endpoint suportar o Microsoft Entra ID, pode usar o seguinte código para criar o cliente:

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

Observação

Se usar o Microsoft Entra ID, certifique-se de que o endpoint foi implementado com esse método de autenticação e que tem as permissões necessárias para o invocar.

Modelos Azure OpenAI

Se estiver a usar um modelo Azure OpenAI, utilize o seguinte código para criar o cliente:

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

Parâmetros de inferência

Você pode configurar como executar a inferência usando a 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
)

Chamar o serviço

Primeiro, ligue para o serviço de conclusão de bate-papo com um histórico de bate-papo simples:

Sugestão

O Semantic Kernel é uma biblioteca assíncrona, por isso precisas de usar a biblioteca assíncrona para executar o código.

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)

Como alternativa, você pode transmitir a resposta do serviço:

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

Criar uma conversa de longa duração

Você pode criar uma conversa de longa duração usando um loop:

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 você estiver transmitindo a resposta, poderá usar o seguinte código:

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

Usar modelos de incorporação

Configure seu ambiente de forma semelhante às etapas anteriores, mas use a AzureAIInferenceEmbeddings classe:

from semantic_kernel.connectors.ai.azure_ai_inference import AzureAIInferenceTextEmbedding

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

O código a seguir mostra como obter incorporações do serviço:

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

for embedding in embeddings:
    print(embedding)

Conteúdo relacionado

  • Last updated on