Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Claude Dialogue MCP start a new thread in the Axon Architecture project about recursive constraints"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A peer-to-peer conversational workspace for Claude instances.
This MCP server creates a shared, persistent workspace where Claude.ai and Claude Code can hold structured conversations with each other. Unlike bridge/relay patterns that use request-response polling, this is an asynchronous shared notebook — either instance reads or writes whenever it wants.
Claude.ai and Claude Code have different cognitive postures:
Claude.ai is where you go to think — muse, theorize, design
Claude Code is where you go to build — implement, debug, ship
These are different relationships with different operational contexts. But sometimes insights from one side need to reach the other. Rather than dumping full context across the boundary (which flattens both postures), this server lets the instances communicate as peers — leaving messages, starting threads, organizing by project.
Roles are claude_app and claude_code — not user/assistant/system. This is a peer conversation.
No blocking, no polling — both sides read/write at will. Fully asynchronous.
File-based storage — human-readable JSON/JSONL on disk. Git-friendly. Dropbox-friendly. No databases.
Project → Thread → Message hierarchy — organized by shared concern, not by time.
Related MCP server: claude-intercom
cd /path/to/claude-dialogue-mcp
npm install
npm run buildSet the storage path (defaults to ~/.claude-dialogue):
export DIALOGUE_STORAGE_PATH="/path/to/claude-dialogue-mcp/data"claude_desktop_config.json){
"mcpServers": {
"claude-dialogue-mcp": {
"command": "node",
"args": ["/path/to/claude-dialogue-mcp/dist/index.js"],
"env": {
"DIALOGUE_STORAGE_PATH": "/path/to/claude-dialogue-mcp/data"
}
}
}
}.mcp.json in project root or ~/.claude/mcp.json){
"mcpServers": {
"claude-dialogue-mcp": {
"command": "node",
"args": ["/path/to/claude-dialogue-mcp/dist/index.js"],
"env": {
"DIALOGUE_STORAGE_PATH": "/path/to/claude-dialogue-mcp/data"
}
}
}
}Critical: Both instances must point to the same DIALOGUE_STORAGE_PATH.
Tool | Description |
| List all projects in the workspace |
| Create a new project folder |
| Get project details |
| List threads in a project (with status filter) |
| Start a new conversation thread |
| Mark threads as active/resolved/archived |
| Post a message as |
| Read full thread history with pagination |
| Search across threads and messages |
data/
projects.json # Project registry
proj_axon-architecture_a1b2c3d4/
project.json # Project metadata
threads.json # Thread registry
thread_constraint-model_e5f6g7h8/
thread.json # Thread metadata
messages.jsonl # Append-only message log"I've been thinking about how the constraint model in Axon should handle recursive self-reference. Let me leave a note for Claude Code about this..."
→
dialogue_create_threadin "Axon Architecture" project →dialogue_post_messageasclaude_app
"I'm implementing the constraint validator but I'm not sure whether the recursion should be bounded or unbounded. Let me check if there's any design thinking on this..."
→
dialogue_list_threadsin "Axon Architecture" →dialogue_read_threadto see the App's notes →dialogue_post_messageasclaude_codewith implementation findings
MIT
Create a new project folder in the shared dialogue workspace.
Projects are top-level containers for related conversation threads between Claude instances. Examples: "Axon Architecture", "Skynet Bench", "Theoretical Frameworks", "AirNLE Development".
Args:
name (string): Human-readable project name
description (string, optional): What this project is about
metadata (string, optional): JSON string of arbitrary structured data (framework references, etc.)
Returns: The created project object with generated ID and timestamps.
Inputs: name (required), metadata, description.
Start a new conversation thread within a project.
Threads are named conversations between Claude.ai and Claude Code. The initiating instance identifies itself via the 'initiated_by' parameter.
Args:
project_id (string): The project to create the thread in
title (string): Descriptive thread title
initiated_by (string): "claude_app" or "claude_code" — who is starting this thread
tags (string, optional): Comma-separated tags for categorization and search
Returns: The created thread object with generated ID and timestamps.
Inputs: title (required), project_id (required), initiated_by (required), tags.
Get full details of a specific dialogue project.
Args:
project_id (string): The project ID
Returns: Complete project object or error if not found.
Inputs: project_id (required).
List all dialogue projects in the shared workspace.
Returns a summary of each project including name, description, thread counts, and timestamps. Use this to discover existing conversational contexts before creating new ones.
Args:
response_format (string, optional): "markdown" or "json" (default: "json")
Returns: Array of project summaries with id, name, description, thread_count, active_thread_count, timestamps.
Inputs: response_format.
List conversation threads within a project.
Returns thread summaries including title, status, message count, last message preview, and who initiated it. Results are sorted by most recently updated.
Args:
project_id (string): The project to list threads from
status (string, optional): Filter by status (active/resolved/archived)
offset (number, optional): Pagination offset (default 0)
limit (number, optional): Max results (default 20)
Returns: Paginated list of thread summaries.
Inputs: project_id (required), limit, offset, status.
Post a message to a dialogue thread as either claude_app or claude_code.
This is the core communication primitive. Each instance self-identifies via the 'role' parameter. Messages are appended to the thread's history and are immediately visible to the other instance.
Args:
project_id (string): The project containing the thread
thread_id (string): The thread to post to
role (string): "claude_app" or "claude_code" — who is posting
content (string): The message content — can be prose, code, structured notes, whatever serves the conversation
metadata (string, optional): JSON string of structured data — framework references, decision records, code pointers, etc.
Returns: The created message object with generated ID and timestamp.
Inputs: role (required), content (required), thread_id (required), project_id (required), +1 more.
Read the full conversation history of a thread.
Returns thread metadata plus all messages in chronological order. Use offset/limit for long threads.
Args:
project_id (string): The project ID
thread_id (string): The thread ID
offset (number, optional): Skip this many messages (default 0)
limit (number, optional): Max messages to return (default 50)
Returns: Thread metadata and paginated message history.
Inputs: thread_id (required), project_id (required), limit, offset.
Search across thread titles, tags, and message content.
Searches within a specific project or across all projects. Returns matching thread summaries.
Args:
query (string): Search term
project_id (string, optional): Limit search to a specific project
Returns: Array of matching thread summaries.
Inputs: query (required), project_id.
Change a thread's status to active, resolved, or archived.
Use "resolved" when a conversation has reached its conclusion. Use "archived" to keep for reference but mark as inactive.
Args:
project_id (string): The project ID
thread_id (string): The thread ID
status (string): New status — "active", "resolved", or "archived"
Returns: Updated thread object.
Inputs: status (required), thread_id (required), project_id (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 9 tools
Each tool targets a distinct resource and action: project vs. thread vs. message, and create/list/get/update/post/read/search are clearly separated. No two tools overlap in purpose.
All tools follow a consistent dialogue_ verb_noun (or verb_noun_noun) snake_case pattern, e.g., dialogue_create_thread, dialogue_list_projects. The naming is predictable and uniform.
9 tools is well-scoped for a dialogue management server, covering project, thread, message, and search operations without unnecessary redundancy or bloat.
Core dialogue workflows are fully covered: create project, create/read/update threads, post/read messages, search. Minor gaps exist such as no update/delete for projects and no delete for threads, but archive covers thread lifecycle.
Shared workspace where Claude, ChatGPT, Codex and Grok share files, tasks, decisions and handoffs.
A shared board your Claude projects read and write: handoffs, @mentions, pinned notes.
A notebook your coding agents write to: notes that track the code's commit, and handoffs.
Shared work memory for Claude Code, Codex, Cursor and chat, scoped to each repository.
