LLM Chain Explained: Revolutionizing Digital Transactions and Security

What will happen if you have the option to upgrade your large language models (LLMs)? Well, an LLM Chain helps you do it. Uncover the vast use cases of LLM Chains in this blog.

Components of LLM Chain

• Prompt Template 
• A language model (can be an LLM or chat model)

The prompt template is made up of input/memory key values and shared with the LLM, which then returns the output of that prompt.

Workflow

The basic workflow of an LLM Chain is segregated into a couple of steps. This is because it works on a sequence of operations and combines tasks in order to generate the output.

1. Prompt formatting or formatting user input
2. Calling the LLM
3. Output parsing

The LLM chain takes in the user input in the form of a prompt. The prompt template changes the input into a form that will be understandable by the LLM. After this, the LLM is called, and the output parser works on the output to extract the necessary information. This output is then displayed or used as input for the next sequence of action.

Let us interpret this with the help of an example. Assume that you need to create a personalized email using the concept of LLM Chains. The user enters the recipient’s name as input. The prompt template works on its formatting. It changes the input in a form that is acceptable to the LLM. The LLM node makes use of the prompt to personalize the mail for the recipient. The output parser works on the parsing of output and extracts necessary information. It uses the recipient’s name to give a personalized touch to the mail.

Check another example to interpret its working :

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain

prompt_template = "What is a good name for a company that makes {product}?"

llm = OpenAI(temperature=0)
llm_chain = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template(prompt_template)
)
llm_chain("colorful socks")

Uses of an LLM Chain

• Text generation
• Languages translation
• Content creation in the form of poems, code, scripts, musical pieces, emails, letters, and others.
• Question-answers in different ways
• Chatbots and virtual assistants creation and development.

In case the enterprise demands a complex LLM, a group of LLM chains are sequentially connected to demand information from users segment by segment and then combine all of them to provide an output.

The Stuffing chain

The work of a stuffing chain LLM is to take text as the user input and send it to the prompt template. It inserts the given text in its right place in the template. Thus, if you are working on a personalized marketing piece or you need to translate your document to another language, you can opt for this type of Chain LLM.

Working on Stuffing Chain

The Stuffing Chain LLM chain covers two parameters: the LLM chain you are using and your template. Let us have a look at the given example to know how this type of chain LLM works. You need to import the langchain library in this case. You are free to use any other LLM too. After that, you need to create the LLM chain and then the stuffing chain. Provide inputs for the two parameters of the Stuffing chain, i.e., the LLM chain and the template. Provide the inputs and use the run() method to put the input in the correct place in the template. Lastly, you just need to print the personalized copy.

import langchain
from langchain.llms import OpenAI

# Create an LLM chain
llm = OpenAI()
llm_chain = langchain.LLMChain(llm=llm)

# Create a Stuffing chain
stuffing_chain = langchain.StuffingChain(
    llm_chain=llm_chain,
    template="Dear [name],\n\nI am writing to you today to tell you about our new [product]. This [product] is the perfect solution for your [problem].\n\nTo learn more, please visit our website at [website address].\n\nSincerely,\n[Your name]"
)

# Generate personalized marketing copy for a customer
customer_name = "John Doe"

# Generate the marketing copy
marketing_copy = stuffing_chain.run(input_text=customer_name)

# Print the marketing copy
print(marketing_copy)

This code will provide the following output:

Dear John Doe,

I am writing to you today to tell you about our new product, the perfect solution for your problem.

To learn more, please visit our website at [website address].

Sincerely,
[Your name]

You can see that the input given to LLM is inserted in the mail directly. The Stuffing chain is responsible for this.

Recommended Reading | Unlocking the Secrets of Lamini

The Map-Reduce LLM chain

The basic functionality of the Map-Reduce chain is to segregate the bigger task into smaller parts and then work on the smaller cases as individual segments. For example, if the user has a lengthy document, the Map-Reduce chain can split it into one-line segments. Then, the LLM can elaborate on each sentence one by one. This method is used in complex tasks majorly. This is because an LLM will find it difficult to work on such data, so it is better to break it down into sub-parts.

When Map-Reduce chains are used?

They have many use cases, some of them are:

• Summarizing long documents
• Translating long documents
• Generating personalized marketing copy

Working of Map-Reduce chains

Now, consider this example to understand how the MapReduce chain works. It splits the entire document into sentences and provides a summary of each sentence. This way, we will get the summary of the whole article.

# Import the necessary libraries
import langchain
from langchain.llms import OpenAI

# Create an LLM chain
llm = OpenAI()
llm_chain = langchain.LLMChain(llm=llm)

# Create a Map-Reduce chain
map_reduce_chain = langchain.MapReduceDocumentsChain(
    llm_chain=llm_chain,
    text_splitter=langchain.CharacterTextSplitter(chunk_size=1000),
    reduce_prompt="Summarize the following sentences:\n{}",
)

# Run the Map-Reduce chain on a document
document = "This is a long document with a lot of text."

# Get the summary of the document
summary = map_reduce_chain.run(input_documents=[document])

# Print the summary
print(summary)

The Refine chain  

You must have read about recursive functions. The refined chain LLM works similarly to those functions. It follows an iterative approach. It loops over the provided inputs time and again and, in the process, refines the output it has generated.

Disadvantages of the Refine LLM chain

The Refine chain LLM holds a few disadvantages, which are listed below:

• The refined chain LLM makes a large number of LLM calls as compared to the other LLM chain techniques.
• The to and fro function calls make the procedure quite complex, even when it is not required. It may provide poor performance in case the user requires accessing information from many documents.

Difference between LLM and LLM Chain

The improvement of LLM chains is dependent on an LLM. However, it is necessary to understand the differences between the two terms. Let us consider the differences in a tabulated format.

LLM Chain with memory

These types of LLM chains can memorize whatever conversations a user had with the LLM in the past. These LLM chains work on key-value pairs in order to memorize the conversation they had with a user. They can use recurrent neural networks also to encode the information.

LLM chain with retriever

These types of LLM chains are capable of retrieving data from the text corpus.

Commonly used tasks of such LLM’s are:

• Question answering
• Summarization
• Translation

LLM chain vs. conversation chain

Some users interpret an LLM Chain as a conversation chain. However, these two keywords are totally different from each other. Let us have a look at the differences.

FAQs

Conclusion

This blog throws light on the LLM Chain. It covers the Components of such a chain and discusses its workflow. Besides, it explains the types of Chains: The Stuffing chain, the Map-reduce chain, and the Refine chain. It also differentiates between an LLM and an LLM Chain.