🔗 LangChain na prática: Conceitos fundamentais e avançados para construir agentes inteligentes

This content originally appeared on DEV Community and was authored by Matheus Filipe de Deus

Introdução

Como criar um agente capaz de pensar, agir e se conectar com o mundo real usando apenas Python e LLMs? Essa é exatamente a proposta do LangChain, um dos frameworks mais poderosos e flexíveis para quem quer sair do “prompt isolado” e construir aplicações inteligentes de verdade.

Neste artigo, você vai entender, de forma prática e progressiva, os conceitos fundamentais e avançados do LangChain: templates, chains, caching, router chains, tools e agentes ReAct.

Tudo o que você precisa para começar a desenvolver suas próprias soluções de IA Generativa.

1. O que é LangChain e por que ele importa

LangChain é um framework open-source que ajuda desenvolvedores a construir aplicações com LLMs de forma modular, escalável e produtiva.

Ele fornece uma estrutura padronizada para lidar com:

• Prompt engineering e templates
• Encadeamento lógico de tarefas (chains)
• Interação com APIs e ferramentas externas
• Memória e caching
• Criação de agentes que tomam decisões

Em resumo: o LangChain transforma simples chamadas de API em sistemas inteligentes com comportamento estruturado.

2. Conceitos Fundamentais

a) Prompt Templates

Um PromptTemplate define como o modelo receberá a entrada.
Em vez de escrever prompts fixos, você cria templates dinâmicos:

from langchain.prompts import PromptTemplate

template = "Traduza o texto a seguir para {idioma}: {texto}"
prompt = PromptTemplate.from_template(template)

print(prompt.format(idioma="inglês", texto="Olá, mundo!"))

Permite padronizar e escalar prompts de forma reproduzível. É essencial em pipelines de LLMOps.

b) Chains

Chains são sequências de etapas que processam entradas e saídas entre componentes.

Um exemplo simples é o LLMChain, que conecta um modelo e um template:

from langchain.chains import LLMChain
from langchain.llms import OpenAI

chain = LLMChain(llm=OpenAI(), prompt=prompt)
result = chain.run({"idioma": "inglês", "texto": "Olá, mundo!"})

As chains permitem criar fluxos de raciocínio como “analisar → resumir → responder”.

3. Conceitos Intermediários

a) Sequential Chains

Uma Sequential Chain conecta múltiplas LLMChains, passando o resultado de uma como entrada da próxima:

from langchain.chains import SimpleSequentialChain

chain1 = LLMChain(llm=OpenAI(), prompt=PromptTemplate.from_template("Resuma: {texto}"))
chain2 = LLMChain(llm=OpenAI(), prompt=PromptTemplate.from_template("Traduza para o inglês: {texto}"))

seq_chain = SimpleSequentialChain(chains=[chain1, chain2])
output = seq_chain.run("LangChain ajuda a criar agentes com LLMs.")

Modela fluxos complexos de processamento de linguagem, mantendo tudo organizado.

b) Router Chains

Quando você precisa decidir qual chain executar com base no contexto, entra a Router Chain.

Imagine uma aplicação que escolhe automaticamente se deve resumir, traduzir ou analisar sentimento:

from langchain.chains.router import MultiRouteChain
# cada rota teria sua própria LLMChain

Cria sistemas adaptativos, a base para agentes autônomos mais avançados.

4. Conceitos Avançados

a) Caching

LangChain oferece caching automático para evitar chamadas repetidas a modelos, economizando custo e tempo.

from langchain.cache import InMemoryCache
import langchain

langchain.llm_cache = InMemoryCache()

Essencial para MLOps e LLMOps, garantindo eficiência e reprodutibilidade.

b) Tools (Ferramentas)

Tools são funções externas que o agente pode usar como: chamar uma API, consultar um banco de dados ou enviar uma mensagem.

Exemplo simples de tool:

from langchain.tools import tool

@tool
def calcular_media(numeros: list):
    """Calcula a média de uma lista de números."""
    return sum(numeros) / len(numeros)

Transforma LLMs em agentes úteis, capazes de interagir com o mundo real.

5. Agents e ReAct Agents

Os Agents do LangChain são o coração do framework.
Eles decidem quais ferramentas usar, quando e como, com base em raciocínio interno (chain-of-thought).

O tipo mais usado é o ReAct Agent (Reason + Act), que combina raciocínio com ação:

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

agent = initialize_agent(
    tools=[calcular_media],
    llm=OpenAI(temperature=0),
    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
)
agent.run("Calcule a média de 5, 7 e 10.")

Representa a interação entre LLMs e sistemas externos, o tipo de abordagem usada em soluções reais de GenAI.

6. Mini-demo: Conectando Tudo

Para ilustrar, imagine um pequeno agente de suporte que responde perguntas sobre uma base de textos.

from langchain.chains import RetrievalQA
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI

# cria um vetor a partir de documentos
db = Chroma.from_texts(["O LangChain é um framework de IA modular."], embedding=OpenAIEmbeddings())

# cria a chain de perguntas e respostas
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    chain_type="stuff",
    retriever=db.as_retriever(),
)

print(qa_chain.run("O que é LangChain?"))

Por que esse exemplo é útil:
Mostra como chains, embeddings e agentes se conectam para formar um fluxo funcional, uma base real para criar aplicações completas.

7. Conclusão

LangChain é o elo entre engenharia de software e inteligência artificial aplicada. Dominar seus conceitos, especialmente tools, chains e agents, é o primeiro passo para criar soluções reais e escaláveis.

Notas Finais

Este conteúdo nasce dos meus estudos contínuos sobre GenAI e do desejo de transformar aprendizado em prática, explorando LLMs e IA para desenvolver soluções. É parte de uma jornada de aprendizado guiada pela curiosidade em aplicar IA de forma real e com impacto.

This content originally appeared on DEV Community and was authored by Matheus Filipe de Deus