LangChain 39 深入理解LangChain 表达式语言四为什么要用LCEL LangChain Expression Language (LCEL)

本文链接：https://blog.csdn.net/zgpeace/article/details/135225189

本文介绍了LangChain系列文章的核心内容，包括使用LCEL构建可扩展的模型链条、执行异步和批量处理、实现表达式语言、集成多种服务如OpenAI和Wikipedia，以及调试和管理智能代理。LCEL强调统一接口和组合原语，简化了复杂任务的处理。

摘要由CSDN通过智能技术生成

LangChain系列文章

在这里插入图片描述

1. 为什么要用 LangChain Expression Language (LCEL)

LCEL使得从基本组件构建复杂链条变得轻而易举。它通过提供以下功能实现这一点：

统一接口A unified interface：每个LCEL对象都实现了Runnable接口，该接口定义了一组通用的调用方法（invoke，batch，stream，ainvoke等）。这使得LCEL对象的链条也能自动支持这些调用。也就是说，每个LCEL对象的链条本身也是一个LCEL对象。
1. 组合原语Composition primitives：LCEL提供了许多原语，使得组合链条、并行化组件、添加回退、动态配置链条内部等变得轻而易举。

要更好地理解LCEL的价值，有助于看到它的实际作用，并考虑如何在没有它的情况下重新创建类似的功能。在本教程中，我们将通过起步部分的基本示例来做到这一点。我们将采用我们的简单提示+模型链条，它在幕后已经定义了许多功能，然后看看重新创建所有这些功能需要做些什么。

from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser


prompt = ChatPromptTemplate.from_template("Tell me a short joke about {topic}")
model = ChatOpenAI(model="gpt-3.5-turbo")
output_parser = StrOutputParser()

chain = prompt | model | output_parser

2. Invoke 调用执行

在最简单的情况下，我们只是想输入一个话题字符串，然后得到一个笑话字符串：

2.1 LCEL 实现

from langchain_core.runnables import RunnablePassthrough
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from dotenv import load_dotenv

load_dotenv()

prompt = ChatPromptTemplate.from_template(
    "Tell me a short joke about {topic}"
)
output_parser = StrOutputParser()
model = ChatOpenAI(model="gpt-3.5-turbo")
chain = (
    {"topic": RunnablePassthrough()} 
    | prompt
    | model
    | output_parser
)

response = chain.invoke("ice cream")
print('response >> ', response)

运行结果

(develop)⚡ [1] % python LCEL/invoke_lcel.py                                                              ~/Workspace/LLM/langchain-llm-app
response >>  Why did the ice cream go to therapy?

Because it had too many toppings and couldn't hold it together!

2.2 不用 LCEL 实现

from typing import List

import openai


prompt_template = "Tell me a short joke about {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("ice cream")

运行结果

(develop)⚡ % python LCEL/invoke.py                                                                       ~/Workspace/LLM/langchain-llm-app
response >>  Why did the ice cream go to therapy? 
Because it had too many toppings!

3. Stream 流式输出，逐个逐个字输出

如果我们想要实时传输结果，我们就需要改变我们的函数：

3.1 LCEL实现

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

输出就像ChatGPT 逐个字打印

Why did the ice cream go to therapy?

Because it had too many sprinkles of anxiety!%

3.2 不用 LCEL实现

需要更改基本上所有的方法

from typing import List
from typing import Iterator
import openai
from langchain_core.runnables import RunnablePassthrough
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from dotenv import load_dotenv

load_dotenv()

prompt_template = "Tell me a short joke about {topic}"
client = openai.OpenAI()
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_template.format(topic=topic)
    return stream_chat_model([{"role": "user", "content": prompt_value}])


for chunk in stream_chain("ice cream"):
    print(chunk, end="", flush=True)

逐个字输出

(develop)⚡ [1] % python LCEL/invoke_stream.py                                                            ~/Workspace/LLM/langchain-llm-app
Why did the ice cream go to therapy?

Because it felt a little soft serve!%

4. Batch 批量处理

如果我们想要并行处理一批输入，我们将需要一个新的函数：

4.1 LCEL实现

response = chain.batch(["ice cream", "spaghetti", "dumplings"])
print('response >> ', response)

输出

(develop)⚡ % python LCEL/invoke_lcel.py                                                                  ~/Workspace/LLM/langchain-llm-app
response >>  ['Why did the ice cream go to therapy? \n\nBecause it was feeling a little rocky road!', 'Why did the spaghetti go to the party? \n\nBecause it heard it was going to "meat" some saucy friends!', 'Why did the dumpling go to the gym?\n\nBecause it wanted to get a little "dough" in shape!']

4.2 不用 LCEL实现

from typing import List

import openai
from langchain_core.runnables import RunnablePassthrough
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from concurrent.futures import ThreadPoolExecutor
from dotenv import load_dotenv

load_dotenv()

prompt_template = "Tell me a short joke about {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)

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

