LangChain — Guia de Início Rápido

11 min readMay 16, 2023

Este tutorial fornece um rápido passo a passo sobre como construir um aplicativo de modelo de linguagem de ponta a ponta com LangChain.

English version: https://python.langchain.com/en/latest/getting_started/getting_started.html

Instalação

Para começar, instale o LangChain com o seguinte comando:

pip install langchain
# or
conda install langchain -c conda-forge

Configurações do ambiente

O uso do LangChain geralmente requer integrações com um ou mais provedores de modelo, armazenamento de dados, APIs, etc.

Para este exemplo, usaremos as APIs do OpenAI, portanto, primeiro precisamos instalar o SDK:

pip install openai

Em seguida, precisaremos definir a variável de ambiente no terminal.

export OPENAI_API_KEY="..."

Como alternativa, você pode fazer isso de dentro do notebook Jupyter (ou script Python):

import os
os.environ["OPENAI_API_KEY"] = "..."

Construindo um Aplicativo de Modelo de Linguagem: LLMs

Agora que instalamos o LangChain e configuramos nosso ambiente, podemos começar a construir nosso aplicativo de modelo de linguagem.

O LangChain fornece muitos módulos que podem ser usados para construir aplicativos de modelo de linguagem. Os módulos podem ser combinados para criar aplicativos mais complexos ou usados individualmente para aplicativos simples.

LLMs: obtenha previsões de um modelo de idioma

O bloco de construção mais básico do LangChain é chamar um LLM em alguma entrada. Vamos ver um exemplo simples de como fazer isso. Para isso, vamos fingir que estamos construindo um serviço que gera um nome de empresa com base no que a empresa faz.

Para fazer isso, primeiro precisamos importar o wrapper LLM.

from langchain.llms import OpenAI

Podemos então inicializar o wrapper com quaisquer argumentos. Neste exemplo, provavelmente queremos que as saídas sejam MAIS aleatórias, então vamos inicializá-lo com uma temperatura ALTA.

llm = OpenAI(temperature=0.9)

Agora podemos chamá-lo em alguma entrada!

text = "What would be a good company name for a company that makes colorful socks?"
print(llm(text))

Para obter mais detalhes sobre como usar LLMs no LangChain, consulte o guia de introdução do LLM .

Modelos de prompt: gerencie prompts para LLMs

Chamar um LLM é um ótimo primeiro passo, mas é apenas o começo. Normalmente, quando você usa um LLM em um aplicativo, não está enviando a entrada do usuário diretamente para o LLM. Em vez disso, você provavelmente está recebendo a entrada do usuário e construindo um prompt e, em seguida, enviando-o para o LLM.

Por exemplo, no exemplo anterior, o texto que passamos foi codificado para solicitar o nome de uma empresa que fabricava meias coloridas. Nesse serviço imaginário, o que gostaríamos de fazer é pegar apenas a entrada do usuário descrevendo o que a empresa faz e, em seguida, formatar o prompt com essas informações.

Isso é fácil de fazer com LangChain!

Primeiro, vamos definir o modelo de prompt:

from langchain.prompts import PromptTemplate

prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)

Vamos agora ver como isso funciona! Podemos chamar o .formatmétodo para formatá-lo.

print(prompt.format(product="colorful socks"))

Resultado:

What is a good name for a company that makes colorful socks?

Chains: Combine LLMs e prompts em fluxos de trabalho de várias etapas

Até agora, trabalhamos com os primitivos PromptTemplate e LLM sozinhos. Mas é claro que um aplicativo real não é apenas um primitivo, mas sim uma combinação deles.

Uma cadeia em LangChain é composta de combinações, que podem ser primitivos como LLMs ou outras cadeias.

O tipo mais importante de chain (cadeia) é um LLMChain, que consiste em um PromptTemplate e um LLM.

Estendendo o exemplo anterior, podemos construir um LLMChain que recebe a entrada do usuário, o formata com um PromptTemplate e, em seguida, passa a resposta formatada para um LLM.

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI

llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
    input_variables=["product"],
    template="What is a good name for a company that makes {product}?",
)

