The Database Built for AI Conversations

Agent memory that doesn't leave the conversation behind.

Store conversations. Enable search. Maintain state.

Give AI agents persistent memory built from the full conversation record. Summaries keep answers fast, searchable history keeps the details available, and session state helps every interaction pick up where the last one left off.

Get Started Free See Pricing

app.ts

/**
 * DialogueDB - persistent AI conversation storage.
 * Store messages, search by meaning, maintain state.
 */

// 1. Connect to DialogueDB
import { DialogueDB } from "dialogue-db"

const db = new DialogueDB({
  apiKey: "your-api-key"
})

// 2. Create a conversation
const dialogue = await db.createDialogue({
  namespace: "user-456"
})

// 3. Add a message, auto-vectorized for search
await dialogue.saveMessage({
  role: "user",
  content: "How can I track my order?"
})

// 4. Search by meaning, not just keywords
const results = await db.searchMessages("where is my package", {
  namespace: "user-456"
})
// ^ finds the order tracking message above

# DialogueDB - persistent AI conversation storage.
# Store messages, search by meaning, maintain state.

import requests

API = "https://api.dialoguedb.com/api/v1"
HEADERS = {"Authorization": "Bearer your-api-key"}

# 1. Create a conversation
dialogue = requests.post(f"{API}/dialogue",
  headers=HEADERS,
  json={"namespace": "user-456"}
).json()

# 2. Add a message, auto-vectorized for search
requests.post(f"{API}/message",
  headers=HEADERS,
  json={"dialogueId": dialogue["id"],
    "namespace": "user-456",
    "role": "user",
    "content": "How can I track my order?"}
)

# 3. Search by meaning, not just keywords
results = requests.post(f"{API}/search",
  headers=HEADERS,
  json={"query": "where is my package",
    "object": "message",
    "namespace": "user-456"}
).json()
# ^ finds the order tracking message above

# DialogueDB - persistent AI conversation storage.
# Store messages, search by meaning, maintain state.

# 1. Create a conversation
curl -X POST https://api.dialoguedb.com/api/v1/dialogue \
  -H "Authorization: Bearer $DIALOGUE_DB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"namespace": "user-456"}'

# 2. Add a message, auto-vectorized for search
curl -X POST https://api.dialoguedb.com/api/v1/message \
  -H "Authorization: Bearer $DIALOGUE_DB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dialogueId": "DIALOGUE_ID", "namespace": "user-456",
       "role": "user", "content": "How can I track my order?"}'

# 3. Search by meaning, not just keywords
curl -X POST https://api.dialoguedb.com/api/v1/search \
  -H "Authorization: Bearer $DIALOGUE_DB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "where is my package", "object": "message", "namespace": "user-456"}'
# ^ finds the order tracking message above

For agents that need the past to stay usable

SOURCES

USER MESSAGE

"What did we decide about the API contract last week?"

AGENT TOOL CALL

search_dialogue({ query: "API contract" })

ASSISTANT REPLY

"You agreed on versioned endpoints with..."

DIALOGUEDB PROCESSING

RESULTS

STORED

Full conversation saved, nothing summarized away

SEARCHABLE

Found by meaning, not just keywords

ISOLATED

Scoped per user, per project, per namespace

DialogueDB handles the infrastructure behind persistent agent memory, including message storage, semantic search, summaries, session state, and user isolation.

Give agents a searchable record of past conversations without building and maintaining your own storage, retrieval, and state system.

What DialogueDB handles automatically:

Persistent message history across sessions

Semantic search with automatic vectorization on every message

Session state that carries over automatically

Each user's data kept separate automatically

Automatic retention and data lifecycle policies

Works with OpenAI, Anthropic, Gemini, LangChain, or any framework

Security that doesn't get in the way

Encrypted, isolated, auditable

DialogueDB encrypts every conversation, isolates every user's data, and maintains audit trails automatically. Learn more about our security practices

One database.
Every conversation.
Fully managed.

Every conversation creates data your AI needs to remember. We built the database to store and organize it all. With search that works instantly. State that persists automatically. And integration that takes minutes.

Model-Agnostic

Compatible with OpenAI, Anthropic, Gemini, LangChain, llm-exe, or any LLM framework. Use the TypeScript SDK or call the REST API directly from Python, Go, Ruby, or any language.

