How can I migrate my chain from LLMChain to using the pipe operator in LangChain?

Below is an explanation and a solution.

Explanation

The error

  TypeError: Expected mapping type as input to ChatPromptTemplate. Received <class 'str'>

indicates that the output of the first chain (chain_a) is a string (after being processed by your llm and parsed by StrOutputParser). However, your second chain (chain_b) is built atop a prompt (ChatPromptTemplate) that expects a dictionary (a mapping) so it can fill in its variables.

In a pipe-based (LCEL) chain, the output of one component is directly passed as the input of the next. When you simply do

  chain_a | chain_b

the result from chain_a (a string) is given to chain_b instead of a dictionary. In your original SequentialChain, you had control over which keys were passed along. When using the pipe operator, you need to manually adapt the output of one chain to meet the input requirements of the next.

How to Adapt

You can solve this by inserting a lambda function (or a custom transformation) that “repackages” the output of chain_a with the other keys required by chain_b. For example, if your first prompt (prompt_candidates) produces an academic theme and your second prompt (prompt_finalists) requires both the academic theme and research_list, then you should merge the result with the original mapping.

Here’s one way to rewrite your chain using lambdas:

PYTHONCopied
from langchain_core.output_parsers import StrOutputParser

# Assuming prompt_candidates, prompt_finalists, and llm are already defined.

# Chain for candidates
chain_a = prompt_candidates | llm | StrOutputParser()

# Chain for finalists
chain_b = prompt_finalists | llm | StrOutputParser()

# Adaptation lambda: merge the output of chain_a with the rest of the original inputs.
# We expect the original input to be a mapping that contains at least "research_list".
# The lambda accepts a tuple: (original_inputs, academic_themes) and builds the mapping required for chain_b.
merge_fn = lambda prev, academic_themes: {**prev, "academic_themes": academic_themes}

# Compose the entire chain
# First, we need a lambda that passes the whole input mapping (for later use) along with the flow.
# For example, you can start with a lambda that splits the input into two parts:
# one to be used later, and one that goes into chain_a.
capture_input = lambda inp: (inp, inp)

# Then you run chain_a on one copy and merge its output with the original mapping.
composed_chain = (
    capture_input
    | (lambda tup: merge_fn(tup[0], chain_a.invoke(tup[1])))  # run chain_a separately; note: .invoke() used for clarity
    | chain_b
)

# Now invoke the fully composed chain
result = composed_chain.invoke({
    "career": "Artificial Intelligence",
    "research_list": "\n".join(research_col)  # assume research_col exists
})
print(result)

Key Points

• Type Mismatch: The error happens because chain_a returns a string (academic theme) but chain_b’s prompt expects a dictionary.
• Adapting the Output: Use a lambda function (or similar mechanism) to combine the result of chain_a with the original input values so that chain_b gets what it needs.
• Sequential Mapping: Unlike the legacy SequentialChain that takes a list of chains and explicitly handles input/output mapping, the pipe operator chains functions by passing output directly to the next function. This requires you to handle cases where a component’s output type does not match the next component’s input type.

Using these ideas, you can modify your chain to produce the correct mapping for each successive component. Adjust the lambda functions as necessary to correctly merge or transform your data for your specific use case.