The advantages of prompt chaining include:

• ✦ Simplified Instructions by Providing Specific Context

  • By focusing on a specific context, instructions become clearer, making it easier for the model to understand and respond accurately.
• ✦ Focused Troubleshooting

  • Helps in isolating specific issues by breaking down the problem into smaller, manageable parts.
  • Allows for more precise troubleshooting and solution, as the troubleshooting process is focused on a particular aspect of the problem.
• ✦ Incremental Validation

  • Validates the accuracy and relevance of each step before moving on to the next, ensuring the intermediate outputs are on the right track.
  • Makes it easier to identify and correct errors at early stages, preventing compounding mistakes.
• ✦ Reduce the Number of Tokens in a Prompt

  • Using fewer tokens can save computational resources and costs, especially important for large-scale applications.
  • Shorter prompts can be processed faster, leading to quicker responses.
• ✦ Allow to Skip Some Chains of the Workflow

  • Provides the ability to bypass certain steps that may not be necessary for every scenario, enhancing efficiency.
• ✦ Have a Human-in-the-Loop as Part of the Workflow

  • Human oversight ensures that the AI's output meets the desired standards and can intervene when necessary.
  • Humans can provide feedback and make adjustments in real-time, allowing the system to cope with unexpected situations or new information.
• ✦ Use External Tools (Web Search, Databases)

  • Incorporating external tools can significantly extend the AI's abilities, allowing it to pull in current data, facts, or figures that it wouldn't otherwise have access to.
  • Access to up-to-date information from the web or specific databases ensures that the AI's responses are both accurate and relevant to the user's query.

• ✦ We have actually applied the prompts chaining in an earlier example Technique 4 Least-to-Most Prompting
  • It was a straightforward example because the output from prompt_1 can be taken wholesale into prompt_2.
  • However, this is often not the case when our prompt get more complex (e.g., using Inner Monologue technique)
  • Below is the core idea of how a simple linear chain can be implemented:

prompt_1 = " Generate 10 facts about the role of e-learning in the education sector"

response_1 = get_completion(prompt_1)

prompt_2 = f"<fact>{response_1}</fact> Use the above facts to write a one paragraph report about the benefits and challenges of e-learning in the education sector:"

response_2 = get_completion(prompt_2)
Copy

• ✦ Here is the example with the output.

text = f"""
In a bustling HDB estate, colleagues Tan and Lee set out on \
a mission to gather feedback from the residents. As they went door-to-door, \
engaging joyfully, a challenge arose—Tan tripped on a stone and tumbled \
down the stairs, with Lee rushing to help. \
Though slightly shaken, the pair returned to their office to \
comforting colleagues. Despite the mishap, \
their dedicated spirits remained undimmed, and they \
continued their public service with commitment.
"""

# This code is modified from the earlier example in `inner monologue` 
def step_1(text):
    step_delimiter = '#####'

    # example 1
    prompt_1 =  f"""
    Your task is to perform the following steps: 
    Step 1 - Summarize the following text delimited by <text> with 1 sentence.
    Step 2 - Translate the summary into Malay.
    Step 3 - List each name in the Malay summary.
    Step 4 - Output a json object that contains the following keys: malay_summary, num_names.
    
    The response MUST be in the following format:
    Step 1:{step_delimiter} <step 1 output>
    Step 2:{step_delimiter} <step 2 output>
    Step 3:{step_delimiter} <step 3 output>
    Step 4:{step_delimiter} <step 4 output>
    
    <text>
    {text}
    </text>
    """
    response = get_completion(prompt_1)

    # Process the output for next step
    json_string = response.split('#####')[-1].strip()
    dict_output = json.loads(json_string)
    return dict_output


def step_2(dict_input_2):
    prompt_2 = f"""
    Write a short English news article within 200 words based on the Summary.
    
    <Summary>
    {dict_input_2['malay_summary']}
    </Summary>
    """

    response = get_completion(prompt_2)
    return response


def run_linear_pipeline(text):
    # Step 1
    output_1 = step_1(text)
    
    # Step 2
    output_2 = step_2(output_1)

    # Step N..
    # output_n = <...>

    # Return final output
    final_output = output_2
    return final_output

run_linear_pipeline(text)
Copy

The example above demonstrates a two-step linear pipeline where the goal is to first summarize and translate a given text into Malay, and then the second step uses the translated summary to generate a short English news article. Here's a breakdown of the key components and how they work together:

• ✦ Decision chain demonstrates a powerful chaining pattern for building dynamic and adaptable conversational AI systems: Decision Chaining.

  • This approach leverages the inherent flexibility of Large Language Models (LLMs) to create a chain of prompts, where each step's response informs the subsequent decision point in the conversation flow.
• ✦ Imagine a traditional program trying to understand a user asking for a "fee waiver," potentially for a late payment. Rigid keyword-based systems might fail if the user doesn't use the exact term "late fee waiver." This is where LLMs, acting as "soft programming logic," shine.

  • In our example below, the first prompt asks the LLM to analyze the user's message and make a simple decision: Is this about a "Late Fee Waiver" (Yes/No)? This isn't about keyword spotting; the LLM understands the intent behind the user's words.
  • Based on this initial "soft" decision, the conversation branches. If the LLM detects a request for a waiver, the next prompt is tailored to gather the necessary information for processing. If it's a general question, the LLM receives a different prompt, guiding it to provide a helpful answer.

• ✦ Diagram below is a graphical representation of the chain.

• ✦ Decision chain pattern, guided by LLM-powered decisions, offers several advantages:
  • Robustness to Vague Input:
    • Users can express themselves naturally, without needing to use hyper-specific language.
  • Dynamic Conversation Flow:
    • The conversation adapts in real-time to the user's needs, leading to a more natural and engaging experience.
  • Simplified Development:
    • Instead of writing complex rules for every possible user input, we focus on crafting clear prompts that empower the LLM to make the right decisions.

• ✦ While LangChain offers a powerful framework for working with language models, we believe that a foundational understanding of prompt chaining is essential for anyone venturing into this field.
  
  

• ✦ This training prioritized a direct "Native Prompt Chaining" approach to provide you with that fundamental knowledge and transparency into the underlying mechanisms. It empowers you to build and troubleshoot chains with greater control and flexibility.
  
  

• ✦ This is not to say LangChain should be disregarded entirely. As your projects grow in complexity and you require advanced features like state management and external integrations, exploring LangChain's capabilities can be incredibly beneficial.
  
  

• ✦ Ultimately, having a strong grasp of the core concepts of prompt chaining will equip you to make informed decisions about the best tools and frameworks for your LLM-powered solutions or applications.