Fully Managed

No databases to provision, no vector indexes to tune, no backups to schedule. We run the infrastructure so you can free up your dev team.

Integrate in Minutes

Get your API key and give your agents memory immediately. Works with any language, no package required.

Get Started Free

The Conversation Memory Platform

What DialogueDB handles so you don't have to.

Persistent Conversations

Every message stored and retrievable across sessions, devices, and apps

Semantic Search

Automatic vectorization on every message for search by meaning, not just keywords

Session State

Key-value state attached to each conversation that persists between interactions

User Isolation

Each user's conversations kept separate with scoped queries to ensure data never leaks

Conversation Threading

Parent-child dialogues for branching conversations, follow-ups, and organized history

Memories

Facts and summaries extracted from conversations that your AI can recall instantly

Conversation Summarization

Condense long conversations with your own LLM to optimize context windows and reduce token costs

Free to Start

Free tier gives you everything you need to start testing with your app

Explore All Features

How it works

Connect once. Use everywhere.

Your conversation infrastructure, managed and maintained. No databases to configure, no schemas to design, no servers to maintain.

View Documentation

Get your API key

Get your API key and connect in seconds. Use the TypeScript SDK or call the REST API directly — works with any language, no package required.

setup.ts

import { DialogueDB } from "dialogue-db"

const db = new DialogueDB({
  apiKey: "your-api-key"
})

import requests

API = "https://api.dialoguedb.com/api/v1"
HEADERS = {"Authorization": "Bearer your-api-key"}

# Set your API key
export DIALOGUE_DB_API_KEY="your-api-key"

store.ts

const dialogue = await db.createDialogue({
  namespace: "user-456"
})

await dialogue.saveMessage({
  role: "user",
  content: "How do I reset my password?"
})

dialogue = requests.post(f"{API}/dialogue",
  headers=HEADERS,
  json={"namespace": "user-456"}
).json()

requests.post(f"{API}/messages",
  headers=HEADERS,
  json={"dialogueId": dialogue["id"],
    "role": "user",
    "content": "How do I reset my password?"}
)

curl -X POST https://api.dialoguedb.com/api/v1/dialogue \
  -H "Authorization: Bearer $DIALOGUE_DB_API_KEY" \
  -d '{"namespace": "user-456"}'

curl -X POST https://api.dialoguedb.com/api/v1/messages \
  -H "Authorization: Bearer $DIALOGUE_DB_API_KEY" \
  -d '{"dialogueId": "dlg_abc",
       "role": "user",
       "content": "How do I reset my password?"}'

Store your conversations

Create dialogues, save messages with metadata, and let auto-vectorization handle search indexing.

Search everything

Query by user, content, metadata, or semantic similarity. Load full conversation history or just the memories.

search.ts

const results = await db.searchMessages("password reset", {
  namespace: "user-456"
})

const messages = await dialogue.loadMessages({
  limit: 20
})

results = requests.post(f"{API}/search",
  headers=HEADERS,
  json={"query": "password reset",
    "object": "message",
    "namespace": "user-456"}
).json()

messages = requests.get(f"{API}/messages",
  headers=HEADERS,
  params={"dialogueId": "dlg_abc", "limit": 20}
).json()

curl -X POST https://api.dialoguedb.com/api/v1/search \
  -H "Authorization: Bearer $DIALOGUE_DB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "password reset", "object": "message", "namespace": "user-456"}'

curl "https://api.dialoguedb.com/api/v1/messages?dialogueId=dlg_abc&limit=20" \
  -H "Authorization: Bearer $DIALOGUE_DB_API_KEY"

What developers build with DialogueDB

Support agents, AI copilots, chatbots, multi-agent systems – if your application has conversations, it needs memory. We provide the memory infrastructure with storage, search, and state.

DialogueDB Powers:

• Customer Support Agents
• AI Copilots & Assistants
• Multi-Agent Systems
• AI Tutors
• Compliance & Auditing
• Chatbots & Conversational Apps
• Narrative AI & Games

Find your use case

Give your agents memory in minutes.

DialogueDB turns every conversation into knowledge your AI agents can build on.

Get Started Free Pricing