LangChain e Python: criando ferramentas com a LLM OpenAI

Utilizando LangChain para gerar respostas de texto com a OpenAI - Apresentação

Olá! Meu nome é Guilherme Silveira, sou instrutor e fundador da Alura, e irei te acompanhar ao longo deste curso de LangChain.

Audiodescrição: Guilherme é um homem branco, de cabelo curto preto, sobrancelhas pretas, e olhos castanho-esverdeados. Ele veste uma camisa preta lisa e está sentado no estúdio da Alura, com uma parede clara ao fundo iluminada em roxo, e uma estante preta à esquerda do instrutor contendo plantas, enfeites, e pontos de iluminação amarela.

O que vamos aprender?

A proposta deste curso é utilizar a ferramenta LangChain como intermediária entre nosso programa, isto é, o código que escrevemos, e as APIs de LLMs (Large Language Models, ou Modelos de Linguagem Grande).

Se utilizarmos uma API de LLM como a OpenAI (remota e pela qual pagamos por requisição) ou uma LLM local, a LangChain tentará abstrair isso e disponibilizar diversos padrões comuns considerados boas práticas na utilização das LLMs.

Dito isso, utilizaremos a OpenAI como fim, isto é, como back-end para utilizar a LangChain, e criaremos diversos exemplos de utilização da LangChain.

Vamos começar com um exemplo simples, no qual trabalhamos com um modelo de prompt e invocamos esse modelo, podendo fazer isso diversas vezes.

Depois, passaremos para exemplos mais complexos, nos quais precisaremos executar um passo e, a depender do resultado, executar o próximo. Em seguida, iremos abrir para executar dois prompts separados em paralelo, para coletar o resultado deles e executar em conjunto.

Considerando toda essa arquitetura dos caminhos que o algoritmo precisa fazer utilizando a LLM, vamos implementar algumas variações utilizando a LangChain, pois ela já fornece isso para nós.

Além disso, ela também fornecerá padrões de formatação para saída, de leitura da saída, e de memória que podemos utilizar — não apenas a memória conversacional, na qual falamos algo e obtemos uma resposta, mas também memória de valores que vieram nessas respostas.

Tudo isso será abordado neste curso, que fornece a base para utilização da LangChain. Em que tipo de sistema? Quando vale a pena fazer isso? Quando temos um sistema no qual vamos executar um processo de chamadas para LLM.

A partir do nosso Language Model, queremos executar uma sequência de prompts, os quais, às vezes, são diversos ao mesmo tempo e se juntam para um resultado final, ou são uma sequência complexa, ou são três prompts pequenos que executamos inúmeras vezes e podemos querer dispará-los em paralelo.

Conclusão

Todas essas variações de arquiteturas e de utilização da LLM, a LangChain nos beneficia. Trabalharemos para esses casos, e entenderemos como funciona esse tipo de situação e como nos beneficiamos com ela.

Nos encontramos na próxima aula. Até mais!

Utilizando LangChain para gerar respostas de texto com a OpenAI - Gerando dicas de viagem com a OpenAI e o GPT 3.5

Olá! Neste vídeo, daremos início ao nosso projeto.

Gerando dicas de viagem com a OpenAI e o GPT 3.5

Criando a pasta do projeto

Com o Visual Studio Code aberto, vamos abrir a pasta onde iremos trabalhar. Nomearemos essa pasta como "langchain" e depois a selecionaremos. Por enquanto, ela está vazia, então precisamos começar a criar os arquivos.

Criando o arquivo main.py

Primeiramente, criaremos um arquivo chamado main.py, onde escreveremos o código Python.

Lembre-se: trabalharemos com Python utilizando a OpenAI para fazer prompts com LLM e seguindo boas práticas.

Criando o prompt e declarando as variáveis

Vamos entender o problema que queremos resolver? Suponha que trabalhamos em uma agência de turismo e queremos automatizar grande parte do processo de geração de roteiros de viagem e esclarecimento de dúvidas sobre as viagens.

Sendo assim, queremos um tipo de prompt que, dadas algumas variáveis, como número de dias de viagem, número de crianças na viagem, e tipos de atividade preferidas, gere um roteiro para nós.

Criaremos isso de forma genérica no arquivo main.py: o prompt será Crie um roteiro de viagem de {numero_de_dias} dias, para uma família com {numero_de_criancas} crianças, que gostam de {atividade}..

