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

Matheus Filipe de Deus — Thu, 13 Nov 2025 04:30:33 +0000

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 construir aplicações 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.

🧩 1. O que é o LangChain e por que ele importa

O LangChain é um framework open-source (código aberto) que ajuda desenvolvedores a construírem aplicações com LLMs de forma modular e escalável.

Ele fornece uma estrutura que consegue lidar com:

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

🧱 2. Fundamentos

🧠 a) Prompt Templates

Um PromptTemplate define como o modelo receberá a entrada.
Em vez de escrever prompts fixos, você consegue criar 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!"))

⚙️ b) Chains

Chains são sequências de etapas que processam entradas e saídas entre os 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!"})

Com as chains, você consegue criar fluxos de raciocínio. Exemplo: analisar → resumir → responder.

🔁 3. Conceitos Intermediários

⚡ a) Sequential Chains

Uma Sequential Chain conecta múltiplas LLMChains, passando o resultado de uma chain 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.")

Essa funcionalidade permite criar fluxos de processamento de linguagem mais complexos sem perder a organização.

🔀 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 um sentimento:

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

Assim, você consegue criar sistemas adaptativos. Sistemas como esses são a base para agentes autônomos mais avançados.

🧰 4. Conceitos Avançados

💾 a) Caching

O LangChain oferece caching automático para evitar chamadas repetidas a modelos. Isso traz uma economia de custo e de tempo.

from langchain.cache import InMemoryCache
import langchain

langchain.llm_cache = InMemoryCache()

O caching é essencial para MLOps e LLMOps, uma vez que garante eficiência e reprodutibilidade.

🧩 b) Tools (Ferramentas)

Tools são funções externas que o agente pode utilizar, como por exemplo: 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)

Tools transformam LLMs em agentes realmente úteis, já que são capazes de interagir com o mundo real.

🤖 5. Agents e ReAct Agents

Por fim, 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.")

O ReAct representa a interação entre LLMs e sistemas externos, sendo extremamente utilizado em soluções reais de IA Generativa.

🧪 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?"))

Mostramos como chains, embeddings e agentes se conectam para formar um fluxo funcional, uma base realista para criar aplicações completas.

📘 7. Conclusão

Vimos que o LangChain é o elo entre engenharia de software e inteligência artificial aplicada. Por isso, dominar seus conceitos é o primeiro passo para criar soluções reais e escaláveis.

✍️ Notas Finais

Chegamos ao fim desse artigo! Espero que tenha gostado. 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. Espero te ver por aqui novamente, até uma próxima :)

Forem: Matheus Filipe de Deus