0Pricing
AI Agents · Lezione

LCEL (LangChain Expression Language)

Componga runnable con l'operatore pipe '|', utilizzi RunnablePassthrough e trasmetta i risultati in streaming attraverso la chain.

LCEL (LangChain Expression Language) è una lezione AI Agents gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Agents, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Agents include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

Che cos'è LCEL?

LangChain Expression Language è il modo moderno di comporre le chain. Usa l'operatore pipe | per concatenare i Runnable.

Ha sostituito le vecchie classi «Chain» (LLMChain, SequentialChain), che ora sono legacy.

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

Propaga l'input senza modificarlo. È utile per mantenere i dati insieme alla chiamata all'LLM:

from langchain_core.runnables import RunnablePassthrough

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

RunnableParallel

Esegue più Runnable in parallelo; i relativi output diventano un dict:

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

Racchiude qualsiasi funzione Python in un 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)

Batch e asincronia

Ogni Runnable supporta batch, ainvoke, astream:

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

Schemi

Aggiungi i suggerimenti sui tipi: LCEL convalida input e output:

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 fallback

Fissa il modello, imposta i retry e aggiungi un modello di fallback:

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'))

Creazione di una chain RAG

Mettiamo insieme tutti gli elementi:

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?')

Debug di LCEL

Esamina i passaggi intermedi:

chain.get_graph().print_ascii()

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

Operatore pipe

Qual è il ruolo di RunnablePassthrough in LCEL?

Riepilogo

LCEL è la base del LangChain moderno. Impara a usare pipe, Parallel, Lambda e Passthrough e potrai creare qualsiasi chain.

Domande Frequenti

La lezione «LCEL (LangChain Expression Language)» è gratuita?

Sì — il testo completo di «LCEL (LangChain Expression Language)» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Agents, passa a CoddyKit PRO. Il corso AI Agents include 4 lezioni in totale.

Cosa imparerò in «LCEL (LangChain Expression Language)»?

Componga runnable con l'operatore pipe '|', utilizzi RunnablePassthrough e trasmetta i risultati in streaming attraverso la chain. Eserciti AI Agents con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Agents?

Non è richiesta alcuna esperienza precedente. AI Agents su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «LCEL (LangChain Expression Language)»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Agents?

Sì. Ogni lezione AI Agents include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Architettura di LangChain: modelli, prompt e chain
  2. Loader, splitter e vector store
  3. LCEL (LangChain Expression Language)
  4. Creare una chain RAG dall'inizio alla fine
← Torna a AI Agents