LangChain: Construindo Aplicações com Grandes Modelos de Linguagem na Prática

O que é o LangChain?

O LangChain é um framework de código aberto criado por Harrison Chase em 2022 que revolucionou a forma como desenvolvedores constroem aplicações com Grandes Modelos de Linguagem (LLMs). Ele abstrai a complexidade de lidar com diferentes provedores de IA, gerencia contextos longos, encadeia chamadas de modelos e conecta LLMs a fontes de dados externas como bancos vetoriais, APIs e planilhas.

Com mais de 100 mil estrelas no GitHub e uma comunidade ativa, o LangChain se tornou o padrão de facto para engenharia de prompt, sistemas RAG (Retrieval-Augmented Generation) e agentes autônomos baseados em IA.

Principais Conceitos do LangChain

Para dominar o LangChain, você precisa entender seis pilares fundamentais:

Models (Modelos): Wrappers unificados para LLMs como OpenAI GPT, Anthropic Claude, Google Gemini, Meta Llama e modelos locais via Ollama. Você troca de provedor alterando apenas uma linha de código.
Prompts (Instruções): Templates de prompt reutilizáveis com variáveis dinâmicas. O LangChain oferece PromptTemplate, ChatPromptTemplate e FewShotPromptTemplate para estruturar entradas de forma consistente.
Chains (Cadeias): Sequências encadeadas de chamadas a LLMs, ferramentas e funções. Uma chain pode, por exemplo, traduzir um texto, resumi-lo e extrair palavras-chave em três passos coordenados.
Memory (Memória): Sistemas para armazenar histórico de conversas — desde BufferMemory simples até resumos compressivos com ConversationSummaryMemory.
Retrieval (Recuperação): Integração com bancos vetoriais (Chroma, Pinecone, Weaviate, Qdrant) para busca semântica. A base do padrão RAG.
Agents (Agentes): LLMs que decidem quais ferramentas usar para completar uma tarefa. Agentes podem pesquisar na web, executar código, calcular expressões ou consultar bancos de dados autonomamente.

Exemplo Prático: Sistema RAG com LangChain

O padrão RAG (Retrieval-Augmented Generation) é a aplicação mais popular do LangChain. Ele permite que um LLM responda perguntas com base em documentos próprios da sua empresa, sem precisar re-treinar o modelo. Veja como implementar:

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.chains import RetrievalQA

# 1. Carregar e dividir documentos
loader = PyPDFLoader("manual.pdf")
documents = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

# 2. Criar banco vetorial
vectorstore = Chroma.from_documents(chunks, OpenAIEmbeddings())

# 3. Configurar chain RAG
qa_chain = RetrievalQA.from_chain_type(
    llm=ChatOpenAI(model="gpt-4o"),
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# 4. Perguntar!
resposta = qa_chain.invoke("Qual é o prazo de garantia do produto?")
print(resposta['result'])

Agentes Autônomos com Ferramentas

Uma das funcionalidades mais poderosas do LangChain são os agentes. Diferente de uma chain que segue passos fixos, um agente decide dinamicamente quais ferramentas usar. Exemplo de um agente com acesso a calculadora e busca na web:

from langchain.agents import create_react_agent, AgentExecutor
from langchain_community.tools import DuckDuckGoSearchRun, Tool
from langchain_openai import ChatOpenAI
from langchain import hub

def calculadora(expressao: str) -> str:
    return str(eval(expressao))

ferramentas = [
    DuckDuckGoSearchRun(),
    Tool(name="Calculadora", func=calculadora, description="Resolve expressões matemáticas")
]

agente = create_react_agent(
    llm=ChatOpenAI(model="gpt-4o"),
    tools=ferramentas,
    prompt=hub.pull("hwchase17/react")
)

executor = AgentExecutor(agent=agente, tools=ferramentas, verbose=True)

resultado = executor.invoke(
    {"input": "Qual a população do Brasil em 2024 elevada ao quadrado?"}
)

LangGraph: O Novo Paradigma

Em 2024, o LangChain introduziu o LangGraph, uma extensão que permite construir grafos de estados para fluxos de trabalho mais complexos que chains lineares. Com LangGraph, você pode criar loops, branches, ciclos de feedback e até mesmo agentes multi-etapa com controle granular sobre o estado.

Enquanto as chains tradicionais são sequenciais (A → B → C), o LangGraph permite fluxos condicionais (se X, vá para A; senão, vá para B), ciclos e paralelismo real entre nós do grafo.

Boas Práticas com LangChain

Versionamento de prompts: Use LangSmith para rastrear, versionar e depurar suas chains em produção. Cada chamada fica registrada com metadados, latência e saída.
Rate limiting e retry: Configure limites de taxa de requisição com callbacks do LangChain para evitar erros 429 das APIs de LLM.
Streaming: Habilite streaming nas respostas para melhorar a experiência do usuário em interfaces de chat. O LangChain suporta streaming token a token nativamente.
Testes com prompts fixos: Congele versões de prompts e modelos ao testar para garantir reprodutibilidade. Use avaliações com dataset de perguntas e respostas esperadas.
Segurança: Nunca confie cegamente na saída de um LLM, especialmente em agentes. Valide comandos executados por ferramentas com whitelists e sanitização.

Conclusão

O LangChain transformou o desenvolvimento de aplicações com IA generativa, oferecendo um ecossistema maduro de abstrações, integrações e ferramentas. Seja para criar um simples chatbot com contexto, um sistema RAG para documentação empresarial ou agentes autônomos complexos, o LangChain fornece os blocos de construção necessários para ir do protótipo à produção com rapidez.

Com a evolução para LangGraph e a crescente integração com plataformas cloud, o framework continua sendo a principal escolha para desenvolvedores que querem construir aplicações inteligentes escaláveis. O próximo passo natural é explorar LangSmith para observabilidade e LangServe para deploy das suas chains como APIs REST.

Data science

Entrar em contato

Entre em contato