Crie um aplicativo de chat personalizado em Python usando o SDK de fluxo de prompt

Neste guia de início rápido, orientamos você na configuração de seu ambiente de desenvolvimento local com o SDK de fluxo de solicitação. Escrevemos um prompt, executamo-lo como parte do código do seu aplicativo, rastreamos as chamadas LLM que estão sendo feitas e executamos uma avaliação básica nas saídas do LLM.

Pré-requisitos

Antes de seguir este guia de início rápido, crie os recursos necessários para seu aplicativo:

• Um hub AI Studio para se conectar a recursos externos.
• Um projeto para organizar seus artefatos de projeto e compartilhar rastreamentos e execuções de avaliação.
• Um modelo de chat OpenAI do Azure implantado (gpt-35-turbo ou gpt-4)

Conclua o início rápido do playground do AI Studio para criar esses recursos, se ainda não o fez. Você também pode criar esses recursos seguindo o guia do SDK para criar um hub e um artigo de projeto .

Conceder acesso para chamar o Serviço OpenAI do Azure usando sua identidade

Para usar as práticas recomendadas de segurança, em vez de chaves de API, usamos a ID do Microsoft Entra para autenticar com o Azure OpenAI usando sua identidade de usuário.

Você ou seu administrador precisa conceder à sua identidade de usuário a função Usuário OpenAI dos Serviços Cognitivos no recurso Serviços de IA do Azure que você está usando. Essa função concede a você a capacidade de chamar o serviço OpenAI do Azure usando sua identidade de usuário.

Para conceder a si mesmo acesso ao recurso dos Serviços de IA do Azure que você está usando:

1. No AI Studio, vá para o seu projeto e selecione Configurações no painel esquerdo.

2. Na seção Recursos conectados, selecione o nome da conexão com o tipo AIServices.

   

   Nota

   Se você não vir a conexão AIServices , use a conexão do Azure OpenAI .

3. Na página de detalhes do recurso, selecione o link sob o título Recurso para abrir o recurso de serviços de IA no portal do Azure.

   

4. Na página à esquerda no portal do Azure, selecione Controle de acesso (IAM)>+ Adicionar>atribuição de função.

5. Procure a função Usuário OpenAI dos Serviços Cognitivos e selecione-a. Em seguida, selecione Seguinte.

   

6. Selecione Usuário, grupo ou entidade de serviço. Em seguida, selecione Selecionar membros.

7. No painel Selecionar membros que é aberto, procure o nome do usuário ao qual você deseja adicionar a atribuição de função. Selecione o usuário e, em seguida, selecione Selecionar.

   

8. Continue pelo assistente e selecione Revisar + atribuir para adicionar a atribuição de função.

Instalar a CLI do Azure e entrar

Você instala a CLI do Azure e entra em seu ambiente de desenvolvimento local, para que possa usar suas credenciais de usuário para chamar o serviço Azure OpenAI.

Na maioria dos casos, você pode instalar a CLI do Azure a partir do seu terminal usando o seguinte comando:

winget install -e --id Microsoft.AzureCLI

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

brew update && brew install azure-cli

Você pode seguir as instruções Como instalar a CLI do Azure se esses comandos não funcionarem para seu sistema operacional ou configuração específicos.

Depois de instalar a CLI do Azure, entre usando o az login comando e entre usando o navegador:

az login

Em alternativa, pode iniciar sessão manualmente através do navegador com um código de dispositivo.

az login --use-device-code

Agora criamos nosso aplicativo e chamamos o Serviço OpenAI do Azure a partir do código.

Criar um novo ambiente Python

Primeiro, precisamos criar um novo ambiente Python que possamos usar para instalar os pacotes SDK de fluxo de prompt. NÃO instale pacotes em sua instalação global do python. Você deve sempre usar um ambiente virtual ou conda ao instalar pacotes python, caso contrário, você pode quebrar sua instalação global do Python.

Se necessário, instale o Python

Recomendamos o uso do Python 3.10 ou posterior, mas é necessário ter pelo menos o Python 3.8. Se você não tiver uma versão adequada do Python instalada, você pode seguir as instruções no VS Code Python Tutorial para a maneira mais fácil de instalar o Python em seu sistema operacional.