O numero_de_dias será uma variável, então colocaremos o prompt do Python como f, e vamos declarar numero_de_dias igual a 7 logo acima. Assim, teremos um roteiro de viagem de 7 dias.

main.py:

numero_de_dias = 7

prompt = f"Crie um roteiro de viagem de {numero_de_dias} dias, para uma família com {numero_de_criancas} crianças, que gostam de {atividade}."

Feito isso, precisamos declarar o numero_de_criancas, que será, por exemplo, 2 crianças, e a atividade, que será "praia". O resultado do prompt irá depender da atividade, do numero_de_criancas e do numero_de_dias.

Para finalizar, vamos imprimir prompt para verificar se funciona conforme esperado.

numero_de_dias = 7
numero_de_criancas = 2
atividade = "praia"

prompt = f"Crie um roteiro de viagem de {numero_de_dias} dias, para uma família com {numero_de_criancas} crianças, que gostam de {atividade}."
print(prompt)

Após executar o código, temos o seguinte retorno no terminal:

Crie um roteiro de viagem de 7 dias, para uma família com 2 crianças, que gostam de praia.

Importando a OpenAI

Agora, precisamos pegar esse prompt e usar na OpenAI, isto é, no LLM do GPT. Para isso, primeiro precisamos da OpenAI, então no início do arquivo, acima das variáveis, faremos a importação:

from openai import OpenAI

# código omitido

Nesse momento, o VS Code irá reclamar que não encontrou openai, pois não instalamos o módulo da OpenAI. Sendo assim, vamos acessar o terminal em "Terminal > New Terminal".

O objetivo é criar um ambiente de desenvolvimento virtual, então vamos digitar o comando python -m venv .venv. Assim, criaremos um diretório de espaço de trabalho chamado .venv.

python -m venv .venv

Após executar o comando, vamos clicar em "Sim" na janela aberta. Dessa forma, pedimos para usar esse ambiente virtual de módulos do Python. Nesse momento, podemos fechar o terminal e abri-lo novamente.

Como já confirmamos para a IDE que queremos utilizar esse ambiente, ela deve estar nele. Para confirmar, podemos executar o comando pip list para verificar que somente o pip está instalado.

pip list

Retorno do comando:

Criando o arquivo requirements.txt

Agora, vamos criar um arquivo com os requerimentos. Para isso, clicaremos em "New File…" e nomearemos como requirements.txt. Nesse arquivo, vamos definir openai igual (==) à versão 1.13.3.

requirements.txt:

openai==1.13.3

Feito isso, vamos instalar no terminal com o seguinte comando:

pip install -r requirements.txt

Dessa forma, será instalada a openai.

Criando o cliente

De volta ao arquivo main.py, o VS Code irá corrigir a importação de openai na linha 1. Após isso, vamos criar o cliente, então na linha 10, após print(), definiremos cliente igual a OpenAI().

Entre os parênteses de OpenAI(), precisamos passar a chave de API para api_key. O instrutor usará a própria chave dele, enquanto você deverá gerar a sua própria no site da OpenAI.

main.py:

# código omitido

cliente = OpenAI(api_key="sua_api_key")

Para gerar a chave de API, com o playground da OpenAI aberto, vamos até "API keys > Create new secret key", onde pediremos para gerar uma nova chave secreta chamada curso-langchain-aovivo.

Essa chave funcionará apenas para o instrutor, pois assim que finalizarmos o curso, ela será deletada. Execute o processo e copie sua própria chave, para colar em api_key no arquivo main.py.

Após colar a chave no lugar de sua_api_key, podemos usar o cliente de acordo com a sugestão da documentação da OpenAI. Nesse caso, usaremos um chat, então na linha 12, digitamos cliente.chat.

No chat, chamaremos a API de completar, ou seja, completions. Assim, teremos cliente.chat.completions. Nesse momento, o VS Code sugere um autocomplete de completions() contendo um prompt, o qual já criamos. Porém, em vez disso, queremos criar um completions.

Para isso, chamamos o método create() logo após completions. Esse método da API receberá alguns parâmetros: o modelo (model), definido como gpt-3.5-turbo; e as mensagens (messages), definidas como uma lista ([]), como se já existissem algumas mensagens entre nós e o sistema.

# código omitido

cliente = OpenAI(api_key="sua_api_key")

cliente.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[

    ]
)

Nessa lista, primeiro o sistema (system) terá a seguinte mensagem como conteúdo (content): "You are a helpful assistant." (em português, "Você é um assistente útil.").