Agora podemos criar uma chain muito simples que receberá a entrada do usuário, formatará o prompt com ela e a enviará para o LLM:

from langchain.chains import LLMChain
chain = LLMChain(llm=llm, prompt=prompt)

Agora podemos executar essa chain apenas especificando o produto!

chain.run("colorful socks")

Para ver o resultado:

print(chain.run("colorful socks"))

Resultado:



Socktastic!

Aqui vamos nós! Há a primeira chain— uma LLM Chain. Este é um dos tipos mais simples de cadeias, mas entender como funciona o preparará bem para trabalhar com cadeias mais complexas.

Para obter mais detalhes, confira o guia de primeiros passos para correntes.

Agentes: chains de chamadas dinâmicas com base na entrada do usuário

Até agora, as chains que examinamos seguem uma ordem predeterminada.

Os agentes não tomam decisões por conta própria, eles usam um LLM para determinar quais ações devem ser executadas e em que ordem. Uma ação pode ser usar uma ferramenta e observar sua saída ou retornar ao usuário.

Quando usados corretamente, os agentes podem ser extremamente poderosos. Neste tutorial, mostramos como usar facilmente os agentes por meio da API mais simples e de nível mais alto.

Para carregar agentes, você deve entender os seguintes conceitos:

Tool: Uma tool (ferramenta) é uma função que realiza uma tarefa específica, como uma pesquisa no Google, consulta ao banco de dados, REPL do Python ou outras chains de funções. A interface de uma tool é uma função que recebe uma string como entrada e retorna uma string como saída.
LLM: O modelo de linguagem que alimenta o agente.
Agente: O agente a ser usado, que deve ser uma string que faz referencia a uma classe de agente de suporte. Com este tutorial se concentra na API de nível mais simples e de nível mais alto, será mencionado apenas o uso dos agentes suportados em nível padrão. Se você deseja implementar um agente personalizado, em breve estará disponível uma documentação para isso.

Agentes : Para obter uma lista de agentes compatíveis e suas especificações, consulte aqui.

Tools: Para obter uma lista de ferramentas predefinidas e suas especificações, consulte aqui.

Para este exemplo, você também precisará instalar o pacote SerpAPI Python.

pip install google-search-results

E defina as variáveis de ambiente apropriadas.

import os
os.environ["SERPAPI_API_KEY"] = "..."

Agora podemos começar!

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.llms import OpenAI

# First, let's load the language model we're going to use to control the agent.
llm = OpenAI(temperature=0)

# Next, let's load some tools to use. Note that the `llm-math` tool uses an LLM, so we need to pass that in.
tools = load_tools(["serpapi", "llm-math"], llm=llm)


# Finally, let's initialize an agent with the tools, the language model, and the type of agent we want to use.
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

# Now let's test it out!
agent.run("What was the high temperature in SF yesterday in Fahrenheit? What is that number raised to the .023 power?")

Resultado

> Entering new AgentExecutor chain...
 I need to find the temperature first, then use the calculator to raise it to the .023 power.
Action: Search
Action Input: "High temperature in SF yesterday"
Observation: San Francisco Temperature Yesterday. Maximum temperature yesterday: 57 °F (at 1:56 pm) Minimum temperature yesterday: 49 °F (at 1:56 am) Average temperature ...
Thought: I now have the temperature, so I can use the calculator to raise it to the .023 power.
Action: Calculator
Action Input: 57^.023
Observation: Answer: 1.0974509573251117

Thought: I now know the final answer
Final Answer: The high temperature in SF yesterday in Fahrenheit raised to the .023 power is 1.0974509573251117.

> Finished chain.

Memória: Adicionar registros às chains e agentes

Até agora, todas as chains e agentes pelos quais passamos não armazenavam informações. Mas, muitas vezes, você pode querer que uma chain ou agente tenha algum conceito de “memória” para que possa se lembrar de informações sobre suas interações anteriores. O exemplo mais claro e simples disso é ao projetar um chatbot — você quer que ele se lembre de mensagens anteriores para que possa usar o contexto disso para ter uma conversa melhor. Isso seria um tipo de “memória de curto prazo”. No lado mais complexo, você poderia imaginar uma chain ou agente lembrando-se de informações-chave ao longo do tempo — isso seria uma forma de “memória de longo prazo”. Para ideias mais concretas sobre o último, veja este artigo incrível.