Criar um ambiente virtual

Se você já tiver o Python 3.10 ou superior instalado, poderá criar um ambiente virtual usando os seguintes comandos:

py -3 -m venv .venv
.venv\scripts\activate

python3 -m venv .venv
source .venv/bin/activate

python3 -m venv .venv
source .venv/bin/activate

Ativar o ambiente Python significa que quando você executa python ou pip a partir da linha de comando, você usa o interpretador Python contido na .venv pasta do seu aplicativo.

Instalar o SDK de fluxo de prompt

Nesta seção, usamos o fluxo imediato para criar nosso aplicativo. O Prompt flow é um conjunto de ferramentas de desenvolvimento projetado para simplificar o ciclo de desenvolvimento de ponta a ponta de aplicativos de IA baseados em LLM, desde a ideação, prototipagem, testes, avaliação até a implantação e monitoramento da produção.

Use pip para instalar o SDK de fluxo de prompt no ambiente virtual que você criou.

pip install promptflow
pip install azure-identity

O SDK de fluxo de prompt depende de vários pacotes, que você pode optar por instalar separadamente se não quiser todos eles:

• promptflow-core: contém o tempo de execução do fluxo de prompt principal usado para executar o código LLM
• promptflow-tracing: biblioteca leve usada para emitir rastreamentos OpenTelemetry em padrões
• promptflow-devkit: contém as ferramentas Prompt Flow Test Bed e Trace Viewer para ambientes de desenvolvimento local
• openai: bibliotecas de cliente para usar o serviço Azure OpenAI
• python-dotenv: usado para definir variáveis de ambiente lendo-as a partir de .env arquivos

Configurar as variáveis de ambiente

Seu ponto de extremidade de serviços de IA e nome de implantação são necessários para chamar o serviço Azure OpenAI a partir do seu código. Neste início rápido, você salva esses valores em um .env arquivo, que é um arquivo que contém variáveis de ambiente que seu aplicativo pode ler. Você pode encontrar esses valores no playground de bate-papo do AI Studio.

1. Crie um .env arquivo e cole o seguinte código:

   AZURE_OPENAI_ENDPOINT=endpoint_value
   AZURE_OPENAI_CHAT_DEPLOYMENT=chat_deployment_name
   AZURE_OPENAI_API_VERSION=api_version
   

2. Navegue até o playground de bate-papo dentro do seu projeto AI Studio. Primeiro, valide se o chat está funcionando com seu modelo enviando uma mensagem para o LLM.

3. Encontre o nome da implantação do Azure OpenAI no playground de bate-papo. Selecione a implantação na lista suspensa e passe o mouse sobre o nome da implantação para visualizá-la. Neste exemplo, o nome da implantação é gpt-35-turbo-16k.

   

4. .env No arquivo, substitua chat_deployment_name pelo nome da implantação da etapa anterior. Neste exemplo, estamos usando o nome gpt-35-turbo-16kda implantação .

5. Selecione o <> botão Exibir código e copie o valor do ponto de extremidade e o valor da versão da API.

   

6. .env No arquivo, substitua endpoint_value pelo valor do ponto de extremidade e substitua api_version pela versão da API copiada da caixa de diálogo na etapa anterior (como "2024-02-15-preview").

Criar um prompt de bate-papo básico e um aplicativo

Primeiro, crie um arquivo Prompty , que é o formato de modelo de prompt suportado pelo fluxo de prompt.

Crie um chat.prompty arquivo e copie o seguinte código para ele:

---
name: Chat Prompt
description: A basic prompt that uses the chat API to answer questions
model:
    api: chat
    configuration:
        type: azure_openai
    parameters:
        max_tokens: 256
        temperature: 0.2
inputs:
    chat_input:
        type: string
    chat_history:
        type: list
        is_chat_history: true
        default: []
outputs:   
  response:
    type: string
sample:
    chat_input: What is the meaning of life?
---
system:
You are an AI assistant who helps people find information.

{% for item in history %}
{{item.role}}:
{{item.content}}
{% endfor %}

user:
{{chat_input}}

Agora vamos criar um arquivo Python que usa esse modelo de prompt. Crie um chat.py arquivo e cole o seguinte código nele:

