As Complexidades das LangChain Chains: Liberando o Poder de Workflows de IA Modernos

Name

Akira Sakamoto

Updated on 14/11/2025

LangChain continua evoluindo rapidamente, e chains permanecem como um de seus conceitos mais essenciais. Neste guia atualizado, exploramos o que LangChain Chains realmente significam em 2025, como elas funcionam usando a nova LCEL (LangChain Expression Language) e como ajudam desenvolvedores a construir aplicações de IA confiáveis e multi-etapas.

Este artigo atualiza todos os exemplos para os padrões modernos do LangChain, substituindo classes obsoletas como LLMChain por Runnables, PromptTemplate, ChatModels e pipelines sequenciais.

O que é LangChain? (Visão Geral 2025)

LangChain é um framework poderoso em Python/JavaScript que ajuda desenvolvedores a construir aplicações de IA usando:

• Large language models (LLMs)
• Prompt templates
• Memory
• Tools & agents
• Retrieval (RAG)
• Workflow graphs (LangGraph)

O conceito mais icônico do LangChain é a Chain:

um pipeline reutilizável e componível que passa dados passo a passo por prompts, models, tools, transformações e output parsers.

📘 Quer uma introdução básica? Leia nosso Artigo de Introdução ao LangChain.

O que São LangChain Chains?

Em 2023, chains eram normalmente criadas usando LLMChain e classes Python personalizadas.
Em 2025, a forma recomendada é LCEL, que usa uma sintaxe funcional e limpa de pipeline:

chain = prompt | model | output_parser

Uma Chain é simplesmente:

• Uma sequência de etapas
• Conectadas em uma única unidade invocável
• Onde a saída de uma etapa se torna a entrada da próxima

LangChain agora fornece:

• Simple Chains (single model + prompt)
• Sequential Chains (múltiplas etapas)
• Parallel Chains (workflows com ramificações)
• Agents (chains dinâmicas que escolhem tools)

Vamos passar por exemplos modernos.

Chains Básicas (Atualizado para 2025)

Uma chain básica aciona um único model com um único prompt.

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
 
prompt = PromptTemplate.from_template(
    "Describe a perfect day in {city}."
)
 
model = ChatOpenAI(model="gpt-4o-mini")
 
chain = prompt | model
 
chain.invoke({"city": "Paris"})

O que Está Acontecendo?

1. PromptTemplate formata "Describe a perfect day in Paris."
2. O LLM gera a descrição
3. A saída é retornada como um ChatMessage ou string, dependendo da configuração

Esta é a chain mais simples possível no LangChain moderno.

Chains Avançadas: Pipelines Multi-Etapas

Chains multi-etapas combinam várias operações.

Exemplo: Summarize → Translate usando LCEL:

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
 
summarize_prompt = PromptTemplate.from_template(
    "Summarize this text:\n\n{text}"
)
 
translate_prompt = PromptTemplate.from_template(
    "Translate this into Spanish:\n\n{summary}"
)
 
model = ChatOpenAI(model="gpt-4o-mini")
 
summarize_chain = summarize_prompt | model
translate_chain = translate_prompt | model
 
full_chain = summarize_chain | (lambda x: {"summary": x.content}) | translate_chain
 
full_chain.invoke({"text": "Climate change is causing rapid ocean warming..."})

Por que isso é importante

Isso reflete as boas práticas modernas do LangChain:

• Runnables em vez das antigas classes de chain
• Composição funcional usando |
• Mapeamento de dados intermediários com funções Python

Chains Sem LLMs (Pipelines de Transform + Clean)

Nem toda chain precisa de um LLM. Você pode criar pipelines de pré-processamento ou pós-processamento.

Exemplo: remover espaços extras → converter para minúsculas → enviar ao LLM:

def cleanup(text):
    return text.strip().lower()
 
chain = cleanup | model
chain("   WHAT is the    WEATHER   LIKE?   ")

Qualquer função Python pode ser inserida em uma chain, desde que aceite e retorne dados serializáveis.

