LCEL (LangChain Expression Language)
Componga runnables con el operador de tubería «|», use RunnablePassthrough y transmita datos por la cadena.
LCEL (LangChain Expression Language) es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
¿Qué es LCEL?
LangChain Expression Language es la forma moderna de componer cadenas. Usa el operador pipe | para encadenar Runnables.
Reemplazó las antiguas clases "Chain" (LLMChain, SequentialChain), que ahora son heredadas.
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
Pasa la entrada sin cambios. Es útil para conservar los datos junto con una llamada al LLM:
from langchain_core.runnables import RunnablePassthrough
chain = (
{'context': retriever, 'question': RunnablePassthrough()}
| prompt
| model
| parser
)
chain.invoke('What is RAG?')RunnableParallel
Ejecuta varios Runnables en paralelo; sus salidas se convierten en un diccionario:
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
Envuelva cualquier función de Python en 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)Procesamiento por lotes y asincronía
Cada Runnable admite batch, ainvoke y astream:
results = chain.batch([
{'text': 'a'}, {'text': 'b'}, {'text': 'c'}
])
# All three run in parallel.Esquemas
Añada sugerencias de tipos; LCEL valida las entradas y salidas:
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 y alternativas
Fije el modelo, establezca reintentos y añada un modelo alternativo:
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'))Construcción de una cadena RAG
Reuniéndolo todo:
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?')Depuración de LCEL
Inspeccione los pasos intermedios:
chain.get_graph().print_ascii()
# Or run step-by-step:
for step in chain.stream_log({'text': '...'}):
print(step)Operador pipe
¿Cuál es la función de RunnablePassthrough en LCEL?
Repaso
LCEL es la base del LangChain moderno. Aprenda pipe, Parallel, Lambda y Passthrough, y podrá construir cualquier cadena.
Preguntas frecuentes
¿La lección «LCEL (LangChain Expression Language)» es gratis?
Sí — el texto completo de «LCEL (LangChain Expression Language)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.
¿Qué aprenderé en «LCEL (LangChain Expression Language)»?
Componga runnables con el operador de tubería «|», use RunnablePassthrough y transmita datos por la cadena. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Agents?
No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «LCEL (LangChain Expression Language)»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Agents?
Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Arquitectura de LangChain: modelos, prompts y cadenas
- Cargadores, divisores y almacenes vectoriales
- LCEL (LangChain Expression Language)
- Crear una cadena RAG de principio a fin