Depois, o usuário (user) irá conversar com a inteligência artificial, reproduzindo a mensagem do prompt, ou seja, Crie um roteiro de viagem de {numero_de_dias} dias, para uma família com {numero_de_criancas} crianças, que gostam de {atividade}..

Isso irá devolver uma resposta, então vamos atribuir a resposta todo o trecho de código entre as linhas 12 e 18. Para finalizar, iremos imprimir a resposta na linha 20 com o método print().

# código omitido

cliente = OpenAI(api_key="sua_api_key")

resposta = cliente.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": prompt}
    ]
)

print(resposta)

Feito isso, vamos salvar as alterações e rodar o arquivo para verificar se funciona. O processo deve demorar um pouco, pois ele acessa a internet, gera a resposta, e depois traz para nós.

Extraindo a mensagem

Após imprimir a resposta, vamos extrair apenas a mensagem. Na saída do terminal, teremos uma resposta bem grande, pois o objeto resposta traz várias informações, como: o ID do chat (id); as escolhas (choices); a razão do término (finish_reason); entre outras.

Na primeira escolha em choices, por exemplo, temos a mensagem (message) "Claro! Aqui está um roteiro de viagem de 7 dias para uma família com 2 crianças que adoram praia:".

As etapas do roteiro são as seguintes:

Dia 1: Chegada

1. Chegada ao destino da viagem e check-in no hotel.
2. Tarde livre para relaxar na praia próxima ao hotel e aproveitar as comodidades do local.
3. Jantar em um restaurante à beira-mar para apreciar o pôr do sol.

[…]

Com base nisso, vamos definir o roteiro_viagem igual a resposta.choices[0].message.content na linha 22. Em seguida, logo abaixo, vamos imprimir roteiro_viagem para visualizar o resultado.

Código final do arquivo main.py:

from openai import OpenAI

numero_de_dias = 7
numero_de_criancas = 2
atividade = "praia"

prompt = f"Crie um roteiro de viagem de {numero_de_dias} dias, para uma família com {numero_de_criancas} crianças, que gostam de {atividade}."
print(prompt)

cliente = OpenAI(api_key="sua_api_key")

resposta = cliente.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": prompt}
    ]
)

print(resposta)

roteiro_viagem = resposta.choices[0].message.content
print(roteiro_viagem)

No prompt, pedimos para criar o roteiro. Após executar o código, ele será gerado e a resposta será impressa no terminal. Vamos analisar essa resposta?

Dia 1: Chegada

• Chegada ao destino da viagem.
• Check-in no hotel.
• Primeiro dia de relaxamento na praia próxima ao hotel.
• Jantar em um restaurante à beira-mar.

Dia 2: Explorando a Região

• Café da manhã no hotel.
• Passeio em uma cidade próxima, visitando pontos turísticos e lojas locais.
• Almoço em um restaurante tradicional.
• Tarde livre na praia para mais diversão em família.

Dia 3: Atividades Aquáticas

• Excursão de barco para explorar as belas paisagens marinhas.
• Parada para snorkeling para observar a vida marinha.
• Almoço a bordo do barco.
• Tarde na praia para relaxar e se divertir.

Dia 4: Dia de Aventura

• Passeio de buggy pelas dunas e praias da região.
• Parada em uma lagoa para nadar e se refrescar.
• Almoço em um restaurante típico.
• Retorno ao hotel para descanso.

Dia 5: Dia de Diversão em Família

• Manhã livre na praia para brincadeiras e banho de mar.
• Almoço em um quiosque de praia.
• Tarde de diversão em um parque aquático próximo.

Dia 6: Explorando a Cultura Local

• Visita a uma vila de pescadores para conhecer a cultura local.
• Almoço com pratos típicos da região.
• Tarde livre para mais atividades na praia.

Dia 7: Último Dia de Viagem

• Manhã na praia para aproveitar os últimos momentos de sol.
• Check-out do hotel e retorno para casa.

Espero que este roteiro possa atender às preferências da sua família. Aproveite a viagem!

Nesse caso, faltou apenas sugerir para onde pode ser a viagem, pois não indicamos no prompt que queríamos um roteiro de viagem citando o nome da cidade de destino. Queremos saber diversas informações além das listadas acima no roteiro, mas trabalharemos essas questões durante o curso.

Criando o arquivo main_langchain.py

No exemplo anterior, criamos o prompt através do Python, mas também queremos começar a usar o LangChain. Dito isso, faremos uma primeira versão mais simples do LangChain para trabalharmos.

