Warum LCEL verwenden (LangChain Expression Language)

1. Einführung in LCEL

LCEL (LangChain Expression Language) ist ein einfaches und benutzerfreundliches Framework zum Aufbau komplexer Ketten. Es bietet eine einheitliche Schnittstelle und zusammengesetzte Primitiven, um den Aufbau von Ketten zu vereinfachen. Jedes LCEL-Objekt implementiert das Runnable-Interface, das eine Reihe häufig verwendeter Aufrufmethoden definiert (wie z.B. invoke, batch, stream, ainvoke usw.). Daher unterstützen die Ketten von LCEL-Objekten automatisch diese Aufrufmethoden und machen die Kette jedes LCEL-Objekts selbst zu einem LCEL-Objekt.

2. Aufruf

2.1. Ohne Verwendung von LCEL

Ohne LCEL können Sie den folgenden Code-Schnipsel verwenden, um eine Themenzeichenkette zu übergeben und eine Witzzeichenkette abzurufen.

from typing import List
import openai

prompt_template = "Erzähl mir einen kurzen Witz über {topic}"
client = openai.OpenAI()

def call_chat_model(messages: List[dict]) -> str:
    response = client.chat.completions.create(
        model="gpt-3.5-turbo", 
        messages=messages,
    )
    return response.choices[0].message.content

def invoke_chain(topic: str) -> str:
    prompt_value = prompt_template.format(topic=topic)
    messages = [{"role": "user", "content": prompt_value}]
    return call_chat_model(messages)

invoke_chain("Eiscreme")

2.2. Verwendung von LCEL

Im Gegensatz dazu können Sie mit LCEL dieselbe Funktionalität prägnanter erreichen. Der folgende Code-Schnipsel zeigt, wie einfach Sie eine Kette mit LCEL-Objekten erstellen können.

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

prompt = ChatPromptTemplate.from_template(
    "Erzähl mir einen kurzen Witz über {topic}"
)
output_parser = StrOutputParser()
model = ChatOpenAI(model="gpt-3.5-turbo")
chain = (
    {"topic": RunnablePassthrough()} 
    | prompt
    | model
    | output_parser
)

chain.invoke("Eiscreme")

3. Streaming

3.1. Ohne Verwendung von LCEL

Der folgende Code-Schnipsel zeigt, wie Sie Prozessergebnisse ohne Verwendung von LCEL streamen können.

from typing import Iterator

def stream_chat_model(messages: List[dict]) -> Iterator[str]:
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        stream=True,
    )
    for response in stream:
        content = response.choices[0].delta.content
        if content is not None:
            yield content

def stream_chain(topic: str) -> Iterator[str]:
    prompt_value = prompt.format(topic=topic)
    stream = stream_chat_model([{"role": "user", "content": prompt_value}])
    for chunk in stream:
        print(chunk, end="", flush=True)

stream_chain("Eiscreme")

3.2. Verwendung von LCEL

Das Streamen von Prozessergebnissen mit LCEL ist bequemer. Der folgende Code-Schnipsel zeigt, wie Sie mit LCEL streamen können.

for chunk in chain.stream("Eiscreme"):
    print(chunk, end="", flush=True)

4. Batch-Verarbeitung

4.1. Ohne Verwendung von LCEL

Der folgende Code-Schnipsel zeigt, wie Sie eine Stapelverarbeitung von Eingaben ohne Verwendung von LCEL parallel verarbeiten können.

from concurrent.futures import ThreadPoolExecutor

def batch_chain(topics: list) -> list:
    with ThreadPoolExecutor(max_workers=5) as executor:
        return list(executor.map(invoke_chain, topics))

batch_chain(["Eiscreme", "Spaghetti", "Knödel"])

4.2. Verwendung von LCEL

Die Stapelverarbeitung mit LCEL ist sehr unkompliziert. Der folgende Code-Schnipsel zeigt, wie Sie LCEL für die Stapelverarbeitung verwenden können.

chain.batch(["Eiscreme", "Spaghetti", "Knödel"])