0Pricing
AI Agents · Lektion

LCEL (LangChain Expression Language)

Verknüpfen Sie Runnables mit dem Pipe-Operator „|“, verwenden Sie RunnablePassthrough und streamen Sie über die Chain.

LCEL (LangChain Expression Language) ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Was ist LCEL?

LangChain Expression Language ist die moderne Methode, Chains zusammenzusetzen. Sie verwendet den Pipe-Operator |, um Runnables zu verketten.

Sie ersetzt die alten „Chain“-Klassen (LLMChain, SequentialChain), die inzwischen veraltet sind.

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

Gibt die Eingabe unverändert weiter. Das ist nützlich, wenn Daten neben einem LLM-Aufruf erhalten bleiben sollen:

from langchain_core.runnables import RunnablePassthrough

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

RunnableParallel

Führen Sie mehrere Runnables parallel aus; ihre Ausgaben werden zu einem 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

Verpacken Sie eine beliebige Python-Funktion in ein 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 und asynchrone Ausführung

Jedes Runnable unterstützt batch, ainvoke und astream:

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

Schemas

Fügen Sie Typannotationen hinzu — LCEL validiert Eingaben und Ausgaben:

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 und Fallbacks

Legen Sie das Modell fest, konfigurieren Sie Wiederholungsversuche und fügen Sie ein Fallback-Modell hinzu:

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

Eine RAG-Chain erstellen

Alles zusammenfügen:

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

LCEL debuggen

Untersuchen Sie die Zwischenschritte:

chain.get_graph().print_ascii()

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

Pipe-Operator

Welche Rolle spielt RunnablePassthrough in LCEL?

Zusammenfassung

LCEL bildet die Grundlage des modernen LangChain. Wenn Sie Pipe, Parallel, Lambda und Passthrough beherrschen, können Sie jede Chain erstellen.

Häufig gestellte Fragen

Ist die Lektion „LCEL (LangChain Expression Language)“ kostenlos?

Ja — der vollständige Text von „LCEL (LangChain Expression Language)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „LCEL (LangChain Expression Language)“?

Verknüpfen Sie Runnables mit dem Pipe-Operator „|“, verwenden Sie RunnablePassthrough und streamen Sie über die Chain. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „LCEL (LangChain Expression Language)“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. LangChain-Architektur: Modelle, Prompts, Chains
  2. Loader, Splitter und Vektorspeicher
  3. LCEL (LangChain Expression Language)
  4. Eine RAG-Chain von Anfang bis Ende erstellen
← Zurück zu AI Agents