partial_variables not working with ChatPromptTemplate (langchain v0.1.9)

[hasansustcse13]

Checked other resources

• I added a very descriptive title to this issue.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.
• I am sure that this is a bug in LangChain rather than my code.

Example Code

   async def partial_test(self):
        prompt_template = "Tell me details about {name}. The output should be in {lang}"
        llm = LLMSelector(self.model).get_language_model()
        prompt = ChatPromptTemplate.from_messages([
            HumanMessagePromptTemplate.from_template(prompt_template, partial_variables={"lang": "Spanish"}),
        ])
        chain = prompt | llm | StrOutputParser()
        result = await chain.ainvoke({'name': 'Open AI'})
        print(result)

Error Message and Stack Trace (if applicable)

Errror: Input to ChatPromptTemplate is missing variables {'lang'}. Expected: ['lang', 'name'] Received: ['name']\"

Description

But this works with PromptTemplate also work with ChatPromptTemplate in previous version

System Info

langchain v0.1.7

[dosubot]

🤖

Hey there @hasansustcse13! Good to see you back around these parts. What's cooking on your end?

Based on the information you've provided and the context I found, it seems like the partial_variables is not working with ChatPromptTemplate in LangChain version v0.1.7 because the from_template method in the ChatMessagePromptTemplate class does not accept partial_variables as an argument. This is unlike the from_template method in the BaseStringMessagePromptTemplate class, which does accept partial_variables.

Here is the relevant code for ChatMessagePromptTemplate:

class ChatMessagePromptTemplate(BaseStringMessagePromptTemplate):
    """Chat message prompt template."""

    role: str
    """Role of the message."""

    @classmethod
    def get_lc_namespace(cls) -> List[str]:
        """Get the namespace of the langchain object."""
        return ["langchain", "prompts", "chat"]

    def format(self, **kwargs: Any) -> BaseMessage:
        """Format the prompt template.

        Args:
            **kwargs: Keyword arguments to use for formatting.

        Returns:
            Formatted message.
        """
        text = self.prompt.format(**kwargs)
        return ChatMessage(
            content=text, role=self.role, additional_kwargs=self.additional_kwargs
        )

And here is the relevant code for BaseStringMessagePromptTemplate:

class BaseStringMessagePromptTemplate(BaseMessagePromptTemplate, ABC):
    """Base class for message prompt templates that use a string prompt template."""

    prompt: StringPromptTemplate
    """String prompt template."""
    additional_kwargs: dict = Field(default_factory=dict)
    """Additional keyword arguments to pass to the prompt template."""

    @classmethod
    def from_template(
        cls: Type[MessagePromptTemplateT],
        template: str,
        template_format: str = "f-string",
        partial_variables: Optional[Dict[str, Any]] = None,
        **kwargs: Any,
    ) -> MessagePromptTemplateT:
        """Create a class from a string template.

        Args:
            template: a template.
            template_format: format of the template.
            partial_variables: A dictionary of variables that can be used to partially
                               fill in the template. For example, if the template is
                              `"{variable1} {variable2}"`, and `partial_variables` is
                              `{"variable1": "foo"}`, then the final prompt will be
                              `"foo {variable2}"`.
            **kwargs: keyword arguments to pass to the constructor.

        Returns:
            A new instance of this class.
        """
        prompt = PromptTemplate.from_template(
            template,
            template_format=template_format,
            partial_variables=partial_variables,
        )
        return cls(prompt=prompt, **kwargs)

As you can see, the from_template method in ChatMessagePromptTemplate does not have the partial_variables argument, which is why it's not working with ChatPromptTemplate in the current version.

I also found a similar solved issue: ChatPromptTemplate with partial variables is giving validation error which was last updated on June 20, 2023. This issue was closed by a pull request: Fix for #6431 - chatprompt template with partial variables throws validation error on June 20, 2023. It might be worth checking out this issue and pull request for more context.

Unfortunately, I wasn't able to find any changes made to the ChatPromptTemplate class in the transition from the previous version of LangChain to v0.1.7. It's possible that the changes were made in a different part of the codebase or that I missed something. If you have more information about this, it would be helpful.

