Flash Skills: RAG e Agentes de IA

Conhecendo o RAG - Apresentação

Apresentando o curso e o instrutor

Olá, sejam bem-vindos a este curso na Alura. Meu nome é Alan Spadini.

Audiodescrição: Alan é um homem branco, com cabelos castanhos. Ele está no estúdio da Alura, com luzes azuis e roxas ao fundo.

Introduzindo o conceito de Retrieval Augmented Learning

Neste curso, vamos trabalhar com REG (Retrieval Augmented Learning), que significa que adicionaremos uma base de dados de conhecimento a alguma LLM, para que ela consiga responder sobre um assunto específico do nosso interesse de maneira mais precisa. Para isso, utilizaremos bibliotecas como LangChain e LangGraph. Esperamos vê-los nos próximos vídeos deste curso. Até lá!

Conhecendo o RAG - Conectando-se a um LLM

Introduzindo o uso de LLMs com a biblioteca LinkedIn

Como podemos fazer com que uma LLM (Modelo de Linguagem Grande) responda de maneira detalhada e precisa sobre um assunto específico de nosso interesse? Para isso, vamos utilizar a biblioteca LinkedIn, que nos permitirá conectar a uma LLM específica e verificar se ela consegue responder sobre o tema desejado de forma precisa.

Para trabalhar com a LLM, utilizaremos o Google Colab, um sistema de notebook do Google que nos permite executar código Python. Inicialmente, instalaremos algumas bibliotecas necessárias. Após a instalação, executamos o comando Shift + Enter na célula de código para instalar o LinkedIn e outras bibliotecas que utilizaremos ao longo do curso. Com essas bibliotecas instaladas, podemos começar a trabalhar.

%pip install -qU pypdf
%pip install -U langchain
%pip install -U langchain-community
%pip install -U langchain-groq
%pip install langchain-huggingface
%pip install langgraph

Obtendo e configurando a chave de API

Para conectar à LLM, precisamos de uma chave de API. Existem diversos provedores de chave de API, como o Google Gemini e a OpenAI, que geralmente são pagos. Para o desenvolvimento deste projeto, escolhemos trabalhar com o Grote, um fornecedor de chave de API que oferece as LLMs da Lama, desenvolvidas pela Meta, de forma gratuita até o momento. Esses modelos do Lama também podem ser baixados localmente, caso desejemos trabalhar com eles sem depender de uma API externa. Por isso, escolhemos os modelos do Lama e o provedor Grote.

Para obter a chave de API, acessamos o site do Grote em grote.com. Após fazer login no site, clicamos em "Start Building" e, em seguida, em "Create API Key". Após a verificação de segurança, uma chave de API é gerada. Copiamos essa chave e a inserimos no Google Colab. No canto esquerdo do Google Colab, no símbolo de chave, podemos adicionar um novo segredo, nomeando-o como "API do Grote" e colando a chave de API gerada.

Configurando variáveis de ambiente e importando módulos necessários

Já temos uma chave de API adicionada, que utilizaremos neste curso, nomeada como Grote API Key. No sistema de Secrets do Google, há um exemplo de código que nos permite copiar essa chave de API para nosso código. Copiamos esse trecho de código, colamos em uma célula de código e substituímos o Secret Name pelo nome da chave de API que adicionamos, GROQ_API_KEY. Assim, conseguimos armazenar o valor da chave de API dentro de uma variável, como API_Key.

from google.colab import userdata
api_key = userdata.get('GROQ_API_KEY')

Além disso, na biblioteca LinkedIn que vamos utilizar, precisamos informar que estamos utilizando a chave de API do Grote. Para isso, adicionaremos essa informação ao sistema. Vamos importar o módulo os e, em seguida, utilizar os.environ para definir a variável de ambiente. Faremos isso abrindo e fechando colchetes e adicionando GROQ_API_KEY igual à chave de API. Com isso, a informação GROQ_API_KEY com o valor da chave será adicionada às nossas variáveis de ambiente, permitindo que o LinkedIn entenda que estamos utilizando a chave de API do Grote. É importante que a variável de ambiente tenha exatamente esse nome, GROQ_API_KEY, para que possamos utilizar o modelo do Llama através do Grote.

import os
os.environ['GROQ_API_KEY'] = api_key

Definindo e testando a LLM com um exemplo prático

Dentro do LinkedIn, precisamos importar o chat_Groq do LinkedIn. Faremos isso com from langchain_groq import ChatGroq. Com isso, conseguimos definir nossa LLM. Vamos definir LLM igual a chat_Groq e, dentro do chat_Groq, especificar o modelo que vamos utilizar, colocando model igual a "Llama 3.3-70B-Versatil". Este é um dos exemplos de modelos disponíveis no Grote. Na página do Grote, em API Keys ou Models, podemos ver outros modelos que podemos testar, como o modelo do Llama 4, os modelos do Quen, da empresa Alibaba, além do Gema e do Mistral, todos modelos interessantes.

from langchain_groq import ChatGroq
llm = ChatGroq(model='llama-3.3-70b-versatile')

Após definir a LLM, vamos verificar se ela consegue responder a alguma pergunta sobre um assunto de interesse. Suponhamos que nosso interesse seja a ida a Marte. Queremos perguntar sobre Marte e verificar se a LLM responde. Vamos adicionar um prompt, definindo prompt igual a três aspas, seguido de um trecho de texto. Adicionaremos messages e dois pontos, seguido de uma informação. Colaremos a informação pré-definida, que é: "Segundo a NASA, quais seriam os benefícios científicos de ir para Marte?". Vamos ver se a LLM sabe responder a isso.

