LangChain: Seu 1º App com LLMs

Artigo atualizado em Setembro 2026: todo o código foi reescrito para o LangChain 1.x (testado com langchain 1.4, langchain-openai 1.6 e langchain-huggingface 1.2). Os imports que não existem mais (from langchain import OpenAI, HuggingFaceHub, langchain.chat_models.ChatOpenAI, ConversationChain, load_summarize_chain) foram trocados pelos atuais, e o modelo gpt-3.5-turbo (em descontinuação) virou gpt-6-luna.

Salve salve Pythonista

Desenvolver aplicações que utilizam Modelos de Linguagem de Grande Porte (LLMs) está se tornando cada vez mais popular.

Neste contexto, o LangChain surge como uma poderosa ferramenta para facilitar a criação de aplicações com LLMs usando Python.

Neste artigo, você aprenderá:

• O que é o LangChain
• Como instalá-lo e configurá-lo
• como conectar-se a diferentes provedores de LLMs como OpenAI e Hugging Face,
• Criar seu primeiro prompt simples
• Executar seu primeiro modelo de linguagem e, por fim
• Desenvolver um exemplo prático de um gerador de texto simples.

Se é novo e quer primeiro ler um artigo introdutório sobre o assunto, clique aqui e leia este outro artigo que escrevi sobre o LangChain (e depois volte pra cá )

Vá Direto ao Assunto…

• O que é LangChain
• Instalação e configuração do ambiente LangChain
• Conectando a um LLM: OpenAI, Hugging Face e mais.
• Criando seu primeiro prompt simples com LangChain
• Exemplo prático: um gerador de texto simples
• Mais Casos Práticos
• Boas Práticas

O que é LangChain

LangChain é uma biblioteca Python que facilita a integração e o gerenciamento de LLMs em aplicações.

Com o crescente uso de modelos de linguagem como os da família GPT, LangChain oferece abstrações que simplificam tarefas complexas, como gestão de prompts, manipulação de respostas e integração com diversas fontes de dados.

Utilizar LangChain com Python é vantajoso devido à flexibilidade da linguagem e à vasta comunidade de desenvolvedores que contribuem para seu ecossistema.

Além disso, LangChain é altamente compatível com outras bibliotecas populares de Python, tornando-o uma escolha ideal para desenvolvedores que buscam construir soluções robustas e escaláveis.

Instalação e configuração do ambiente LangChain

Para começar a usar o LangChain, primeiro instale-o no seu ambiente Python.

É recomendado utilizar um ambiente virtual para gerenciar as dependências do seu projeto.

Se não souber configurar um ambiente virtual, veja esse artigo completo sobre virtualenv!

1

pip install -U langchain langchain-openai

Desde o LangChain 1.0, cada provedor de modelos tem seu próprio pacote de integração: langchain-openai para a OpenAI, langchain-huggingface para a Hugging Face, e assim por diante.

Após a instalação, você precisa configurar as credenciais dos provedores de LLM que pretende utilizar.

Por exemplo, para usar a OpenAI, defina a variável de ambiente OPENAI_API_KEY com sua chave de API.

1

export OPENAI_API_KEY='sua-chave-api'

Isso garante que suas credenciais estejam seguras e acessíveis para o LangChain.

E adivinha só: também temos um artigo completo ensinando a integrar o ChatGPT ao seu código Python, é só clicar aqui e depois voltar pra cá

Conectando a um LLM: OpenAI, Hugging Face e mais.

LangChain suporta diversos provedores de LLMs, como OpenAI, Hugging Face e outros.

Vamos ver como se conectar a alguns deles.

Conectando-se à OpenAI

Para conectar-se à OpenAI, certifique-se de que sua chave de API está configurada.

Em seguida, utilize o seguinte código:

1
2
3
4
5

from langchain_openai import ChatOpenAI

