How to input multiple inputs in RunnableWithMessageHistory of LangChain?

[JANGSOONMYUN]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

# Import necessary modules from langchain
from langchain.chains import ChatPromptTemplate, RunnableWithMessageHistory
from langchain.prompts import (
    SystemMessagePromptTemplate,
    MessagesPlaceholder,
    HumanMessagePromptTemplate
)
from langchain.output_parsers import StructuredOutputParser, ResponseSchema
from langchain.memory import ChatMessageHistory
from langchain.chat_models import ChatOpenAI

# Setup the OpenAI chat model
llm = ChatOpenAI(
    model="gpt-4",
    temperature=0,
    max_tokens=None,
    timeout=None,
    max_retries=2,
    api_key="your_api_key", 
    organization="your_organization"
    # base_url="...",
    # other params...
)

# Store for session histories
store = {}

# Function to get session history, initializing if not present
def get_session_history(session_id):
    if session_id not in store: 
        store[session_id] = ChatMessageHistory()
    return store[session_id]  

# Define the output schemas
response_schemas = [
    ResponseSchema(name="output1", description="translates first word to English"),
    ResponseSchema(name="output2", description="translates next word to English")
]

# Create the output parser
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)

# Create the prompt template with system and human messages
prompt_template_1 = ChatPromptTemplate(
    messages=[
        SystemMessagePromptTemplate.from_template(
            "Output MUST be JSON format"
        ),
        MessagesPlaceholder(variable_name="chat_history"),
        HumanMessagePromptTemplate.from_template(
            "Translate {korean_word1} and {korean_word2} to English."
            "\n{format_instructions}"
        )
    ],
    input_variables=["korean_word1", "korean_word2"],
    partial_variables={"format_instructions": output_parser.get_format_instructions()}
)

# Combine the prompt template and LLM into a chain
chain1 = prompt_template_1 | llm | output_parser

# Wrap the chain to handle message history
chain_with_history = RunnableWithMessageHistory(
    chain1,
    get_session_history,  
    history_messages_key="chat_history",  
)

# Define the input words
word1 = '미래'  # Korean for 'future'
word2 = '과거'  # Korean for 'past'

# Invoke the chain with history, using a specific session ID
result = chain_with_history.invoke(
    {"korean_word1": word1, "korean_word2": word2},
    config={"configurable": {"session_id": "abc123"}},
)

# Print the result
print(result)

Description

I would like to ask about LangChain for LLM in python.

I need multiple inputs with chatting history to run the model, so I tried to use RunnableWithMessageHistory but got an error.

Error in RootListenersTracer.on_chain_end callback: KeyError('input')
{'output1': 'future', 'output2': 'past'}

And I tried to use 'input_messages_key' in RunnableWithMessageHistory but also failed. Because input_messages_key allow one key only, not multiple keys.

chain_with_history = RunnableWithMessageHistory(
    chain1,
    get_session_history, 
    input_messages_key=["korean_word1", "korean_word2"], // Error Here
    history_messages_key="chat_history", 
)

Please help me to write the correct code

System Info

langchain==0.2.9
langchain-community==0.2.9
langchain-core==0.2.22
langchain-openai==0.1.10
langchain-text-splitters==0.2.2
langchainhub==0.1.21

linux(ubuntu)
python 3.9

[dosubot[bot]]

Hey there, @JANGSOONMYUN! I'm here to help you out 🤖

To correctly handle multiple inputs with RunnableWithMessageHistory in LangChain, you need to ensure that the RunnableWithMessageHistory is configured properly with the necessary keys for input messages, history messages, and any additional configuration required by the session history factory.

Here is an example of how to set up and invoke RunnableWithMessageHistory with multiple inputs:

from typing import List
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.messages import BaseMessage, AIMessage, HumanMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnableWithMessageHistory, ConfigurableFieldSpec
from langchain_community.chat_models import ChatAnthropic

# Define an in-memory chat message history
class InMemoryHistory(BaseChatMessageHistory):
    def __init__(self):
        self.messages = []

    def add_messages(self, messages: List[BaseMessage]) -> None:
        self.messages.extend(messages)

    def clear(self) -> None:
        self.messages = []

# Store for chat histories
store = {}

def get_session_history(user_id: str, conversation_id: str) -> BaseChatMessageHistory:
    if (user_id, conversation_id) not in store:
        store[(user_id, conversation_id)] = InMemoryHistory()
    return store[(user_id, conversation_id)]