I hope this helps! If you have any more questions or need further clarification, feel free to ask.

Sources

• ChatPromptTemplate with partial variables is giving validation error
• libs/core/langchain_core/prompts/chat.py

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[keenborder786]

@hasansustcse13 Can you please tell what LLMSelector is, as in where are you importing it from?

[hasansustcse13]

This is an internal class. Just replace it with any chat model (ChatOpenAI)
llm = ChatOpenAI(model="gpt-4", openai_api_key="key")

[hasansustcse13]

After further investigation I have found that there is a problem in base class (_StringImageMessagePromptTemplate) from_template function. This function doesn't take any partial_variables. That's why HumanMessagePromptTemplate/SystemMessagePromptTemplate doesn't work with partial variables. If I rewrite the method like this it works.

@classmethod
    def from_template(
        cls: Type[_StringImageMessagePromptTemplateT],
        template: Union[str, List[Union[str, _TextTemplateParam, _ImageTemplateParam]]],
        template_format: str = "f-string",
        partial_variables: Optional[Dict[str, Any]] = None,
        **kwargs: Any,
    ) -> _StringImageMessagePromptTemplateT:
        if isinstance(template, str):
            prompt: Union[StringPromptTemplate, List] = PromptTemplate.from_template(
                template, template_format=template_format, partial_variables=partial_variables
            )
            return cls(prompt=prompt, **kwargs)

But list can also pass to template in that function. In that case how would we pass the partial variables?
I need to upgrade langchain(0.1.9) to get some feature. But for this issue I couldn't as it breaks my whole application.

@baskaryan @eyurtsev Could you please share your valuable thought on this?

[thejollyrogers]

This is the offending commit that broke this in a backwards incompatible way: #14263

This backwards incompatible change broke many of my chains that relied on SystemMessagePromptTemplate inheriting from BaseStringMessagePromptTemplate.

Pinning at langchain==1.0.4 and langchain-core==0.1.16 fixes the issue for me, until I can re-write my SystemMessagePromptTemplate.from_template logic.

[baskaryan]

great catch, thank you for flagging @hasansustcse13! as a workaround while we fix, the following should still work (and is hopefully a bit simpler)

from langchain_core.prompts import ChatPromptTemplate

prompt_template = "Tell me details about {name}. The output should be in {lang}"
prompt = ChatPromptTemplate.from_messages([("human", prompt_template)])
prompt = prompt.partial(lang="Spanish")
prompt.invoke({"name": "foo"})

[hasansustcse13]

@baskaryan Thanks for the workaround. I know there are couple of workaround for the problem. The problem is that I have to change in lots of file which I don't want. And I have just demonstrated the bug using simple example. In my case it little bit more complex. Is there any plan to fix this bug in next release? If you share your planning (how to solve it) I can give it a try though I am new to open-source contribution.

[rahilvora]

Hey @baskaryan

Does this bug still need help? If yes, I would like to contribute (I am a first time contributor). Let me know if it is a good fit for first time contributor and how I can get started :). Thanks

Best,
Rahil

[DmitriyLeybel]

Same case with SystemMessagePromptTemplate.from_template

graph_creator_content = \
"""
Your instructions are:
{instructions}
History:
{history}
"""
graph_analyst_template = SystemMessagePromptTemplate.from_template(template=graph_creator_content,
                                                    input_variables=['history'],
                                                    partial_variables={'instructions': json_prompt_instructions})
graph_analyst_template.format(history='history')

KeyError: 'instructions'

[liugddx]

Same case with SystemMessagePromptTemplate.from_template

graph_creator_content = \
"""
Your instructions are:
{instructions}
History:
{history}
"""
graph_analyst_template = SystemMessagePromptTemplate.from_template(template=graph_creator_content,
                                                    input_variables=['history'],
                                                    partial_variables={'instructions': json_prompt_instructions})
graph_analyst_template.format(history='history')

KeyError: 'instructions'

#20711 You can try this.