AI Engineering Academy · Pelajaran

Membangun Rantai dengan LCEL

Gunakan operator pipa untuk merangkai templat perintah, LLM, dan pengurai keluaran menjadi urutan Runnable, memanggilnya secara sinkron maupun asinkron, serta memeriksa keluaran antara.

Pelajaran 2 dari 413 langkah

Membangun Rantai dengan LCEL adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa Itu LCEL?

LCEL (LangChain Expression Language) adalah cara deklaratif untuk mengomposisikan komponen LangChain menjadi pipeline. Alih-alih membuat instance kelas Chain yang panjang, Anda menghubungkan Runnable dengan operator |. Rantai LCEL mendukung streaming, asinkron, pemrosesan batch, dan fallback secara otomatis—Anda mendapatkan semua kemampuan ini hanya dengan menggunakan sintaks pipa.

Rantai LCEL Pertama Anda

Rantai LCEL paling sederhana menggabungkan PromptTemplate, ChatModel, dan OutputParser. Setiap komponen merupakan Runnable, dan operator pipa menghubungkan semuanya. Saat Anda memanggil chain.invoke(), input mengalir melalui setiap langkah secara berurutan, dengan output setiap langkah menjadi input untuk langkah berikutnya.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template(
    'Write a product description for: {product}'
)
model = ChatOpenAI(model='gpt-4o-mini', temperature=0.7)
parser = StrOutputParser()

chain = prompt | model | parser

result = chain.invoke({'product': 'noise-cancelling headphones'})
print(result)

Memeriksa Internal Rantai

Rantai LCEL menampilkan strukturnya secara transparan. chain.steps mencantumkan komponen sesuai urutannya. Anda dapat memanggil chain.input_schema dan chain.output_schema untuk memeriksa tipe data yang masuk dan keluar. Pemanggilan invoke() juga menerima parameter config untuk meneruskan nama proses, tag, dan callback ke satu pemanggilan tanpa mengubah definisi rantai.

# Inspect chain structure
print('Steps:', chain.steps)
print('Input schema:', chain.input_schema.schema())
print('Output schema:', chain.output_schema.schema())

# Named run for observability
result = chain.invoke(
    {'product': 'coffee maker'},
    config={'run_name': 'product-desc-run', 'tags': ['production']}
)

Invoke Sinkron vs Asinkron

Rantai LCEL menyediakan versi sinkron dan asinkron untuk semua metode. invoke() memblokir thread pemanggil. ainvoke() adalah padanan asinkronnya dan sebaiknya digunakan dalam handler FastAPI serta konteks asinkron lainnya agar tidak memblokir event loop. Versi asinkron memiliki semantik yang sama—perbedaan antarmukanya hanya pada await.

import asyncio
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

chain = ChatPromptTemplate.from_template('Explain {topic}') | ChatOpenAI() | StrOutputParser()

async def main():
    # Async invocation
    result = await chain.ainvoke({'topic': 'quantum computing'})
    print(result)

asyncio.run(main())

Streaming Token Melalui Rantai

Rantai LCEL meneruskan streaming hingga ke seluruh bagian rantai. Panggil chain.stream() untuk menerima token saat dihasilkan oleh model. StrOutputParser memahami streaming dan meneruskan potongan string satu per satu, alih-alih menunggu respons lengkap. Dengan demikian, pengguna segera mendapatkan umpan balik, bukan jeda panjang yang diikuti jawaban lengkap.

chain = (
    ChatPromptTemplate.from_template('Tell me about {topic} in detail.')
    | ChatOpenAI(model='gpt-4o-mini')
    | StrOutputParser()
)

# Print each token as it arrives
for chunk in chain.stream({'topic': 'neural networks'}):
    print(chunk, end='', flush=True)
print()  # newline at end

# Async streaming
async def stream_async():
    async for chunk in chain.astream({'topic': 'transformers'}):
        print(chunk, end='', flush=True)

Pemrosesan Batch untuk Banyak Input

chain.batch() menerima daftar kamus input dan memprosesnya dengan konkurensi yang dapat dikonfigurasi. Secara internal, LangChain menjalankan pemanggilan dalam thread paralel, sehingga pemrosesan batch jauh lebih cepat daripada memanggil invoke() dalam perulangan. Parameter max_concurrency membatasi jumlah pemanggilan API paralel agar tetap dalam batas laju. Hasil dikembalikan dalam urutan yang sama seperti input.

products = [
    {'product': 'laptop'},
    {'product': 'tablet'},
    {'product': 'smartwatch'},
    {'product': 'earbuds'},
]

# Process all 4 concurrently
results = chain.batch(products, config={'max_concurrency': 4})

for product, description in zip(products, results):
    print(f'{product["product"]}: {description[:80]}...')

RunnablePassthrough dan RunnableLambda

RunnablePassthrough meneruskan input tanpa perubahan—berguna untuk meneruskan konteks asli bersama data yang telah diubah. RunnableLambda membungkus fungsi Python apa pun sebagai Runnable, sehingga Anda dapat menyisipkan logika arbitrer ke dalam rantai LCEL. Keduanya memungkinkan manipulasi data di antara langkah rantai tanpa menulis kelas Runnable khusus lengkap.

from langchain_core.runnables import RunnablePassthrough, RunnableLambda

def word_count(text: str) -> str:
    count = len(text.split())
    return f'{text}\n\n[Word count: {count}]'

