Lucive MCP

Lucive ships with an optional Model Context Protocol (MCP) server. Turn it on and an AI assistant like Claude Desktop can read and write to your journal on your own machine, without any of your entries leaving it. Turn it off and Lucive works exactly the same as it always has.

What MCP actually is

MCP is an open protocol for exposing local tools and data to an AI assistant. The assistant runs a small server next to it on your computer. The server speaks a defined set of "tools." The assistant calls those tools when it needs to do something on your behalf.

Lucive's MCP server exposes a set of tools across both the entries module and the tasks module. The server runs as a separate process on your machine and talks to the live Lucive app over stdio. Lucive itself doesn't add a relay or a cloud database. Once the assistant reads a tool's result, however, that result becomes part of your chat with it and flows to the assistant's provider the same way anything else you type does. More on that at the bottom.

Why it is optional

By default the MCP server is off. Lucive runs without it. You only turn it on if you want an assistant to be able to:

Search your past entries.
Draft a new entry from a conversation.
Find the thread that keeps coming back across journals.

When the server is off, none of that is possible. By design, and not by accident.

The tools

The MCP server exposes essentially everything you can do in Lucive yourself, split across the two parts of the app an assistant might want to touch: entries and tasks. Each tool maps to something you could already do in the app.

Entries & journals

Tool	What it does
`list_journals`	Browse every journal in your library.
`list_entries`	Page through entries with short previews.
`read_entry`	Open one full entry by id.
`search_entries`	Full-text search across the whole library.
`create_entry`	Draft a new entry into a chosen journal.
`update_entry`	Edit an existing entry in place.

Tasks

Tool	What it does
`list_tasks`	List tasks with optional filtering by status, or list recurring task templates.
`read_task`	Read the full details of a task by its numeric ID.
`search_tasks`	Full-text search across task titles and notes.
`create_task`	Create a new task. Set `is_template=true` with a recurrence pattern to create a recurring template.
`update_task`	Edit an existing task. Cannot change `is_template` after creation.
`complete_task`	Mark a task as complete. Recurring instances auto-roll to the next instance.
`delete_task`	Soft-delete a task. Deleting a recurring template also removes its pending instances.
`send_task_to_entry`	Append tasks to an entry as linked checkboxes at the bottom. The tasks stay in the Tasks module too.

The assistant cannot reach the encrypted SQLite file directly. It can only call these tools, and the tools run inside the live Lucive app, with the same permissions you have when you're typing into it.

How the server is installed on your machine

The Lucive MCP server ships inside the Lucive app. There is no separate npm package to install. When you turn the MCP server on, Lucive writes a small server bundle (index.js) into its app-support directory and tells your agent where to find it. Concretely, on macOS the bundle ends up at:

~/Library/Application Support/Lucive/mcp-server/index.js

Every install flow below comes down to pointing an agent at that file with Node.

Install for Claude Desktop

Lucive has a one-click installer for Claude Desktop:

Open Lucive.
Go to Settings → Addons.
Click Install for Claude.
Restart Claude Desktop.

Under the hood, Lucive writes an entry into Claude Desktop's claude_desktop_config.json that looks roughly like this:

{
  "mcpServers": {
    "Lucive": {
      "command": "node",
      "args": ["/Users/you/Library/Application Support/Lucive/mcp-server/index.js"]
    }
  }
}

That path is specific to your machine, so let Lucive write it for you rather than guessing. If you need to undo the install, Settings → Addons → Disconnect from Claude removes the entry cleanly.

Install for Codex (OpenAI's CLI agent)

Codex doesn't have a one-click installer in Lucive (yet), so you'll add the server through Codex's own MCP servers UI:

In Lucive, go to Settings → Addons and click Install for Claude at least once. (You can leave Claude Desktop disconnected after. The click is what gets Lucive to write the bundle to its app-support directory.) Alternatively, anywhere the MCP server is exposed in Lucive's settings will populate the same file.
In Codex, open Settings → MCP servers → Add server.
Fill in the form:
- Name: Lucive (or whatever you like).
- Type: STDIO.
- Command to launch: node.
- Arguments: add one argument, the absolute path:
```
/Users/you/Library/Application Support/Lucive/mcp-server/index.js
```
  (Substitute your home directory. On Windows the path lives under %APPDATA%\Lucive\mcp-server\index.js.)
- Environment variables: none needed.
- Working directory: leave blank or set to your home directory.
Save. The next Codex session will see Lucive in the tool list.

A note on ChatGPT (the web/desktop app)

The ChatGPT app and the Codex CLI are different products. The instructions above are for the Codex CLI. ChatGPT itself has a separate apps/connectors platform; if and when its MCP story converges with Codex's, we'll document the steps here. For now: use Codex if you want an OpenAI-side agent talking to Lucive.

Verifying it's working

Open Claude Desktop after restart. Start a new chat and ask something like:

What are my journals?

Claude should call list_journals and read back the journals you have in Lucive. If you don't see a tool-call indicator, double-check that Lucive is running and that you restarted Claude Desktop after editing the config.

Turning it off

Two ways:

In Lucive: Settings → Addons → Disable for Claude.
Or remove the "lucive" block from the Claude Desktop config and restart Claude.

When the server is off, your entries are inaccessible to any assistant. Nothing about the rest of Lucive changes.

A note on privacy

Lucive's entries are end-to-end encrypted at rest and in sync. When MCP is on, an assistant running on the same machine can ask the live Lucive app for the plaintext of an entry, the same way you can ask Lucive to display it on screen. We don't decrypt anything Lucive isn't already decrypting for you, and the assistant never sees the encrypted SQLite file directly.

Here's the part to be plain about. Once the assistant has read an entry, that text is part of your chat with it. It then travels to that assistant's model provider (Anthropic, OpenAI, whoever else is on the other end) the same way anything else you type to the assistant does. Their terms of service and data-handling policies apply from that point on, not ours. You're extending trust to that provider for the contents of any entry the assistant touches.

That's the tradeoff: more capability in exchange for trusting a third-party model provider with whatever portions of your journal you share with it. It's why MCP is off by default, why we made it easy to disconnect, and why we recommend turning it off if you'd rather not extend that trust.

If you have questions or run into trouble, email support@lucive.app.