modelo = ChatOpenAI(model="gpt-6-luna")  # lê a chave de OPENAI_API_KEY
resposta = modelo.invoke("Qual é a capital da França?")
print(resposta.text)

E a saída será algo como (a resposta exata do modelo varia):

1

A capital da França é Paris.

O ChatOpenAI devolve uma mensagem (AIMessage), não uma string; o texto fica em resposta.text. Sempre informe o model: o gpt-6-luna é o modelo mais econômico da família GPT-6 da OpenAI, e você pode trocá-lo por gpt-6-sol ou gpt-6-astra em tarefas mais difíceis.

Conectando-se à Hugging Face

Para usar modelos da Hugging Face, instale o pacote de integração e configure seu token de acesso da Hugging Face na variável de ambiente HUGGINGFACEHUB_API_TOKEN.

1
2

pip install -U langchain-huggingface
export HUGGINGFACEHUB_API_TOKEN='seu-token'

1
2
3
4
5
6
7
8
9
10
11

from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint

llm = HuggingFaceEndpoint(
    repo_id="deepseek-ai/DeepSeek-R1-0528",
    task="text-generation",
    max_new_tokens=512,
    provider="auto",  # deixa a Hugging Face escolher o provedor de inferência
)
modelo = ChatHuggingFace(llm=llm)
resposta = modelo.invoke("Explique a teoria da relatividade.")
print(resposta.text)

O repo_id é o nome do modelo no Hub da Hugging Face (usamos o mesmo do exemplo da documentação do LangChain); nem todo modelo do Hub está disponível para inferência remota, então confira na página do modelo. Como o DeepSeek-R1 é um modelo de raciocínio, a resposta pode vir acompanhada do “pensamento” do modelo antes do texto final.

E a saída será algo similar a:

1
2

A teoria da relatividade, desenvolvida por Albert Einstein, descreve a interação entre
espaço e tempo e como a gravidade afeta essa interação.

Outros Provedores

Além de OpenAI e Hugging Face, LangChain suporta outros provedores como Cohere, AI21, entre outros.

A conexão segue um padrão similar, onde você inicializa o modelo com as credenciais apropriadas e utiliza os métodos disponíveis para interagir com ele.

Quer ver o LangChain em ação? O Ebookr.ai é um exemplo real de aplicação construída com LLMs e LangChain. Ele gera ebooks profissionais sobre qualquer tema, com capa gerada por IA, infográficos e revisão automática - tudo usando as mesmas técnicas que você está aprendendo aqui. Confere!

Criando seu primeiro prompt simples com LangChain

Agora que conectamos ao LLM, vamos criar um prompt simples para obter uma resposta.

1
2
3
4
5
6

from langchain_openai import ChatOpenAI

modelo = ChatOpenAI(model="gpt-6-luna")
prompt_simples = "Escreva uma breve introdução sobre Python."
resposta = modelo.invoke(prompt_simples)
print(resposta.text)

E a saída será algo como:

1
2

Python é uma linguagem de programação versátil e poderosa, amplamente utilizada para
desenvolvimento web, análise de dados, automação e inteligência artificial.

Explicação do código:

1. Importação: Importamos a classe ChatOpenAI do pacote langchain-openai.
2. Inicialização do Modelo: Criamos uma instância do modelo; a chave de API vem da variável de ambiente OPENAI_API_KEY.
3. Definição do Prompt: Especificamos o prompt que queremos enviar ao modelo.
4. Obtenção da Resposta: Chamamos modelo.invoke() com o prompt e recebemos a resposta.
5. Exibição da Resposta: Imprimimos o texto da resposta (resposta.text).

Exemplo prático: um gerador de texto simples

Vamos aplicar o que aprendemos para criar um gerador de texto simples que cria descrições de produtos.

1
2
3
4
5
6
7
8
9
10
11
12
13

from langchain_openai import ChatOpenAI

