Python e Gemini: orquestrando LLMs com LangChain

Primeiros passos com o LangChain - Apresentação

Olá! Meu nome é André Santana, sou instrutor na Alura, na Escola de Programação e IA.

Audiodescrição: André Santana é um homem branco de olhos castanhos. Tem barba cheia e cabelo curto, ambos castanhos. Usa óculos de armação arredondada e camiseta azul. Ao fundo, ambiente com luz arroxeada e estante com decorações.

Gostaria de te dar as boas-vindas ao curso da formação de Python com Gemini, que abordará LangChain.

Este curso é destinado a quem deseja se aperfeiçoar no uso de Python com programação orientada a objetos (POO) e inteligência artificial. Também é voltado para quem quer criar novas soluções com Gemini, tornando-as mais robustas e conectadas aos principais frameworks utilizados no mercado.

O que vamos aprender?

Até o momento, nesta formação, utilizamos especificamente uma única LLM (Large Language Model) para resolver problemas de interação com as IAs generativas que conhecemos.

Em específico, estamos utilizando uma abordagem multimodal com Gemini, mas nossas soluções têm uma limitação que impede a alteração flexível da LLM. Isso nos restringe a iniciar e terminar um projeto sempre com o mesmo tipo de tecnologia. Mas, nem toda LLM é adequada para todos os tipos de problemas que enfrentamos.

Para resolver esse tipo de problema, neste curso, criaremos uma solução envolvendo uma IA para apoiar nos seus estudos, permitindo analisar imagens e construir explicações mais didáticas.

Ao final do curso, esperamos criar um projeto que utilize diferentes tipos de LLM, empregue os principais frameworks do mercado, como o LangChain, e te ajude a construir soluções cada vez mais robustas, onde possamos ter mais autonomia de controle sobre como a resposta será gerada ao longo do processo.

Neste curso, aprenderemos a utilizar o Gemini com o framework LangChain, implementar cadeias sequenciais, utilizar a LLM mais adequada para cada tipo de problema, criar um agente orquestrador que escolha a melhor forma de responder a uma pergunta do usuário, sem se limitar apenas ao conhecimento da própria LLM.

Também implementaremos ferramentas que envolvem análise de imagem e descrição adequada, além da construção de explicações mais didáticas e conectadas ao uso prático do dia a dia, integrando todas as ferramentas dentro de um orquestrador usando o LangChain.

Pré-requisitos

Para aproveitar melhor este curso, é importante ter concluído os cursos anteriores desta formação, possuir algum conhecimento em Python e em Programação Orientada a Objetos.

Além dos vídeos, temos as atividades, a comunidade no Discord da Alura e o fórum para tirar dúvidas.

Bons estudos e até a primeira aula!

Primeiros passos com o LangChain - Usando LLMs via LangChain

Olá, pessoal. Vamos começar a implementar nosso projeto e, para isso, utilizaremos um framework chamado LangChain, bastante utilizado quando buscamos independência na escolha de modelos e queremos garantir robustez na abordagem determinística, ou seja, trazendo previsibilidade na geração de resultados com IA generativa.

Para isso, temos alguns arquivos de base que serão utilizados para implementar um assistente que auxiliará nos estudos. Basicamente, utilizaremos o LangChain para trabalhar com diferentes LLMs que nos ajudarão a interpretar imagens para facilitar anotações de estudos e simplificar a compreensão de determinados assuntos.

Conhecendo o projeto

Para a implementação, utilizaremos três arquivos que já estão no projeto base. O primeiro deles gerencia nossas chaves de acesso da API:

my_keys.py:

import os
from dotenv import load_dotenv

load_dotenv()

GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
MARITACA_API_KEY = os.getenv("MARITACA_API_KEY")

Neste curso, usaremos a API do Gemini e a API da Maritaca, uma LLM brasileira. No curso, há uma atividade "Para Saber Mais" explicando como gerar essa chave de acesso e utilizar os créditos disponíveis.

Além disso, utilizaremos outros dois arquivos de script. Um deles contém os principais modelos que usaremos:

my_models.py:

