0Pricing
AI Engineering Academy · Aula

Criando cadeias com LCEL

Use o operador de barra vertical para encadear um modelo de prompt, um LLM e um analisador de saída em uma sequência Runnable, invoque-a de forma síncrona e assíncrona e inspecione as saídas intermediárias.

Criando cadeias com LCEL é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.

O que é LCEL?

LCEL (LangChain Expression Language) é a forma declarativa de combinar componentes do LangChain em pipelines. Em vez de instanciar classes de cadeia verbosas, conecte componentes executáveis com o operador |. As cadeias LCEL oferecem transmissão, execução assíncrona, processamento em lote e alternativas automáticas — basta usar a sintaxe de tubo para obter todos esses recursos.

Sua primeira cadeia LCEL

A cadeia LCEL mais simples combina um PromptTemplate, um ChatModel e um OutputParser. Cada componente é um componente executável, e o operador de tubo os conecta. Quando chama chain.invoke(), a entrada passa por cada etapa em sequência, e a saída de cada uma se torna a entrada da próxima.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template(
    'Write a product description for: {product}'
)
model = ChatOpenAI(model='gpt-4o-mini', temperature=0.7)
parser = StrOutputParser()

chain = prompt | model | parser

result = chain.invoke({'product': 'noise-cancelling headphones'})
print(result)

Inspecionando os detalhes internos da cadeia

As cadeias LCEL expõem sua estrutura de forma transparente. chain.steps lista os componentes na ordem em que aparecem. Pode chamar chain.input_schema e chain.output_schema para inspecionar quais tipos entram e saem. A chamada invoke() também aceita um parâmetro config para passar nomes de execução, etiquetas e callbacks a uma única invocação sem alterar a definição da cadeia.

# Inspect chain structure
print('Steps:', chain.steps)
print('Input schema:', chain.input_schema.schema())
print('Output schema:', chain.output_schema.schema())

# Named run for observability
result = chain.invoke(
    {'product': 'coffee maker'},
    config={'run_name': 'product-desc-run', 'tags': ['production']}
)

Invoke síncrono versus assíncrono

As cadeias LCEL oferecem versões síncronas e assíncronas de todos os métodos. invoke() bloqueia a thread que faz a chamada. ainvoke() é a versão assíncrona equivalente e deve ser usado em manipuladores do FastAPI e em outros contextos assíncronos para evitar o bloqueio do loop de eventos. A versão assíncrona tem semântica idêntica — a única diferença na interface é await.

import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

chain = ChatPromptTemplate.from_template('Explain {topic}') | ChatOpenAI() | StrOutputParser()

async def main():
    # Async invocation
    result = await chain.ainvoke({'topic': 'quantum computing'})
    print(result)

asyncio.run(main())

Transmitindo tokens pela cadeia

As cadeias LCEL propagam a transmissão por todo o percurso. Chame chain.stream() para receber os tokens à medida que são gerados pelo modelo. O StrOutputParser reconhece transmissões e encaminha trechos individuais de string em vez de esperar a resposta completa. Isso oferece feedback imediato aos usuários, em vez de uma longa pausa seguida da resposta completa.

chain = (
    ChatPromptTemplate.from_template('Tell me about {topic} in detail.')
    | ChatOpenAI(model='gpt-4o-mini')
    | StrOutputParser()
)

# Print each token as it arrives
for chunk in chain.stream({'topic': 'neural networks'}):
    print(chunk, end='', flush=True)
print()  # newline at end

# Async streaming
async def stream_async():
    async for chunk in chain.astream({'topic': 'transformers'}):
        print(chunk, end='', flush=True)

Processamento em lote de várias entradas

chain.batch() aceita uma lista de dicionários de entrada e os processa com simultaneidade configurável. Internamente, o LangChain executa as chamadas em threads paralelas, tornando o processamento em lote muito mais rápido do que chamar invoke() em um loop. O parâmetro max_concurrency limita as chamadas de API paralelas para respeitar os limites de frequência. Os resultados retornam na mesma ordem das entradas.

products = [
    {'product': 'laptop'},
    {'product': 'tablet'},
    {'product': 'smartwatch'},
    {'product': 'earbuds'},
]

# Process all 4 concurrently
results = chain.batch(products, config={'max_concurrency': 4})

for product, description in zip(products, results):
    print(f'{product["product"]}: {description[:80]}...')

RunnablePassthrough e RunnableLambda

RunnablePassthrough encaminha sua entrada sem alterações — útil para passar o contexto original junto com dados transformados. RunnableLambda encapsula qualquer função Python como um componente executável, permitindo inserir lógica arbitrária em uma cadeia LCEL. Juntos, eles permitem manipular dados entre as etapas da cadeia sem escrever uma classe completa de componente executável personalizado.

from langchain_core.runnables import RunnablePassthrough, RunnableLambda

def word_count(text: str) -> str:
    count = len(text.split())
    return f'{text}\n\n[Word count: {count}]'

chain = (
    ChatPromptTemplate.from_template('Write about {topic}')
    | ChatOpenAI(model='gpt-4o-mini')
    | StrOutputParser()
    | RunnableLambda(word_count)  # Add word count to output
)

result = chain.invoke({'topic': 'climate change'})
print(result)

