What actually works for LangChain memory management in production?

Hey folks! 👋 I've been working with LangChain in production for a few months now, and memory management has been one of the trickiest parts to get right. The docs show a lot of options, but which ones actually hold up under real load? I wanted to share what's worked for me and see what others have found.

For our chatbot handling hundreds of concurrent sessions, we started with the simple `ConversationBufferMemory`. It worked in dev, but quickly fell apart in production because it just kept growing. We switched to `ConversationBufferWindowMemory` to limit token usage, which helped, but we still needed persistence. Here's our current setup using Redis for memory backends:

```python
from langchain.memory import RedisChatMessageHistory, ConversationBufferWindowMemory

redis_url = "redis://localhost:6379/0"
message_history = RedisChatMessageHistory(
session_id="user_session_123",
url=redis_url,
key_prefix="langchain:memory:"
)

memory = ConversationBufferWindowMemory(
chat_memory=message_history,
k=10, # Keep last 10 exchanges
return_messages=True,
memory_key="chat_history"
)
```

**What actually worked for us:**
- **Redis backend**: Reliable and fast for production-scale sessions
- **Windowed memory**: Keeping `k=10-15` exchanges balances context vs token costs
- **Session TTLs**: Setting expiry on Redis keys (e.g., 24 hours) prevents memory leaks
- **Separate memory chains**: Using different memory instances for different conversation types (e.g., customer support vs data querying)

We also tried `ConversationSummaryMemory` but found the summarization added latency and sometimes lost important nuances. For cost-sensitive applications, we've had success with `ConversationTokenBufferMemory` using token counting with tiktoken.

**Biggest pitfalls we hit:**
- Not cleaning up old sessions (hence the TTLs!)
- Assuming memory would automatically handle context truncation (it doesn't)
- Forgetting that some memory backends don't play nicely with all chain types

What's working for everyone else? Have you found a sweet spot for memory window sizes? Any other backends (Postgres, MongoDB) that handle high concurrency well?

Happy coding!