LCEL (langage d’expressions de LangChain)
Composez des exécutables avec l’opérateur tube « | », utilisez RunnablePassthrough et diffusez les résultats dans la chaîne.
LCEL (langage d’expressions de LangChain) est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Qu’est-ce que LCEL ?
Le langage d’expressions LangChain est la méthode moderne pour composer des chaînes. Il utilise l’opérateur de canalisation | pour enchaîner les éléments exécutables.
Il a remplacé les anciennes classes « Chain » (LLMChain, SequentialChain), désormais obsolètes.
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
Faites passer l’entrée sans la modifier. C’est utile pour conserver des données parallèlement à un appel de LLM :
from langchain_core.runnables import RunnablePassthrough
chain = (
{'context': retriever, 'question': RunnablePassthrough()}
| prompt
| model
| parser
)
chain.invoke('What is RAG?')RunnableParallel
Exécutez plusieurs éléments exécutables en parallèle ; leurs sorties deviennent un dictionnaire :
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
Enveloppez n’importe quelle fonction Python dans un élément exécutable :
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)Traitement par lots et asynchrone
Chaque élément exécutable prend en charge batch, ainvoke et astream :
results = chain.batch([
{'text': 'a'}, {'text': 'b'}, {'text': 'c'}
])
# All three run in parallel.Schémas
Ajoutez des indications de type : LCEL valide les entrées et les sorties :
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 et solutions de repli
Épinglez le modèle, définissez les nouvelles tentatives et ajoutez un modèle de repli :
fast = ChatOpenAI(model='gpt-4o-mini')
big = ChatOpenAI(model='gpt-4o')
chain = prompt | fast.with_fallbacks([big]) | parserwith_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'))Construire une chaîne RAG
Assemblons le tout :
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?')Déboguer LCEL
Inspectez les étapes intermédiaires :
chain.get_graph().print_ascii()
# Or run step-by-step:
for step in chain.stream_log({'text': '...'}):
print(step)Opérateur de canalisation
Quel est le rôle de RunnablePassthrough dans LCEL ?
Récapitulatif
LCEL est le fondement du LangChain moderne. Apprenez la canalisation, le parallélisme, les fonctions lambda et le passage direct, et vous pourrez construire n’importe quelle chaîne.
Questions Fréquemment Posées
La leçon « LCEL (langage d’expressions de LangChain) » est-elle gratuite ?
Oui — le texte complet de « LCEL (langage d’expressions de LangChain) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « LCEL (langage d’expressions de LangChain) » ?
Composez des exécutables avec l’opérateur tube « | », utilisez RunnablePassthrough et diffusez les résultats dans la chaîne. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Agents ?
Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « LCEL (langage d’expressions de LangChain) » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?
Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Architecture de LangChain : modèles, prompts et chaînes
- Chargeurs, découpeurs et stockages vectoriels
- LCEL (langage d’expressions de LangChain)
- Construire une chaîne RAG de bout en bout