O que é o LangChain e como funciona

Artigo atualizado em Setembro 2026: todo o código foi reescrito para o LangChain 1.x (testado com langchain 1.4 e langchain-openai 1.6). Os imports antigos (langchain.llms, langchain.chat_models.ChatOpenAI, ConversationChain, RetrievalQA) foram trocados pelos atuais, a memória agora usa create_agent com checkpointer e o modelo gpt-3.5-turbo (em descontinuação) virou gpt-6-luna.

Salve salve Pythonista

O universo das aplicações com modelos de linguagem de grande porte (LLMs) está em constante expansão.

Para desenvolvedores que buscam aproveitar todo o potencial desses modelos, ferramentas como o LangChain se tornam essenciais.

Neste artigo, vamos explorar o que é o LangChain, sua importância, componentes chave, funcionamento, funcionalidades, vantagens, primeiros passos para utilizá-lo e exemplos práticos de aplicação.

Entender o LangChain é fundamental para criar soluções robustas e eficientes utilizando LLMs em seus projetos Python.

Vá Direto ao Assunto…

• O que é o LangChain e sua importância em aplicações com LLMs
• Componentes chave do LangChain: LLMs, Prompts, Chains e mais
• Como o LangChain funciona: a interação entre seus componentes
• Funcionalidades do LangChain: chatbots, Q&A, sumarização
• Vantagens de usar LangChain para desenvolver aplicações com LLMs
• Primeiros passos: como começar a usar a biblioteca LangChain
• Exemplos práticos de uso do LangChain em aplicações reais
• Código: Exemplo Completo
• LangChain vs Outras Bibliotecas
• Quando Usar LangChain
• Quando NÃO Usar LangChain
• Armadilhas Comuns

O que é o LangChain e sua importância em aplicações com LLMs

O LangChain é uma biblioteca em Python projetada para facilitar a criação de aplicações que utilizam modelos de linguagem de grande porte (LLMs), como os modelos GPT da OpenAI, o Claude, o DeepSeek ou o Grok.

Sua importância reside na capacidade de integrar e orquestrar diferentes componentes necessários para desenvolver funcionalidades avançadas, como chatbots inteligentes, sistemas de perguntas e respostas (Q&A) e ferramentas de sumarização de texto.

Ao simplificar o processo de desenvolvimento com LLMs, o LangChain permite que desenvolvedores se concentrem na lógica de negócio e na experiência do usuário, eliminando a complexidade de lidar diretamente com as APIs dos modelos de linguagem.

Componentes chave do LangChain: LLMs, Prompts, Chains e mais

O LangChain é composto por diversos componentes chave que trabalham em conjunto para proporcionar funcionalidades avançadas.

Os principais componentes incluem:

• LLMs (Modelos de Linguagem): São os motores de processamento de linguagem natural que geram textos, respondem perguntas e executam tarefas baseadas em texto.
• Prompts: São as instruções ou perguntas fornecidas aos LLMs para obter respostas específicas. A qualidade dos prompts impacta diretamente na eficácia das respostas.
• Chains (Cadeias): Sequências de chamadas a LLMs e outros componentes, permitindo a criação de fluxos de trabalho complexos e multifásicos.
• Agents (Agentes): Componentes que tomam decisões inteligentes sobre quais ações executar com base nas entradas recebidas e nos resultados obtidos dos LLMs.
• Memory (Memória): Mecanismo que permite aos modelos de linguagem lembrar de interações anteriores, melhorando a contextualização e a coerência das respostas. No LangChain 1.x, a memória de curto prazo é feita com um checkpointer (do LangGraph, que o LangChain usa por baixo dos panos) que guarda o histórico de cada conversa.

Esses componentes permitem a flexibilidade e modularidade na construção de aplicações, facilitando a personalização conforme as necessidades específicas do projeto.

Como o LangChain funciona: a interação entre seus componentes

O funcionamento do LangChain baseia-se na interação harmoniosa entre seus componentes principais.

Veja como essa interação ocorre:

1. Input do Usuário: O processo começa com a entrada fornecida pelo usuário, que pode ser uma pergunta, um comando ou qualquer tipo de texto.
2. Prompting: O LangChain prepara um prompt adequado com base na entrada do usuário. Esse prompt é projetado para orientar o LLM a gerar a resposta desejada.
3. Chamada ao LLM: O prompt é enviado ao LLM, que processa a informação e gera uma resposta.
4. Processamento de Resposta: A resposta do LLM pode ser processada por outros componentes, como Chains ou Agents, para refinar ou direcionar a resposta final.
5. Memória: Se necessário, a interação é armazenada na memória, permitindo que o LLM utilize o contexto de conversas anteriores em interações futuras.
6. Output para o Usuário: Finalmente, a resposta final é apresentada ao usuário, completando o ciclo de interação.