GEMINI_PRO = "gemini-1.5-pro"
GEMINI_FLASH = "gemini-1.5-flash"
MARITACA_SABIA = "sabia-3"

Na linha 1 e 2, temos os dois modelos do Gemini, Gemini Pro e Gemini Flash; enquanto na linha 3, acrescentamos o Maritaca Sabiá-3, o modelo mais moderno disponível nesta LLM brasileira.

O terceiro script, chamado my_helper.py, contém um código curto que permite abrir uma imagem, dado um caminho passado como parâmetro para a função encode_image().

my_helper.py:

import base64

def encode_image(image):
    with open(image, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
    return encoded_string

Abrimos a imagem e a convertemos para uma base chamada base64. Com a imagem convertida para base64 e no formato de string, conseguimos enviá-la para uma LLM para análise e retorno.

Importando biblioteca e modelo do Gemini

Vamos criar nosso primeiro script. No diretório raiz do projeto, criaremos um novo arquivo chamado lang_chain.py. Nele, faremos as implementações necessárias para conectar com a API da LLM escolhida, tornando-a o mais independente possível e garantindo que os recursos do LangChain nos ajudem a trabalhar com aplicações mais complexas. Ressaltamos que esse framework é amplamente utilizado no mercado.

A primeira ação será importar a biblioteca do LangChain. Para isso, utilizaremos o módulo langchain_google_genai. Dentro deste módulo, encontraremos os recursos necessários para instanciar uma LLM, que inicialmente será a LLM do Gemini. Para isso, importaremos o construtor ChatGoogleGenerativeAI.

lang_chain.py:

from langchain_google_genai import ChatGoogleGenerativeAI

O próximo passo é garantir que possamos tornar genérica a relação de envio de mensagens para a LLM, dissociando o processo de escolha. Para isso, faremos outra importação dentro da biblioteca langchain_core, que oferece diversos recursos. Como queremos trocar mensagens, vamos usar o recurso de messages e importar HumanMessage para assumir o papel de um ser humano que faz perguntas para a LLM.

from langchain_core.messages import HumanMessage

Além disso, precisamos importar nossa chave de acesso e o modelo que utilizaremos. Acessaremos os modelos no my_models e importaremos o modelo mais econômico do Gemini, o GEMINI_FLASH, além da chave de acesso no my_keys, importando a chave GEMINI_API_KEY. Lembre-se de configurá-la no espaço de variáveis de ambiente.

from my_models import GEMINI_FLASH
from my_keys import GEMINI_API_KEY

Por fim, a última importação envolverá nosso encoder. No my_helper, importaremos o encode_image.

from my_helper import encode_image

Criando LLM via LangChain

Com todas as bibliotecas necessárias, podemos interagir com a LLM. Vamos trocar uma mensagem "Olá Mundo", para mostrar que já conseguimos enviar uma imagem e obter uma resposta da LLM.

Vamos começar a criar a LLM. Escolheremos uma variável com nome genérico, pois migraremos de LLM do Gemini para outras LLMs durante o curso. Por isso, chamaremos essa variável de llm.

Em vez de criar uma LLM do zero, traremos a LLM do Gemini para cá. Para isso, usaremos o construtor ChatGoogleGenerativeAI(), que espera dois parâmetros: a chave de acesso, importada na linha 4 como GEMINI_API_KEY; e o tipo de modelo, que será o GEMINI_FLASH importado na linha 3.

llm = ChatGoogleGenerativeAI(
  api_key=GEMINI_API_KEY,
  model=GEMINI_FLASH
)

Note como esse construtor é mais genérico. Como o LangChain é o orquestrador, ele tira essas diferenças existentes quando criamos um código que utiliza IA generativa.

Codificando imagem

Agora, temos uma LLM que podemos usar na aplicação. O próximo passo é importar a imagem de teste. Para isso, criaremos uma variável chamada imagem e usaremos o método encode_image(), passando o caminho da imagem como parâmetro.

No diretório raiz do projeto, há uma pasta "dados" com um exemplo de gráfico. Este gráfico, criado com dados fictícios, mostra a relação de crescimento do percentual da população brasileira com smartphones ao longo dos anos.

Clicando com o botão direito em exemplo_grafico.jpg, escolhemos a opção para copiar o caminho relativo da imagem (atalho "Ctrl + K, Ctrl + Shift + C") e o inserimos no método encode_image(), entre aspas duplas, no script lang_chain.py .

imagem = encode_image("dados\exemplo_grafico.jpg")

Assim, transformamos a imagem em base64 para enviá-la à LLM para análise. A abordagem varia conforme a LLM escolhida, mas adotamos este orquestrador para reduzir diferenças de interface.

Criando mensagem

Na próxima linha, começamos a criar nossa mensagem. Primeiro, vamos criar a pergunta que faremos a LLM. A variável pergunta vai receber uma string qualquer, como "Descreva a imagem". Desse modo, a LLM deve interpretar e descrever a imagem.

pergunta = "Descreva a imagem: "

Por padrão, entregamos aos modelos multimodais, como o Gemini, um texto com a pergunta e a imagem a ser analisada.

Para compor a mensagem, utilizamos o construtor HumanMessage() para passar uma mensagem humana composta por uma estrutura básica, que é o content.

Esse conteúdo é uma lista com dois objetos dicionários. O primeiro dicionário envolve a mensagem de texto com a pergunta. O par chave-valor inicial, "type": "text", envolve o tipo de mensagem utilizada que, nesse caso, será um texto.

Usamos o termo "multimodal", porque enviamos tanto texto quanto imagem, ou seja, diferentes modais de informação.

Depois do tipo, também precisamos informar o conteúdo textual que a IA vai interpretar, que é a pergunta. Por isso, passamos a chave text com o valor armazenado na variável pergunta.

mensagem = HumanMessage(
  content = [
    {
      "type" : "text", 
      "text" : pergunta
    }
  ]
)

O segundo dicionário indica o conteúdo da imagem. Para especificar o tipo, usamos a chave type com valor image_url.

O conteúdo da image_url será uma imagem no formato de base64. Por isso, em vez de uma string literal, usamos uma f-string. Assim parte dela é composta pela variável imagem.

Basta começar com a letra f e abrir e fechar aspas, para indicar a composição com variável. Definimos o protocolo data, indicando um dado composto, do tipo imagem no formato JPEG em base 64. E aí, sim, passamos a imagem inteira para a LLM.

mensagem = HumanMessage(
  content = [
    {
      "type" : "text", 
      "text" : pergunta
    },
    {
      "type" : "image_url",
      "image_url" : f"data:image/jpeg;base64,{imagem}"
    }
  ]
)

Embora diferente do que aprendemso em outros cursos, essa abordagem garante robustez ao trocar de LLMs, pois esse formato se manterá igual.

Recebendo a resposta

Agora, vamos enviar a pergunta à LLM. Criamos uma variável resposta e usamos a llm com o método invoke(), que espera um único parâmetro: a mensagem que será enviada.

Passamos o parâmetro como lista de conteúdos, entre colchetes, informando a variável mensagem.

resposta = llm.invoke([mensagem])

Por fim, imprimimos a resposta através do método print(). Lembrando que será devolvido um objeto composto. Podemos extrair apenas a resposta textual, se desejado.

print(resposta)

Salvamos o arquivo com "Ctrl + S" e clicamos no botão "Run Python File" no canto superior direito para executar e conferir a resposta da LLM.

Retorno no terminal:

imagem = encode_image("dados\exemplo_grafico.jpg")
content="Claro, aqui está uma descrição da imagem:\n\nA imagem é um gráfico de linha que mostra o percentual da população com smartphones de 2010 a 2020. O eixo x representa o ano, e o eixo y representa o percentual da população. A linha mostra um aumento constante no percentual da população com smartphones durante esse período. Em 2010, o percentual era de cerca de 15%, enquanto em 2020, o percentual era de cerca de 90%. O título do gráfico é 'Percentual da População com Smartphones (2010-2020)'. O gráfico é claro e fácil de entender, e mostra uma tendência clara de aumento no uso de smartphones ao longo do tempo."
additional_kwargs={} response_metadata={'prompt_feedback': {'block_reason': 0, 'safety_ratings': []}, 'finish_reason': 'STOP', 'safety_ratings': []} id='run-08244224-cc24-409c-9ffd-7e774014c39b-0' usage_metadata={'input_tokens': 265, 'output_tokens': 160, 'total_tokens': 425, 'input_token_details': {'cache_read': 0}}

A LLM retorna a resposta, dentro de content, com o texto: "Claro, aqui está uma descrição da imagem. A imagem é um gráfico de linhas, que mostra o percentual da população com smartphones de 2010 até 2020. O eixo X representa o ano, e o eixo Y representa o percentual da população." Isso demonstra que a LLM conseguiu interpretar a imagem.

Próximos passos

Com isso, já conseguimos interagir, desacoplando a dependência de um modelo de LLM específico, como o Gemini, e tornando o processo de troca de modelos mais flexível.

No próximo vídeo, discutiremos como trocar rapidamente de LLM. Até lá.

Primeiros passos com o LangChain - Flexibilizando a troca de LLMs

Quando começamos a criar ou analisar dados, muitas vezes temos LLMs diferentes que nos proporcionam desempenhos variados durante o processo de análise. Até agora, utilizamos a LLM do Gemini para analisar um gráfico sobre o cenário de smartphones no Brasil.

No entanto, durante a composição e criação desse texto, muitas vezes a LLM pode utilizar termos que talvez sejam muito diferentes da nossa linguagem natural, que é o português do Brasil; ou até mesmo referências que não são puramente brasileiras ou sem tanta prioridade quanto deveria, já que a pergunta está em português.

Ao trabalhar com aplicações comerciais, é comum garantir que cada LLM utilizada esteja associada ao seu melhor cenário de desempenho e aos melhores casos de uso para as quais foi desenvolvida.

Por conta disso, vamos utilizar agora o poder que o LangChain nos oferece, que é a facilidade de migrar entre LLMs. Para isso, utilizaremos a Maritaca.

A Maritaca possui um LLM chamado Sabiá-3, desenvolvido e treinado com dados para o idioma português do Brasil. Assim, trará algumas diferenças, por exemplo, se tivermos perguntas específicas associadas ao contexto brasileiro.

Importando modelo do Sabiá-3

Para utilizar a Maritaca, após a importação de ChatGoogleGenerativeAI na linha 1, vamos importar o construtor para garantir o acesso a essa LLM.

Dentro os vários modelos diferentes disponíveis no langchain_community.chat_models, queremos importar justamente o ChatMaritalk.

from langchain_community.chat_models import ChatMaritalk

Uma vez que já temos acesso ao construtor, precisamos garantir que teremos acesso às chaves associadas às nossas variáveis de ambiente e ao modelo certo para utilizar com a Maritaca.

Para isso, ao lado da importação do GEMINI_FLASH, na linha 4, adicionamos o modelo MARITACA_SABIA, que está no arquivo my_models no projeto base. Já na linha 5, trazemos a chave de acesso, MARITACA_API_KEY, do arquivo my_keys.

from my_models import GEMINI_FLASH, MARITACA_SABIA
from my_keys import GEMINI_API_KEY, MARITACA_API_KEY

Confira a atividade "Para Saber Mais" para saber como configurar e acessar alguns recursos da Maritaca através de um cupom exclusivo da Alura.

Fazendo uma pergunta

Uma vez que já temos acesso ao modelo desejado e à chave, faremos uma pergunta para a LLM para saber qual tipo de resposta ela trará.

Faremos uma adaptação rápida do código para garantir que a LLM do Gemini responda a mesma pergunta textual que será enviada para a Maritaca.

Para isso, criaremos uma variável chamada resposta, após a llm com o modelo do Gemini. Vamos atribuir essa variável uma chamada a llm com o método invoke(), passando um pedido de indicações de canais de YouTube sobre smartphones - sem dar informações específicas de contexto.

resposta = llm.invoke("Quais canais de Youtube você recomenda para que eu possa saber mais a respeito de smarpthones?")

Para mostrar essa resposta, utilizaremos o comando print() com uma string composta para associar a resposta do Gemini ao resposta.content para acessar, assim, apenas o conteúdo textual que o Gemini trouxe.

print("Gemini: ", resposta.content)

Para utilizar a Maritaca, usaremos quase o mesmo código, com a diferença do construtor.

Primeiro, criaremos uma nova llm, sobrescrevendo o conteúdo dela, mas agora utilizaremos o construtor da Maritaca, que é o ChatMaritalk. De maneira similar a estrutura da LLM do Gemini, precisaremos passar dois parâmetros: a chave de acesso (api_key) e o modelo (model) da Maritaca que serão, MARITACA_API_KEY e MARITACA_SABIA, respectivamente.

llm = ChatMaritalk(
  api_key=MARITACA_API_KEY,
  model=MARITACA_SABIA
)

Feito isso, já temos a configuração e podemos copiar a forma de enviar a pergunta para a LLM. É transparente para a parte interna do nosso sistema, não precisamos saber como esse processo opera, já que estamos utilizando o LangChain como interface principal para desenvolver.

Basta copiar e colar a estrutura da variável resposta e do print(), com a única diferença de que imprimiremos a string "Maritaca" para saber que essa resposta veio da Maritaca.

resposta = llm.invoke("Quais canais de Youtube você recomenda para que eu possa saber mais a respeito de smarpthones?")

print("Maritaca: ", resposta.content)

Comparando as respostas

Pode aparecer um erro de exceção, pois a Maritaca será utilizada, mas já conversaremos sobre isso, já que nosso foco agora é ler a resposta de cada LLM.

Após executar o arquivo, confirmamos que a troca de LLM acontece de forma flexível e rápida, já que só muda o construtor, enquanto o restante da estrutura permanece o mesmo. No entanto, o teor da resposta varia bastante.

O Gemini recomenda uma série de canais de YouTube sobre smartphones, como Linus Tech Tips, MKBHD, Dave2D, entre outros. Esses canais são em inglês, o que pode não ser exatamente o que procuramos quando fazemos uma pergunta em português.

Retorno:

Gemini: Há muitos canais excelentes no YouTube sobre smartphones, dependendo do seu interesse e específico. Para te recomendar melhor, preciso saber o que você quer saber exatamente. Mas, de forma geral, aqui estão alguns canais populares e recomendados, divididos por foco:

**Canais com foco em reviews e comparações:**

* **Linus Tech Tips:** Embora não seja *exclusivamente* sobre smartphones, eles frequentemente fazem reviews detalhados e comparações de diversos aparelhos, com testes práticos e análises técnicas. Ótimo para quem quer uma visão abrangente.
* **MKBHD (Marques Brownlee):** Considerado um dos melhores canais de tecnologia do YouTube, MKBHD oferece reviews de alta qualidade, bem produzidos e imparciais de smartphones top de linha. O foco é na experiência do usuário e em detalhes técnicos.
* **Dave2D:** Similar ao MKBHD, Dave2D produz reviews aprofundados, com foco na experiência prática e na comparação entre diferentes modelos.
* **PhoneBuff:** Conhecido por seus testes de resistência e benchmarks de desempenho, o PhoneBuff oferece comparações diretas entre smartphones em diferentes tarefas.
* **JerryRigEverything:** Este canal foca nos testes de durabilidade e resistência dos smartphones, mostrando como eles se comportam em situações extremas (riscos, quedas, etc.).

**Canais com foco em dicas e truques:**

* **Android Central:** Oferece dicas, tutoriais e notícias sobre o sistema operacional Android.
* **9to5Google:** Outro canal com foco em Android, notícias e análises.

**Canais com foco em tecnologia em geral (mas com cobertura de smartphones):**

* **TechLinked:** Oferece uma variedade de conteúdo de tecnologia, incluindo reviews de smartphones, notícias e análises.

**Considerações:**

* **Idioma:** A maioria dos canais listados acima é em inglês. Se você prefere conteúdo em português, pesquise por "reviews de smartphones em português" no YouTube para encontrar canais locais.
* **Nível de detalhe:** Alguns canais são mais técnicos que outros. Escolha aqueles que se alinham ao seu nível de conhecimento e interesse.
* **Viés:** Lembre-se que todos os canais têm um certo viés, mesmo que tentem ser objetivos. Considere assistir a reviews de diferentes canais para ter uma visão mais completa.

Para uma recomendação mais precisa, me diga:

* **Que tipo de smartphone você está interessado?** (Android, iPhone, gama alta, gama média, etc.)
* **Que tipo de informação você busca?** (Reviews, comparações, dicas de uso, notícias, testes de resistência, etc.)
* **Qual o seu nível de conhecimento técnico?** (Iniciante, intermediário, avançado)

Com essas informações, posso te dar recomendações mais específicas e úteis.

Enquanto a Maritaca sugere canais do YouTube como Canaltech, TudoCelular.com, TechTudo, que são brasileiros.

Retorno:

Maritaca: Existem vários canais no YouTube que são populares e confiáveis para aprender mais sobre smartphones. Aqui estão algumas recomendações:

1. **Canaltech**: Um dos maiores canais de tecnologia do Brasil, com notícias, reviews, comparativos e tutoriais.
2. **TudoCelular.com**: Oferece reviews, comparações e notícias sobre smartphones e tecnologia móvel.
3. **TechTudo**: Produzido pelo portal TechTudo, oferece uma variedade de conteúdos relacionados a smartphones, incluindo dicas e tutoriais.
4. **Oficina da Net**: Um canal com foco em tecnologia que oferece análises detalhadas e notícias sobre smartphones.
5. **Celso Zucatelli**: O jornalista Celso Zucatelli compartilha suas análises e opiniões sobre smartphones e outros dispositivos tecnológicos.
6. **Unbox Therapy**: Um dos maiores canais de tecnologia do mundo, com foco em smartphones, gadgets e produtos eletrônicos em geral.
7. **Marques Brownlee (MKBHD)**: Um dos mais influentes canais de tecnologia no YouTube, com análises profundas e comparativos de smartphones.
8. **Dave2D**: Oferece análises e opiniões sobre smartphones e outros dispositivos tecnológicos.
9. **Acerola Tech**: Um canal brasileiro que oferece análises de smartphones e outros produtos de tecnologia, com uma abordagem descontraída e informativa.
10. **Android Authority**: Um canal focado em dispositivos Android, com notícias, análises e tutoriais.

Lembre-se de verificar o idioma do conteúdo, pois alguns canais podem estar em inglês ou outros idiomas. Se preferir conteúdo em português, os canais brasileiros serão mais adequados.

Mesmo não sendo parte de uma corporação muito recente, o fato de existir uma LLM especializada no idioma português do Brasil garante que a resposta gerada para esse contexto seja mais relevante.

No entanto, foi lançada uma exceção que indica que a Maritaca encontrou um erro de requisição.

langchain_community.chat_models.maritalk.MaritalkHTTPError:

HTTP Error: 400 - Bad Request

Detail: Sorry, we currently do not support images as content. Make sure that the content of your message is a string.

Isso ocorre porque a última LLM utilizada é a Maritaca. Por isso, ela é utilizada para descrever a imagem do gráfico. Contudo, ela não possui a capacidade multimodal que o Gemini tem.

Embora ganhemos a vantagem de ter um texto mais abrasileirado, relevante para o contexto do problema que analisamos, perdemos a função de analisar uma imagem.

Conclusão

O ideal é que consigamos migrar facilmente de uma LLM para outra, mas mantendo a LLM mais adequada para o problema que estamos resolvendo. Daqui para frente aprenderemos como podemos dar mais independência aos resultados que utilizaremos e desenvolveremos junto com o framework LangChain.

Até o próximo vídeo.

Sobre o curso Python e Gemini: orquestrando LLMs com LangChain

O curso Python e Gemini: orquestrando LLMs com LangChain possui 108 minutos de vídeos, em um total de 42 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:

• Primeiros passos com o LangChain
• Prompt Templates e Output Parsing
• Estruturando saídas: diferentes formatos de resposta
• Agentes orquestradores
• Criando ferramentas com diferentes LLMs