LangChain fornece várias chains especialmente criadas apenas para esta finalidade. Este tutorial usa uma dessas chain (a ConversationChain) com dois tipos diferentes de memória.

Por padrão, o ConversationChain possui um tipo simples de memória que lembra todas as entradas/saídas anteriores e as adiciona ao contexto que é passado. Vamos dar uma olhada no uso desta chain (configuração verbose=Truepara que possamos ver o prompt).

from langchain import OpenAI, ConversationChain

llm = OpenAI(temperature=0)
conversation = ConversationChain(llm=llm, verbose=True)

output = conversation.predict(input="Hi there!")
print(output)

Resultado:

> Entering new chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:

Human: Hi there!
AI:

> Finished chain.
' Hello! How are you today?'

Continuando a execução em modo interativo:

output = conversation.predict(input="I'm doing well! Just having a conversation with an AI.")
print(output)

Resultado:

> Entering new chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:

Human: Hi there!
AI:  Hello! How are you today?
Human: I'm doing well! Just having a conversation with an AI.
AI:

> Finished chain.
" That's great! What would you like to talk about?"

Construindo um Aplicativo de Modelo de Linguagem: Modelos de Chat

Da mesma forma, você pode usar modelos de chat (bate-papo) em vez de LLMs. Os modelos de chat são uma variação dos modelos de linguagem. Embora os modelos de chat usem modelos de linguagem sob o capô, a interface que eles expõem é um pouco diferente: em vez de expor uma API de “entrada de texto, saída de texto”, eles expõem uma interface em que “mensagens de bate-papo” são as entradas e saídas.

As APIs do modelo de bate-papo são relativamente novas, então ainda estamos descobrindo as abstrações corretas.

Você pode obter conclusões de chat passando uma ou mais mensagens para o modelo de chat. A resposta será uma mensagem. Os tipos de mensagens atualmente suportados no LangChain são AIMessage, HumanMessage, SystemMessagee ChatMessage.

Obter conclusões de mensagem de um modelo de chat

O ChatMessageassume um parâmetro de função arbitrário. Na maioria das vezes, você estará lidando apenas com HumanMessage, AIMessagee SystemMessage.

from langchain.chat_models import ChatOpenAI
from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)

chat = ChatOpenAI(temperature=0)

Você pode obter conclusões passando uma única mensagem.

chat([HumanMessage(content="Translate this sentence from English to French. I love programming.")])
# -> AIMessage(content="J'aime programmer.", additional_kwargs={})

Você também pode passar várias mensagens para os modelos gpt-3.5-turbo e gpt-4 da OpenAI.

Você pode ir além e gerar conclusões para vários conjuntos de mensagens usando generate. Isso retorna um LLMResult com um parâmetro message adicional:

batch_messages = [
    [
        SystemMessage(content="You are a helpful assistant that translates English to French."),
        HumanMessage(content="I love programming.")
    ],
    [
        SystemMessage(content="You are a helpful assistant that translates English to French."),
        HumanMessage(content="I love artificial intelligence.")
    ],
]
result = chat.generate(batch_messages)
result
# -> LLMResult(generations=[[ChatGeneration(text="J'aime programmer.", generation_info=None, message=AIMessage(content="J'aime programmer.", additional_kwargs={}))], [ChatGeneration(text="J'aime l'intelligence artificielle.", generation_info=None, message=AIMessage(content="J'aime l'intelligence artificielle.", additional_kwargs={}))]], llm_output={'token_usage': {'prompt_tokens': 57, 'completion_tokens': 20, 'total_tokens': 77}})

Você pode recuperar coisas, como o uso de token deste LLMResult:

result.llm_output['token_usage']
# -> {'prompt_tokens': 57, 'completion_tokens': 20, 'total_tokens': 77}

Modelos de prompt de chat