Para começar, criaremos um novo arquivo chamado main_langchain.py. Neste arquivo, o processo será muito parecido, mas em vez de importar OpenAI, importaremos ChatOpenAI de langchain_openai.

main_langchain.py:

from langchain_openai import ChatOpenAI

Importando e instalando o LangChain

Nesse momento, será indicado um erro em langchain_openai, pois ainda não importamos no arquivo requirements.txt. Após acessá-lo, faremos a importação de langchain na versão 0.1.11.

Se houver uma versão mais recente, você pode importá-la sem problemas.

Porém, além da ferramenta LangChain, usamos o LangChain com a OpenAI, então precisamos importar também langchain-openai na versão 0.0.8. Assim, teremos os dois requerimentos necessários.

requirements.txt:

openai==1.13.3
langchain==0.1.11
langchain-openai==0.0.8

Feito isso, precisamos executar o seguinte comando no terminal:

pip install -r .\requirements.txt

Após a instalação, podemos retornar ao código do arquivo main_langchain.py para usar isso.

Construindo o código de main_langchain.py

No arquivo main.py, temos as variáveis numero_de_dias, numero_de_criancas, e atividade. Teremos tudo isso também no arquivo main_langchain.py, então basta copiar o trecho entre as linhas 3 e 5 do arquivo main.py e colar em main_langchain.py a partir da linha 3.

main_langchain.py:

from langchain_openai import ChatOpenAI

numero_de_dias = 7
numero_de_criancas = 2
atividade = "praia"

Conhecendo erros comuns importantes

Em seguida, precisamos criar o prompt, que seria igual ao prompt anterior. Porém, antes de começarmos a usar a LangChain, queremos te mostrar alguns erros comuns muito importantes.

Se usarmos uma chave inválida em api_key, ao rodar o código, será retornado o erro "Incorrect API key provided" (em português, "Chave de API incorreta fornecida").

Em outros casos, se não passarmos nenhuma chave entre aspas e executarmos o código, pode ser gerado um erro indicando que os créditos acabaram, em vez de informar que a chave é inválida.

É importante ter cuidado e atenção a esses detalhes, pois podem ser retornadas mensagens de erro diferentes. Portanto, atente-se a esse tipo de problema com a chave: tanto a chave inválida, quanto o campo da chave vazio, podem gerar mensagens de erro inusitadas.

Evidentemente, você precisa cadastrar um cartão de crédito na plataforma, independentemente de comprar crédito ou não, a depender da sua forma de utilizar a OpenAI. Porém, é necessário ter o cartão cadastrado para utilizar, pois é um serviço pago.

Conclusão

Com isso, terminamos a primeira versão usando a OpenAI. Na próxima versão, utilizaremos o LangChain. Nos encontramos no próximo vídeo!

Utilizando LangChain para gerar respostas de texto com a OpenAI - Utilizando LangChain e a OpenAI com GPT 3.5

Neste vídeo, passaremos a utilizar o LangChain em vez da OpenAI pura.

Utilizando LangChain e OpenAI com GPT 3.5

Criando o arquivo main_langchain.py

Começaremos criando um arquivo novo chamado main_langchain.py. Neste arquivo, teremos basicamente o mesmo conteúdo, mas a importação não será da OpenAI, e sim do LangChain.

Sendo assim, em vez de importar OpenAI de openai, importaremos ChatOpenAI de langchain_openai. Dessa forma, solicitamos a API de chat diretamente do LangChain, que já possui camadas para facilitar chat.

main_langchain.py:

from langchain_openai import ChatOpenAI

Importando e instalando as bibliotecas

No arquivo requirements.txt, precisaremos adicionar tanto o langchain com a versão 0.1.11, quanto o LangChain já implementado para OpenAI, ou seja, langchain-openai, na versão 0.0.8.

requirements.txt:

openai==1.13.3
langchain==0.1.11
langchain-openai==0.0.8

Feito isso, vamos executar o seguinte comando no terminal:

pip install -r .\requirements.txt

Uma vez instaladas as bibliotecas, podemos começar a usá-las.

Usando as bibliotecas

De volta ao arquivo main_langchain.py, as variáveis numero_de_dias, numero_de_criancas, e atividade permanecerão iguais ao arquivo main.py, bem como o prompt. Nosso interesse no momento é usar a API da OpenAI, então é apenas isso que queremos mudar.

main_langchain.py:

from langchain_openai import ChatOpenAI