prompt = '''
messages: Segundo a NASA quais seriam os beneficios cientificos de ir para Marte?
'''

Executando o prompt e analisando a resposta da LLM

Definimos o prompt, e dentro da variável prompt temos essa informação. Em seguida, definimos resposta igual a llm.invoke(prompt), perguntando à LLM sobre essa questão. Ao executar, podemos ver que temos a mensagem da IA e o conteúdo da resposta, que menciona vários benefícios científicos de ir para Marte.

resposta = llm.invoke(prompt)

resposta

Preparando para integrar conhecimento externo à LLM

Agora, suponhamos que tenhamos um documento sobre Marte, como um documento da NASA. Escolhemos propositalmente um documento da NASA, pois é um órgão público e seus documentos geralmente estão em domínio público. Este documento está em domínio público, mas não é de conhecimento da LLM, pois ela foi treinada até uma determinada data, e o documento foi publicado posteriormente. Queremos que a LLM responda sobre o conteúdo desse documento. Como fazemos isso?

O intuito do reg é adicionar conhecimento de uma base de dados externa, seja da internet ou de um documento PDF que tenhamos localmente, ou um documento de conhecimento da nossa empresa. No próximo vídeo, veremos como carregar esse documento e como começar a trabalhar com ele para que a LLM possa responder sobre seu conteúdo.

Montando base de dados para fazer buscas - Carregando um PDF para o RAG

Introduzindo o objetivo do projeto

Agora, queremos adicionar informações a partir de um documento em texto que tenhamos salvo de alguma forma, para que a LLM consiga responder sobre esse documento. Neste caso, trata-se de um documento que fala sobre Marte e a NASA.

Instalando bibliotecas necessárias

No início do nosso conteúdo, realizamos a instalação de algumas bibliotecas, como a PyPDF e a LinkedIn Community. Vamos começar instalando essas bibliotecas necessárias para o nosso projeto:

%pip install -qU pypdf
%pip install -U langchain
%pip install -U langchain-community
%pip install -U langchain-groq
%pip install langchain-huggingface
%pip install langgraph

Carregando o documento PDF

A partir da LinkedIn Community, conseguimos carregar alguns loaders (carregadores de informação de documentos), e é isso que vamos fazer.

O documento está disponível em um repositório no GitHub, é um documento em PDF. Colocamos o link desse documento dentro de uma variável chamada url:

url = 'https://raw.githubusercontent.com/allanspadini/curso-flash-rag/main/m2m_strategy_and_objectives_development.pdf'

Utilizando o PyPDFLoader

Em seguida, fazemos a importação do PyPDFLoader com o comando correto:

from langchain_community.document_loaders import PyPDFLoader

Utilizamos o PyPDFLoader para criar uma variável chamada loader, que será igual a PyPDFLoader(url), definindo assim nosso loader:

loader = PyPDFLoader(url)

Dividindo o documento em páginas

No entanto, não queremos carregar todo o documento em um único bloco; vamos carregá-lo dividido em páginas, por exemplo. Para isso, criamos uma lista vazia chamada pages:

pages = []

E utilizamos um laço for para iterar sobre loader.lazy_load(), adicionando página por página dentro dessa lista:

for page in loader.lazy_load():
    pages.append(page)

Após corrigir um erro de digitação no nome da biblioteca, conseguimos realizar o carregamento das informações, dividindo o documento em páginas.

Explorando o conteúdo do documento

Outra forma comum de carregar documentos e informações é em chunks (blocos) de trechos de texto que possuem uma certa quantidade de caracteres.

Carregar o documento em páginas é bastante conveniente, pois representa uma divisão lógica do nosso documento. Isso é interessante porque precisamos buscar informações dentro desse documento de alguma forma. Para verificar a informação, podemos tentar imprimir o conteúdo da primeira página, que é a página zero. Podemos usar o comando:

print(f"{pages[0].metadata}\n")

Para visualizar os metadados do documento carregado, que é um arquivo PDF da biblioteca versão 17.0. Esses metadados incluem as datas do documento, a origem do carregamento e o número total de páginas, que é 68. Também conseguimos visualizar o conteúdo da página.

Visualizando o conteúdo da primeira página

Para isso, utilizamos:

print(pages[0].page_content)

E, ao executar, vemos que a página zero contém informações da capa do documento, como o nome "nasasmustemars", que está em inglês. Temos essas informações do documento e queremos continuar trabalhando com ele. Uma das formas de adicionar conhecimento para a LLM é inserir o texto no prompt e perguntar sobre ele, facilitando a busca de informações.

Considerando o problema da janela de contexto

No entanto, ao observar os metadados, percebemos que o documento tem 78 páginas no total, o que é bastante extenso. Se já interagimos com o ChatGPT ou o Gemini, notamos que, quanto mais longa a conversa, maior a tendência de confusão, erros ou esquecimento das primeiras interações. Isso se deve ao problema de janela de contexto.

Por essa razão, ao trabalhar com documentos e bases de conhecimento, não adicionamos diretamente todo o conhecimento no prompt para a LLM. Em vez disso, rastreamos a informação relevante para responder à pergunta que estamos fazendo. Vamos explorar como fazer isso no próximo vídeo.

Sobre o curso Flash Skills: RAG e Agentes de IA

O curso Flash Skills: RAG e Agentes de IA possui 66 minutos de vídeos, em um total de 20 atividades. Gostou? Conheça nossos outros cursos de IA para Programação 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:

• Conhecendo o RAG
• Montando base de dados para fazer buscas
• Agentes Autônomos com Fluxo e Memória