![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2023\/02\/Tom-Darmon-300x300.jpeg\")
TL;DR<\/h2><\/div>- <\/i><\/span>\n
Faster POC to prod<\/strong>: As langchain documentation describes it, “LCEL is a declarative way to easily compose chains together. LCEL was designed from day 1 to support putting prototypes in production, with no code change”.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Custom chain creation<\/strong>: LCEL simplifies the process of creating custom chains with a new syntax.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Out of the box streaming and batch<\/strong>: LCEL gives you batch, streaming and async capabilities for free.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Unified interface<\/strong>: It offers automatic parallelization, typing capabilities, and any future feature LangChain might develop.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
LCEL is the future of LangChain<\/strong>: LCEL provides a fresh perspective on LLM-based application development. I highly recommended using it for your next LLM project.<\/p>\n<\/div><\/li><\/ul>LangChain<\/strong> has become one of the most used Python library<\/strong> to interact with LLMs<\/strong> in less than a year, but LangChain was mostly a library for POCs<\/strong> as it lacked the ability to create complex and scalable applications<\/strong>.
\nEverything changed in August 2023 when they released LangChain Expression Language (LCEL)<\/strong>, a new syntax that bridges the gap from POC to production<\/strong>. This article will guide you through the ins and outs of LCEL, showing you how it simplifies the creation of custom chains<\/strong> and why you must learn it if you are building LLM applications<\/strong>!<\/p>\n<\/div>Prompts, LLM and chains, let\u2019s refresh our memory<\/h2><\/div>Before diving into the LCEL syntax, I think it is beneficial to refresh our memory on LangChain concepts such as LLM and Prompt or even a Chain.<\/p>\n<\/div>
LLM<\/strong>: In langchain, llm is an abstraction around the model used to make the completions such as openai gpt3.5, claude, etc\u2026<\/p>\n<\/div>Prompt<\/strong>: This is the input of the LLM object, which will ask the LLM questions and give its objectives.<\/p>\n<\/div>Chain<\/strong>: This refers to a sequence of calls to an LLM, or any data processing step.<\/p>\n<\/div>![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2024\/01\/visuel-1-article-medium-langchain.png\" "\\"visuel")
<\/span><\/div>Now that definitions are out of the way, let\u2019s suppose we want to create a company! We need a really cool and catchy name and a business model to make some money!<\/p>\n<\/div>
Example \u2014 Company name & Business model with Old Chains<\/h3><\/div>\nfrom langchain.chains import LLMChain
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_community.llms import OpenAI<\/p>\n
USER_INPUT = \"colorful socks\"
\nllm = OpenAI(temperature=0)<\/p>\n
prompt_template_product = \"What is a good name for a company that makes ?\"
\ncompany_name_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_product))
\ncompany_name_output = company_name_chain(USER_INPUT)<\/p>\n
prompt_template_business = \"Give me the best business model idea for my company named: \"
\nbusiness_model_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_business))
\nbusiness_model_output = business_model_chain(company_name_output[\"text\"])<\/p>\n
print(company_name_output)
\nprint(business_model_output)<\/p>\n
>>>
\n>>> <\/p>\n<\/div>\n<\/div>
This is quite easy to follow, we can see a bit of redundancy, but it is manageable.<\/p>\n<\/div>
Let\u2019s add some customization by handling the cases where the user is not using our chain as expected.
\nMaybe the user will input something completely unrelated to the goal of our chain? In that case, we want to detect it and respond appropriately.<\/p>\n<\/div>
Example \u2014 Customization & Routing with Old Chains<\/h3><\/div>\nfrom langchain.chains import LLMChain
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_community.llms import OpenAI
\nimport ast<\/p>\n
USER_INPUT = \"Harrison Chase\"
\nllm = OpenAI(temperature=0)<\/p>\n
# \u2014- Same code as before
\nprompt_template_product = \"What is a good name for a company that makes ?\"
\ncompany_name_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_product))<\/p>\n
prompt_template_business = \"Give me the best business model idea for my company named: \"
\nbusiness_model_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_business))<\/p>\n
# \u2014- New code<\/p>\n
prompt_template_is_product = (
\n\"Your goal is to find if the input of the user is a plausible product namen\"
\n\"Questions, greetings, long sentences, celebrities or other non relevant inputs are not considered productsn\"
\n\"input: n\"
\n\"Answer only by 'True' or 'False' and nothing moren\"
\n)<\/p>\n
prompt_template_cannot_respond = (
\n\"You cannot respond to the user input: n\"
\n\"Ask the user to input the name of a product in order for you to make a company out of it.n\"
\n)<\/p>\n
cannot_respond_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_cannot_respond))
\ncompany_name_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_product))
\nbusiness_model_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_business))
\nis_a_product_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_is_product))<\/p>\n
# If we use bool on a non empty str it will be True, so we need `literal_eval`
\nis_a_product = ast.literal_eval(is_a_product_chain(USER_INPUT)[\"text\"])
\nif is_a_product:
\ncompany_name_output = company_name_chain(USER_INPUT)
\nbusiness_model_output = business_model_chain(company_name_output[\"text\"])
\nprint(business_model_output)
\nelse:
\nprint(cannot_respond_chain(USER_INPUT))<\/p>\n<\/div>\n<\/div>
This becomes a bit harder to understand, let\u2019s summarize:<\/p>\n<\/div>
- <\/i><\/span>\n
We created a new chain is_real_product_chain() that detects if the user input can be considered a product.<\/p>\n<\/div><\/li>
- <\/i><\/span>\n
We implement if\/else conditions to branch between the chains.<\/p>\n<\/div><\/li><\/ul>
There are multiple problems that start to arise:<\/p>\n<\/div>
- <\/i><\/span>\n
The code is a bit redundant as there is a lot of boilerplate.<\/p>\n<\/div><\/li>
- <\/i><\/span>\n
It’s hard to distinguish what LLMChain is link to which LLMChain, we need to trace the inputs and outputs to understand it.<\/p>\n<\/div><\/li>
- <\/i><\/span>\n
We can easily make errors on the output types of the chains, for example, the output of is_a_product_chain() is a str that should be later evaluated as bool.<\/p>\n<\/div><\/li><\/ul>
What is LangChain Expression Language (LCEL)?<\/h2><\/div>LCEL is a unified interface and syntax to write composable production ready chains, there is a lot to unpack to understand what it means.<\/p>\n
We will first try to understand the new syntax by rewriting the chain from earlier.<\/p>\n<\/div>
Example \u2014 Company name & Business model with LCEL<\/h3><\/div>\nfrom langchain_core.runnables import RunnablePassthrough
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_community.llms import OpenAI<\/p>\n
USER_INPUT = \"colorful socks\"
\nllm = OpenAI(temperature=0)<\/p>\n
prompt_template_product = \"What is a good name for a company that makes ?\"
\nprompt_template_business = \"Give me the best business model idea for my company named: \"<\/p>\n
chain = (
\nPromptTemplate.from_template(prompt_template_product)
\n| llm
\n|
\n| PromptTemplate.from_template(prompt_template_business)
\n| llm
\n)<\/p>\n
business_model_output = chain.invoke()<\/p>\n<\/div>\n<\/div>
A lot of unusual code, in just a few lines :<\/p>\n<\/div>
- <\/i><\/span>\n
There is a weird | operator between a PromptTemplate, an llm and a dictionnary?!<\/strong> The | operator is simply here to say: “take the dictionnary on the left and pass it as input of the object on the right”.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Why are we passing the variable product inside a dictionnary instead of a string like before?<\/strong> If you’ve read #1 you know that the | operator expects the inputs as dictionnary, therefore we give the product argument product inside a dictionnary.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Why is there a function name RunnablePassthrough() instead of the company name?<\/strong> The RunnablePassthrough() is a placeholder to say: “we don’t have the company name for now, but when we have it, place it here”. I’ll explain what the “Runnable” term means in the next parts, for now it is ok to ignore it.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Why do we need a specific method .invoke() instead of writing chain() ?<\/strong>We will understand this in the next part, but it is a sneak peek to why LCEL makes industrialization easier!<\/p>\n<\/div><\/li><\/ul>But is it really more composable to create chains this way ?
\n<\/strong>Let\u2019s put it to the test by adding the is_a_product_chain() and the branching if the user input is not correct. We can even type the chain with Python Typing, let\u2019s do this as a good practice.<\/p>\n<\/div>Example \u2014 Customisation & Routing with LCEL<\/h3><\/div>\nfrom typing import Dict
\nfrom langchain_core.runnables import RunnablePassthrough, RunnableBranch
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_core.output_parsers import StrOutputParser
\nfrom langchain.output_parsers import BooleanOutputParser
\nfrom langchain_community.llms import OpenAI<\/p>\n
USER_INPUT = \"Harrrison Chase\"
\nllm = OpenAI(temperature=0)<\/p>\n
prompt_template_product = \"What is a good name for a company that makes ?\"
\nprompt_template_cannot_respond = (
\n\"You cannot respond to the user input: n\"
\n\"Ask the user to input the name of a product in order for you to make a company out of it.n\"
\n)
\nprompt_template_business = \"Give me the best business model idea for my company named: \"
\nprompt_template_is_product = (
\n\"Your goal is to find if the input of the user is a plausible product namen\"
\n\"Questions, greetings, long sentences, celebrities or other non relevant inputs are not considered productsn\"
\n\"input: n\"
\n\"Answer only by 'True' or 'False' and nothing moren\"
\n)<\/p>\n
answer_user_chain = (
\nPromptTemplate.from_template(prompt_template_product)
\n| llm
\n|
\n| PromptTemplate.from_template(prompt_template_business)
\n| llm
\n).with_types(input_type=Dict[str, str], output_type=str)<\/p>\n
is_product_chain = (
\nPromptTemplate.from_template(prompt_template_is_product)
\n| llm
\n| BooleanOutputParser(true_val='True', false_val='False')
\n).with_types(input_type=Dict[str, str], output_type=bool)<\/p>\n
cannot_respond_chain = (
\nPromptTemplate.from_template(prompt_template_cannot_respond) | llm
\n).with_types(input_type=Dict[str, str], output_type=str)<\/p>\n
full_chain = RunnableBranch(
\n(is_product_chain, answer_user_chain),
\ncannot_respond_chain
\n).with_types(input_type=Dict[str, str], output_type=str)<\/p>\n
print(full_chain.invoke())<\/p>\n<\/div>\n<\/div>
Let\u2019s list the differences:<\/p>\n<\/div>
- <\/i><\/span>\n
The syntax is different, ok that’s a given.<\/p>\n<\/div><\/li>
- <\/i><\/span>\n
There are intermediary chains defined and called in a bigger chain, almost like functions.<\/p>\n<\/div><\/li>
- <\/i><\/span>\n
Inputs and outputs are typed, almost like functions.<\/p>\n<\/div><\/li>
- <\/i><\/span>\n
This doesn’t feel like python.<\/p>\n<\/div><\/li><\/ul>
Why is LCEL better for industrialization?<\/h2><\/div>If I was reading this article until this exact point, and someone asked me if I was convinced about LCEL, I would probably say no. The syntax is too different, and I can probably organize my code into functions to get almost the exact same code. But I\u2019m here, writing this article, so there must be something more.<\/p>\n<\/div>
Out of the box invoke, stream and batch<\/h3><\/div>By using LCEL your chain automatically has:<\/p>\n<\/div>
- <\/i><\/span>\n
.invoke()<\/strong>: You want to pass your input and get the output, nothing more, nothing less.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
.batch()<\/strong>: You want to pass multiple inputs to obtain multiple outputs, the parallelization is handled for you (faster than calling invoke 3 times).<\/p>\n<\/div><\/li>- <\/i><\/span>\n
.stream()<\/strong>: This allows you to start printing the beginning of the completion before the full completion is finished.<\/p>\n<\/div><\/li><\/ul>\nmy_chain = prompt | llm<\/p>\n
# ———invoke——— #
\nresult_with_invoke = my_chain.invoke(“hello world!”)<\/p>\n
# ———batch——— #
\nresult_with_batch = my_chain.batch([“hello”, “world”, “!”])<\/p>\n
# ———stream——— #
\nfor chunk in my_chain.stream(“hello world!”):
\nprint(chunk, flush=True, end=””)<\/p>\n<\/div>\n<\/div>
When you iterate, you can use the invoke method to ease the development process. But when showing the output of your chain in a UI, you want to stream the response. You can now use the stream method without rewriting anything.<\/p>\n<\/div>
Out of the box async methods<\/h3><\/div>Most of the time, the frontend and backend of your application will be separated, meaning the frontend will make a request to the backend. If you have multiple users, you might need to handle multiple request on your backend at the same time.<\/p>\n
Since most of the code in LangChain is just waiting between API calls, we can leverage asynchronous code to improve API scalability, if you want to understand why it is important I recommend reading the concurrent burgers story of the FastAPI documentation<\/a>.<\/strong>
\nThere is no need to worry about the implementation, because async methods are already available if you use LCEL:<\/p>\n.ainvoke() \/ .abatch() \/ .astream<\/strong>: asynchronous versions of invoke, batch and stream.<\/p>\n
Faster POC to prod<\/strong>: As langchain documentation describes it, “LCEL is a declarative way to easily compose chains together. LCEL was designed from day 1 to support putting prototypes in production, with no code change”.<\/p>\n<\/div><\/li> Custom chain creation<\/strong>: LCEL simplifies the process of creating custom chains with a new syntax.<\/p>\n<\/div><\/li> Out of the box streaming and batch<\/strong>: LCEL gives you batch, streaming and async capabilities for free.<\/p>\n<\/div><\/li> Unified interface<\/strong>: It offers automatic parallelization, typing capabilities, and any future feature LangChain might develop.<\/p>\n<\/div><\/li> LCEL is the future of LangChain<\/strong>: LCEL provides a fresh perspective on LLM-based application development. I highly recommended using it for your next LLM project.<\/p>\n<\/div><\/li><\/ul> LangChain<\/strong> has become one of the most used Python library<\/strong> to interact with LLMs<\/strong> in less than a year, but LangChain was mostly a library for POCs<\/strong> as it lacked the ability to create complex and scalable applications<\/strong>. Before diving into the LCEL syntax, I think it is beneficial to refresh our memory on LangChain concepts such as LLM and Prompt or even a Chain.<\/p>\n<\/div> LLM<\/strong>: In langchain, llm is an abstraction around the model used to make the completions such as openai gpt3.5, claude, etc\u2026<\/p>\n<\/div> Prompt<\/strong>: This is the input of the LLM object, which will ask the LLM questions and give its objectives.<\/p>\n<\/div> Chain<\/strong>: This refers to a sequence of calls to an LLM, or any data processing step.<\/p>\n<\/div> Now that definitions are out of the way, let\u2019s suppose we want to create a company! We need a really cool and catchy name and a business model to make some money!<\/p>\n<\/div> from langchain.chains import LLMChain USER_INPUT = \"colorful socks\" prompt_template_product = \"What is a good name for a company that makes ?\" prompt_template_business = \"Give me the best business model idea for my company named: \" print(company_name_output) >>> This is quite easy to follow, we can see a bit of redundancy, but it is manageable.<\/p>\n<\/div> Let\u2019s add some customization by handling the cases where the user is not using our chain as expected. from langchain.chains import LLMChain USER_INPUT = \"Harrison Chase\" # \u2014- Same code as before prompt_template_business = \"Give me the best business model idea for my company named: \" # \u2014- New code<\/p>\n prompt_template_is_product = ( prompt_template_cannot_respond = ( cannot_respond_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_cannot_respond)) # If we use bool on a non empty str it will be True, so we need `literal_eval` This becomes a bit harder to understand, let\u2019s summarize:<\/p>\n<\/div> We created a new chain is_real_product_chain() that detects if the user input can be considered a product.<\/p>\n<\/div><\/li> We implement if\/else conditions to branch between the chains.<\/p>\n<\/div><\/li><\/ul> There are multiple problems that start to arise:<\/p>\n<\/div> The code is a bit redundant as there is a lot of boilerplate.<\/p>\n<\/div><\/li> It’s hard to distinguish what LLMChain is link to which LLMChain, we need to trace the inputs and outputs to understand it.<\/p>\n<\/div><\/li> We can easily make errors on the output types of the chains, for example, the output of is_a_product_chain() is a str that should be later evaluated as bool.<\/p>\n<\/div><\/li><\/ul> LCEL is a unified interface and syntax to write composable production ready chains, there is a lot to unpack to understand what it means.<\/p>\n We will first try to understand the new syntax by rewriting the chain from earlier.<\/p>\n<\/div> from langchain_core.runnables import RunnablePassthrough USER_INPUT = \"colorful socks\" prompt_template_product = \"What is a good name for a company that makes ?\" chain = ( business_model_output = chain.invoke()<\/p>\n<\/div>\n<\/div> A lot of unusual code, in just a few lines :<\/p>\n<\/div> There is a weird | operator between a PromptTemplate, an llm and a dictionnary?!<\/strong> The | operator is simply here to say: “take the dictionnary on the left and pass it as input of the object on the right”.<\/p>\n<\/div><\/li> Why are we passing the variable product inside a dictionnary instead of a string like before?<\/strong> If you’ve read #1 you know that the | operator expects the inputs as dictionnary, therefore we give the product argument product inside a dictionnary.<\/p>\n<\/div><\/li> Why is there a function name RunnablePassthrough() instead of the company name?<\/strong> The RunnablePassthrough() is a placeholder to say: “we don’t have the company name for now, but when we have it, place it here”. I’ll explain what the “Runnable” term means in the next parts, for now it is ok to ignore it.<\/p>\n<\/div><\/li> Why do we need a specific method .invoke() instead of writing chain() ?<\/strong>We will understand this in the next part, but it is a sneak peek to why LCEL makes industrialization easier!<\/p>\n<\/div><\/li><\/ul> But is it really more composable to create chains this way ? from typing import Dict USER_INPUT = \"Harrrison Chase\" prompt_template_product = \"What is a good name for a company that makes ?\" answer_user_chain = ( is_product_chain = ( cannot_respond_chain = ( full_chain = RunnableBranch( print(full_chain.invoke())<\/p>\n<\/div>\n<\/div> Let\u2019s list the differences:<\/p>\n<\/div> The syntax is different, ok that’s a given.<\/p>\n<\/div><\/li> There are intermediary chains defined and called in a bigger chain, almost like functions.<\/p>\n<\/div><\/li> Inputs and outputs are typed, almost like functions.<\/p>\n<\/div><\/li> This doesn’t feel like python.<\/p>\n<\/div><\/li><\/ul> If I was reading this article until this exact point, and someone asked me if I was convinced about LCEL, I would probably say no. The syntax is too different, and I can probably organize my code into functions to get almost the exact same code. But I\u2019m here, writing this article, so there must be something more.<\/p>\n<\/div> By using LCEL your chain automatically has:<\/p>\n<\/div> .invoke()<\/strong>: You want to pass your input and get the output, nothing more, nothing less.<\/p>\n<\/div><\/li> .batch()<\/strong>: You want to pass multiple inputs to obtain multiple outputs, the parallelization is handled for you (faster than calling invoke 3 times).<\/p>\n<\/div><\/li> .stream()<\/strong>: This allows you to start printing the beginning of the completion before the full completion is finished.<\/p>\n<\/div><\/li><\/ul> my_chain = prompt | llm<\/p>\n # ———invoke——— # # ———batch——— # # ———stream——— # When you iterate, you can use the invoke method to ease the development process. But when showing the output of your chain in a UI, you want to stream the response. You can now use the stream method without rewriting anything.<\/p>\n<\/div> Most of the time, the frontend and backend of your application will be separated, meaning the frontend will make a request to the backend. If you have multiple users, you might need to handle multiple request on your backend at the same time.<\/p>\n Since most of the code in LangChain is just waiting between API calls, we can leverage asynchronous code to improve API scalability, if you want to understand why it is important I recommend reading the concurrent burgers story of the FastAPI documentation<\/a>.<\/strong> .ainvoke() \/ .abatch() \/ .astream<\/strong>: asynchronous versions of invoke, batch and stream.<\/p>\n
\nEverything changed in August 2023 when they released LangChain Expression Language (LCEL)<\/strong>, a new syntax that bridges the gap from POC to production<\/strong>. This article will guide you through the ins and outs of LCEL, showing you how it simplifies the creation of custom chains<\/strong> and why you must learn it if you are building LLM applications<\/strong>!<\/p>\n<\/div>Prompts, LLM and chains, let\u2019s refresh our memory<\/h2><\/div>
<\/span><\/div>Example \u2014 Company name & Business model with Old Chains<\/h3><\/div>
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_community.llms import OpenAI<\/p>\n
\nllm = OpenAI(temperature=0)<\/p>\n
\ncompany_name_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_product))
\ncompany_name_output = company_name_chain(USER_INPUT)<\/p>\n
\nbusiness_model_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_business))
\nbusiness_model_output = business_model_chain(company_name_output[\"text\"])<\/p>\n
\nprint(business_model_output)<\/p>\n
\n>>> <\/p>\n<\/div>\n<\/div>
\nMaybe the user will input something completely unrelated to the goal of our chain? In that case, we want to detect it and respond appropriately.<\/p>\n<\/div>Example \u2014 Customization & Routing with Old Chains<\/h3><\/div>
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_community.llms import OpenAI
\nimport ast<\/p>\n
\nllm = OpenAI(temperature=0)<\/p>\n
\nprompt_template_product = \"What is a good name for a company that makes ?\"
\ncompany_name_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_product))<\/p>\n
\nbusiness_model_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_business))<\/p>\n
\n\"Your goal is to find if the input of the user is a plausible product namen\"
\n\"Questions, greetings, long sentences, celebrities or other non relevant inputs are not considered productsn\"
\n\"input: n\"
\n\"Answer only by 'True' or 'False' and nothing moren\"
\n)<\/p>\n
\n\"You cannot respond to the user input: n\"
\n\"Ask the user to input the name of a product in order for you to make a company out of it.n\"
\n)<\/p>\n
\ncompany_name_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_product))
\nbusiness_model_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_business))
\nis_a_product_chain = LLMChain(llm=llm, prompt=PromptTemplate.from_template(prompt_template_is_product))<\/p>\n
\nis_a_product = ast.literal_eval(is_a_product_chain(USER_INPUT)[\"text\"])
\nif is_a_product:
\ncompany_name_output = company_name_chain(USER_INPUT)
\nbusiness_model_output = business_model_chain(company_name_output[\"text\"])
\nprint(business_model_output)
\nelse:
\nprint(cannot_respond_chain(USER_INPUT))<\/p>\n<\/div>\n<\/div>What is LangChain Expression Language (LCEL)?<\/h2><\/div>
Example \u2014 Company name & Business model with LCEL<\/h3><\/div>
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_community.llms import OpenAI<\/p>\n
\nllm = OpenAI(temperature=0)<\/p>\n
\nprompt_template_business = \"Give me the best business model idea for my company named: \"<\/p>\n
\nPromptTemplate.from_template(prompt_template_product)
\n| llm
\n|
\n| PromptTemplate.from_template(prompt_template_business)
\n| llm
\n)<\/p>\n
\n<\/strong>Let\u2019s put it to the test by adding the is_a_product_chain() and the branching if the user input is not correct. We can even type the chain with Python Typing, let\u2019s do this as a good practice.<\/p>\n<\/div>Example \u2014 Customisation & Routing with LCEL<\/h3><\/div>
\nfrom langchain_core.runnables import RunnablePassthrough, RunnableBranch
\nfrom langchain.prompts import PromptTemplate
\nfrom langchain_core.output_parsers import StrOutputParser
\nfrom langchain.output_parsers import BooleanOutputParser
\nfrom langchain_community.llms import OpenAI<\/p>\n
\nllm = OpenAI(temperature=0)<\/p>\n
\nprompt_template_cannot_respond = (
\n\"You cannot respond to the user input: n\"
\n\"Ask the user to input the name of a product in order for you to make a company out of it.n\"
\n)
\nprompt_template_business = \"Give me the best business model idea for my company named: \"
\nprompt_template_is_product = (
\n\"Your goal is to find if the input of the user is a plausible product namen\"
\n\"Questions, greetings, long sentences, celebrities or other non relevant inputs are not considered productsn\"
\n\"input: n\"
\n\"Answer only by 'True' or 'False' and nothing moren\"
\n)<\/p>\n
\nPromptTemplate.from_template(prompt_template_product)
\n| llm
\n|
\n| PromptTemplate.from_template(prompt_template_business)
\n| llm
\n).with_types(input_type=Dict[str, str], output_type=str)<\/p>\n
\nPromptTemplate.from_template(prompt_template_is_product)
\n| llm
\n| BooleanOutputParser(true_val='True', false_val='False')
\n).with_types(input_type=Dict[str, str], output_type=bool)<\/p>\n
\nPromptTemplate.from_template(prompt_template_cannot_respond) | llm
\n).with_types(input_type=Dict[str, str], output_type=str)<\/p>\n
\n(is_product_chain, answer_user_chain),
\ncannot_respond_chain
\n).with_types(input_type=Dict[str, str], output_type=str)<\/p>\nWhy is LCEL better for industrialization?<\/h2><\/div>
Out of the box invoke, stream and batch<\/h3><\/div>
\nresult_with_invoke = my_chain.invoke(“hello world!”)<\/p>\n
\nresult_with_batch = my_chain.batch([“hello”, “world”, “!”])<\/p>\n
\nfor chunk in my_chain.stream(“hello world!”):
\nprint(chunk, flush=True, end=””)<\/p>\n<\/div>\n<\/div>Out of the box async methods<\/h3><\/div>
\nThere is no need to worry about the implementation, because async methods are already available if you use LCEL:<\/p>\n