Why does using the | operator with ChatPromptTemplate and ChatOpenAI trigger a ValueError in LangChain?

Below is an explanation of why your code using the pipe operator ( | ) fails and what you can do about it:

---

What’s Happening

When you use an LLMChain, the chain is designed to accept a dictionary of variables. Internally it uses the prompt’s formatting logic so that your dictionary (with keys such as "input_user_message") gets converted to a valid prompt (a PromptValue or list of BaseMessages) before being fed into the language model.

With the pipe operator, you are composing runnables in a sequence. In this mode the output of one runnable must exactly match the expected input type of the next runnable. For example, your ChatPromptTemplate expects a PromptValue, a string, or a list of BaseMessages. However, by directly piping the components, your initial input remains a dictionary. That causes the error:

  ValueError: Invalid input type <class 'dict'>. Must be a PromptValue, str, or list of BaseMessages.

---

How to Fix It

To chain using the  |  operator, you need to ensure that the components are receiving the types they expect. In your case, that means converting your input dictionary into a valid prompt format before passing it to the ChatPromptTemplate.

There are two main approaches:

1. Manually Format the Prompt First:

   Instead of passing a raw dict into the piped chain, call the prompt’s formatter before chaining to produce a valid PromptValue:

   PYTHONCopied
   # Create the prompt using your dictionary (pre-format)
   formatted_prompt = chat_prompt.format_prompt(
       input_user_message=input_user_message,
       history_messages=st.session_state.store.get(session_id, ChatMessageHistory()).messages
   )
   # Chain the components once you have the properly formatted prompt:
   conversation_chain = formatted_prompt | llm | output_parser
   result = conversation_chain.invoke()

2. Use a Chain Wrapper That Handles Dicts:

   If you still wish to pass a dict as input, you’ll need to add a convertor that takes the dictionary and applies the prompt’s formatting. For example, you can wrap your prompt in a small function or runnable that does that conversion:

   PYTHONCopied
   from langchain_core.runnables import RunnableLambda
   
   format_runnable = RunnableLambda(
       lambda inputs: chat_prompt.format_prompt(
           input_user_message=inputs["input_user_message"],
           history_messages=inputs["history_messages"]
       )
   )
   
   # Now rebuild your chain:
   conversation_chain = format_runnable | llm | output_parser
   
   response = conversation_chain.invoke({
       "input_user_message": input_user_message,
       "history_messages": st.session_state.store.get(session_id, ChatMessageHistory()).messages,
   })

In both cases the key is to ensure your chain’s first component consumes a dict, formats it to a valid prompt type, and then passes that output on to the language model.

---

Summary

• LLMChain handles dictionaries internally by formatting the prompt before calling the LLM.
• With the pipe operator, each runnable must receive the exact type it expects. A plain dict isn’t valid for a ChatPromptTemplate.
• You can resolve the error by manually formatting the prompt or by inserting a conversion step in the pipe chain.

By following one of the suggested approaches, you should be able to compose your ChatOpenAI, ChatPromptTemplate, and StrOutputParser using the  |  operator without running into the type error.