Sequential Chains (Substitui SimpleSequentialChain)

SimpleSequentialChain e SequentialChain estão obsoletos.
O equivalente em LCEL é simplesmente:

chain = step1 | step2 | step3

Exemplo: Limpar o prompt → reescrever → responder

from langchain_openai import ChatOpenAI
 
clean = lambda x: x.strip()
rewrite_prompt = PromptTemplate.from_template(
    "Rewrite this more clearly: {text}"
)
answer_prompt = PromptTemplate.from_template(
    "Answer this question: {question}"
)
 
model = ChatOpenAI(model="gpt-4o-mini")
 
rewrite_chain = rewrite_prompt | model
answer_chain = answer_prompt | model
 
chain = clean | (lambda x: {"text": x}) | rewrite_chain | (lambda x: {"question": x.content}) | answer_chain
 
chain.invoke("   What is LangChain used for?  ")

Esta é a substituição moderna para SimpleSequentialChain.

O Papel dos Agents em LangChain (Edição 2025)

Agents permitem que LLMs escolham tools dinamicamente:

• Motores de busca
• Execução de código
• Calculadoras
• APIs
• Retrievers
• Funções personalizadas

Exemplo (sintaxe moderna):

from langchain.agents import AgentExecutor, load_tools, create_react_agent
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-4o-mini")
tools = load_tools(["llm-math"], llm=llm)
 
agent = create_react_agent(llm, tools)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
executor.invoke({"input": "If I'm half my dad's age and he'll be 60 next year, how old am I?"})

Agents são mais indicados quando a tarefa exige:

• Raciocínio
• Escolha correta de tools
• Várias etapas de decisão

Para workflows fixos, uma simple chain costuma ser melhor.

Exemplo Prático: Um Workflow de Recomendação de Filmes (Atualizado)

Vamos modernizar o seu exemplo de chain com dois LLMs usando LCEL.

Passo 1 — Perguntar ao usuário sobre gêneros

from langchain.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
 
ask_prompt = PromptTemplate.from_template(
    "Ask the user about their favorite movie genres."
)
 
ask_chain = ask_prompt | ChatOpenAI(model="gpt-4o-mini")

Passo 2 — Recomendar filmes

recommend_prompt = PromptTemplate.from_template(
    "Based on these genres: {genres}, recommend 5 movies."
)
 
recommend_chain = recommend_prompt | ChatOpenAI(model="gpt-4o-mini")

Combinar as duas

chain = ask_chain | (lambda x: {"genres": x.content}) | recommend_chain
chain.invoke({})

Adicionando memory (moderno)

from langchain.memory import ConversationBufferMemory
 
memory = ConversationBufferMemory(return_messages=True)
 
# pipelines can load memory before passing to next step

Conclusão

O LangChain moderno (2024–2025) torna mais fácil do que nunca construir workflows de IA escaláveis usando pipelines LCEL, Runnables e agents. Quer você esteja:

• Fazendo pré-processamento de texto
• Construindo workflows multi-etapas
• Integrando tools
• Criando agents dinâmicos

LangChain fornece os blocos de construção para conectar tudo de forma limpa e confiável.

Experimente sem medo — simple chains podem rapidamente evoluir para aplicações de IA poderosas.

FAQ (Atualizado)

1. O que é LangChain?
   LangChain é um framework para construir aplicações de IA usando prompts, models, tools, memory e workflow graphs.

2. O que substitui SimpleSequentialChain?
   Pipelines LCEL usando o operador | para processamento sequencial.

3. Como adiciono memory?
   Use ConversationBufferMemory, SummaryMemory ou memory personalizada injetada na sua chain.

4. Agents ainda são úteis?
   Sim — quando é necessário fazer seleção dinâmica de tools. Para etapas fixas, chains são mais simples.

5. Onde posso aprender mais?
   Visite a documentação do LangChain ou explore LangGraph para orquestração de agents baseada em workflows.