0Pricing
AI Engineering Academy · Ders

LCEL ile Zincirler Oluşturma

Bir istem şablonunu, LLM'yi ve çıktı ayrıştırıcısını bir Runnable dizisinde zincirlemek için boru işleçini kullanın; diziyi eş zamanlı ve eş zamansız olarak çağırıp ara çıktıları inceleyin.

LCEL ile Zincirler Oluşturma, CoddyKit'te ücretsiz bir AI Engineering Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, AI Engineering Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. AI Engineering Academy kursu toplamda 4 dersten oluşur.

LCEL Nedir?

LCEL (LangChain Expression Language), LangChain bileşenlerini işlem hatlarında birleştirmenin bildirimsel yoludur. Ayrıntılı Chain sınıflarını örneklemek yerine Runnable'ları | işleciyle bağlarsınız. LCEL zincirleri akışı, eşzamansız çalışmayı, toplu işlemeyi ve geri dönüşleri otomatik olarak destekler; yalnızca boru sözdizimini kullanarak tüm bu özellikleri elde edersiniz.

İlk LCEL Zinciriniz

En basit LCEL zinciri bir PromptTemplate, bir ChatModel ve bir OutputParser'ı birleştirir. Her bileşen bir Runnable'dır ve boru işleci bunları birbirine bağlar. chain.invoke() çağrıldığında girdi her adımdan sırayla geçer; her adımın çıktısı bir sonrakinin girdisi olur.

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)

Zincirin İç Yapısını İnceleme

LCEL zincirleri yapılarını şeffaf biçimde sunar. chain.steps, bileşenleri sırayla listeler. Girdiden ve çıktıya hangi türlerin aktığını incelemek için chain.input_schema ve chain.output_schema çağrılarını kullanabilirsiniz. invoke() çağrısı ayrıca, zincir tanımını değiştirmeden tek bir çağrıya çalıştırma adlarını, etiketleri ve geri çağrıları aktarmak için bir config parametresi kabul eder.

# 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']}
)

Eşzamanlı ve Eşzamansız Invoke

LCEL zincirleri tüm yöntemlerin hem eşzamanlı hem de eşzamansız sürümlerini sunar. invoke(), çağrıyı yapan iş parçacığını bloke eder. ainvoke() bunun eşzamansız karşılığıdır ve olay döngüsünü bloke etmemek için FastAPI işleyicilerinde ve diğer eşzamansız bağlamlarda kullanılmalıdır. Eşzamansız sürüm aynı anlambilime sahiptir; arayüzdeki tek fark await kullanılmasıdır.

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

Belirteçleri Zincir Boyunca Akışla Aktarma

LCEL zincirleri akışı baştan sona iletir. Model tarafından üretildikçe belirteçleri almak için chain.stream() çağrısını kullanın. StrOutputParser akışın farkındadır ve yanıtın tamamını beklemek yerine tek tek dize parçalarını aktarır. Böylece kullanıcılar, uzun bir beklemenin ardından tam yanıtı görmek yerine anında geri bildirim alır.

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)

Birden Çok Girdiyi Toplu İşleme

chain.batch(), girdi sözlüklerinden oluşan bir listeyi kabul eder ve bunları yapılandırılabilir eşzamanlılıkla işler. LangChain, çağrıları dahili olarak paralel iş parçacıklarında çalıştırdığından toplu işleme, bir döngüde invoke() çağrısı yapmaktan çok daha hızlıdır. max_concurrency parametresi, hız sınırları içinde kalmak için paralel API çağrılarının sayısını sınırlar. Sonuçlar girdilerle aynı sırada döner.

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 ve RunnableLambda

RunnablePassthrough, girdisini değiştirmeden iletir; bu, özgün bağlamı dönüştürülmüş verinin yanında aktarmak için kullanışlıdır. RunnableLambda, herhangi bir Python işlevini Runnable olarak sarar ve LCEL zincirine rastgele bir mantık eklemenizi sağlar. Birlikte kullanıldıklarında, tam bir özel Runnable sınıfı yazmadan zincir adımları arasında veri işleme yapmanıza olanak tanırlar.

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)

