0Pricing
AI Agents · Aula

LCEL (linguagem de expressões do LangChain)

Componha objetos executáveis com o operador de canal “|”, utilize RunnablePassthrough e faça transmissões pela cadeia.

LCEL (linguagem de expressões do LangChain) é uma aula grátis de AI Agents no CoddyKit. Esta é a aula 3 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 Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

O que é LCEL?

LangChain Expression Language é a forma moderna de compor cadeias. Ela usa o operador de canalização | para encadear Runnables.

Ela substituiu as antigas classes "Chain" (LLMChain, SequentialChain), que agora são legadas.

A Basic LCEL Chain

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

prompt = ChatPromptTemplate.from_template('Translate {text} to French.')
model = ChatOpenAI(model='gpt-4o-mini')
parser = StrOutputParser()

chain = prompt | model | parser
print(chain.invoke({'text': 'Hello, world!'}))

RunnablePassthrough

Transmite a entrada sem alterações. É útil para manter dados junto a uma chamada de LLM:

from langchain_core.runnables import RunnablePassthrough

chain = (
    {'context': retriever, 'question': RunnablePassthrough()}
    | prompt
    | model
    | parser
)
chain.invoke('What is RAG?')

RunnableParallel

Executa vários Runnables em paralelo; as saídas tornam-se um dicionário:

from langchain_core.runnables import RunnableParallel

chain = RunnableParallel(
    summary=summary_prompt | model | parser,
    keywords=keywords_prompt | model | parser
) | merge_prompt | model | parser

result = chain.invoke({'text': '...'})

RunnableLambda

Envolva qualquer função Python em um Runnable:

from langchain_core.runnables import RunnableLambda

def uppercase(text: str) -> str:
    return text.upper()

chain = prompt | model | parser | RunnableLambda(uppercase)

Streaming Through LCEL

for chunk in chain.stream({'text': 'Hello'}):
    print(chunk, end='', flush=True)

Lote e execução assíncrona

Todo Runnable oferece suporte a batch, ainvoke, astream:

results = chain.batch([
    {'text': 'a'}, {'text': 'b'}, {'text': 'c'}
])
# All three run in parallel.

Esquemas

Adicione dicas de tipo — LCEL valida as entradas e saídas:

from pydantic import BaseModel

class Input(BaseModel):
    text: str

class Output(BaseModel):
    translation: str

chain = chain.with_types(input_type=Input, output_type=Output)

with_config e alternativas

Fixe o modelo, configure novas tentativas e adicione um modelo alternativo:

fast = ChatOpenAI(model='gpt-4o-mini')
big = ChatOpenAI(model='gpt-4o')

chain = prompt | fast.with_fallbacks([big]) | parser

with_retry

class Chain:
    def invoke(self, x):
        return f'processed: {x}'
    def with_retry(self, stop_after_attempt=3, wait_exponential_jitter=True):
        print(f'Chain will retry up to {stop_after_attempt} times with jittered backoff')
        return self

chain = Chain()
chain = chain.with_retry(stop_after_attempt=3, wait_exponential_jitter=True)
print(chain.invoke('input data'))

Criando uma cadeia RAG

Reunindo tudo:

rag_chain = (
    {'context': retriever | format_docs, 'question': RunnablePassthrough()}
    | rag_prompt
    | model
    | StrOutputParser()
)

def format_docs(docs):
    return '\n\n'.join(d.page_content for d in docs)

rag_chain.invoke('What is in the handbook?')

Depurando LCEL

Inspecione as etapas intermediárias:

chain.get_graph().print_ascii()

# Or run step-by-step:
for step in chain.stream_log({'text': '...'}):
    print(step)

Operador de canalização

Qual é a função de RunnablePassthrough no LCEL?

Recapitulação

LCEL é a base do LangChain moderno. Aprenda pipe, Parallel, Lambda e Passthrough para poder criar qualquer cadeia.

Perguntas Frequentes

A aula “LCEL (linguagem de expressões do LangChain)” é grátis?

Sim — o texto completo de “LCEL (linguagem de expressões do LangChain)” é 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 Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “LCEL (linguagem de expressões do LangChain)”?

Componha objetos executáveis com o operador de canal “|”, utilize RunnablePassthrough e faça transmissões pela cadeia. Você pratica AI Agents 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 Agents?

Nenhuma experiência prévia é necessária. AI Agents 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 3 de 4.

Quanto tempo leva a aula “LCEL (linguagem de expressões do LangChain)”?

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 Agents?

Sim. Cada aula de AI Agents 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: modelos, prompts, cadeias
  2. Carregadores, divisores e armazenamentos vetoriais
  3. LCEL (linguagem de expressões do LangChain)
  4. Construindo uma cadeia RAG de ponta a ponta
← Voltar para AI Agents