chain = (
    ChatPromptTemplate.from_template('Write about {topic}')
    | ChatOpenAI(model='gpt-4o-mini')
    | StrOutputParser()
    | RunnableLambda(word_count)  # Add word count to output
)

result = chain.invoke({'topic': 'climate change'})
print(result)

Meneruskan Konteks Tambahan dengan RunnablePassthrough

Pola umum dalam RAG adalah meneruskan dokumen yang diambil dan pertanyaan pengguna ke prompt akhir. Gunakan RunnablePassthrough.assign() untuk menambahkan bidang hasil perhitungan ke kamus input tanpa kehilangan kunci asli. Dengan begitu, objek konteks diperkaya saat mengalir melalui rantai dan semua data tersedia bagi template prompt.

from langchain_core.runnables import RunnablePassthrough

# Fake retriever for illustration
def retrieve_docs(question: str):
    return ['Doc 1 content', 'Doc 2 content']

retriever = RunnableLambda(retrieve_docs)

rag_chain = (
    RunnablePassthrough.assign(context=retriever)  # adds 'context' key
    | ChatPromptTemplate.from_template(
        'Context: {context}\n\nAnswer: {question}'
    )
    | ChatOpenAI()
    | StrOutputParser()
)

result = rag_chain.invoke({'question': 'What is machine learning?'})

Menambahkan Fallback ke Rantai

Rantai LCEL mendukung fallback—rantai alternatif yang dicoba jika rantai utama menimbulkan pengecualian. Panggil chain.with_fallbacks([backup_chain]) untuk mendaftarkan satu atau beberapa rantai fallback. LangChain mencoba rantai utama terlebih dahulu, menangkap pengecualian apa pun, lalu mencoba setiap fallback sesuai urutan. Inilah cara standar untuk menangani gangguan penyedia atau kesalahan model dengan baik.

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

primary_chain = (
    ChatPromptTemplate.from_template('Answer: {question}')
    | ChatOpenAI(model='gpt-4o')
    | StrOutputParser()
)

fallback_chain = (
    ChatPromptTemplate.from_template('Answer: {question}')
    | ChatAnthropic(model='claude-3-haiku-20240307')
    | StrOutputParser()
)

robust_chain = primary_chain.with_fallbacks([fallback_chain])
# If OpenAI fails, automatically tries Anthropic

Men-debug dengan intermediate_steps

Men-debug rantai LCEL menjadi lebih mudah dengan config milik invoke() dan opsi verbose=True. Anda juga dapat menggunakan .with_config({'verbose': True}) pada rantai apa pun untuk mencatat input dan output setiap langkah. Untuk debugging terstruktur, bungkus rantai dengan set_verbose(True) secara global atau gunakan pelacakan LangSmith untuk merekam setiap nilai perantara dalam penjelajah jejak visual.

from langchain.globals import set_verbose, set_debug

# Verbose: logs LLM inputs/outputs
set_verbose(True)

# Debug: logs everything including prompts, parsers, and runnables
set_debug(True)

result = chain.invoke({'product': 'smart watch'})

# Or per-chain verbose config
chain_debug = chain.with_config({'verbose': True})
result = chain_debug.invoke({'product': 'laptop'})

Rantai yang Dapat Dikonfigurasi saat Runtime

Rantai LCEL mendukung konfigurasi runtime melalui ConfigurableField. Anda dapat mengekspos parameter model—temperature, nama model, max_tokens—sebagai opsi yang dapat dikonfigurasi tanpa menuliskannya secara tetap. Saat pemanggilan dilakukan, berikan config Configurable untuk mengganti nilai default. Dengan demikian, satu rantai dapat melayani banyak pengguna dengan pengaturan berbeda atau menguji konfigurasi model secara A/B.

from langchain_core.runnables import ConfigurableField

llm = ChatOpenAI(model='gpt-4o-mini').configurable_fields(
    temperature=ConfigurableField(
        id='temperature',
        name='LLM Temperature',
        description='Controls output creativity'
    )
)

chain = ChatPromptTemplate.from_template('Write about {topic}') | llm | StrOutputParser()

# Low temperature for factual output
factual = chain.invoke(
    {'topic': 'history of Rome'},
    config={'configurable': {'temperature': 0.0}}
)

Pemeriksaan Singkat

Uji pemahaman Anda tentang pembuatan rantai dengan LCEL.

Jawab di pelajaran interaktif

Rangkuman Pelajaran

Dalam pelajaran ini Anda telah mempelajari: komposisi pipa LCEL menghubungkan Runnable dengan | menjadi pipeline yang rapi dan mudah dibaca; RunnablePassthrough dan RunnableLambda memungkinkan Anda menyisipkan langkah manipulasi data tanpa meninggalkan paradigma LCEL; dan fallback membuat rantai lebih tangguh dengan otomatis mencoba rantai cadangan saat terjadi kegagalan. Selanjutnya, kita akan mempelajari percabangan dan rantai paralel untuk logika perutean yang lebih kompleks.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Rantai dengan LCEL” gratis?

Ya — teks lengkap “Membangun Rantai dengan LCEL” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun Rantai dengan LCEL”?

Gunakan operator pipa untuk merangkai templat perintah, LLM, dan pengurai keluaran menjadi urutan Runnable, memanggilnya secara sinkron maupun asinkron, serta memeriksa keluaran antara. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Membangun Rantai dengan LCEL” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke AI Engineering Academy