RunnablePassthrough ile Ek Bağlam Aktarma

RAG'de yaygın bir yaklaşım, alınan belgeleri ve kullanıcının sorusunu son isteme birlikte aktarmaktır. Özgün anahtarları kaybetmeden girdi sözlüğüne hesaplanmış alanlar eklemek için RunnablePassthrough.assign() kullanın. Bu işlem, zincir boyunca ilerlerken bağlam nesnesini zenginleştirir ve tüm verileri istem şablonunun kullanımına sunar.

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

Zincirlere Geri Dönüşler Ekleme

LCEL zincirleri, birincil zincir bir istisna oluşturursa denenmek üzere geri dönüşleri (alternatif zincirleri) destekler. Bir veya daha fazla geri dönüş zinciri kaydetmek için chain.with_fallbacks([backup_chain]) çağrısını kullanın. LangChain önce birincil zinciri dener, oluşan istisnayı yakalar ve ardından her geri dönüşü sırayla dener. Bu, sağlayıcı kesintilerini veya model hatalarını düzgün biçimde ele almanın standart yoludur.

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

Ara Adımlarla Hata Ayıklama

LCEL zincirlerinde hata ayıklamak, invoke() yönteminin yapılandırması ve verbose=True seçeneğiyle daha kolaydır. Herhangi bir zincirde .with_config({'verbose': True}) kullanarak her adımın girdisini ve çıktısını günlüğe kaydedebilirsiniz. Yapılandırılmış hata ayıklama için zinciri genel olarak set_verbose(True) ile sarmalayabilir veya her ara değeri görsel bir iz gezgininde yakalamak üzere LangSmith izlemeyi kullanabilirsiniz.

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

Çalışma Zamanında Yapılandırılabilir Zincirler

LCEL zincirleri, ConfigurableField aracılığıyla çalışma zamanı yapılandırmasını destekler. Model parametrelerini (temperature, model name, max_tokens) sabit kodlamadan yapılandırılabilir seçenekler olarak sunabilirsiniz. Çağrı sırasında varsayılanları geçersiz kılmak için bir Configurable yapılandırması aktarın. Böylece tek bir zincir, farklı ayarlara sahip birden çok kullanıcıya hizmet verebilir veya model yapılandırmaları üzerinde A/B denemesi yapabilir.

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

Kısa Kontrol

LCEL ile zincir oluşturma konusunu ne kadar anladığınızı sınayın.

Ders Özeti

Bu derste şunları öğrendiniz: LCEL boru birleştirmesi, Runnable'ları | ile birleştirerek temiz ve okunabilir işlem hatları oluşturur; RunnablePassthrough ve RunnableLambda, LCEL yaklaşımından çıkmadan veri işleme adımları eklemenizi sağlar; geri dönüşler ise hata durumunda yedek zincirleri otomatik olarak deneyerek zincirleri dayanıklı hâle getirir. Sırada, daha karmaşık yönlendirme mantığı için dallanmayı ve paralel zincirleri inceleyeceğiz.

Sıkça Sorulan Sorular

“LCEL ile Zincirler Oluşturma” dersi ücretsiz mi?

Evet — “LCEL ile Zincirler Oluşturma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve AI Engineering Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. AI Engineering Academy kursu toplamda 4 dersten oluşur.

“LCEL ile Zincirler Oluşturma” dersinde ne öğreneceğim?

Bir istem şablonunu, LLM'yi ve çıktı ayrıştırıcısını bir Runnable dizisinde zincirlemek için boru işleçini kullanın; diziyi eş zamanlı ve eş zamansız olarak çağırıp ara çıktıları inceleyin. AI Engineering Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

AI Engineering Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te AI Engineering Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“LCEL ile Zincirler Oluşturma” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu AI Engineering Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her AI Engineering Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. LangChain Mimarisi ve Temel Soyutlamalar
  2. LCEL ile Zincirler Oluşturma
  3. Dallanma ve Paralel Zincirler
  4. LangChain'de Akışlı Çıktı
← AI Engineering Academy Sayfasına Dön