← Quickstart / MCP setup

MCP setup

Connect Lorah to everything else.

Use Lorah as an MCP server so Claude Desktop / Cursor / Claude Code can read its context, or let a Lorah teammate connect to an external MCP tool. Write-back always lands in your Review Queue.

What it is

Lorah supports MCP — the Model Context Protocol — so your workspace can connect with external AI tools and services. MCP is a standard way for AI tools to exchange context and use each other’s tools.

In Lorah, MCP answers three questions:

1

An external client reads Lorah.
Claude Desktop, Cursor or Claude Code talk to Lorah’s MCP server and read approved workspace context: memory, decisions, glossary.
2

An external client proposes memory.
The same client can submit an item or a session summary. It lands in your Review Queue, never directly in memory.
3

A Lorah teammate uses an external tool.
A teammate inside Lorah uses a Command, an MCP stdio server, or an MCP SSE server as its connection.

Plan and platforms. All three need Pro. On Free the server still lists its tools but refuses to run them. The server config panel is in Lorah on Windows and macOS.

Lorah as an MCP server

Use this when you want an external MCP-compatible client to connect to Lorah — Claude Desktop, Cursor, Claude Code, or any MCP client.

Lorah exposes workspace tools through a local MCP server. External clients can read approved workspace context and, where supported, submit items back into Lorah.

External tools can propose. You approve what becomes memory.

Write tools queue items into the Review Queue. Nothing enters Lorah’s project memory automatically.

What a client reads leaves Lorah. Lorah’s review gate covers what comes back, not what the client does with what it read; check that client’s own data policy.

Where to find it

In Lorah, open Settings → Advanced → MCP server. You’ll see a configuration block with the real path for your install already filled in:

{
  "mcpServers": {
    "lorah": {
      "command": "/Applications/Lorah.app/Contents/MacOS/Lorah",
      "args": [
        "/Applications/Lorah.app/Contents/Resources/app.asar.unpacked/out/kernel/mcp-main.js"
      ],
      "env": {
        "ELECTRON_RUN_AS_NODE": "1",
        "BOND_KERNEL_DATA_ROOT": "<your Lorah data folder>",
        "BOND_MCP_WORKSPACE_ID": "<the workspace you picked>",
        "BOND_KERNEL_PACKAGED": "1"
      }
    }
  }
}

The paths above are the macOS shape; on Windows the command points at Lorah.exe and the same four environment variables are filled in for you. The server is bound to one workspace, and the block embeds which one.

Copy the block exactly as the app shows it (the Copy button does that) into your MCP client’s config file. For Claude Desktop:

macOS:    ~/Library/Application Support/Claude/claude_desktop_config.json
Windows:  %APPDATA%\Claude\claude_desktop_config.json

After saving, restart the external client.

Lorah — Settings → Advanced → MCP server block

What the external client can do

Five tools, the same five the MCP Server panel lists: search_memory, get_recent_decisions and get_glossary read approved workspace memory; queue_for_review and submit_summary write. Read tools retrieve Lorah workspace context. Write tools submit proposed updates back into Lorah. Write-back is review-gated — proposed items appear in the Review Queue before they become project memory.

Revoke or move access

There is no token in the block: the config is a local command, the path to Lorah’s MCP entry point, and the id of the workspace it may read. To revoke a client, delete the lorah block from that client’s config. To point a client at a different workspace, pick the workspace in the MCP Server panel and copy the block again. The server runs only on your computer and only while a client is talking to it.

A Lorah teammate using MCP

Use this when you want a teammate inside Lorah to connect to an external tool or MCP server — Claude Code, a local CLI, a local stdio server, a remote SSE server, or a service like Linear or GitHub through an MCP-compatible connector.

Open the teammate’s settings (the pencil beside the picker at the top), go to the Engine tab, and set the provider to MCP Agent. The MCP Connection section appears. Lorah supports three connection modes:

Mode · Command

Command

For local command-line tools that accept input on stdin and return output in the terminal. Useful for Claude Code-style workflows.

Command:    claude
Arguments:  -p

Command: The command to run. Example: claude
Arguments: Space-separated arguments. Example: -p
Persistent session: Keeps conversation continuity across messages when the tool supports it.
Task timeout: How long Lorah waits before stopping a long-running tool call.

Lorah — Teammate edit modal showing MCP Connection in Command mode

Mode · MCP stdio

MCP stdio

For a local MCP server that communicates over standard input and output. The standard mode for most local MCP servers.

Command:    npx
Arguments:  -y my-mcp-server

Command: The executable that starts the MCP server.
Arguments: Space-separated arguments passed to the command.
Environment variables: Optional secrets the MCP server needs. Stored encrypted in your OS keychain. Do not put secrets into Workspace Context.

Lorah — Teammate edit modal showing MCP Connection in MCP stdio mode with Environment Variables

Mode · MCP SSE

MCP SSE

For a remote MCP server over Server-Sent Events. Use this mode only for MCP servers you trust.

Server URL: https://example.com/sse

Server URL: The SSE endpoint for the remote MCP server.
Tool name: Optional. Leave blank if you want the teammate to pick the right tool based on the message.
Workspace context: Optional notes injected into the tool-selection prompt — workspace IDs, naming conventions. Never put API keys or credentials here.

Lorah — Teammate edit modal showing MCP Connection in MCP SSE mode with Server URL, Tool name, and Workspace Context

Secrets & context

For secrets

Environment variables

API keys, tokens, anything sensitive an MCP tool needs. For example: LINEAR_API_KEY, GITHUB_TOKEN. Lorah stores these encrypted in your OS keychain and passes them to the MCP subprocess at dispatch time — never written into the teammate prompt or workspace context.

For routing

Workspace context

Non-secret operational notes the tool needs to choose correctly — workspace IDs, team keys, default project names. Example: Use workspace ID abc123. Use team key ENG. Do not put API keys, tokens, passwords, or any private credentials in Workspace Context.

Review Queue and write-back

If an MCP tool sends something back into Lorah, it doesn’t automatically become durable project memory. It lands in the Review Queue. From there you can:

approve it
edit it
reject it
dismiss it

That’s how Lorah keeps MCP useful without giving external tools silent control over your workspace memory.

Which mode should I use?

Goal	Use
Let Claude Desktop or Cursor read Lorah context	`Settings → Advanced → MCP server`
Connect a teammate to a local command-line tool	`Teammate MCP → Command`
Connect a teammate to a local MCP server	`Teammate MCP → MCP stdio`
Connect a teammate to a remote MCP server	`Teammate MCP → MCP SSE`
Store API keys for an MCP tool	`Environment Variables`
Add non-secret routing hints	`Workspace Context`
Review proposed memory or write-back	`Review Queue`

Troubleshooting

The external client doesn’t see Lorah

MCP config wasn’t pasted into the correct config file
External client wasn’t restarted
Command path is wrong
Workspace isn’t active in Lorah
Access token was rotated since the config was copied

A teammate can’t connect to an MCP server

Command doesn’t work in a terminal
Arguments are wrong
MCP server isn’t installed
Required environment variables aren’t configured
Timeout is too short
Remote SSE URL isn’t reachable

A write-back didn’t become memory

That’s expected. Open the Review Queue — MCP write-back items wait for your approval before becoming project memory.

← Back to Quickstart FAQ →

Reviewed 8 September 2026 against the upcoming Lorah release · owner: Jonathan