import os
from dotenv import load_dotenv
load_dotenv()

from promptflow.core import Prompty, AzureOpenAIModelConfiguration

model_config = AzureOpenAIModelConfiguration(
    azure_deployment=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT")
)

prompty = Prompty.load("chat.prompty", model={'configuration': model_config})
result = prompty(
    chat_history=[
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."}
    ],
    chat_input="Do other Azure AI services support this too?")

print(result)

Agora, a partir do seu console, execute o código Python:

python chat.py

Agora você deve ver a saída da execução do prompty:

Yes, other Azure AI services also support various capabilities and features. Some of the Azure AI services include Azure Cognitive Services, Azure Machine Learning, Azure Bot Service, and Azure Databricks. Each of these services offers different AI capabilities and can be used for various use cases. If you have a specific service or capability in mind, feel free to ask for more details.

Rastreie a execução do seu código de chat

Agora damos uma olhada em como o rastreamento de fluxo rápido pode fornecer informações sobre as várias chamadas LLM que estão acontecendo em nossos scripts Python.

No início do arquivo, adicione o seguinte código para habilitar o rastreamento de fluxo de chat.py prompt:

from promptflow.tracing import start_trace
start_trace()

Execute novamente o seu chat.py novamente:

python chat.py

Desta vez, você verá um link na saída para exibir um rastreamento de fluxo de prompt da execução:

Starting prompt flow service...
Start prompt flow service on port 23333, version: 1.10.1.
You can stop the prompt flow service with the following command:'pf service stop'.
Alternatively, if no requests are made within 1 hours, it will automatically stop.
You can view the trace detail from the following URL:
http://localhost:23333/v1.0/ui/traces/?#collection=aistudio-python-quickstart&uiTraceId=0x59e8b9a3a23e4e8893ec2e53d6e1e521

Se você selecionar esse link, verá o rastreamento mostrando as etapas da execução do programa, o que foi passado para o LLM e a saída de resposta.

O rastreamento de fluxo de prompt também permite rastrear chamadas de função específicas e rastrear rastreamentos de log para o AI Studio, para obter mais informações, verifique Como usar o rastreamento no SDK de fluxo de prompt.

Avalie o seu pedido

Agora vamos mostrar como podemos usar avaliadores de fluxo imediato para gerar métricas que podem pontuar a qualidade da conversa em uma escala de 0 a 5. Executamos o prompt novamente, mas desta vez armazenamos os resultados em uma matriz contendo a conversa completa e, em seguida, passamos isso para uma ChatEvaluator pontuação.

Primeiro, instale o promptflow-evals package:

pip install promptflow-evals

Agora copie o seguinte código para um evaluate.py arquivo:

import os
from dotenv import load_dotenv
load_dotenv()

from promptflow.core import Prompty, AzureOpenAIModelConfiguration
from promptflow.evals.evaluators import ChatEvaluator

model_config = AzureOpenAIModelConfiguration(
    azure_deployment=os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT"),
    api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT")
)

chat_history=[
    {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
    {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."}
]
chat_input="Do other Azure AI services support this too?"

prompty = Prompty.load("chat.prompty", model={'configuration': model_config})
response = prompty(chat_history=chat_history, chat_input=chat_input)

conversation = chat_history
conversation += [
    {"role": "user", "content": chat_input},
    {"role": "assistant", "content": response}
]

chat_eval = ChatEvaluator(model_config=model_config)
score = chat_eval(conversation=conversation)

print(score)

Execute o evaluate.py script:

python evaluate.py

Você verá uma saída parecida com esta:

{'gpt_coherence': 5.0, 'gpt_fluency': 5.0, 'evaluation_per_turn': {'gpt_coherence': {'score': [5.0, 5.0]}, 'gpt_fluency': {'score': [5.0, 5.0]}}}

Parece que pontuamos 5 para coerência e fluência das respostas LLM nesta conversa!

Para obter mais informações sobre como usar avaliadores de fluxo de prompt, incluindo como criar seus próprios avaliadores personalizados e registrar resultados de avaliação no AI Studio, verifique Avaliar seu aplicativo usando o SDK de fluxo de prompt.

Próximo passo