Passando contexto adicional com RunnablePassthrough

Um padrão comum em RAG é passar tanto os documentos recuperados quanto a pergunta do usuário ao prompt final. Use RunnablePassthrough.assign() para adicionar campos calculados ao dicionário de entrada sem perder as chaves originais. Isso enriquece o objeto de contexto à medida que ele percorre a cadeia, deixando todos os dados disponíveis para o modelo de prompt.

from langchain_core.runnables import RunnablePassthrough

# Fake retriever for illustration
def retrieve_docs(question: str):
    return ['Doc 1 content', 'Doc 2 content']

retriever = RunnableLambda(retrieve_docs)

rag_chain = (
    RunnablePassthrough.assign(context=retriever)  # adds 'context' key
    | ChatPromptTemplate.from_template(
        'Context: {context}\n\nAnswer: {question}'
    )
    | ChatOpenAI()
    | StrOutputParser()
)

result = rag_chain.invoke({'question': 'What is machine learning?'})

Adicionando alternativas às cadeias

As cadeias LCEL aceitam alternativas — cadeias substitutas a serem tentadas caso a cadeia principal lance uma exceção. Chame chain.with_fallbacks([backup_chain]) para registrar uma ou mais cadeias alternativas. O LangChain tenta primeiro a cadeia principal, captura qualquer exceção e depois tenta cada alternativa na ordem. Essa é a forma padrão de lidar adequadamente com indisponibilidade de provedores ou erros de modelo.

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

primary_chain = (
    ChatPromptTemplate.from_template('Answer: {question}')
    | ChatOpenAI(model='gpt-4o')
    | StrOutputParser()
)

fallback_chain = (
    ChatPromptTemplate.from_template('Answer: {question}')
    | ChatAnthropic(model='claude-3-haiku-20240307')
    | StrOutputParser()
)

robust_chain = primary_chain.with_fallbacks([fallback_chain])
# If OpenAI fails, automatically tries Anthropic

Depurando com intermediate_steps

Depurar cadeias LCEL é mais fácil com a configuração de invoke() e a opção verbose=True. Também pode usar .with_config({'verbose': True}) em qualquer cadeia para registrar a entrada e a saída de cada etapa. Para uma depuração estruturada, envolva globalmente a cadeia com set_verbose(True) ou use o rastreamento do LangSmith para capturar cada valor intermediário em um explorador visual de rastreamentos.

from langchain.globals import set_verbose, set_debug

# Verbose: logs LLM inputs/outputs
set_verbose(True)

# Debug: logs everything including prompts, parsers, and runnables
set_debug(True)

result = chain.invoke({'product': 'smart watch'})

# Or per-chain verbose config
chain_debug = chain.with_config({'verbose': True})
result = chain_debug.invoke({'product': 'laptop'})

Cadeias configuráveis durante a execução

As cadeias LCEL aceitam configuração durante a execução por meio de ConfigurableField. Pode expor parâmetros do modelo — temperatura, nome do modelo e max_tokens — como opções configuráveis, sem defini-los permanentemente no código. No momento da invocação, passe uma configuração Configurable para substituir os valores padrão. Isso permite que uma única cadeia atenda a vários usuários com configurações diferentes ou teste configurações de modelo em um experimento A/B.

from langchain_core.runnables import ConfigurableField

llm = ChatOpenAI(model='gpt-4o-mini').configurable_fields(
    temperature=ConfigurableField(
        id='temperature',
        name='LLM Temperature',
        description='Controls output creativity'
    )
)

chain = ChatPromptTemplate.from_template('Write about {topic}') | llm | StrOutputParser()

# Low temperature for factual output
factual = chain.invoke(
    {'topic': 'history of Rome'},
    config={'configurable': {'temperature': 0.0}}
)

Verificação rápida

Teste sua compreensão sobre a construção de cadeias com LCEL.

Recapitulação da lição

Nesta lição, você aprendeu que a composição de tubos da LCEL conecta componentes executáveis com | em pipelines limpos e fáceis de ler; RunnablePassthrough e RunnableLambda permitem inserir etapas de manipulação de dados sem sair do paradigma LCEL; e as alternativas tornam as cadeias resilientes ao tentarem automaticamente cadeias substitutas em caso de falha. A seguir, exploraremos cadeias com ramificações e paralelas para uma lógica de roteamento mais complexa.

Perguntas Frequentes

A aula “Criando cadeias com LCEL” é grátis?

Sim — o texto completo de “Criando cadeias com LCEL” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.

O que vou aprender em “Criando cadeias com LCEL”?

Use o operador de barra vertical para encadear um modelo de prompt, um LLM e um analisador de saída em uma sequência Runnable, invoque-a de forma síncrona e assíncrona e inspecione as saídas intermed… Você pratica AI Engineering Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Engineering Academy?

Nenhuma experiência prévia é necessária. AI Engineering Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Criando cadeias com LCEL”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Engineering Academy?

Sim. Cada aula de AI Engineering Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Arquitetura do LangChain e abstrações principais
  2. Criando cadeias com LCEL
  3. Cadeias ramificadas e paralelas
  4. Transmitindo a saída em LangChain
← Voltar para AI Engineering Academy