E se tivesse de responder a mais de 200 emails todos os dias?
Durante uma das minhas sessões de formação, um participante chamou a minha atenção — ou, melhor dizendo, não estava a prestar atenção. Passou a maior parte do dia a olhar para o Outlook, em vez do caso de análise de dados que eu estava a mostrar. Inicialmente, pensei que ele simplesmente não estava interessado no curso. Acabei por perguntar por que razão se tinha inscrito se ia passar o dia inteiro a responder a emails.
A resposta dele foi desarmante:
“Tenho de responder a mais de 200 emails de fornecedores por dia. Se eu parar, o processo inteiro para.”
Essa conversa deu-me uma ideia... Então, caro participante — se estiver a ler isto — aqui está como pode automatizar o seu trabalho e finalmente recuperar algum tempo para, de facto, pensar.
Criar um flow do Power Automate para recolher preços de commodities
O objetivo do flow que vamos construir é automatizar a recolha, validação e armazenamento centralizado de preços de mercado de commodities, disponibilizando dados em tempo real para a área de aprovisionamento e tomada de decisão no negócio.
Ao converter todos os preços para um formato padronizado e ao filtrar dados inválidos, o flow garante que apenas informação significativa e acionável entra numa tabela do Dataverse.
Primeiro passo – Criar uma tabela do Dataverse para armazenar os preços das commodities, atualizada a cada hora.
Para armazenar os preços das commodities, as relevantes para o negócio de combustíveis, escolhemos o Dataverse, e criamos a tabela CommodityPrices com as seguintes colunas:
| Coluna | Descrição | Tipo de dados |
|---|---|---|
| Símbolo | Símbolo curto que representa a commodity (ex: CORN, CPO, SOYBEAN). É usado para referência rápida e mapeamento da API. | Texto (Linha Única) |
| Produto | Nome completo ou descrição da commodity (ex: Milho (proxy ag), Óleo de Palma Bruto, Soja (proxy UCO)). | Texto (Linha Única) |
| Preço Bruto | O preço bruto devolvido diretamente pela API, antes da conversão de unidade. | Número decimal |
| Unidade bruta | A unidade de medida do preço bruto (ex: por bushel, por tonelada). Este campo ajuda a monitorizar como cada commodity é cotada no mercado. | Texto (Linha Única) |
| Preço EUR por Tonelada | O preço normalizado em €/ton, usado para todas as comparações e cálculos internos. Este valor é calculado automaticamente durante a ingestão de dados. | Número decimal |
| Moeda | A moeda do preço convertido (normalmente EUR). | Texto (Linha Única) |
| Data de Recolha | Timestamp da recolha dos dados a partir da API. Útil para monitorizar atualizações e validar a frequência de atualização. | data e hora |
| Origem | A origem dos dados ou o fornecedor da API (ex: Commodities-API). | Texto (Linha Única) |
| RawJson | O payload JSON completo devolvido pela chamada da API, armazenado para rastreabilidade, depuração (debugging) e validação de futuras conversões. | Texto (Várias Linhas) |
Esta tabela armazena dados de mercado em tempo real para commodities chave, usadas como matéria-prima (feedstock) ou referências de preço na indústria de biocombustíveis. É atualizada automaticamente a cada hora, através de API. Serve como base para o sistema de referência de preços de mercado.
Os flows subsequentes do Power Automate leem desta tabela para comparar ofertas de fornecedores, calcular deltas de preço e acionar alertas ou fluxos de trabalho de aprovação no Power Apps.
Segundo passo – Obter uma chave API em commodities-api.com
Para recolher preços de commodities em tempo real automaticamente, precisa de uma chave API em commodities-api.com. Esta chave autentica os seus pedidos e monitoriza o seu plano de utilização.
1. Criar uma conta
Aceda a commodities-api.com e clique em Registar-se. Após o registo, o seu Dashboard irá mostrar a sua chave API pessoal (uma string semelhante a 2f3b7c…). Esta chave deve ser incluída em todos os pedidos HTTP, por exemplo:
https://api.commodities-api.com/api/latest?access_key=YOUR_API_KEY&symbols=SOYBEAN,CORN,CPO&base=EUR
2. Compreender os planos disponíveis
A plataforma fornece vários planos de preços, dependendo do número de chamadas de que necessita por mês e com que frequência os dados devem ser atualizados.
| Plano | Mensalidade | Chamadas/mês | Limite de Taxa | Símbolos/pedido | Frequência de Atualização |
|---|---|---|---|---|---|
| Pro | $49.99 | 1 000 | 60 chamadas/minuto | Up to 5 | Atualizações a cada 10 minutos |
| Pro Plus | $99.99 | 10 000 | 120 chamadas/minuto | Up to 5 | a cada 60 segundos |
| Professional Advanced | $199.99 | 20 000 | 120 chamadas/minuto | Up to 10 | a cada 60 segundos |
| Plus | $499.99 | 50 000 | 240 chamadas/minuto | Up to 20 | a cada 60 segundos |
3. Armazenar a chave de forma segura
Em vez de codificar a chave diretamente (hard-coding) no Power Automate, armazene-a como variável de ambiente do Power Platform.
Terceiro passo – Criar o sistema de recolha de preços do Power Automate
Vamos recolher preços de commodities da API a cada hora, pelo que o gatilho será agendado em conformidade:
Em seguida, armazenamos a URL base, a chave API, a moeda base e os símbolos das commodities de que precisamos dos preços em variáveis:
Aqui estão as definições das variáveis:
varAPIBase, type String:
https://commodities-api.com/api/latest
varApiKey, type String:
@{parameters('APISecretKey (nn_APISecretKey)')}
Note que deve primeiro criar uma solução que inclua este flow e a variável de ambiente “APISecretKey” para a tornar acessível aqui.
varBaseCcy, type String:
EUR
varSymbols, type Array:
[ "SOYBEAN", "CORN", "CPO" ]
Em seguida, precisamos de chamar a API, usando um pedido HTTP, da seguinte forma:
O código no URL é:
concat(variables('varApiBase'),
'?access_key=', variables('varApiKey'),
'&base=', variables('varBaseCcy'),
'&symbols=', join(variables('varSymbols'), ','))
Isto cria o URL completo, incluindo a chave API, a moeda na qual queremos os preços e a matriz de símbolos como um valor de string separado por vírgulas.
Portanto, o flow, até agora, deverá ser o seguinte:
O próximo passo irá analisar a resposta que obtemos em formato JSON a partir da chamada da API:
O Conteúdo é:
body('HTTP')
E o Esquema é:
{
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"success": {
"type": "boolean"
},
"timestamp": {
"type": "integer"
},
"date": {
"type": "string"
},
"base": {
"type": "string"
},
"rates": {
"type": "object",
"properties": {
"CORN": {
"type": "number"
},
"CPO": {
"type": "number"
},
"SOYBEAN": {
"type": "number"
}
}
},
"unit": {
"type": "object",
"properties": {
"SOYBEAN": {
"type": "string"
},
"CORN": {
"type": "string"
},
"CPO": {
"type": "string"
}
}
}
}
}
}
}
A resposta que obtemos da API é semelhante ao seguinte exemplo para CPO:
{
"data": {
"success": true,
"timestamp": 1761667860,
"date": "2025-10-28",
"base": "EUR",
"rates": {
"CPO": 0.0011332695018226
},
"unit": {
"CPO": "per ton"
}
}
}
Agora, precisamos de criar três ações Compose para extrair a moeda base, o objeto de taxas (rates) que contém o preço e o timestamp. Fazemos da seguinte forma:
As expressões de cada uma destas ações são:
body('Parse_JSON')['data']['base']
body('Parse_JSON')['data']['rates']
body('Parse_JSON')?['data']?['timestamp']
Em seguida, teremos de iterar sobre cada um dos itens da matriz de commodities e inserir os resultados que obtemos da API na tabela do Dataverse. Para isso, vamos precisar de uma ação “Aplicar a cada”, como:
A origem da ação Aplicar a cada é a variável que definimos previamente:
variables('varSymbols')
Uma vez que as unidades de cada preço podem diferir de commodity para commodity, precisamos de converter tudo para euros por tonelada. Para isso, vamos adicionar três ações Compose adicionais, conforme visível na captura de ecrã acima.
Compose cmpPrice:
coalesce(body('Parse_JSON')?['data']?['rates']?[items('Apply_to_each')], 0)
Isto irá extrair o preço tal como ele está.
Compose cmpUnitForSymbol:
coalesce(
body('Parse_JSON')?['data']?['unit']?[items('Apply_to_each')],
'unknown'
)
Esta ação irá extrair a unidade, como: “por tonelada”, “por bushel”, etc.
Compose priceEURperTon:
if(
equals(items('Apply_to_each'),'SOYBEAN'),
div(float(outputs('Compose_cmpPrice')), 0.027216),
if(
equals(items('Apply_to_each'),'CORN'),
div(float(outputs('Compose_cmpPrice')), 0.0254),
float(outputs('Compose_cmpPrice'))
)
)
E esta ação irá converter todos os preços para euros por tonelada.
Por fim, vamos usar uma condição antes de inserir no Dataverse.
Após normalizar todos os preços de commodities para euros por tonelada, irá frequentemente querer filtrar, validar ou acionar ações específicas apenas quando determinados critérios forem cumpridos. Isto é alcançado usando uma ação Condição.
A configuração da condição é a seguinte:
outputs('Compose_cmpPrice')
Operador É maior que
Value: 0
Se esta condição for avaliada como Verdadeira, o Power Automate executa o próximo passo: Adicionar uma nova linha no Dataverse. Esta ação insere um novo registo na tabela do Dataverse usando os valores normalizados calculados anteriormente para símbolo, produto, preço bruto, unidade, preço por tonelada, moeda, origem, timestamp e payload JSON.
Se a condição for Falsa (ex: o preço é zero ou não foi devolvido), o flow ignora a inserção, mantendo assim a tabela limpa e fiável.
Esta inserção condicional garante que apenas preços válidos e atualizados são registados no Dataverse, apoiando análises em tempo real e decisões de aprovisionamento para a sua equipa.
Portanto, o resultado, após algumas execuções do Power Automate ao longo do dia, será o seguinte:
Como pode verificar, a API está a devolver os dados de que precisamos para criar um modelo de decisão. Isto irá permitir-nos comparar as ofertas dos fornecedores com os preços de mercado e automatizar decisões.
Analise os e-mails do fornecedor e compare os preços com a base de dados
Iremos agora criar um fluxo do Power Automate separado e dedicado à leitura de e-mails recebidos de fornecedores que contenham orçamentos e ofertas. Este novo fluxo irá extrair automaticamente os preços orçamentados para as matérias-primas relevantes, diretamente do corpo dos e-mails ou dos documentos anexos.
Os dados extraídos serão depois analisados e normalizados, permitindo uma comparação direta com os preços de mercado em tempo real armazenados na base de dados Dataverse. Ao integrar ambos os fluxos, as equipas de compras podem aferir instantaneamente as propostas dos fornecedores face às condições atuais do mercado e tomar decisões de compra baseadas em dados com uma intervenção manual mínima.
Primeiro passo – Criar uma pasta dedicada no Outlook
Comece por criar uma pasta no Outlook chamada "Orçamentos de Fornecedores" ou algo semelhante. Deve ser pedido aos fornecedores que enviem as suas ofertas para um endereço específico (ex: compras@empresa.com), o qual move automaticamente as mensagens recebidas para essa pasta através de regras do Outlook.
Segundo passo – Criar um novo fluxo do Power Automate dentro da solução para ser acionado quando um novo e-mail chegar a esta pasta
O acionador será assim:
Incluímos os anexos, pois podem conter informações importantes. Além disso, apenas os e-mails enviados para compras@swell.com.pt serão lidos para evitar a ativação de e-mails irrelevantes.
Now, we’ll create a Compose action to retrieve the contents of the email.
concat('Subject: ', triggerOutputs()?['body/subject'], '\nFrom: ', triggerOutputs()?['body/from'], '\nBody:\n', triggerOutputs()?['body/body'])
Isto irá concatenar o assunto com o remetente e o corpo do e-mail com o orçamento.
O passo seguinte dentro deste fluxo será criar e executar um prompt que receberá como entrada o resultado da ação de Composição anterior. Estas são as instruções que lhe iremos passar:
Sistema:
É um extrator de informações rigoroso para orçamentos de fornecedores na indústria de combustíveis/biocombustíveis.
Produza APENAS JSON estrito, sem markdown, sem comentários.
Utilizador
Extraia do e-mail abaixo o(s) orçamento(s) e normalize os campos.
Se os números utilizarem vírgulas como decimais, converta-os para pontos.
Normalize a moeda para “EUR” ou “USD”.
Normalize a unidade para uma das seguintes: “por tonelada”, “por mt”, “por kg”, “por litro”, “desconhecido”.
Se a quantidade/unidade estiver ausente, defina como "null".
Se houver vários produtos/preços num único e-mail, devolva um array com vários itens.
Devolva EXATAMENTE este formato JSON:
{
"supplier_name": string | null,
"supplier_email": string | null,
"offers": [
{
"product_text": string, // e.g., "Biodiesel (B100)", "UCO", "CPO"
"symbol_guess": string | null, // e.g., "B100","UCO","CPO","CORN","SOYBEAN","DIESEL","GASOLINE"
"unit_price_value": number | null, // numeric, dot decimal
"unit_price_currency": "EUR"|"USD"|null,
"unit_price_unit": "per ton"|"per mt"|"per kg"|"per liter"|"unknown",
"quantity_tons": number | null,
"incoterms": string | null, // e.g., "CIF", "FOB", etc.
"location": string | null, // e.g., "Vila do Conde"
"delivery_time_days": number | null,
"payment_terms_text": string | null,
"notes": string | null,
"confidence_0_1": number // 0..1
}
]
}
EMAIL:
Estamos a utilizar o GPT-4.1 mini como modelo para extrair, em formato JSON, o orçamento das mercadorias (commodities) em que estamos interessados. Testamos o prompt com o seguinte e-mail de exemplo:
Subject: Weekly Biofuels Quotation – UCO & B100 From: EcoEnergy Partners offers@ecoenergy-partners.com Dear Procurement Team, Below our updated weekly quotation: Product Quantity Unit Price Terms Delivery Location UCO 600 MT €935 per ton FOB Sines Biodiesel (B100) 400 MT €1,065 per ton CIF Aveiro Payment terms: 30 days after delivery. Valid until: 04 Nov 2025. Best regards, Alice Keller EcoEnergy Partners GmbH
Isto pode ser feito inserindo o conteúdo do texto acima na área de "Sample data" (Dados de exemplo) no parâmetro "Text Input" (Introdução de Texto) do prompt:
E ao premir o botão de teste, obtemos a resposta do Modelo imediatamente:
Parece-me bastante bem para começar. Guarde a definição do Prompt e volte ao Power Automate. Agora, adicione os resultados (outputs) da ação de Composição anterior no campo de entrada de Texto (Text input):
Até agora, este fluxo tem este aspeto:
Precisamos agora de explorar os resultados do Prompt, normalizar os mesmos e prepará-los para adicionar uma nova linha a uma nova tabela do Dataverse (falaremos sobre isso mais adiante). Aqui fica, de forma concisa, um guia das ações imediatamente após o "Run a prompt", com as expressões exatas.
1) Composição – cmpJsonText
Gets the JSON string returned by the prompt.
body('Run_a_prompt')?['responsev2']?['predictionOutput']?['text']
2) Analisar JSON
Transforma essa string num objeto.
json(outputs('Compose_cmpJsonText'))
(Esquema = o esquema das ofertas que definiu.)
3) Aplicar a cada (ofertas)
Itera cada oferta extraída:
body('Parse_JSON')?['offers']
Dentro do ciclo
Composição – cmpProduct
items('Apply_to_each')?['product_text']
Composição – cmpSymbol
coalesce(items('Apply_to_each')?['symbol_guess'], 'OTHER')
Composição cmpUnitPrice
float(items('Apply_to_each')?['unit_price_value'])
Composição - cmpCurrency
toUpper(items('Apply_to_each')?['unit_price_currency'])
Composição - cmpUnit
items('Apply_to_each')?['unit_price_unit']
Composição - cmpQuantityTons
coalesce(items('Apply_to_each')?['quantity_tons'], null)
Composição - cmpIncoterms
coalesce(items('Apply_to_each')?['incoterms'], null)
Composição - cmpLocation
coalesce(items('Apply_to_each')?['location'], null)
Composição - cmpDeliveryTime
coalesce(items('Apply_to_each')?['delivery_time_days'], null)
Composição - cmpPaymentTerms
coalesce(items('Apply_to_each')?['payment_terms_text'], null)
Composição - cmpPriceEURperTon
Converte para €/ton (gere a moeda e a unidade de uma só vez).
Requer uma variável varUsdToEur (ex: 0.93) se o "USD" aparecer.
if(
or(
equals(items('Apply_to_each')?['unit_price_unit'], 'per ton'),
equals(items('Apply_to_each')?['unit_price_unit'], 'per mt')
),
float(items('Apply_to_each')?['unit_price_value']),
if(
equals(items('Apply_to_each')?['unit_price_unit'], 'per kg'),
mul(float(items('Apply_to_each')?['unit_price_value']), 1000),
if(
equals(items('Apply_to_each')?['unit_price_unit'], 'per liter'),
div(float(items('Apply_to_each')?['unit_price_value']), 0.88),
float(items('Apply_to_each')?['unit_price_value'])
)
)
)
Composição cmpMarketSymbol
coalesce(
if(equals(toUpper(items('Apply_to_each')?['symbol_guess']),'UCO'),'SOYBEAN',
if(equals(toUpper(items('Apply_to_each')?['symbol_guess']),'B100'),'CPO',
if(equals(toUpper(items('Apply_to_each')?['symbol_guess']),'CPO'),'CPO',
if(equals(toUpper(items('Apply_to_each')?['symbol_guess']),'CORN'),'CORN',
if(equals(toUpper(items('Apply_to_each')?['symbol_guess']),'SOYBEAN'),'SOYBEAN', null)
)
)
)
),
'SOYBEAN'
)
É exatamente isso—estas ações pegam no output do modelo, normalizam-no e produzem um preço limpo em €/ton, juntamente com os metadados que irá armazenar ou comparar a seguir.
O terceiro passo é onde a magia da persistência de dados acontece. Vamos criar a tabela SupplierQuotations no Dataverse para servir como o nosso "repositório de inteligência de mercado".
O Supplier Quotations A tabela armazena todas as cotações extraídas automaticamente dos e-mails dos fornecedores.
Foi concebida para centralizar, normalizar e comparar cotações para compras de biocombustíveis e mercadorias — tais como Biodiesel (B100), Óleo Alimentar Usado (UCO), Óleo de Palma Bruto (CPO), Milho ou Soja — face aos preços de mercado atuais armazenados na CommodityPrices .
Cada registo representa uma única linha de cotação de um e-mail, enriquecida com dados normalizados (por exemplo, todos os preços convertidos para €/ton) e ligada a dados de mercado para análise automatizada no Power BI ou Power Apps.
Informação geral:
Nome de Exibição: Supplier Quotations
Nome lógico: cre05_supplierquotations
Nome da coluna primária: cre05_name
Nome de Exibição Principal: AutoNumber → SQ-{SEQNUM:6}
Descrição: Tabela que armazena as cotações de fornecedores analisadas automaticamente a partir de e-mails recebidos, utilizando um fluxo do Power Automate integrado com um prompt de GPT. A tabela permite que as equipas de compras monitorizem as ofertas, comparem-nas com os preços de mercado em tempo real e identifiquem potenciais oportunidades ou riscos.
Definições das Colunas
Abaixo encontra-se a especificação completa das colunas incluídas nesta tabela:
- Supplier Name (cre05_suppliername) – Text (Single line)
- Supplier Email (cre05_supplieremail) – Email
- Product Text (cre05_producttext) – Text (Single line)
- Symbol (cre05_symbol) – Text field (B100, UCO, CPO, CORN, SOYBEAN, DIESEL, GASOLINE, OTHER)
- Unit Price Value (cre05_unitpricevalue) – Decimal Number (18,4)
- Unit Price Currency (cre05_unitpricecurrency) – Text field
- Unit Price Unit (cre05_unitpriceunit) – Text field
- Quantity (tons) (cre05_quantitytons) – Decimal Number (18,4)
- Incoterms (cre05_incoterms) – Text field
- Location (cre05_location) – Text (Single line)
- Delivery Time (days) (cre05_deliverytimedays) – Whole Number
- Payment Terms (cre05_paymenttermstext) – Texto (Várias Linhas)
- Notes (cre05_notes) – Texto (Várias Linhas)
- Confidence (0–1) (cre05_confidence01) – Decimal Number (18,4)
- Quoted Price (€/ton) (cre05_quotedprice_eur_ton) – Decimal Number (18,4)
- Market Price (€/ton) (cre05_marketprice_eur_ton) – Decimal Number (18,4)
- Delta (%) (cre05_deltapercent) – Decimal Number (18,6)
- Received At (cre05_receivedat) – Date & Time (Time-zone)
- Email ID (cre05_emailid) – Text (Single line)
- Raw JSON (cre05_rawjson) – Texto (Várias Linhas)
Quarto passo – adicionar as cotações no Dataverse
Continuamos a adicionar ações dentro do ciclo Apply to each. Para cada cotação recuperada do e-mail que o fornecedor envia, precisamos de obter cada cotação de fornecedor com os dados de referência de mercado antes de a inserir no Dataverse.
Listar linhas – CommodityPrices
Recupera o preço de mercado mais recente para a commodity que corresponde ao símbolo extraído do e-mail.
Filtro: nn_symbol eq @{outputs('Compose_cmpMarketSymbol')}
ordenado por: nn_collectedat desc
Contagem de linhas: 1
Isto garante que obtemos apenas o registo de mercado mais recente.
Composição cmpMarketRow
Seleciona o primeiro registo do output da ação List rows.
first(body('List_rows')?['value'])
Composição cmpMarketPrice
Extrai o preço de mercado normalizado em €/ton.
outputs('Compose_cmpMarketRow')?['nn_priceeurperton']
Composição cmpDeltaPct
Calcula a diferença percentual entre o preço cotado pelo fornecedor e o preço de mercado.
if(
and(not(empty(string(outputs('Compose_cmpMarketPrice')))), greater(float(outputs('Compose_cmpMarketPrice')), 0)),
div(
sub(float(outputs('Compose_cmpPriceEURperTon')), float(outputs('Compose_cmpMarketPrice'))),
float(outputs('Compose_cmpMarketPrice'))
),
null
)
Adicionar uma nova linha – SupplierQuotations
Insere um novo registo na tabela do Dataverse SupplierQuotations com todos os campos normalizados:
- Nome e e-mail do fornecedor
- Produto & símbolo
- Quantidade, unidade, incoterms, localização
- Preço cotado (€/ton), preço de mercado, delta %
- Informações adicionais (condições de pagamento,
Quinto passo – testar o processo de automação com um e-mail de amostra
Aqui está um e-mail de amostra que podemos utilizar para testar este fluxo:
Subject: UCO & B100 Weekly Offer – CIF Aveiro Dear Procurement Team, Please find below our latest offer: Product Quantity Unit Price Terms Delivery Location UCO 550 MT €940 per ton FOB Sines Biodiesel (B100) 400 MT €1,070 per ton CIF Aveiro Best regards, Laura Schmidt GreenFuel Europe laura.schmidt@greenfuel.eu
Vamos testar e verificar o fluxo em execução, a comparação de preços com a nossa base de dados de commodities e o cálculo do delta!
O fluxo extraiu automaticamente ambas as ofertas, enriqueceu-as com dados de referência de mercado da tabela CommodityPrices e criou os registos correspondentes no Dataverse (SupplierQuotations).
| Field | UCO (Row 1) | Biodiesel (B100) (Row 2) |
|---|---|---|
| SupplierName | GreenFuel Europe | GreenFuel Europe |
| SupplierEmail | laura.schmidt@greenfuel.eu | laura.schmidt@greenfuel.eu |
| ProductText | UCO | Biodiesel (B100) |
| Símbolo | UCO | B100 |
| QuantityTons | 550 | 400 |
| UnitPriceValue (Quoted) | €940.00 | €1,070.00 |
| UnitPriceCurrency | EUR | EUR |
| UnitPriceUnit | per ton | per ton |
| MarketPriceEURperTon | €338.02 | €876.13 |
| DeltaPercent | 1.7809 → +178.1 % | 0.2213 → +22.1 % |
| Incoterms | FOB | CIF |
| Location | Sines | Aveiro |
| PaymentTermsText | 30 days after delivery | 30 days after delivery |
| Notes | Valid until: 05 Nov 2025 | Valid until: 05 Nov 2025 |
| Confidence_0_1 | 0.95 | 0.95 |
| ReceivedAt | 29/10/2025 18:05 | 29/10/2025 18:05 |
Cada linha de cotação do e-mail foi convertida num registo no Dataverse, com todos os dados contextuais e calculados corretamente preenchidos:
- O Nome e o E-mail do Fornecedor foram extraídos diretamente da assinatura do e-mail através da inteligência artificial.
- O MarketPriceEURperTon (Preço de Mercado em €/ton) e o DeltaPercent (Variação Percentual) foram calculados com precisão matemática pelo fluxo.
- As Notas e os Termos de Pagamento foram preservados.
- Confidence_0_1 = 0.95, confirmando uma alta confiança de processamento (parsing) do prompt.
Sexto Passo – Hora da Diversão!
Ao final desta jornada de automação, transformamos um processo repetitivo e propenso a erros — a leitura e comparação manual de cotações de fornecedores — num fluxo de trabalho inteligente e totalmente automatizado.
Cada novo e-mail contendo ofertas de commodities é agora processado por IA, estruturado em tabelas do Dataverse e imediatamente cruzado com os preços de mercado mais recentes.
Isto poupa horas de trabalho manual, elimina erros de "copiar e colar" e permite que a equipa de compras se foque na negociação e estratégia, em vez de se perder em tarefas administrativas.
Os resultados falam por si: em questão de segundos, cada cotação é extraída, validada e enriquecida com dados de mercado — pronta para dashboards, alertas ou fluxos de aprovação.
O que pode ser feito a seguir
Este fluxo é apenas a base.
Várias melhorias podem levá-lo ainda mais longe:
- Alertas automáticos e pontuação – envie notificações no Teams ou por e-mail quando o preço de um fornecedor exceder os limites de mercado acima de um patamar definido.
- Integração Power BI – visualize tendências históricas, o desempenho dos fornecedores e os desvios de custo diretamente em dashboards ligados ao Dataverse.
- Enriquecimento da base de dados de fornecedores – crie ou atualize automaticamente perfis de fornecedores quando surgirem novos remetentes.
- Ciclo de feedback de IA – utilize cada novo e-mail para treinar ou ajustar continuamente o prompt de extração, melhorando a precisão ao longo do tempo.
- Automação de contratos – acione a geração de documentos (Word/PDF) assim que uma cotação for aprovada, completando todo o processo de aprovação e compra de ponta a ponta.
