LangChain RunnableWithMessageHistory — session_id and config_specs errors

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.messages import BaseMessage
from typing import Dict

# 1) The base chain
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Refer to prior turns when relevant."),
    MessagesPlaceholder(variable_name="history"),          # ← history goes here
    ("human", "{input}"),                                  # ← new user message here
])

model = ChatOpenAI(model="gpt-4o-mini")
chain = prompt | model | StrOutputParser()

# 2) The session-history store (in-memory for demo; use SQL/Redis in prod)
store: Dict[str, InMemoryChatMessageHistory] = {}

def get_session_history(session_id: str) -> InMemoryChatMessageHistory:
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

# 3) Wire the wrapper
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",         # matches {input} in the prompt
    history_messages_key="history",     # matches MessagesPlaceholder variable_name
)

# 4) Invoke with session_id
config = {"configurable": {"session_id": "user_42"}}

r1 = chain_with_history.invoke({"input": "My name is Alice."}, config=config)
print(r1)
# > Nice to meet you, Alice!

r2 = chain_with_history.invoke({"input": "What is my name?"}, config=config)
print(r2)
# > Your name is Alice.

from langchain_community.chat_message_histories import SQLChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory

# Option A: SQL (SQLite, Postgres, MySQL — via SQLAlchemy)
def get_sql_history(session_id: str) -> BaseChatMessageHistory:
    return SQLChatMessageHistory(
        session_id=session_id,
        connection="postgresql+psycopg2://user:pass@localhost/mydb",
        # The table is auto-created on first use
        table_name="chat_history",
    )

# Option B: Redis
from langchain_community.chat_message_histories import RedisChatMessageHistory

def get_redis_history(session_id: str) -> BaseChatMessageHistory:
    return RedisChatMessageHistory(
        session_id=session_id,
        url="redis://localhost:6379/0",
        ttl=60 * 60 * 24 * 7,   # 7-day retention on Redis
    )

# Option C: DynamoDB (for AWS-native apps)
from langchain_aws.chat_message_histories import DynamoDBChatMessageHistory

def get_dynamo_history(session_id: str) -> BaseChatMessageHistory:
    return DynamoDBChatMessageHistory(
        table_name="chat_history_prod",
        session_id=session_id,
    )

# Wire whichever you chose
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_sql_history,                     # or get_redis_history, get_dynamo_history
    input_messages_key="input",
    history_messages_key="history",
)

# Async version — use SQL with async driver or the async-friendly backends
# (make sure to use the async variant of the history class if your chain is async)

from langchain_core.runnables import ConfigurableFieldSpec
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import SQLChatMessageHistory

def get_session_history(user_id: str, conversation_id: str):
    """Look up history scoped to both user and conversation."""
    return SQLChatMessageHistory(
        session_id=f"{user_id}:{conversation_id}",
        connection="postgresql+psycopg2://...",
    )

chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
    history_factory_config=[
        ConfigurableFieldSpec(
            id="user_id",
            annotation=str,
            name="User ID",
            description="The current user's ID",
            default="",
            is_shared=True,
        ),
        ConfigurableFieldSpec(
            id="conversation_id",
            annotation=str,
            name="Conversation ID",
            description="This conversation's ID within the user's history",
            default="",
            is_shared=True,
        ),
    ],
)

# Invoke with the extra config
config = {
    "configurable": {
        "user_id": "alice_42",
        "conversation_id": "conv_2026_07_30_001",
    }
}

response = chain_with_history.invoke({"input": "Hello"}, config=config)