LangChain em Python: Como Criar Aplicações Inteligentes com LLMs do Zero | Data Driven School

LangChain em Python: Como Criar Aplicações Inteligentes com LLMs do Zero

29 de maio de 2025 7 min de leitura

Introdução: Minha Jornada com LangChain

Desde que comecei a explorar inteligência artificial generativa para nossos cursos na Data Driven School, uma ferramenta me chamou muito a atenção: LangChain. Como alguém que sempre busca maneiras práticas de ensinar conceitos complexos, percebi rapidamente o potencial dessa biblioteca para democratizar o desenvolvimento de aplicações com IA.

Durante meus anos como Head de Dados, trabalhei com diversas APIs e frameworks, mas raramente vi algo tão elegante quanto LangChain para conectar modelos de linguagem a aplicações reais. Hoje vou compartilhar tudo que aprendi sobre esta biblioteca revolucionária.

O que é LangChain e Por Que É Importante?

LangChain é um framework open-source em Python projetado especificamente para facilitar o desenvolvimento de aplicações baseadas em Large Language Models (LLMs). Imagino que você já interagiu com o ChatGPT, certo? Pois bem, LangChain é a ferramenta que permite criar suas próprias aplicações inteligentes usando esses mesmos tipos de modelos.

Principais Características do LangChain:

  • Interface Unificada: Conecta-se com diferentes provedores (OpenAI, Hugging Face, Anthropic)
  • Modularidade: Componentes reutilizáveis como blocos LEGO
  • Chains (Correntes): Combina múltiplas operações em sequência
  • Agents: Sistemas que tomam decisões baseadas em contexto
  • Memory: Mantém contexto entre interações

Instalação e Configuração Inicial

Vamos começar com o básico. A instalação do LangChain é simples:

# Instalação básica
pip install langchain

# Para usar com OpenAI
pip install langchain-openai

# Para usar com Hugging Face
pip install langchain-huggingface

# Pacote completo (recomendado para iniciantes)
pip install 'langchain[all]'

Após a instalação, você precisa configurar suas chaves de API. Eu sempre recomendo usar variáveis de ambiente:

import os
from langchain_openai import ChatOpenAI

# Configure sua chave da OpenAI
os.environ['OPENAI_API_KEY'] = 'sua-chave-aqui'

# Inicialize o modelo
llm = ChatOpenAI(model='gpt-3.5-turbo', temperature=0.7)

Primeiro Exemplo Prático: Gerador de Descrições de Produtos

Em meus cursos, sempre enfatizo a importância de começar com exemplos práticos. Vamos criar uma aplicação que gera descrições de produtos para e-commerce:

from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

# Configuração do modelo
llm = ChatOpenAI(model='gpt-3.5-turbo', temperature=0.7)

# Template do prompt
prompt_template = ChatPromptTemplate.from_template(
    'Crie uma descrição atrativa para o produto: {produto}
'
    'Características: {caracteristicas}
'
    'Público-alvo: {publico_alvo}

'
    'A descrição deve ser envolvente, destacar os benefícios e ter no máximo 150 palavras.'
)

# Parser de saída
output_parser = StrOutputParser()

# Criando a chain
chain = prompt_template | llm | output_parser

# Testando a aplicação
resultado = chain.invoke({
    'produto': 'Fone de ouvido Bluetooth',
    'caracteristicas': 'Cancelamento de ruído, 30h de bateria, resistente à água',
    'publico_alvo': 'Profissionais que trabalham remotamente'
})

print(resultado)

Conceitos Fundamentais que Todo Desenvolvedor Deve Conhecer

1. Prompt Templates

Os templates são essenciais para criar prompts consistentes e reutilizáveis:

from langchain.prompts import PromptTemplate

# Template simples
template = PromptTemplate(
    input_variables=['linguagem', 'nivel'],
    template='Explique {linguagem} para um programador de nível {nivel}'
)

prompt = template.format(linguagem='Python', nivel='iniciante')
print(prompt)

2. Chains (Correntes)

As chains permitem combinar múltiplas operações. Na minha experiência ensinando, este é o conceito que mais transforma a forma como os alunos pensam sobre aplicações de IA:

from langchain.chains import LLMChain

# Chain simples
chain = LLMChain(
    llm=llm,
    prompt=prompt_template,
    output_parser=output_parser
)

# Chain com múltiplas etapas
from langchain.chains import SequentialChain

# Primeira chain: gera um resumo
resumo_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=['texto'],
        template='Resuma o seguinte texto: {texto}'
    ),
    output_key='resumo'
)

# Segunda chain: traduz o resumo
traducao_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=['resumo'],
        template='Traduza para inglês: {resumo}'
    ),
    output_key='traducao'
)

# Chain sequencial
chain_completa = SequentialChain(
    chains=[resumo_chain, traducao_chain],
    input_variables=['texto'],
    output_variables=['resumo', 'traducao']
)

Caso de Uso Avançado: Sistema de Q&A com Documentos

Aqui está um exemplo que uso frequentemente em workshops - um sistema que responde perguntas baseado em documentos próprios:

from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA

# 1. Carregando e processando documentos
loader = TextLoader('meu_documento.txt')
documents = loader.load()

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

# 3. Criando embeddings
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(texts, embeddings)

