Uma introdução ao prompt engineering com LangChain

LangChain é um framework open source pensado para construir aplicações com modelos de linguagem como GPT, LLaMA, Mistral etc., de forma simples.

Um dos recursos mais poderosos do LangChain é o suporte a prompt engineering avançado. Prompt engineering é o processo de desenhar e otimizar prompts para obter respostas mais precisas e relevantes de um modelo de linguagem.

Neste post, vamos cobrir o básico sobre prompts, como o LangChain utiliza prompts, templates de prompt, memória, agentes e chains. Para cada um desses conceitos, veremos vários exemplos de código em Python para que, ao final do tutorial, você se sinta à vontade para criar suas próprias aplicações com o framework LangChain em Python.

Curioso para ver como LangChain e GPT podem ser usados para criar um agente de IA simples? Confira nosso Prompt Engineering with GPT & LangChain AI Code-Along:

O que é prompt engineering?

Imagem do autor

Temos um guia completo sobre prompt engineering, mas, relembrando rapidamente, trata-se da prática de criar entradas em texto que se comunicam de forma eficaz com modelos de IA generativa. Esses prompts, em linguagem natural, especificam a tarefa que queremos que a IA execute.

Eles podem assumir formas diversas: desde perguntas simples, como pedir a explicação de um teorema matemático, até solicitações criativas, como escrever um poema sobre um tema específico.

Em prompt engineering, o segredo não é só o que você pede, mas como você pede. Isso inclui escolher as palavras certas, definir um tom ou estilo, fornecer contexto essencial ou até atribuir um papel à IA, como pedir que responda como se fosse falante nativa de determinado idioma.

Em alguns casos, os prompts também podem incluir exemplos para orientar o processo de aprendizado do modelo. Essa técnica, conhecida como few-shot learning, é especialmente eficaz em tarefas mais complexas.

Para modelos que geram imagens ou áudio, os prompts costumam descrever o resultado desejado em detalhes — do assunto e estilo à composição e ao clima do produto final. A arte do prompt engineering está em ajustar esses elementos para guiar a IA até o resultado esperado.

Os fundamentos dos prompts

Imagem do autor

Prompts são as entradas fornecidas aos large language models (LLMs) para obter uma resposta desejada. Prompts bem elaborados são cruciais para extrair bons resultados de LLMs. O objetivo do prompt engineering é construir prompts com cuidado para gerar respostas precisas, relevantes e úteis.

Um bom prompt geralmente tem quatro componentes:

1. Instruções — Diga ao modelo o que fazer, como usar as informações fornecidas, o que fazer com a consulta e como estruturar a saída.
2. Exemplo de entrada — Forneça entradas de exemplo para mostrar ao modelo o que é esperado.
3. Exemplo de saída — Forneça as saídas correspondentes aos exemplos.
4. Consulta — A entrada real que você quer que o modelo processe.

Exceto pela consulta, todo o resto é opcional, mas pode impactar bastante a qualidade da resposta — especialmente as instruções, que orientam o LLM sobre a tarefa e o formato esperado.

Exemplos mostram o formato de saída desejado para um exemplo de entrada específico.

A consulta é a pergunta ou solicitação feita ao LLM.

Construir prompts eficazes envolve combinar esses elementos de forma criativa conforme o problema que você quer resolver.

Prompts no LangChain

O LangChain oferece várias classes e funções para ajudar a construir e trabalhar com prompts, facilitando a gestão de tarefas complexas com modelos de linguagem.

O LangChain dá suporte de primeira linha a prompt engineering por meio do objeto PromptTemplate.

Os templates de prompt funcionam como guias estruturados para formular consultas a modelos de linguagem.

Eles geralmente incluem diretrizes, uma seleção de entradas de exemplo (few-shot) e perguntas e contextos ajustados para tarefas específicas.

O objetivo do LangChain é projetar templates compatíveis com diversos modelos de linguagem, facilitando a migração de templates entre modelos.

Resumindo: você pode usar a classe PromptTemplate para criar um template de prompt em texto.

from langchain.prompts import PromptTemplate


prompt_template = PromptTemplate.from_template(
    "Tell me a {adjective} joke about {content}."
)
prompt_template.format(adjective="sad", content="data scientists")

Saída:

>>> 'Tell me a sad joke about data scientists.'

Não é obrigatório ter variáveis. Você pode criar um prompt com essa classe mesmo sem nenhuma variável.

from langchain.prompts import PromptTemplate
prompt_template = PromptTemplate.from_template("Tell me a joke")
prompt_template.format()

Saída:

>>> 'Tell me a joke'

E se você estiver criando um app de chat em que precisa salvar e enviar o histórico de mensagens ao LLM sempre que o usuário manda uma nova mensagem? Fazer isso manualmente toma tempo.

Para modelos de chat compatíveis, você pode usar o ChatPromptTemplate:

from langchain.prompts import ChatPromptTemplate


chat_template = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a helpful AI bot. Your name is {name}."),
        ("human", "Hello, how are you doing?"),
        ("ai", "I'm doing well, thanks!"),
        ("human", "{user_input}"),
    ]
)


messages = chat_template.format_messages(name="Bob", user_input="What is your name?")


print(messages)

Saída:

>>> [SystemMessage(content='You are a helpful AI bot. Your name is Bob.'),

>>> HumanMessage(content='Hello, how are you doing?'),

>>> AIMessage(content="I'm doing well, thanks!"),

>>> HumanMessage(content='What is your name?')]

Você pode estar se perguntando: por que precisamos de PromptTemplates? Por que não passar a string diretamente ao LLM? Aqui vão bons motivos para usar o PromptTemplate do LangChain:

• Templates de prompt são reutilizáveis: você cria uma vez e usa em vários cenários, como resumir artigos diferentes sem reescrever o prompt.
• Eles separam a formatação do prompt da chamada ao modelo, deixando o código mais modular e permitindo atualizar template e modelo de forma independente.
• Usar templates melhora a legibilidade do código, encapsulando lógica complexa em um formato simples, com variáveis nomeadas e claras.
• A manutenção fica mais fácil, já que mudanças na lógica do prompt são feitas em um único lugar, não em cada prompt individual.

Memória no LangChain

Em aplicações de chat com modelos de linguagem, é importante que o sistema se lembre das conversas anteriores.

Como em uma conversa normal, o sistema precisa conseguir relembrar o que foi dito antes.

No nível mais simples, isso significa enxergar algumas mensagens anteriores. Em sistemas mais avançados, envolve lembrar detalhes, como fatos sobre diferentes tópicos e como eles se conectam.

Essa capacidade de lembrar conversas passadas é chamada de "memória". O LangChain ajuda a adicionar memória a esses sistemas de chat.

Uma memória no LangChain faz duas coisas principais:

1. Antes de enviar a consulta ao LLM, o sistema lê a memória para enriquecer o prompt inicial recebido do usuário.
2. Depois que o LLM retorna a resposta, o sistema grava isso na memória para interações futuras, antes de entregar o resultado ao usuário.

Memória no LangChain (fonte da imagem)

Para usar o recurso de Memory no LangChain, você pode utilizar a classe ConversationBufferMemory.

from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(return_messages=True)
memory.chat_memory.add_user_message("hi!")
memory.chat_memory.add_ai_message("what's up?")
memory.chat_memory.add_user_message("how are you doing?")
memory.chat_memory.add_ai_message("I am fine, thank you and you?")


# to check the variables history
memory.load_memory_variables({})

Saída:

>>> {'history': [HumanMessage(content='hi!'),

>>> AIMessage(content="what's up?"),

>>> HumanMessage(content='how are you doing?'),

>>> AIMessage(content='I am fine, thank you and you?')]}

Ele retorna um dicionário em que a chave padrão é history. Essa chave aponta para uma lista de mensagens, que podem ser do humano (HumanMessage) ou do LLM (AIMessage).

Chains no LangChain

Para tarefas simples, usar um único LLM (Large Language Model) funciona bem. Já para tarefas mais complexas, normalmente é preciso encadear várias etapas e/ou modelos.

A forma legada de usar Chains no LangChain é pela interface Chain.

O método mais novo e recomendado é a LangChain Expression Language (LCEL). Embora o LCEL seja preferível para novos projetos, o método com Chain ainda é útil e suportado.

from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema import StrOutputParser


model = ChatOpenAI(openai_api_key = “...”)


prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You're a expert data scientist and machine learning engineer who offer its expertise and responds to the point and accurately.",
        ),
        ("human", "{question}"),
    ]
)
runnable = prompt | model | StrOutputParser()


for chunk in runnable.stream({"question": "How is machine learning different than deep learning?"}):
    print(chunk, end="", flush=True)

Saída:

>>> Machine learning and deep learning are subfields of artificial intelligence (AI) that involve training models to make predictions or decisions based on data. While there is an overlap between the two, they ……..

A forma como runnable é criado não é muito comum em Python, mas esse | é um operador pipe. Prompt | model | StrOutputParser() significa que o Prompt é passado pelo model, e a saída disso é passada para o StrOutputParser(). Cada etapa na chain transforma os dados de alguma maneira.

Quer conhecer mais casos de uso e aplicações interessantes com LangChain? Confira nosso tutorial de engenharia de dados e aplicações.

Agentes no LangChain

O conceito central de agentes envolve usar um modelo de linguagem para selecionar uma sequência de ações.

Diferente das chains, em que a sequência de ações é pré-determinada e embutida no código, os agentes utilizam um modelo de linguagem como mecanismo de decisão para escolher quais ações executar e em que ordem.

Há três conceitos-chave nos Agents do LangChain:

1. Ferramentas: descrições das ferramentas disponíveis ao LLM
2. Entrada do usuário: o objetivo macro da tarefa
3. Etapas intermediárias: pares (ação, saída da ferramenta) já executados para atingir o objetivo do usuário

Ferramentas representam funcionalidades que um agente pode acionar. Dois pontos cruciais no design de ferramentas são:

• Garantir que o agente tenha acesso às ferramentas certas.
• Definir as ferramentas de forma que maximizem sua utilidade para o agente.

Para diversas atividades rotineiras, um agente precisa de um conjunto de ferramentas interconectadas. Para isso, o LangChain introduz o conceito de toolkits. O LangChain oferece uma ampla variedade de toolkits para você começar.

Para saber mais sobre Agents, veja este guia oficial do LangChain.

Crédito: alguns exemplos deste blog foram gerados usando a documentação oficial do LangChain.

Conclusão

Ao oferecer uma abordagem estruturada para desenhar prompts, o LangChain não só simplifica a interação com diferentes modelos de linguagem como também maximiza a eficiência e a relevância das respostas. Recursos como PromptTemplate e Memory mostram uma integração cuidadosa entre flexibilidade e precisão no prompt engineering, cobrindo desde consultas simples até contextos conversacionais complexos.

As funcionalidades avançadas de Chains e Agents ampliam o potencial de aplicações que podem ser construídas com poucas linhas de código no LangChain, independentemente do LLM escolhido — e há muitas opções.

Seja para tarefas simples ou aplicações sofisticadas, a abordagem do LangChain para prompt engineering é simples, clara e fácil de adotar.

Quer aprender mais? Confira a parte 1 de How to Build LLM Applications with LangChain na DataCamp.