Descubra como utilizar o LangChain no Python para criar seu próprio sistema de inteligência artificial personalizado e eficiente!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Já pensou em desenvolver seu próprio sistema de inteligência artificial, totalmente personalizado e eficiente?
Nesta publicação, você vai descobrir como utilizar o LangChain, um poderoso framework que facilitará a criação de sistemas de inteligência artificial, permitindo a construção de soluções que podem integrar diferentes APIs de IA.
Com o LangChain no Python, é possível construir chatbots, tradutores e diversos outros tipos de sistemas baseados em linguagem natural com recursos avançados.
A proposta é te mostrar como criar do zero um chatbot que traduz e converte textos entre diferentes idiomas, demonstrando a funcionalidade dessa ferramenta sensacional.
A partir disso, você poderá criar seus próprios sistemas de IA, desenvolver um chatbot inteligente que compreenda as informações específicas do seu negócio e responda em tempo real.
Para tornar seu aprendizado ainda mais completo, vamos finalizar esse projeto criando a API da nossa inteligência artificial para que ela possa ser usada em diferentes códigos e projetos.
LangChain é um framework que simplifica e facilita o uso de Large Language Models (LLMs). Com ele, você pode criar suas próprias soluções de LLM, como um chatbot personalizado.
A principal vantagem dessa ferramenta é a capacidade de integrar múltiplas APIs de inteligência artificial, construindo sistemas complexos sem a necessidade de se aprofundar em cada API individualmente.
Ele permite que você utilize suas próprias bases de dados e informações para personalizar as respostas dos modelos de IA, adaptando-os às necessidades específicas que desejar.
Além disso, o LangChain é capaz de executar uma sequência de operações ou funções encadeadas para realizar tarefas mais complexas, conhecidas como cadeia de passos.
Cada passo nessa cadeia transforma ou realiza uma ação específica com a entrada do usuário.
A saída de um passo serve como entrada para o próximo, permitindo que você integre diferentes funcionalidades e crie uma cadeia de operações flexível e prática.
Você pode adicionar, remover ou modificar cada passo sem alterar a estrutura geral da cadeia.
Para começar a usar o LangChain, será preciso instalar o framework através do comando pip no terminal do seu editor de códigos.
pip install langchain
Além do LangChain, também é preciso instalar o pacote da API com a qual desejamos trabalhar. Nesse caso, utilizaremos a API da OpenAI:
pip install langchain-openai
Para utilizar a API da OpenAI, assim como outras APIs, é necessário ter uma chave de acesso que é única para cada usuário.
Para gerar sua chave, o primeiro passo será acessar o site da API e fazer login. Caso você não tenha uma conta, será necessário criar uma.
Site da OpenAI API: OpenAI API
Feito o login, no canto superior direito da tela, clique em Dashboard.
Em seguida, ao lado esquerdo, selecione a opção API key e clique em Create new secret key.
Na janela que será aberta, dê um nome para a sua chave e clique em Create secret key.
Com isso, você terá gerado a sua chave de acesso à API da OpenAI.
Essa chave é única para cada usuário, então iremos configurá-la dentro de uma variável de ambiente. Dessa forma, garantimos que ela não ficará exposta no código, trazendo mais segurança ao projeto.
Uma prática muito comum ao trabalhar com chaves e tokens de acesso de APIs é criar uma variável de ambiente para armazená-los.
As variáveis de ambiente criadas no seu computador só estarão disponíveis nele. Dessa forma, mesmo que você compartilhe o código com outras pessoas, elas não conseguirão visualizar as informações armazenadas nessa variável.
Para criar sua variável de ambiente, é simples: na pasta onde está desenvolvendo seu projeto, crie um arquivo chamado .env.
Dentro dele, você irá criar a variável responsável por armazenar a sua chave de acesso.
OPENAI_API_KEY = "Insira aqui a chave obtida no site da OpenAI"
Além disso, para poder ler esse arquivo .env e utilizar a variável de ambiente criada dentro do seu projeto, será preciso instalar a biblioteca dotenv do Python através do comando:
pip install python-dotenv
Feita a instalação, importe a função load_dotenv() da biblioteca dotenv para carregar as variáveis de ambiente e a biblioteca os para acessá-las.
from dotenv import load_dotenv
import os
load_dotenv()
chave_api = os.getenv("OPENAI_API_KEY")Para saber mais sobre variáveis de ambiente e sobre a biblioteca dotenv, leia também:
Variáveis de ambiente no Python – O que são e como usá-las?
No LangChain, as interações são tratadas como mensagens, então é importante diferenciarmos entre as mensagens do sistema (instruções e contextos) e as mensagens dos usuários.
Para criar essa estrutura de mensagens, utilizamos duas classes do módulo langchain_core.messages: SystemMessage e HumanMessage. Vamos importá-las no início do código.
As mensagens do sistema (SystemMessage) são usadas para fornecer instruções ou contexto ao modelo de IA. Elas ajudam a definir o comportamento desejado do modelo e a orientar suas respostas.
O modelo entende que essa mensagem contém uma instrução sobre como ele deve processar a próxima entrada.
As mensagens humanas (HumanMessage) são as solicitações que o usuário deseja que o modelo processe, interprete ou responda.
O modelo de linguagem entende que dentro dessa mensagem está a entrada do usuário e que ele precisa processá-la de acordo com a instrução recebida na SystemMessage.
Para passar essa estrutura para o modelo, combinamos tanto a SystemMessage quanto a HumanMessage em uma lista de mensagens.
Como nosso objetivo é desenvolver um modelo de tradução de texto, vamos criar a nossa mensagem de sistema com foco nisso. Inicialmente, utilizaremos uma SystemMessage e uma HumanMessage padrão.
Com a estrutura de mensagens definida, precisamos criar nosso modelo de linguagem. Para isso, vamos importar a classe ChatOpenAI da biblioteca langchain_openai, que representa o ChatGPT.
Feito isso, podemos criar uma instância do modelo de linguagem, passando como parâmetro qual versão desejamos utilizar.
No meu caso, estarei utilizando a versão do GPT-4 Omni, que é o melhor modelo disponível para a versão paga. Caso você esteja utilizando a versão gratuita da API, você provavelmente terá acesso ao 3.5 Turbo.
Para verificar qual modelo você pode utilizar em seu projeto, acesse a página da API e vá na guia Chat.
Feito isso, podemos invocar o modelo com as mensagens configuradas através do método invoke. Esse método invoca o nosso modelo de linguagem, envia as mensagens para o modelo, recebe a resposta e retorna a tradução gerada.
Para visualizar essa resposta, podemos printar esse resultado.
from dotenv import load_dotenv
import os
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_openai import ChatOpenAI
load_dotenv()
chave_api = os.getenv("OPENAI_API_KEY")
mensagens = [
SystemMessage("Traduza o texto a seguir para inglês"),
HumanMessage("Se inscrevam no canal para aprender Python")
]
modelo = ChatOpenAI(model="gpt-4o")
resposta = modelo.invoke(mensagens)
print(resposta)
Veja que dentro da resposta temos a tradução do texto “Se inscrevam no canal para aprender Python” para inglês, conforme foi instruído pela SystemMessage.
No entanto, dentro dessa resposta, além do conteúdo (tradução do texto), temos diversos outros dados e informações sobre a solicitação feita ao modelo do ChatGPT.
E aqui entra outra vantagem de utilizar o LangChain: ele oferece uma forma prática e rápida de extrair a informação desejada, sem precisar se aprofundar e entender muito a estrutura interna dessa resposta.
Um dos principais benefícios ao trabalhar com LangChain é a abstração de complexidade que ele nos proporciona. O LangChain consegue simplificar diversas etapas e processos realizados na integração e interação com os modelos de linguagem.
Entre as funcionalidades disponíveis que esse framework nos oferece, temos a classe StrOutputParser, que processa a resposta obtida pelo modelo e a converte em uma string formatada apenas com o conteúdo desejado.
Vamos importar essa classe para o código, criar uma instância dela e utilizar o método invoke para processar a resposta.
from dotenv import load_dotenv
import os
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
load_dotenv()
chave_api = os.getenv("OPENAI_API_KEY")
mensagens = [
SystemMessage("Traduza o texto a seguir para inglês"),
HumanMessage("Se inscrevam no canal para aprender Python")
]
modelo = ChatOpenAI(model="gpt-4o")
parser = StrOutputParser()
resposta = modelo.invoke(mensagens)
texto = parser.invoke(resposta)
print(texto)
Outro recurso muito interessante do LangChain é a cadeia de passos que ele consegue executar.
No nosso código, perceba que primeiro precisamos gerar a resposta utilizando o modelo e depois o texto final utilizando o parser.
No entanto, dentro do LangChain, podemos encadear esses dois passos, de modo que a resposta obtida pelo modelo seja automaticamente utilizada dentro do parser.
Para fazer isso, vamos criar uma chain (cadeia). Para essa chain, passaremos as etapas que desejamos executar separadas pelo operador de barra vertical (|).
from dotenv import load_dotenv
import os
from langchain_core.messages import SystemMessage, HumanMessage
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
load_dotenv()
chave_api = os.getenv("OPENAI_API_KEY")
mensagens = [
SystemMessage("Traduza o texto a seguir para inglês"),
HumanMessage("Se inscrevam no canal para aprender Python")
]
modelo = ChatOpenAI(model="gpt-4o")
parser = StrOutputParser()
chain = modelo | parser
texto = chain.invoke(mensagens)
print(texto)Essa é uma grande vantagem em utilizar o LangChain. Apesar de nesse exemplo estarmos lidando apenas com dois passos, isso te permite encadear várias operações em uma única execução, aumentando a eficiência do processo.
Agora que você já compreendeu melhor o funcionamento do LangChain, vamos aprimorar o nosso sistema de inteligência artificial.
Por enquanto, estamos trabalhando com uma estrutura de mensagens pré-definida. No entanto, podemos implementar o template de mensagens através da classe ChatPromptTemplate para criar mensagens dinâmicas.
Essa classe nos permite definir um template de mensagens a partir de uma lista de tuplas que utiliza variáveis para criar as instruções de forma dinâmica para o modelo de linguagem.
A primeira tupla corresponderá à mensagem do sistema que instrui o modelo a traduzir o texto para o idioma especificado pela variável {idioma}.
Já a segunda tupla define a mensagem do usuário que contém o texto a ser traduzido, representado pela variável {texto}.
Criamos as instâncias do modelo e do parser normalmente, como já vimos anteriormente. E dentro da cadeia, vamos adicionar o template_mensagem.
Feito isso, basta invocar a nossa chain, passando para ela um dicionário com os valores das variáveis idioma e texto.
Ou seja, dentro do método invoke, vamos definir para qual idioma queremos traduzir o texto e qual texto deverá ser traduzido.
from dotenv import load_dotenv
import os
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
load_dotenv()
chave_api = os.getenv("OPENAI_API_KEY")
template_mensagem = ChatPromptTemplate.from_messages([
("system", "Traduza o texto a seguir para {idioma}"),
("user", "{texto}"),
])
modelo = ChatOpenAI(model="gpt-4o")
parser = StrOutputParser()
chain = template_mensagem | modelo | parser
texto = chain.invoke({"idioma": "francês", "texto": "Dê like no vídeo e comente o que você tá achando"})
print(texto)Executando esse código, teremos a tradução do texto definido dentro do método invoke para o francês.
Agora que já temos nosso template de mensagens funcionando, vamos criar um servidor que disponibiliza essa funcionalidade via API. Para isso, utilizaremos o LangServe e o FastAPI.
O primeiro passo será ajustar nosso código onde está a cadeia de passos, removendo a última parte onde a invocamos.
from dotenv import load_dotenv
import os
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
load_dotenv()
chave_api = os.getenv("OPENAI_API_KEY")
template_mensagem = ChatPromptTemplate.from_messages([
("system", "Traduza o texto a seguir para {idioma}"),
("user", "{texto}"),
])
modelo = ChatOpenAI(model="gpt-4o")
parser = StrOutputParser()
chain = template_mensagem | modelo | parserEm seguida, vamos criar um novo arquivo chamado servidor.py e instalar o LangServe através do comando:
pip install “langserve[all]”
Dessa forma, instalaremos o LangServe e todas as suas funcionalidades, juntamente com o FastAPI.
Com a instalação feita, vamos importar nossa cadeia (chain) do arquivo codigo.py, além do LangServe e do FastAPI.
Feito isso, criaremos uma instância do FastAPI, passando um título (title) e uma descrição (description).
Utilizamos a função add_routes da biblioteca LangServe para integrar nossa cadeia de tradução (chain) com o aplicativo criado pelo FastAPI (app) dentro da rota /tradutor.
Dessa forma, teremos a funcionalidade de tradução disponível a partir da URL terminada com /tradutor na nossa API.
Por fim, inicializamos o servidor localmente (localhost) usando o uvicorn.
from codigo import chain from fastapi import FastAPI from langserve import add_routes app = FastAPI(title="Meu app de IA", description="Traduza o texto que você quiser para qualquer língua") add_routes(app, chain, path="/tradutor") if __name__ == "__main__": import uvicorn uvicorn.run(app, host="localhost", port=8000)
Caso você tenha dúvida quanto à linha if __name__ == “__main__” dentro do nosso código, essa é uma abordagem comum para garantir que essa parte do código só seja executada quando o script estiver sendo executado diretamente e não quando for importado.
Leia também: If name main no Python, o que significa isso?
Para testar sua API, você pode acessar o endereço http://localhost:8000/tradutor/playground
Essa rota /playground fornece uma interface visual para que você possa interagir com a sua API.
Perceba que você pode utilizar o idioma e o texto que quiser. Isso é muito interessante para testar e visualizar os resultados obtidos com a API. Além disso, nessa página também é possível visualizar cada etapa que foi executada.
Leia também: API em Python com FastAPI – Criando sua primeira API
Já temos nosso servidor FastAPI configurado com a nossa inteligência artificial pronta para traduzir textos.
Agora, vamos ver como interagir com esse modelo a partir de outro código, criando um cliente.
Crie um novo arquivo Python e, dentro dele, importe a classe RemoteRunnable do LangServe. Essa classe permite que você se conecte e envie requisições para APIs remotas.
Vamos criar uma instância dessa classe, passando para ela a rota da nossa API, com o endpoint /tradutor. Dessa forma, o RemoteRunnable saberá para onde deve enviar as requisições e como acessar o serviço de tradução.
Feito isso, podemos utilizar nossa cadeia de funções normalmente, passando para ela os parâmetros idioma e texto.
from langserve import RemoteRunnable
chain_remota = RemoteRunnable("http://localhost:8000/tradutor")
texto = chain_remota.invoke({"idioma": "espanhol", "texto": "Já deu like no vídeo? Se não, dá agora"})
print(texto)
Perceba que apenas com esse pequeno código somos capazes de traduzir qualquer texto.
Isso é possível porque temos, no arquivo codigo.py, a configuração do modelo de linguagem e a cadeia de comandos que devem ser executados. No servidor.py, temos a configuração da nossa API.
Dessa forma, quando executamos o servidor.py para colocar a API no ar e, em seguida, executamos o código em cliente.py, esse código consome os dados da API e realiza o processo de tradução feito pelo modelo de inteligência artificial.
Caso você queira fazer o deploy da sua API, colocando-a em um servidor para que outras pessoas possam acessar, pode ler a publicação: Criar site em Python com Flask – Criação e publicação de site.
Nessa publicação, você aprendeu como criar seu próprio sistema de inteligência artificial de forma prática e eficiente.
Através do framework do LangChain, você será capaz de criar e implementar soluções de IA personalizadas de forma simples e rápida.
Com ele, você pode integrar diversos modelos de IA, criar cadeias de operações complexas e ainda disponibilizar esses serviços através de APIs que podem ser integradas a diversos projetos.
Dessa forma, você pode criar seu próprio chatbot que compreenda as informações específicas do seu negócio e responda aos seus clientes em tempo real.
Para acessar outras publicações de Python, clique aqui!
Posts mais recentes de Python
Posts mais recentes da Hashtag Treinamentos
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.