Esse fluxo de trabalho integrado garante que aplicações desenvolvidas com o LangChain sejam eficientes, contextuais e adaptáveis às necessidades dos usuários.

Antes de continuar… Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Funcionalidades do LangChain: chatbots, Q&A, sumarização

O LangChain oferece uma variedade de funcionalidades que permitem a criação de aplicações sofisticadas utilizando LLMs.

As principais funcionalidades incluem:

Chatbots Inteligentes

O LangChain possibilita a criação de chatbots que entendem e respondem de maneira natural às interações dos usuários.

Utilizando componentes como memória e chains, esses chatbots conseguem manter o contexto da conversa e fornecer respostas coerentes e relevantes ao longo do tempo.

Sistemas de Perguntas e Respostas (Q&A)

Com o LangChain, é possível desenvolver sistemas de Q&A que respondem a perguntas específicas dos usuários com base em um conjunto de dados ou documentos fornecidos.

A capacidade de extrair informações e fornecer respostas precisas torna essa funcionalidade ideal para aplicações em atendimento ao cliente, suporte técnico e educação.

Sumarização de Texto

A funcionalidade de sumarização permite que o LangChain resuma textos longos de forma eficiente, destacando os pontos principais e facilitando a compreensão rápida das informações.

Essa ferramenta é útil para gerenciar grandes volumes de texto, como artigos, relatórios e notícias.

Essas funcionalidades demonstram a versatilidade e potência do LangChain na criação de soluções baseadas em linguagem natural.

Vantagens de usar LangChain para desenvolver aplicações com LLMs

Utilizar o LangChain para desenvolver aplicações com LLMs traz diversas vantagens, tais como:

• Facilidade de Integração: O LangChain simplifica a integração de diferentes componentes necessários para trabalhar com LLMs, reduzindo a complexidade do desenvolvimento.
• Modularidade e Flexibilidade: A estrutura modular permite que desenvolvedores combinem e personalizem componentes conforme as necessidades específicas do projeto.
• Gestão de Memória: Com a capacidade de armazenar e utilizar o contexto de interações anteriores, as aplicações tornam-se mais inteligentes e contextualizadas.
• Escalabilidade: O LangChain suporta a criação de aplicações escaláveis, que podem crescer em complexidade e capacidade conforme a demanda.
• Comunidade Ativa: Uma comunidade ativa e documentação abrangente facilitam o aprendizado e a resolução de problemas, além de oferecer suporte contínuo para melhorias e atualizações.
• Produtividade Aumentada: Ao abstrair tarefas complexas, o LangChain permite que desenvolvedores se concentrem na inovação e na melhoria da experiência do usuário.

Essas vantagens fazem do LangChain uma escolha robusta para desenvolvedores que buscam criar aplicações avançadas com modelos de linguagem.

Primeiros passos: como começar a usar a biblioteca LangChain

Iniciar com o LangChain é simples e direto.

Siga os passos abaixo para configurar e começar a utilizar a biblioteca em seus projetos:

1. Instalação

Primeiro, é necessário instalar o LangChain e a integração com o provedor de modelos (aqui, a OpenAI) utilizando o pip:

1

pip install -U langchain langchain-openai

Desde a versão 1.0, cada provedor tem seu próprio pacote (langchain-openai, langchain-anthropic, langchain-ollama…). O pacote langchain traz o núcleo e os agentes.

2. Configuração Inicial

Após a instalação, defina sua chave de API da OpenAI na variável de ambiente OPENAI_API_KEY (no terminal: export OPENAI_API_KEY="sua_chave_api") e importe os componentes básicos em seu projeto Python:

1
2
3

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

3. Configuração do LLM

Configure o modelo de linguagem que será utilizado. Por exemplo, utilizando um modelo GPT da OpenAI:

1

modelo = ChatOpenAI(model="gpt-6-luna")

O ChatOpenAI lê a chave da variável OPENAI_API_KEY automaticamente. Sempre informe o model: o gpt-6-luna é o modelo mais econômico da família GPT-6 da OpenAI; para tarefas mais difíceis, use gpt-6-sol ou gpt-6-astra.

4. Criação de um Prompt

Defina o prompt que será enviado ao LLM. O {assunto} é uma variável que será preenchida na execução:

1

prompt = ChatPromptTemplate.from_template("Explique o que é o {assunto} em detalhes.")

5. Construção de uma Chain

Crie uma chain que conecta o prompt ao modelo. O operador | liga os componentes em sequência: a saída de um vira a entrada do próximo, e o StrOutputParser extrai só o texto da resposta:

1

chain = prompt | modelo | StrOutputParser()

6. Execução

Execute a chain para obter a resposta:

1
2

resposta = chain.invoke({"assunto": "LangChain"})
print(resposta)

E a saída será algo como (a resposta do modelo varia a cada execução):

1
2
3
4
5
6
7

LangChain é uma biblioteca em Python projetada para facilitar a criação de aplicações que
utilizam modelos de linguagem de grande porte (LLMs), como o GPT-4. Ela fornece ferramentas
para integrar e orquestrar diferentes componentes, permitindo a criação de funcionalidades
avançadas como chatbots inteligentes, sistemas de perguntas e respostas e ferramentas de
sumarização de texto. Com o LangChain, os desenvolvedores podem se concentrar na lógica de
negócio e na experiência do usuário, eliminando a complexidade de lidar diretamente com as
APIs dos modelos de linguagem.

Esses passos fornecem uma base sólida para começar a desenvolver aplicações com o LangChain.

A documentação oficial oferece recursos adicionais para aprofundar o conhecimento e explorar funcionalidades avançadas.

Curiosidade: O Ebookr.ai - minha plataforma de geração de ebooks com IA - foi construído usando LangChain! A mesma tecnologia que você está aprendendo aqui. Com ele, você cria ebooks profissionais sobre qualquer assunto, com capas, infográficos automáticos e exportação em PDF. Vale conhecer!

Exemplos práticos de uso do LangChain em aplicações reais

Para ilustrar o potencial do LangChain, vamos explorar alguns exemplos práticos de aplicações desenvolvidas com a biblioteca:

1. Chatbot de Atendimento ao Cliente

Um chatbot inteligente desenvolvido com o LangChain pode entender e responder a perguntas dos clientes de forma natural.

Utilizando Chains e Memory, o chatbot mantém o contexto da conversa, proporcionando um atendimento mais eficiente e personalizado.

2. Sistema de Suporte Técnico

Empresas de tecnologia podem utilizar o LangChain para criar sistemas de suporte técnico automatizado.

O sistema pode analisar descrições de problemas fornecidas pelos usuários e fornecer soluções precisas ou orientar para recursos adicionais.

3. Ferramenta de Sumarização de Documentos

Organizações que lidam com grandes volumes de texto, como advogados ou jornalistas, podem utilizar o LangChain para desenvolver ferramentas que resumem documentos extensos, facilitando a análise rápida e a extração de informações essenciais.

4. Plataforma de Educação Interativa

Educadores podem criar plataformas interativas que utilizam o LangChain para fornecer resumos de aulas, responder a perguntas dos estudantes e adaptar o conteúdo de acordo com o progresso individual de cada aluno.

5. Análise de Sentimento em Redes Sociais

Empresas de marketing podem utilizar o LangChain para analisar postagens em redes sociais, identificando sentimentos e tendências que ajudam na tomada de decisões estratégicas.

Esses exemplos demonstram como o LangChain pode ser aplicado em diversas indústrias para resolver problemas complexos e melhorar a eficiência operacional.

Antes de colar esse código, vale lembrar: dominar Python de verdade, com POO e boas práticas, é o que sustenta qualquer projeto com LLMs depois. Essa base é construída na Jornada Python, do zero ao avançado:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Código: Exemplo Completo

Chat Básico com Memória

As antigas ConversationChain e ConversationBufferMemory saíram do pacote principal no LangChain 1.0 (foram para o pacote de legado langchain-classic). A forma recomendada hoje é criar um agente com create_agent e um checkpointer, que guarda o histórico de cada conversa (identificada por um thread_id):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import InMemorySaver

# Configurar modelo
llm = ChatOpenAI(model="gpt-6-luna")

# Agente sem ferramentas, com memória em RAM
agente = create_agent(
    model=llm,
    tools=[],
    system_prompt="Você é um assistente prestativo.",
    checkpointer=InMemorySaver(),
)

# Cada thread_id é uma conversa separada
config = {"configurable": {"thread_id": "conversa-1"}}


def conversar(texto):
    resultado = agente.invoke({"messages": [{"role": "user", "content": texto}]}, config)
    return resultado["messages"][-1].text


# Diálogo com contexto
print(conversar("Olá, meu nome é João"))
print(conversar("Qual é meu nome?"))  # Lembra do contexto!

O InMemorySaver perde tudo quando o programa termina; em produção, a documentação recomenda um checkpointer com banco de dados (como o PostgresSaver).

RAG (Retrieval Augmented Generation)