Semelhante aos LLMs, você pode usar templates usando um MessagePromptTemplate.

Você pode construir um ChatPromptTemplatea partir de um ou mais MessagePromptTemplate.

Você pode usar ChatPromptTemplate'(s) format_prompt– isso retorna um PromptValue, que pode ser convertido em uma string ou um objeto Message, dependendo se você deseja usar o valor formatado como entrada para um modelo llm ou chat.

Por conveniência, há um método from_template exposto no template. Se você fosse usar este modelo, seria assim:

from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

chat = ChatOpenAI(temperature=0)

template = "You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

# get a chat completion from the formatted messages
chat(chat_prompt.format_prompt(input_language="English", output_language="French", text="I love programming.").to_messages())
# -> AIMessage(content="J'aime programmer.", additional_kwargs={})

Chains com Modelos de Chat

O LLMChain discutido na seção acima também pode ser usado com modelos de chat:

from langchain.chat_models import ChatOpenAI
from langchain import LLMChain
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

chat = ChatOpenAI(temperature=0)

template = "You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

chain = LLMChain(llm=chat, prompt=chat_prompt)
chain.run(input_language="English", output_language="French", text="I love programming.")
# -> "J'aime programmer."

Agents com Modelos de Chat

Agentes também podem ser usados com modelos de chat, você pode inicializar um usando AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION como tipo de agente.

from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.llms import OpenAI

# First, let's load the language model we're going to use to control the agent.
chat = ChatOpenAI(temperature=0)

# Next, let's load some tools to use. Note that the `llm-math` tool uses an LLM, so we need to pass that in.
llm = OpenAI(temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)


# Finally, let's initialize an agent with the tools, the language model, and the type of agent we want to use.
agent = initialize_agent(tools, chat, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

# Now let's test it out!
agent.run("Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?")

Resultado:


> Entering new AgentExecutor chain...
Thought: I need to use a search engine to find Olivia Wilde's boyfriend and a calculator to raise his age to the 0.23 power.
Action:
{
  "action": "Search",
  "action_input": "Olivia Wilde boyfriend"
}

Observation: Sudeikis and Wilde's relationship ended in November 2020. Wilde was publicly served with court documents regarding child custody while she was presenting Don't Worry Darling at CinemaCon 2022. In January 2021, Wilde began dating singer Harry Styles after meeting during the filming of Don't Worry Darling.
Thought:I need to use a search engine to find Harry Styles' current age.
Action:
{
  "action": "Search",
  "action_input": "Harry Styles age"
}

Observation: 29 years
Thought:Now I need to calculate 29 raised to the 0.23 power.
Action:
{
  "action": "Calculator",
  "action_input": "29^0.23"
}

Observation: Answer: 2.169459462491557

Thought:I now know the final answer.
Final Answer: 2.169459462491557

> Finished chain.
'2.169459462491557'

Memória: Adicionar registro à chains e agentes

Você pode usar Memory com chains e agentes inicializados com chat models. A principal diferença entre este e o Memory for LLMs é que, em vez de tentar condensar todas as mensagens anteriores em uma string, podemos mantê-las como seu próprio objeto de memória exclusivo.

from langchain.prompts import (
    ChatPromptTemplate, 
    MessagesPlaceholder, 
    SystemMessagePromptTemplate, 
    HumanMessagePromptTemplate
)
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory

prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template("The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know."),
    MessagesPlaceholder(variable_name="history"),
    HumanMessagePromptTemplate.from_template("{input}")
])

llm = ChatOpenAI(temperature=0)
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)

conversation.predict(input="Hi there!")
# -> 'Hello! How can I assist you today?'


conversation.predict(input="I'm doing well! Just having a conversation with an AI.")
# -> "That sounds like fun! I'm happy to chat with you. Is there anything specific you'd like to talk about?"

conversation.predict(input="Tell me about yourself.")
# -> "Sure! I am an AI language model created by OpenAI. I was trained on a large dataset of text from the internet, which allows me to understand and generate human-like language. I can answer questions, provide information, and even have conversations like this one. Is there anything else you'd like to know about me?"