Name

Lynn Mikami

Published on 30/04/2024

Introdução ao LangChain para Large Language Models

Large Language Models (LLMs) revolucionaram o campo de processamento de linguagem natural, permitindo a criação de aplicativos poderosos como Chatbots, sistemas de pergunta e resposta e ferramentas de geração de texto. No entanto, construir esses aplicativos do zero pode ser desafiador e demorado. É aí que entra o LangChain - uma biblioteca em Python que facilita o desenvolvimento de aplicativos com LLMs.

Neste artigo, vamos explorar o LangChain e como ele pode ser usado para construir aplicativos com LLM. Vamos cobrir a instalação, conceitos-chave e fornecer exemplos de código para ajudá-lo a começar.

O que é o LangChain?

LangChain é uma biblioteca de código aberto que fornece uma interface padrão para trabalhar com LLMs. Ela abstrai muitas das complexidades de interagir diretamente com LLMs, permitindo que os desenvolvedores foquem na construção de seus aplicativos.

Algumas características principais do LangChain incluem:

• Suporte a vários fornecedores de LLMs, como OpenAI, Cohere, Hugging Face, etc.
• Componentes modulares, como prompts, chains, agents e memory
• Utilitários para trabalhar com documentos, embeddings e vector stores
• Integração com outras ferramentas e frameworks

Ao aproveitar o LangChain, os desenvolvedores podem prototipar e implantar rapidamente aplicativos com LLMs sem se preocupar com os detalhes de baixo nível das APIs de LLM.

Instalação

Para começar com o LangChain, você precisa instalá-lo usando o pip. É recomendado criar um ambiente virtual primeiro:

python -m venv langchain-env
source langchain-env/bin/activate
pip install langchain

Você também precisa instalar os pacotes do fornecedor de LLM que deseja usar. Por exemplo, para usar os modelos da OpenAI:

pip install openai

Certifique-se de ter uma chave de API para o fornecedor que você está usando. Você pode definir isso como uma variável de ambiente:

export OPENAI_API_KEY=sua_chave_api_aqui

Conceitos-Chave

Prompts

Prompts são as instruções ou contexto que você fornece ao LLM para orientar sua saída. O LangChain fornece uma classe PromptTemplate para facilitar a criação e uso de prompts.

Aqui está um exemplo de criação de um modelo de prompt:

from langchain import PromptTemplate
 
template = """
Você é um assistente que ajuda os usuários a escrever e-mails profissionais.
 
Dado o seguinte contexto:
{context}
 
Escreva uma resposta de e-mail profissional. Assine o e-mail como "John".
"""
 
prompt = PromptTemplate(
    input_variables=["context"],
    template=template,
)

Você pode então usar o prompt passando as variáveis de entrada:

context = "Preciso informar meu chefe que irei tirar férias na próxima semana."
print(prompt.format(context=context))

Isso irá imprimir o prompt completo com o contexto fornecido.

LLMs

O LangChain fornece uma interface padrão para interagir com diferentes fornecedores de LLMs por meio da classe LLM.

Aqui está um exemplo de uso do modelo text-davinci-003 da OpenAI:

from langchain.llms import OpenAI
 
llm = OpenAI(model_name="text-davinci-003")
 
resultado = llm("Qual é a capital da França?")
print(resultado)

Isso imprimirá a resposta do modelo para a pergunta.

Chains

Chains permitem combinar vários componentes, como prompts e LLMs, para criar aplicativos mais complexos. O LangChain fornece várias chains embutidas, bem como a capacidade de criar chains personalizadas.

Aqui está um exemplo de uma simples chain sequencial que recebe um prompt, o passa para um LLM e, em seguida, passa a saída do LLM para um segundo prompt:

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
 
primeiro_prompt = PromptTemplate(
    input_variables=["produto"],
    template="Qual é um bom nome para uma empresa que fabrica {produto}?",
)
 
segundo_prompt = PromptTemplate(
    input_variables=["nome_empresa"],
    template="Escreva uma frase de efeito para a seguinte empresa: {nome_empresa}",
)
 
chain = LLMChain(llm=llm, prompt=primeiro_prompt)
segunda_chain = LLMChain(llm=llm, prompt=segundo_prompt)
 
resultado = chain.run("meias coloridas")
print(f"Nome da empresa: {resultado}")
 
resultado = segunda_chain.run(resultado)
print(f"Frase de efeito: {resultado}")

Isso irá gerar um nome de empresa com base no produto "meias coloridas" e, em seguida, gerar uma frase de efeito para esse nome de empresa.

Agents

Agents são sistemas que usam LLMs para determinar dinamicamente quais ações tomar com base na entrada do usuário. Eles podem usar ferramentas para interagir com o mundo exterior e tomar decisões sobre o que fazer em seguida.

Aqui está um exemplo de um agente simples que usa uma ferramenta de busca e uma ferramenta de calculadora:

from langchain.agents import initialize_agent, Tool
from langchain.tools import BaseTool
from langchain.llms import OpenAI
 
def busca_api(query):
    return "Os resultados da busca por {query} seriam retornados aqui"
 
def calculadora(expressao):
    return eval(expressao)
 
ferramenta_busca = Tool(
    name="Busca",
    func=busca_api,
    description="Útil para buscar informações na internet."
)
 
ferramenta_calculadora = Tool(
    name="Calculadora",
    func=calculadora,
    description="Útil para fazer cálculos matemáticos."
)
 
ferramentas = [ferramenta_busca, ferramenta_calculadora]
 
llm = OpenAI(temperature=0)
agente = initialize_agent(ferramentas, llm, agent="zero-shot-react-description", verbose=True)
 
resultado = agente.run("Qual é a população do Canadá dividida pela população dos Estados Unidos?")
print(resultado)

Esse agente irá primeiro buscar as populações do Canadá e dos EUA, extrair os números dos resultados da busca e, em seguida, usar a calculadora para dividi-los.

Conclusão

LangChain é uma biblioteca poderosa que facilita o desenvolvimento de aplicações alimentadas por LLMs (Linguagem Modelada por Aprendizado). Ao fornecer uma interface padrão e componentes modulares, permite que os desenvolvedores se concentrem na construção de suas aplicações, em vez de se preocupar com os detalhes das APIs de LLM.

Neste artigo, abordamos os conceitos básicos do LangChain, incluindo instalação, conceitos-chave como prompts, LLMs, cadeias e agentes, e fornecemos exemplos de código para ajudá-lo a começar.

Para saber mais sobre o LangChain, confira a documentação oficial em https://langchain.readthedocs.io/ (opens in a new tab). Você também pode explorar o diretório de exemplos no repositório do GitHub para casos de uso e ideias mais avançadas.

À medida que os LLMs continuam a avançar, ferramentas como o LangChain desempenharão um papel cada vez mais importante em torná-los acessíveis e fáceis de usar para uma ampla variedade de aplicações. Ao aproveitar o LangChain, você pode construir aplicações poderosas baseadas em linguagem e estar na vanguarda deste campo emocionante.