A antiga RetrievalQA também foi para o langchain-classic. Com as peças atuais, o RAG em dois passos (buscar os trechos relevantes e depois perguntar ao modelo) fica explícito e fácil de entender:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

from pathlib import Path

from langchain_core.documents import Document
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter

# 1. Carregar documentos
texto = Path("documentacao.txt").read_text(encoding="utf-8")
documents = [Document(page_content=texto, metadata={"source": "documentacao.txt"})]

# 2. Dividir em chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
texts = text_splitter.split_documents(documents)

# 3. Criar embeddings e armazenar
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = InMemoryVectorStore.from_documents(texts, embeddings)

# 4. Buscar os trechos mais parecidos com a pergunta
pergunta = "Como funciona a funcionalidade X?"
trechos = vectorstore.similarity_search(pergunta, k=4)
contexto = "\n\n".join(doc.page_content for doc in trechos)

# 5. Perguntar ao modelo usando os trechos como contexto
llm = ChatOpenAI(model="gpt-6-luna")
response = llm.invoke(
    f"Responda usando apenas o contexto abaixo.\n\nContexto:\n{contexto}\n\nPergunta: {pergunta}"
)
print(response.text)

O InMemoryVectorStore é ótimo para aprender e para poucos documentos. Para volumes maiores, troque por um banco vetorial com pacote próprio (como langchain-chroma ou langchain-postgres).

LangChain vs Outras Bibliotecas

Quando Usar LangChain

✅ Aplicações com múltiplos steps Chains complexas são o forte do LangChain

✅ Precisa de memória conversacional Histórico por conversa com checkpointers

✅ RAG (busca em documentos) Integração nativa com vectorstores

✅ Agentes autônomos Agentes que decidem quais tools usar

✅ Prototipar rapidamente Abstrações de alto nível facilitam

Quando NÃO Usar LangChain

❌ App muito simples (1 call de API) Overhead desnecessário - use API direta

❌ Precisa máximo controle Abstrações podem esconder detalhes

❌ Performance crítica Camadas de abstração adicionam latency

❌ Apenas busca em docs LlamaIndex é mais especializado

Armadilhas Comuns

1. Gestão de Custos

1
2
3
4
5
6

from langchain_core.callbacks import get_usage_metadata_callback

# Monitorar o consumo de tokens (é por tokens que a API cobra)
with get_usage_metadata_callback() as cb:
    result = chain.invoke({"assunto": "LangChain"})
    print(cb.usage_metadata)  # tokens de entrada, saída e total, por modelo

Multiplique os tokens pelos preços da página de preços do provedor para estimar o custo. O antigo get_openai_callback calculava o custo sozinho, mas vinha do langchain-community, pacote que foi descontinuado em 2026.

2. Rate Limiting

1
2
3
4
5
6
7
8

from langchain_openai import ChatOpenAI

# Configurar retry e timeout
llm = ChatOpenAI(
    model="gpt-6-luna",
    max_retries=3,  # novas tentativas automáticas em erros temporários
    timeout=30,  # segundos
)

3. Vazão de Dados Sensíveis

1
2
3
4
5
6
7
8
9
10

# ❌ Evite mandar dados sensíveis para uma API externa sem necessidade
llm = ChatOpenAI(model="gpt-6-luna")
response = llm.invoke(f"Analise: {dados_sensiveis_usuario}")

# ✅ Use modelos locais para dados sensíveis
# pip install langchain-ollama  e  ollama pull gpt-oss:20b
from langchain_ollama import ChatOllama  # Modelo local, via Ollama

llm = ChatOllama(model="gpt-oss:20b")
response = llm.invoke(f"Analise: {dados_sensiveis_usuario}")

Conclusão

Neste guia sobre LangChain, você aprendeu:

✅ O que é - Framework para apps com LLMs
✅ Componentes - Models, Prompts, Chains, Memory, Agents
✅ Código real - Chat com memória e RAG
✅ Comparações - vs LlamaIndex, Haystack, API direta
✅ Quando usar - Apps complexas, RAG, agentes
✅ Armadilhas - Custos, rate limiting, dados sensíveis

Principais lições:

• LangChain é ideal para apps complexas com LLMs
• Chains e Memory são os conceitos fundamentais
• Monitore custos com callbacks
• Para apps simples, API direta pode ser melhor
• RAG é poderoso para busca em documentos

Próximos passos:

• Aprenda Web Scraping com LangChain
• Explore Prompts no LangChain
• Pratique criando seu primeiro app LLM
• Estude sobre Agents e Tools

Quer fortalecer a base de Python que sustenta esses projetos com LLMs? Conheça a Jornada Python, nosso curso completo de Python.

Por Vinícius Ramos em 01/03/2025

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•