Does it work with BufferMemory and ConversationChain?

Yes, DialogueChatHistory works with BufferMemory and ConversationChain. Pass new DialogueChatHistory({ dialogueId: sessionId, namespace: userId }) as the chatHistory prop on BufferMemory (or ConversationSummaryMemory, ConversationTokenBufferMemory, and other classic memory classes) and everything keeps working with persistent storage.

What happens to tool calls and tool results?

The reference DialogueChatHistory class persists each message as a role and text content. For agent runs, that is typically enough context to resume the conversation and let the model plan the next tool call. If the app needs to replay structured tool_call objects verbatim, extend the class to serialize the full BaseMessage into the DialogueDB content and metadata fields.

Can I use DialogueChatHistory inside a LangGraph node?

Yes, DialogueChatHistory works inside a LangGraph node. LangGraph nodes accept LangChain message history classes through the standard interface, so instantiate DialogueChatHistory inside the node and read or write to it exactly as you would in a chain.

How do I scope conversations per user with Clerk, Auth.js, or NextAuth?

Pass the user ID from your auth provider as the namespace on every read and write. Namespaces are the DialogueDB way of isolating one user, tenant, or workspace at the data layer, so scoping stays out of your chain code.

I already use a Redis-backed history class. How do I migrate?

Read your existing Redis conversation keys, group messages by session ID, and write each session as a DialogueDB dialogue with dialogue.saveMessages. Namespaces map to your user identifier. Once the backfill completes, swap the chatHistory field in your memory constructor and remove the Redis dependency.

Is there a Python version of the DialogueDB SDK?

No, DialogueDB currently offers a TypeScript client. LangChain.js is fully supported. A Python client is on the roadmap.

Where does DialogueDB not fit for LangChain?

DialogueDB stores conversational content: messages, memory values, and dialogue state. Large binary attachments, embeddings for your own document corpus, and RAG over private knowledge bases remain the job of LangChain retrievers and dedicated vector stores.

LangChain Integration

Drop-in chat history and memory for LangChain

A managed chat history for LangChain chains and agents. Long-term user memory and semantic search included, no vector database to run.

Get Your Free API Key See Example Code

BufferMemory

ConversationSummaryMemory

RunnableWithMessageHistory

implements BaseListChatMessageHistory

DialogueChatHistory

Backed by DialogueDB

Messages

Memory

Where the default chat history stops

The default chat history is scoped to a single process

Every LangChain memory class delegates to a chat history object. The default, InMemoryChatMessageHistory, keeps messages in an in-process array and drops them on restart. Fine for local development, and short on the guarantees a chatbot needs when it runs on serverless, in a container, or across multiple worker instances.

How the default is built

Every message lives in a plain array on one instance
One chain instance per session, no shared state model
Message history only, nothing for facts or preferences
Retrieval walks the array, no semantic query

Where it hits the wall

Restarts, deploys, and serverless cold starts wipe every user
Multi-instance workers don't see each other's history
Nothing to carry facts about a user across sessions
"What did we discuss about X" needs a separate search stack

What DialogueDB adds

A managed chat history for LangChain, plus three things the defaults leave out

The chat history class implements the interface every LangChain memory surface already accepts, so nothing about the chain changes. DialogueDB then covers the three concerns the defaults leave for the developer to solve.

Chat history that survives every restart

Every message from every user persists to DialogueDB. Chains and agents keep their context across deploys, cold starts, and multi-instance workers.

Namespaces for multi-user chains

Pass a namespace on every read and write. Conversations, memory, and search stay isolated per user, tenant, or workspace at the data layer.

Memory that carries across sessions

Store facts and preferences the assistant should remember beyond a single conversation. Retrieve them on the next run to seed the system prompt.

Semantic search over past runs

Query past messages and memory by meaning, not keyword. Inject into a prompt or expose as a tool the agent can call, no vector database to run.

The integration pattern

Add DialogueChatHistory to the memory constructor, and the chain runs exactly as it did before

One line in the constructor persists every message the chain touches. Two optional calls around the run cover long-term memory and semantic search, and nothing else about the chain code has to change.

The patternchain-run.ts

const db = new DialogueDB()

// 1. Construct DialogueChatHistory
const history = new DialogueChatHistory({
  dialogueId: sessionId,
  namespace: userId,
})

// 2. Wire it into the memory class
const memory = new BufferMemory({
  chatHistory: history,
  returnMessages: true,
})

// 3. Search memory (optional)
const facts = await db.searchMemories(
  userInput, { namespace: userId }
)

// 4. Run the chain
const chain = new ConversationChain({ llm, memory })
const result = await chain.call({ input: userInput })

// 5. Save new facts (optional)
await db.createMemory({ value: newFact, namespace: userId })

What this unlocks in your LangChain app