numero_de_dias = 7
numero_de_criancas = 2
atividade = "praia"

prompt = f"Crie um roteiro de viagem de {numero_de_dias} dias, para uma família com {numero_de_criancas} crianças, que gostam de {atividade}."
print(prompt)

Como usaremos uma LLM genérica, independentemente da OpenAI, vamos especificar como ChatOpenAI() somente quando instanciarmos a llm, isto é, o modelo de linguagem. Faremos isso na linha 10.

Nesse caso, entre os parênteses de ChatOpenAI(), utilizaremos a mesma chave de API (api_key) de antes. O instrutor utilizará a própria chave de API, enquanto você utilizará a sua própria.

# código omitido

llm = ChatOpenAI(api_key="sua_api_key")

Com isso, criamos o ChatOpenAI(). Porém, além da api_key, também precisamos do modelo (model), o qual definiremos como gpt-3.5-turbo.

Existem outros parâmetros que podemos passar, como, por exemplo, a temperatura (temperature). Nesse caso, definiremos a temperature como 0.5.

São vários os parâmetros de LLM que nós, como pessoas desenvolvedoras, podemos passar. Usaremos esses três (model, temperature e api_key) como padrão, para entendermos que quando instanciamos um objeto do tipo ChatOpenAI, falamos coisas específicas da OpenAI.

# código omitido

llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.5,
    api_key="sua_api_key")

A partir de agora, vamos trabalhar com a llm, independentemente de qual ela seja. Dito isso, se queremos invocar algo na llm, basta passar o prompt entre os parênteses de llm.invoke().

O VS Code irá autocompletar com o parâmetro role="user", mas não precisamos dele. Sendo assim, podemos removê-lo e manter somente llm.invoke(prompt).

Isso devolve para nós uma resposta, a qual iremos imprimir na linha 16.

# código omitido

llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.5,
    api_key="sua_api_key")

resposta = llm.invoke(prompt)
print(resposta)

Ao executar o código, será retornado um resultado com o roteiro. Para acessarmos apenas o conteúdo da resposta, basta imprimir resposta.content, em vez de apenas resposta.

Código final do arquivo mainlangchain.py até o momento:

from langchain_openai import ChatOpenAI

numero_de_dias = 7
numero_de_criancas = 2
atividade = "praia"

prompt = f"Crie um roteiro de viagem de {numero_de_dias} dias, para uma família com {numero_de_criancas} crianças, que gostam de {atividade}."
print(prompt)

llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.5,
    api_key="sua_api_key")

resposta = llm.invoke(prompt)
print(resposta.content)

Lembre-se: a cada vez que rodamos o código, usamos a API da OpenAI e pagamos por isso. Há um pequeno pagamento pelo número de tokens de entrada e saída do modelo escolhido.

Como saída, obtivemos o seguinte roteiro:

[…]

Dia 5: Praia da Barra da Lagoa

• Dia de relaxar na Praia da Barra da Lagoa
• Passeio de barco pela Lagoa da Conceição
• Almoço em um restaurante à beira da lagoa

Dia 6: Praia dos Ingleses

• Dia de curtir a Praia dos Ingleses, com suas águas calmas e extensa faixa de areia
• Passeio de banana boat para as crianças
• Jantar em um restaurante com vista para o mar

Dia 7: Retorno

• Manhã livre para aproveitar a praia
• Check-out do hotel e transfer para o aeroporto
• Retorno para casa

Conclusão

Com o LangChain, qual foi a diferença por enquanto? Apenas instanciamos ChatOpenAI() e já chamamos o prompt diretamente em llm.invoke(). Não foi necessário passar as mensagens, por exemplo.

A OpenAI pode fazer uma API dessas para nós a qualquer momento. Entretanto, a vantagem não está presente por enquanto.

A grande vantagem começará a aparecer à medida que criarmos modelos mais complexos. Faremos isso no próximo vídeo. Até mais!

Sobre o curso LangChain e Python: criando ferramentas com a LLM OpenAI

O curso LangChain e Python: criando ferramentas com a LLM OpenAI possui 148 minutos de vídeos, em um total de 45 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:

• Utilizando LangChain para gerar respostas de texto com a OpenAI
• Utilizando SimpleSequentialChain e o JSONOutputParser para gerar um roteiro de viagens
• Refatorando as cadeias implementadas com LangChain Expression Language (LCEL)
• Gerenciando a memória de uma conversa com LangChain
• Utilizando arquivos para gerar respostas com LangChain