0Pricing
AI Agents · Lekcja

LCEL (LangChain Expression Language)

Łącz runnable za pomocą operatora potoku „|”, używaj RunnablePassthrough i strumieniuj dane przez łańcuch.

LCEL (LangChain Expression Language) to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Czym jest LCEL?

LangChain Expression Language to nowoczesny sposób komponowania łańcuchów. Wykorzystuje operator potoku | do łączenia obiektów Runnable.

Zastąpił stare klasy „Chain” (LLMChain, SequentialChain), które są obecnie uznawane za starsze rozwiązanie.

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

Przekazuje dane wejściowe bez zmian. Przydaje się do zachowania danych obok wywołania LLM:

from langchain_core.runnables import RunnablePassthrough

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

RunnableParallel

Uruchamia wiele obiektów Runnable równolegle, a ich wyniki tworzą słownik:

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

Opakowuje dowolną funkcję języka Python w obiekt 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)

Przetwarzanie wsadowe i asynchroniczne

Każdy obiekt Runnable obsługuje batch, ainvoke i astream:

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

Schematy

Dodaj adnotacje typów — LCEL sprawdza dane wejściowe i wyjściowe:

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 i mechanizmy awaryjne

Przypisz model, ustaw ponawianie prób i dodaj model awaryjny:

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

Budowanie łańcucha RAG

Połączmy wszystkie elementy:

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

Debugowanie LCEL

Sprawdzaj kroki pośrednie:

chain.get_graph().print_ascii()

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

Operator potoku

Jaka jest rola RunnablePassthrough w LCEL?

Podsumowanie

LCEL stanowi podstawę nowoczesnego LangChain. Poznaj Pipe, Parallel, Lambda i Passthrough, a będziesz w stanie budować dowolne łańcuchy.

Często zadawane pytania

Czy lekcja „LCEL (LangChain Expression Language)” jest bezpłatna?

Tak — pełny tekst „LCEL (LangChain Expression Language)” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.

Co nauczysz się w „LCEL (LangChain Expression Language)”?

Łącz runnable za pomocą operatora potoku „|”, używaj RunnablePassthrough i strumieniuj dane przez łańcuch. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Agents?

Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „LCEL (LangChain Expression Language)”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?

Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Architektura LangChain: modele, prompty, łańcuchy
  2. Loadery, splittery i magazyny wektorowe
  3. LCEL (LangChain Expression Language)
  4. Budowanie łańcucha RAG od początku do końca
← Powrót do AI Agents