Six patterns the integration makes shorter to build.

Chatbots that survive every deploy

A chain that talked to a user yesterday picks up the same conversation today, even if the process restarted in between.

DialogueChatHistory

Support agents that carry ticket history

Every past conversation about a customer is a load call away. The agent picks up mid-thread without you re-hydrating context.

dialogueId

Onboarding chains with real user profiles

As the assistant learns preferences and answers, store them as Memory objects. The next session starts with a profile, not a blank slate.

db.createMemory()

Agent conversations that pick up where they stopped

On restart, the agent reloads every prior message from DialogueDB and continues with full context of what the last run said and answered.

DialogueChatHistory

Multi-tenant SaaS with per-user isolation

One codebase, many customers, each with their own namespace. No cross-tenant leakage, no WHERE clauses in your chain code.

namespace: userId

Recall past runs by meaning

Search over every past conversation, scoped to a namespace. Answer "what did we discuss about X" even when the reader phrased it differently.

db.searchMessages()

Install in 3 steps

From npm install to the first message that survives a restart, in under five minutes.

Install the client

npm install dialogue-db

Set the API key

DIALOGUE_DB_API_KEY=...

Drop in the chat history

new BufferMemory({
  chatHistory: new DialogueChatHistory({
    dialogueId: sessionId,
    namespace: userId,
  }),
})

Copy the class from the examples repo.

Get Your Free API Key

No credit card. Free tier to start. Starter is $29/month when usage grows.

The reference example

A LangChain example repo with two runnable samples, cloneable and locally runnable in about a minute.

hello-world.tsView source →

A conversation chain that survives a cold restart

A BufferMemory and ConversationChain with a DialogueDB-backed chat history. Runs a short exchange, restarts the process, and continues with the earlier context intact.

agent-with-tools.tsView source →

A tool-calling agent that resumes on the next call

A createToolCallingAgent with two example tools and a DialogueDB-backed chat history. Runs a multi-step query, restarts the process, and picks up a follow-up in the same thread.

Read the DialogueChatHistory class

The full implementation lives in the same example repo. Select a section to jump to its lines.

Clone the full example repo

src/lib/dialogue-history.ts

import { BaseListChatMessageHistory } from "@langchain/core/chat_history"

import { BaseMessage, HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages"

import { DialogueDB, type Dialogue } from "dialogue-db"

export class DialogueChatHistory extends BaseListChatMessageHistory {

lc_namespace = ["langchain", "stores", "message", "dialoguedb"]

private db = new DialogueDB()

private dialogue: Dialogue | null = null

constructor(private opts: { dialogueId: string; namespace: string }) { super() }

private async ensureDialogue() {

this.dialogue ??= await this.db.getOrCreateDialogue({

id: this.opts.dialogueId, namespace: this.opts.namespace

})

return this.dialogue

}

async getMessages(): Promise<BaseMessage[]> {

const dialogue = await this.ensureDialogue()

await dialogue.loadMessages({ order: "asc" })

return dialogue.messages.map((m) => {

const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content)

switch (m.role) {

case "user": return new HumanMessage(content)

case "assistant": return new AIMessage(content)

case "system": return new SystemMessage(content)

default: return new HumanMessage(content)

}

})

}

async addMessage(message: BaseMessage): Promise<void> {

const dialogue = await this.ensureDialogue()

const role = toRole(message)

await dialogue.saveMessage({ role, content: typeof message.content === "string" ? message.content : JSON.stringify(message.content) })

}

Condensed view. Full source at github.com/dialoguedb/examples.

Where DialogueDB fits

Options for LangChain chat history and cross-session memory, side by side.

	InMemoryChatMessageHistory LangChain default	Redis or SQL history @langchain/community classes	Standalone memory service Facts and preferences only	DialogueDB
Persists messages	No, in-process	Yes	Facts only	Yes, every message
Multi-user isolation	None	Bring your own	By user ID	Namespaces, first-class
Long-term memory across sessions	No	No	Yes	Yes, Memory objects
Semantic search over past runs	No	Build it yourself	Facts only	Every message and memory
Infra to run	None (in-process)	Redis or DB you host	Their managed service	Managed

If you know LangChain, you already know DialogueDB

The concepts map one-to-one to what LangChain already exposes.

LangChain	DialogueDB
`BaseListChatMessageHistory`	`DialogueChatHistory`
`HumanMessage`, `AIMessage`, `SystemMessage`	`message` with `role`
Session identifier from your app	`dialogueId`
User from your auth layer	`namespace`
Tool call on an AIMessage	`message` content and metadata (extend the class to serialize)
Facts the assistant should carry	`memory`

Frequently asked questions

One API for messages, memory, and search

Add it to your LangChain app in minutes.

Get Your Free API Key See Example Code