def gerar_descricao(produto, características):
    modelo = ChatOpenAI(model="gpt-6-luna")
    prompt = f"Crie uma descrição atraente para um produto chamado '{produto}' com as seguintes características: {características}."
    descricao = modelo.invoke(prompt)
    return descricao.text

# Exemplo de uso
produto = "Smartwatch XYZ"
características = "monitor de frequência cardíaca, GPS integrado, bateria com duração de 7 dias"
descricao = gerar_descricao(produto, características)
print(descricao)

E a saída será algo como (cada execução gera um texto diferente):

1
2
3

O Smartwatch XYZ combina estilo e funcionalidade, oferecendo monitoramento preciso da frequência cardíaca,
GPS integrado para rastreamento fácil de suas atividades e uma bateria que dura até 7 dias, garantindo
que você esteja sempre conectado.

Explicação do código:

1. Definição da Função: Criamos uma função gerar_descricao que recebe o nome do produto e suas características.
2. Inicialização do Modelo: Dentro da função, inicializamos o modelo da OpenAI (a chave vem de OPENAI_API_KEY).
3. Criação do Prompt: Montamos um prompt que solicita a criação de uma descrição baseada nas características fornecidas.
4. Execução do Modelo: Passamos o prompt para modelo.invoke() e recebemos a descrição.
5. Retorno da Descrição: A função retorna o texto da descrição gerada (descricao.text).
6. Uso da Função: Demonstramos como usar a função com um exemplo de produto.

A descrição gerada será uma narrativa atraente destacando as características do produto, pronta para uso em estratégias de marketing.

Esses casos práticos com LangChain só saem do papel com Python bem dominado por trás - é essa base, do zero ao avançado, que a Jornada Python ensina:

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!

Mais Casos Práticos

1. Chatbot com Memória

No LangChain 1.x, ConversationChain e ConversationBufferMemory saíram do pacote principal. A forma recomendada é um agente (create_agent) com um checkpointer, que guarda o histórico de cada conversa pelo 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

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

def criar_chatbot():
    """Chatbot que lembra do contexto da conversa"""
    llm = ChatOpenAI(model="gpt-6-luna")
    return create_agent(
        model=llm,
        tools=[],
        system_prompt="Você é um assistente simpático.",
        checkpointer=InMemorySaver(),  # memória em RAM
    )

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

# Uso
bot = criar_chatbot()
print(conversar(bot, "Olá, meu nome é Maria"))
print(conversar(bot, "Qual é meu nome?"))  # Lembra que é Maria!

2. Sumarizador de Textos Longos

A antiga load_summarize_chain foi para o pacote de legado langchain-classic. A mesma estratégia map-reduce (resumir cada pedaço e depois juntar os resumos) cabe em poucas linhas com as peças atuais:

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

from langchain_openai import ChatOpenAI
from langchain_text_splitters import RecursiveCharacterTextSplitter

def sumarizar_texto_longo(texto):
    """Sumariza textos que excedem limite de tokens"""
    # Dividir texto em chunks
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=2000,
        chunk_overlap=200
    )
    pedacos = text_splitter.split_text(texto)

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

    # Map: resume cada pedaço (batch envia as chamadas em paralelo)
    resumos = llm.batch(
        [f"Resuma o trecho abaixo em poucas frases:\n\n{p}" for p in pedacos]
    )

    # Reduce: junta os resumos parciais em um resumo final
    parciais = "\n\n".join(r.text for r in resumos)
    final = llm.invoke(f"Combine os resumos abaixo em um único resumo coeso:\n\n{parciais}")
    return final.text

# Uso
artigo_longo = """... texto muito longo ..."""
resumo = sumarizar_texto_longo(artigo_longo)
print(resumo)

3. Validador de Dados com LLM

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

from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field, field_validator

class Endereco(BaseModel):
    rua: str
    numero: int
    cidade: str
    estado: str = Field(description="Sigla do estado, ex.: SP")
    cep: str = Field(description="Somente os 8 dígitos do CEP")

    @field_validator("cep")
    @classmethod
    def validar_cep(cls, v):
        if len(v) != 8 or not v.isdigit():
            raise ValueError("CEP deve ter 8 dígitos")
        return v