# 4. Criando o sistema de Q&A
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type='stuff',
    retriever=vectorstore.as_retriever(),
    return_source_documents=True
)

# 5. Fazendo perguntas
resultado = qa_chain({'query': 'Qual é o tema principal do documento?'})
print(f'Resposta: {resultado["result"]}')
print(f'Fontes: {len(resultado["source_documents"])} documentos consultados')

Agents: O Próximo Nível

Os agents são onde LangChain realmente brilha. Eles podem tomar decisões sobre quais ferramentas usar:

from langchain.agents import initialize_agent, Tool
from langchain.tools import DuckDuckGoSearchRun

# Definindo ferramentas
search = DuckDuckGoSearchRun()

tools = [
    Tool(
        name='Search',
        func=search.run,
        description='Útil para buscar informações atuais na internet'
    )
]

# Criando o agent
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent='zero-shot-react-description',
    verbose=True
)

# Testando
resultado = agent.run('Qual é a cotação atual do dólar?')

Boas Práticas que Aprendi na Prática

1. Gerenciamento de Custos

# Sempre monitore o uso
from langchain.callbacks import get_openai_callback

with get_openai_callback() as cb:
    resultado = chain.run('Sua pergunta aqui')
    print(f'Custo total: ${cb.total_cost}')
    print(f'Tokens usados: {cb.total_tokens}')

2. Tratamento de Erros

try:
    resultado = chain.run(input_data)
except Exception as e:
    print(f'Erro na execução: {e}')
    # Implementar fallback ou retry

3. Cache para Performance

from langchain.cache import InMemoryCache
import langchain

# Ativa cache em memória
langchain.llm_cache = InMemoryCache()

Integração com Outras Ferramentas do Ecossistema Python

Uma das coisas que mais aprecio no LangChain é como ele se integra naturalmente com ferramentas que já uso em análise de dados:

import pandas as pd
from langchain.agents import create_pandas_dataframe_agent

# Carregando dados
df = pd.read_csv('vendas.csv')

# Criando agent para DataFrame
agent = create_pandas_dataframe_agent(
    llm=llm,
    df=df,
    verbose=True
)

# Fazendo perguntas sobre os dados
resposta = agent.run('Qual foi o produto mais vendido no último trimestre?')

Casos de Uso Reais que Implementei

1. Assistente de Código SQL

Criei um sistema que gera consultas SQL baseadas em linguagem natural - muito útil para alunos iniciantes:

sql_template = ChatPromptTemplate.from_template(
    'Converta a seguinte pergunta em uma consulta SQL:
'
    'Pergunta: {pergunta}
'
    'Esquema da tabela: {esquema}

'
    'SQL:'
)

sql_chain = sql_template | llm | StrOutputParser()

2. Analisador de Feedback de Clientes

feedback_template = ChatPromptTemplate.from_template(
    'Analise o seguinte feedback e classifique:
'
    'Feedback: {feedback}

'
    'Forneça:
'
    '1. Sentimento (Positivo/Neutro/Negativo)
'
    '2. Principais temas mencionados
'
    '3. Ações sugeridas'
)

Monitoramento e Debugging

Uma lição importante que aprendi: sempre implemente observabilidade:

from langchain.callbacks import StdOutCallbackHandler

# Handler para debug
callback = StdOutCallbackHandler()

# Use em suas chains
resultado = chain.run(
    input_data,
    callbacks=[callback]
)

Performance e Otimização

Algumas dicas para otimizar suas aplicações LangChain:

  • Use streaming para respostas longas
  • Implemente cache para consultas repetidas
  • Ajuste a temperatura conforme a aplicação
  • Escolha o modelo certo para cada tarefa
# Exemplo de streaming
for chunk in llm.stream('Conte uma história longa'):
    print(chunk.content, end='', flush=True)

Próximos Passos e Recursos

Se você chegou até aqui, parabéns! Você já tem uma base sólida para começar a criar aplicações incríveis com LangChain. Aqui estão algumas sugestões para continuar sua jornada:

  1. Experimente diferentes modelos: Teste Anthropic, Cohere, ou modelos open-source via Hugging Face
  2. Explore LangSmith: Ferramenta oficial para monitoramento e debugging
  3. Estude RAG (Retrieval Augmented Generation): Técnica fundamental para aplicações corporativas
  4. Pratique com projetos reais: Comece pequeno e vá evoluindo

Conclusão: O Futuro das Aplicações de IA

Após implementar LangChain em diversos projetos, posso afirmar com certeza: esta ferramenta está democratizando o desenvolvimento de aplicações de IA. O que antes exigia equipes especializadas, hoje pode ser feito por qualquer desenvolvedor Python com curiosidade e dedicação.

Lembre-se: a chave do sucesso com LangChain é começar simples e ir evoluindo gradualmente. Cada chain que você constrói, cada agent que você treina, é um passo a mais na direção de aplicações verdadeiramente inteligentes.

Quer mergulhar mais fundo no mundo da análise de dados e IA? Confira nossos cursos na Data Driven School, onde ensinamos não apenas as ferramentas, mas como aplicá-las em cenários reais do mercado de trabalho.

E você, já teve alguma experiência com LangChain? Compartilhe nos comentários qual aplicação gostaria de construir!

Análise de Dados Python SQL