response = batch_chain(["ice cream", "spaghetti", "dumplings"])
print('response >> ', response)

输出

develop)⚡ [1] % python LCEL/batch_chain.py                                                              ~/Workspace/LLM/langchain-llm-app
response >>  ['Why did the ice cream go to therapy?\n\nBecause it had too many sprinkles of anxiety!', 'Why did the spaghetti go to the spa? \n\nBecause it needed to pasta tense!', 'Why did the dumpling go to the bakery? \nBecause it wanted to make some dough!']

5. Async 异步执行

如果我们需要一个异步版本：

5.1 LCEL实现

chain.ainvoke("ice cream")

调用实现


from langchain.globals import set_debug

set_debug(True)

async def main():
    await chain.ainvoke("ice cream")

import asyncio
asyncio.run(main())

debug 输出

(develop)⚡ % python LCEL/invoke_lcel.py                                                                  ~/Workspace/LLM/langchain-llm-app
[chain/start] [1:chain:RunnableSequence] Entering Chain run with input:
{
  "input": "ice cream"
}
[chain/start] [1:chain:RunnableSequence > 2:chain:RunnableParallel] Entering Chain run with input:
{
  "input": "ice cream"
}
[chain/start] [1:chain:RunnableSequence > 2:chain:RunnableParallel > 3:chain:RunnablePassthrough] Entering Chain run with input:
{
  "input": "ice cream"
}
[chain/end] [1:chain:RunnableSequence > 2:chain:RunnableParallel > 3:chain:RunnablePassthrough] [3ms] Exiting Chain run with output:
{
  "output": "ice cream"
}
[chain/end] [1:chain:RunnableSequence > 2:chain:RunnableParallel] [11ms] Exiting Chain run with output:
{
  "topic": "ice cream"
}
[chain/start] [1:chain:RunnableSequence > 4:prompt:ChatPromptTemplate] Entering Prompt run with input:
{
  "topic": "ice cream"
}
[chain/end] [1:chain:RunnableSequence > 4:prompt:ChatPromptTemplate] [3ms] Exiting Prompt run with output:
{
  "lc": 1,
  "type": "constructor",
  "id": [
    "langchain",
    "prompts",
    "chat",
    "ChatPromptValue"
  ],
  "kwargs": {
    "messages": [
      {
        "lc": 1,
        "type": "constructor",
        "id": [
          "langchain",
          "schema",
          "messages",
          "HumanMessage"
        ],
        "kwargs": {
          "content": "Tell me a short joke about ice cream",
          "additional_kwargs": {}
        }
      }
    ]
  }
}
[llm/start] [1:chain:RunnableSequence > 5:llm:ChatOpenAI] Entering LLM run with input:
{
  "prompts": [
    "Human: Tell me a short joke about ice cream"
  ]
}
[llm/end] [1:chain:RunnableSequence > 5:llm:ChatOpenAI] [2.32s] Exiting LLM run with output:
{
  "generations": [
    [
      {
        "text": "Why did the ice cream go to therapy?\n\nBecause it had too many toppings and couldn't cone-trol itself!",
        "generation_info": {
          "finish_reason": "stop",
          "logprobs": null
        },
        "type": "ChatGeneration",
        "message": {
          "lc": 1,
          "type": "constructor",
          "id": [
            "langchain",
            "schema",
            "messages",
            "AIMessage"
          ],
          "kwargs": {
            "content": "Why did the ice cream go to therapy?\n\nBecause it had too many toppings and couldn't cone-trol itself!",
            "additional_kwargs": {}
          }
        }
      }
    ]
  ],
  "llm_output": {
    "token_usage": {
      "completion_tokens": 23,
      "prompt_tokens": 15,
      "total_tokens": 38
    },
    "model_name": "gpt-3.5-turbo",
    "system_fingerprint": null
  },
  "run": null
}
[chain/start] [1:chain:RunnableSequence > 6:parser:StrOutputParser] Entering Parser run with input:
[inputs]
[chain/end] [1:chain:RunnableSequence > 6:parser:StrOutputParser] [3ms] Exiting Parser run with output:
{
  "output": "Why did the ice cream go to therapy?\n\nBecause it had too many toppings and couldn't cone-trol itself!"
}
[chain/end] [1:chain:RunnableSequence] [2.36s] Exiting Chain run with output:
{
  "output": "Why did the ice cream go to therapy?\n\nBecause it had too many toppings and couldn't cone-trol itself!"
}

5.2 不用LCEL实现

async_client = openai.AsyncOpenAI()

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

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

async def main():
    response = await ainvoke_chain("ice cream")
    print('response >> ', response)

import asyncio
asyncio.run(main())

输出

(develop)⚡ % python LCEL/invoke.py                                                                       ~/Workspace/LLM/langchain-llm-app
response >>  Why did the ice cream go to therapy?

Because it had too many toppings and couldn't handle the sprinkles anymore!