Pydantic AI: automatizando a criação de apresentações

Criação do primeiro agente - Apresentação

Apresentando o curso e o instrutor

Boas-vindas a mais este curso na Alura. Provavelmente, já ouvimos falar do Pydantic e de como ele é utilizado em diversos frameworks de agentes de IA para realizar a validação dos tipos de dados e tipos de saídas das LLMs. No entanto, não é exatamente com essa ferramenta que vamos trabalhar aqui.

Meu nome é Alain Spadini.

Audiodescrição: Alain é um homem branco, com cabelos e olhos castanhos. Ele está no estúdio da Alura, com uma estante e uma parede colorida ao fundo.

Introduzindo o Pydentic AI e seus objetivos

Neste curso, utilizaremos o Pydentic AI, um framework do mesmo grupo do Pydentic, voltado para a construção de agentes. Com ele, seremos capazes de criar agentes que também são hábeis na validação de dados. Além disso, desenvolveremos agentes com o objetivo de criar apresentações de slides. Ou seja, nossos agentes, uma vez combinados, serão capazes de construir uma apresentação de slides.

Para acompanhar este curso, é necessário já ter conhecimento da linguagem de programação Python, preferencialmente voltado para data science. Estaremos juntos nos próximos vídeos deste curso. Até lá!

Criação do primeiro agente - Entendendo a estrutura do Markdown

Introduzindo a automação de apresentações de slides

Nós trabalhamos para a Gatito Pet Shop e percebemos uma série de atividades repetitivas que poderiam ser automatizadas. Nosso objetivo se tornou automatizar a construção de apresentações de slides utilizando Inteligência Artificial. Para isso, decidimos utilizar a Pidentic AI, uma ferramenta, um framework de agentes de Inteligência Artificial, que nos permitirá criar um agente capaz de construir uma apresentação de slides.

Como as LLMs e os agentes normalmente trabalham bem com texto, optamos por um framework que nos permitirá construir slides através do Markdown. Ou seja, ao escrever texto em Markdown, esse framework conseguirá transformá-lo em uma apresentação de slides. O framework que utilizamos é o Quarto, que possui a opção de Presentations. Ao criar texto em Markdown, como mostrado na tela, ele compila e transforma o texto em uma apresentação. Por exemplo, ao passar o título do slide com duas hashtags, seguido de um traço, uma palavra ou uma frase, ele transforma isso em um bullet e assim por diante. Com isso, conseguimos definir o conteúdo de um slide. Há também uma parte de configuração do slide, como título, autor e formato da apresentação.

Estruturando um arquivo Markdown para apresentações

Para ilustrar, veja um exemplo de como um arquivo Markdown pode ser estruturado para criar uma apresentação:

---
title: "Habits"
author: "John Doe"
format: revealjs
---

## Getting up

- Turn off alarm
- Get out of bed

## Going to sleep

- Get in bed
- Count sheep

Para utilizar esse framework e renderizar a apresentação ao final da criação, é ideal ter o Quarto instalado na máquina. Na página de Get Started, basta fazer o download e, no Windows, por exemplo, é só dar dois cliques e seguir os passos de instalação. Além disso, para renderizar a apresentação, faremos o processo dentro do VSCode. No VSCode, criamos uma pasta e o arquivo index.qmd, onde colocamos o conteúdo da apresentação. Também precisamos da extensão do Quarto no VSCode. No canto direito do VSCode, clicamos no menu Extensions, procuramos por Quarto e instalamos. Com o Quarto instalado, no arquivo index.qmd, no canto superior direito, aparece uma opção de preview, que utilizaremos em breve.

Configurando o ambiente no Google Colab

Agora, vamos para o Google Colab. No Google Colab, fizemos a instalação da PyDentic AI e das principais bibliotecas que utilizaremos no curso. Para isso, executamos os seguintes comandos:

%pip install pydantic-ai-slim[tavily]
%pip install docling
%pip install fastembed
%pip install qdrant-client

Queremos usar a PyDentic AI para criar nosso primeiro agente, que tentará criar uma apresentação de slides para a Gatito Pet Shop. Além da biblioteca que utiliza agentes, precisamos de uma chave de API para uma LLM. Durante o curso, utilizaremos o Gemini como nossa LLM. No entanto, dentro da PyDentic AI, é possível utilizar tanto a API do GPT quanto outras APIs, como a do Grok, que permite usar modelos como o Llama.

Obtendo e configurando a chave de API

No Google Colab, importamos UserData e pegamos a chave Gemini_API_key com UserData.get("Gemini_API_key"). Colocamos esse nome porque, dentro do Google Colab, já inserimos nossa chave de API do Gemini. No menu à esquerda, no símbolo de chave onde está escrito Secrets, clicamos e inserimos nossas chaves. Demos acesso a essa chave ao notebook, permitindo seu uso no Google Colab.