# Define the prompt template
prompt = ChatPromptTemplate.from_messages([
    ("system", "You're an assistant who's good at {ability}"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{question}"),
])

# Define the chain
chain = prompt | ChatAnthropic(model="claude-2")

# Wrap the chain with message history management
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history=get_session_history,
    input_messages_key="question",
    history_messages_key="history",
    history_factory_config=[
        ConfigurableFieldSpec(
            id="user_id",
            annotation=str,
            name="User ID",
            description="Unique identifier for the user.",
            default="",
            is_shared=True,
        ),
        ConfigurableFieldSpec(
            id="conversation_id",
            annotation=str,
            name="Conversation ID",
            description="Unique identifier for the conversation.",
            default="",
            is_shared=True,
        ),
    ],
)

# Invoke the chain with history management
result = chain_with_history.invoke(
    {"ability": "math", "question": "What does cosine mean?"},
    config={"configurable": {"user_id": "123", "conversation_id": "1"}}
)

print(result)

In this example:

• get_session_history is a function that retrieves or creates a chat message history based on user_id and conversation_id.
• RunnableWithMessageHistory is configured with input_messages_key and history_messages_key to handle the input and history messages correctly.
• The history_factory_config parameter is used to specify additional configuration fields required by the session history factory.

This setup ensures that multiple inputs are handled correctly, and the chat message history is managed appropriately ^[1][2].

To continue talking to Dosu, mention @dosu.

[JANGSOONMYUN]

And how to reduce the history if it is over the limitation of token?

[dosubot[bot]]

To reduce the history if it exceeds the token limit in your LangChain setup, you can use the trim_messages utility. This utility provides strategies for trimming a list of messages to fit within a specified token limit. Here is an example of how to implement this:

from langchain_core.messages import (
    AIMessage,
    HumanMessage,
    SystemMessage,
    trim_messages,
)
from langchain_openai import ChatOpenAI

# Initialize the language model
llm = ChatOpenAI(model="gpt-4")

# Define your messages
messages = [
    SystemMessage("You're a good assistant, you always respond with a joke."),
    HumanMessage("I wonder why it's called LangChain"),
    AIMessage('Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'),
    HumanMessage("And who is Harrison chasing anyways?"),
    AIMessage("Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),
    HumanMessage("What do you call a speechless parrot?"),
]

# Trim messages to fit within the token limit
trimmed_messages = trim_messages(
    messages,
    max_tokens=45,
    strategy="last",
    token_counter=llm,
    include_system=True,
)

# Use the trimmed messages in your chain
from operator import itemgetter
from langchain_core.runnables import RunnablePassthrough

chain = (
    RunnablePassthrough.assign(messages=itemgetter("messages") | trimmed_messages)
    | prompt
    | model
)

response = chain.invoke(
    {
        "messages": trimmed_messages + [HumanMessage(content="What's my name?")],
        "language": "English",
    }
)
print(response.content)

Additionally, LangChain provides a more automated way to manage chat history using the RunnableWithMessageHistory class. This class can handle the process of appending new messages and trimming old ones automatically. Here is an example of how to set it up:

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory

# Define the prompt template
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a helpful assistant. Answer all questions to the best of your ability."),
        ("placeholder", "{chat_history}"),
        ("human", "{input}"),
    ]
)

# Initialize the language model
chat = ChatOpenAI(model="gpt-3.5-turbo-0125")

# Create the chain
chain = prompt | chat

# Initialize chat history
demo_ephemeral_chat_history = ChatMessageHistory()

# Wrap the chain with message history management
chain_with_message_history = RunnableWithMessageHistory(
    chain,
    lambda session_id: demo_ephemeral_chat_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

# Invoke the chain
response = chain_with_message_history.invoke(
    {"input": "Translate this sentence from English to French: I love programming."},
    {"configurable": {"session_id": "unused"}},
)
print(response.content)

This setup ensures that your chatbot can handle long-running conversations by automatically managing the chat history, including trimming old messages when necessary ^{[1][2][3][4][5]}.

To continue talking to Dosu, mention @dosu.

[jiange91]

I have the same question for the input key in RunnableWithMessageHistory. Why can't I track multiple inputs at the same time? My prompt template looks like this:

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You're an assistant who's good at {ability}. Respond in 20 words or fewer.\n{format_instructions}\n",
        ),
        MessagesPlaceholder(variable_name="history"),
        ("human", "{name}: {input}"),
    ]
).partial(format_instructions=parser.get_format_instructions())

When I manually inspect the recorded history, it either stores "name" or "input" field depends on what I put as the input key. How can I track both inputs in the chat history ?

[vsocrates]

I'm having the same problem as @jiange91 !