def extrair_endereco(texto_livre):
    """Extrai endereço estruturado de texto livre"""
    llm = ChatOpenAI(model="gpt-6-luna")
    # O modelo responde já no formato do Endereco; o Pydantic valida o resultado
    llm_estruturado = llm.with_structured_output(Endereco)
    return llm_estruturado.invoke(f"Extraia o endereço deste texto: {texto_livre}")

# Uso
texto = "Moro na Rua das Flores, número 123, São Paulo, SP, CEP 01234567"
endereco = extrair_endereco(texto)
print(f"Cidade: {endereco.cidade}, Estado: {endereco.estado}")

O with_structured_output é a forma recomendada pela documentação do LangChain para obter respostas estruturadas: ele usa o recurso de structured output da própria API da OpenAI, então você não precisa colar instruções de formato no prompt nem fazer o parse manual. Se o modelo devolver um CEP inválido, o field_validator (sintaxe do Pydantic v2) levanta um erro de validação.

Boas Práticas

1. Controle de Custos

1
2
3
4
5
6
7
8

from langchain_core.callbacks import get_usage_metadata_callback
from langchain_openai import ChatOpenAI

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

with get_usage_metadata_callback() as cb:
    result = llm.invoke("Sua pergunta")
    print(cb.usage_metadata)  # tokens de entrada, saída e total, por modelo

A API cobra por token; multiplique os valores pelos preços da página de preços da OpenAI para estimar o custo. O antigo get_openai_callback (que também mostrava o custo em dólares) vinha do langchain-community, pacote descontinuado em 2026.

2. Tratamento de Erros

O ChatOpenAI já refaz automaticamente as chamadas que falham por erros temporários (parâmetro max_retries; sem configurar, vale o padrão do SDK da OpenAI, que são 2 novas tentativas). Se quiser controlar a espera entre as tentativas, desligue esse retry e use a biblioteca tenacity (pip install tenacity):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import openai
from langchain_openai import ChatOpenAI
from tenacity import retry, stop_after_attempt, wait_exponential

llm = ChatOpenAI(model="gpt-6-luna", max_retries=0)

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=4, max=10)
)
def call_llm_with_retry(prompt):
    try:
        return llm.invoke(prompt).text
    except openai.RateLimitError:
        print("⚠️ Rate limit atingido, tentando novamente...")
        raise
    except Exception as e:
        print(f"❌ Erro: {e}")
        raise

3. Usar Streaming para Respostas Longas

1
2
3
4
5
6
7
8

from langchain_openai import ChatOpenAI

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

# Exibe resposta em tempo real
for chunk in llm.stream("Escreva um artigo sobre IA"):
    print(chunk.text, end="", flush=True)
# O texto aparece aos pedaços na tela, conforme é gerado!

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

Conclusão

Neste guia sobre Seu Primeiro App com LLMs, você aprendeu:

✅ Setup básico - Instalação e configuração LangChain
✅ Primeiro prompt - OpenAI e Hugging Face
✅ Casos práticos - Chatbot, sumarizador, validador
✅ Boas práticas - Custos, erros, streaming
✅ Gerador de texto - App completo passo a passo
✅ Memória - Chatbot que lembra contexto

Principais lições:

• LangChain simplifica integração com LLMs
• Monitore custos com callbacks
• Use retry para lidar com rate limits
• Streaming melhora UX em respostas longas
• Pydantic para estruturar dados

Próximos passos:

• Explore LangChain conceitos
• Aprenda Prompts avançados
• Integre ChatGPT em apps
• Estude sobre RAG e embeddings

Quer praticar Python e construir projetos completos, do zero ao avançado? Conheça a Jornada Python, nosso curso de Python completo.

Por Vinícius Ramos em 05/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:

• 
• 
•