from google.colab import userdata
GEMINI_API_KEY = userdata.get('GEMINI_API_KEY')

Para obter essa chave, é necessário acessar o Google AI Studio. No Google, digitamos "Google AI Studio" e, ao acessar, clicamos em Get API Key no menu superior. Concordamos com as opções e criamos uma nova chave de API em um novo projeto.

Criando e utilizando a chave de API no Google Cloud

Para utilizar a API do Google Cloud, é necessário possuir uma conta na plataforma. Podemos criar uma chave de API dentro de um projeto do Google Cloud. Caso já tenhamos projetos no Google Cloud, a chave será criada dentro de um projeto ativo, e essa chave será paga. No entanto, se não tivermos uma conta, é possível criar uma chave sem cobranças. Por exemplo, ao criar um projeto do Google Cloud sem cobrança ativada, podemos utilizar essa chave em um nível gratuito.

Após criar a chave de API, basta copiá-la e inseri-la no Google Colab. No nosso caso, já temos uma chave de API no Google Colab. Precisamos utilizá-la e adicionar a Gemini API às nossas variáveis de ambiente. Para isso, utilizamos um comando pré-definido, executando Shift + Enter, e adicionamos a chave às variáveis de ambiente com:

import os
os.environ['GEMINI_API_KEY'] = GEMINI_API_KEY

Com isso, o Pydantic reconhecerá a chave do Gemini por padrão, permitindo seu uso no Pydantic AI.

Criando o agente de apresentação

Em seguida, fazemos o import do Pydantic AI com:

from pydantic_ai import Agent
import nest_asyncio
nest_asyncio.apply()

Vamos criar nosso primeiro agente, solicitando que ele crie uma apresentação genérica para o Gatito Pet Shop, seguindo um padrão específico. Criamos o agente com:

agent = Agent(
    'google-gla:gemini-2.0-flash',
    system_prompt='''
Você é um criador de apresentações que cria apresentações neste formato:

---
title: "Habits"
author: "John Doe"
format: revealjs
---

## Getting up

- Turn off alarm
- Get out of bed

## Going to sleep

- Get in bed
- Count sheep

Ao receber um tema crie a apresentação.
'''
)

Executando o agente e analisando resultados

Para rodar o agente, utilizamos:

result = agent.run_sync('Indústria de petshops')

O resultado é armazenado na variável result, e podemos imprimi-lo com:

print(result.data)

Após executar, obtemos um resultado com as configurações iniciais, título "Indústria de PetShops", autor como GPT-3 (embora estejamos usando Gemini), e o formato review.js, além de uma apresentação com bullets.

Já temos uma estrutura em texto da apresentação, mas há melhorias a serem feitas. Estamos criando uma apresentação genérica, mas queremos uma específica para a PetShop. No próximo vídeo, trabalharemos na formatação da apresentação. Até lá!

Criação do primeiro agente - Formatando resultados

Analisando a estrutura inicial da apresentação

Nós criamos um agente capaz de elaborar a estrutura para a apresentação. No entanto, ao analisarmos o resultado da saída do nosso primeiro agente, identificamos alguns pontos a serem melhorados. A saída, por exemplo, está respondendo além do conteúdo da apresentação, com uma mensagem genérica como "aqui está uma apresentação". A apresentação é genérica, relacionada à indústria de pet shops, com o nome do autor, mas ainda está muito superficial. Nosso objetivo agora é trabalhar na formatação da apresentação, para que a pessoa tenha a estrutura esperada para a apresentação da Gatito Pet Shop.

Para visualizar o que foi criado, vamos copiar o conteúdo gerado e colá-lo no VSCode, dentro do arquivo index.qmd. Precisamos remover o que aparece antes e depois do conteúdo da apresentação, pois são informações extras. Com isso, já temos o conteúdo da apresentação. Ao clicar no canto superior, onde instalamos a extensão do quarto, a apresentação será renderizada. Isso deve gerar um link que nos permitirá visualizar a apresentação no navegador, mas também conseguimos vê-la na tela. Podemos navegar desde a introdução até o final da apresentação. No entanto, a apresentação está em branco, genérica, apenas com marcadores e sem personalização para o nosso caso específico, que é o da Gatito Pet Shop.

Criando o agente formatador de apresentação

Por isso, vamos trabalhar apenas no conteúdo inicial da apresentação. Vamos criar um agente específico para esse conteúdo inicial, que chamaremos de agente formatador da apresentação. Ele será responsável apenas pela formatação. Para isso, utilizaremos a biblioteca Pydent, especificamente a Pydent QA, ao longo do curso. Neste vídeo, utilizaremos a Pydent, que facilitará o processo de validação de um formato e estrutura de dados necessários. Faremos o import da Pydent com:

from pydantic import BaseModel

e também da biblioteca YAML:

import yaml

Vamos criar uma classe de formatação que utilizará o BaseModel. Queremos que, ao receber um prompt, por exemplo, "gerar uma apresentação para Gatito Pet Shop com o título tal e tema de cores tal", a LLM consiga identificar as informações relevantes passadas no prompt. Dentro da formatação inicial, podemos ter campos como title: str, author: str, format: str, theme: str, e incremental: bool. O campo incremental é para que a apresentação tenha animações, apresentando cada marcador individualmente.

class Formatacao(BaseModel):
    title: str
    author: str
    format: str
    theme: str
    incremental: bool

Configurando o agente formatador

Após isso, criaremos o agente formatador, denominado agente_formador, que será igual ao agente. Passaremos a LLM e copiaremos o conteúdo desse agente, explicando-o detalhadamente. Corrigiremos eventuais erros, como parênteses a mais. Dentro do nosso agente, temos a LLM que estamos utilizando e o nosso system prompt, que agora é um pouco diferente. O prompt define que o agente é um criador de apresentações que retorna a formatação para a apresentação.

agente_formador = Agent(
    'google-gla:gemini-2.0-flash',
    system_prompt='''Você é um criador de apresentações que retorna a formatação para apresentação. A formatação tem
    ---
    title: "Presentation"
    author: "John Doe"
    format:
     revealjs:
      theme: dark
      incremental: true
    ---

    As opções de tema são:
    beige
    blood
    dark
    default
    league
    moon
    night
    serif
    simple
    sky
    solarized

    Você deve inferir quais as propriedades da formatação a partir do prompt.
    ''',result_type=Formatacao
)

Executando o agente e formatando a saída

Vamos utilizar esse agente. Vou rodar novamente esse agente com o prompt. Estou passando o agente formatador.handsync, e o nosso prompt será o seguinte: quero uma apresentação com um tema escuro, o autor é "Gatito Pet Shop", e o título é "Ganhos em Vendas de Arranhadores".

result = agente_formador.run_sync('Quero uma apresentação com o tema escuro, o autor é a Gatito Petshop, e o títul é Ganhos em vendas de arranhadores')
print(result.data)

Um aviso que está sendo mostrado é que o result.data, que pode ser encontrado na documentação, será depreciado, e agora precisamos usar o result.output. Isso é algo novo, foi lançado esta semana, e eu tinha lido na documentação. Inclusive, tinha preparado todo o documento com o result.data, mas vamos testar aqui.

print(result.output)

Agora ele mostra a saída mais limpa, onde vemos o título, "Ganhos em Vendas de Arranhadores", "Gatito Pet Shop", review JS, e assim por diante.

Convertendo a saída para YAML

Essas são as informações que precisamos para a configuração, porém, não estão exatamente no formato que queremos, que é o formato YAML, que aparece na configuração. Por exemplo, algo que gostaria de mostrar, porque é recorrente em aplicações em geral, seria utilizar o formato JSON. Para utilizar o JSON, passar essa informação para o formato JSON, bastaria fazer o formato agora, não ponto data, mas sim ponto output, ponto output, ponto model dump, e passaríamos para o formato JSON, mas ainda não é o JSON que queremos.

Para criar o YAML, vou criar uma função que pega aquele tipo de saída e passa para o formato YAML.

def formatar_para_yaml(result_data):
    """Formata os dados para um yaml"""
    yaml_data = {
        'title': result_data.title,
        'author': result_data.author,
        'format': {
            result_data.format: {
                'theme': result_data.theme,
                'incremental': result_data.incremental
            }
        }
    }
    return yaml.dump(yaml_data,sort_keys=False,default_flow_style=False)

Vou pegar o resultado e chamar essa função, então vou pegar o result.output, e vou fazer a impressão.

yaml_formatado = formatar_para_yaml(result.output)
print(yaml_formatado)

E agora temos uma estrutura muito mais parecida com o que estávamos esperando.

Considerando melhorias futuras

No entanto, há um pequeno problema: e se a pessoa no prompt não passar o título da apresentação? Como fazemos? Até o momento, o uso do agente está sendo muito parecido com simplesmente passar um prompt. No próximo vídeo, veremos como validar a saída do agente de alguma forma.

Sobre o curso Pydantic AI: automatizando a criação de apresentações

O curso Pydantic AI: automatizando a criação de apresentações possui 148 minutos de vídeos, em um total de 48 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Criação do primeiro agente
• Estruturando o RAG
• Criando ferramentas
• Aplicando múltiplos agentes
• Criando uma aplicação