Desenvolver aplicativos com Kernel semântico e Microsoft Foundry (clássico)

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

Neste artigo, você aprenderá a usar Kernel semântico com modelos implantados no catálogo de modelos do Foundry no portal do Microsoft Foundry.

Pré-requisitos

• Uma conta Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta de Azure free, que inclui uma assinatura de avaliação gratuita.

• Um projeto do Foundry, conforme explicado em Criar um projeto no portal do Foundry.

• Um modelo implantado que dá suporte à API de Inferência de Modelo de IA Azure. Este artigo utiliza uma implantação de Mistral-Large. Você pode usar qualquer modelo. Para usar recursos de inserções no LlamaIndex, você precisa de um modelo de inserção como cohere-embed-v3-multilingual.

  • Siga as instruções em Implantar modelos como implantações de API sem servidor.

• Python 3.10 ou posterior instalado, incluindo pip.

• Kernel semântico instalado. Você pode usar o seguinte comando:

  pip install semantic-kernel
  

• Este artigo usa a API de Inferência de Modelo, portanto, instale as dependências de Azure relevantes. Você pode usar o seguinte comando:

  pip install semantic-kernel[azure]
  

Configurar o ambiente

Para usar modelos de linguagem implantados no portal do Foundry, você precisa do ponto de extremidade e das credenciais para se conectar a seu projeto. Siga estas etapas para obter as informações necessárias no modelo:

1. Entre no Microsoft Foundry.

2. Abra o projeto em que o modelo é implantado, se ele ainda não estiver aberto.

3. Vá para Modelos + pontos de extremidade e selecione o modelo implantado conforme indicado nos pré-requisitos.

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

   Dica

   Se você implantou seu modelo com suporte Microsoft Entra ID, não precisará 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>")

Como alternativa, se o endpoint suportar Microsoft Entra ID, você poderá 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>")

modelos do Azure OpenAI

Se você estiver usando um modelo Azure OpenAI, use 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
)

Chamando o serviço técnico

Primeiro, chame o serviço de conclusão de chat com um histórico de chat simples:

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 contínua

Você pode criar uma conversa prolongada 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 inserções

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 inserçõ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

• Como começar a usar Azure SDKs de IA
• Referência para integração de modelo Kernel semântico