Connectors: how Meru will run its own servers

A connector is a program Meru needs, such as the search engine behind web search, that Meru installs, starts, checks and restarts for you. This page walks through the design in issue #87: what you set, what Meru's developers set, what happens on disk, and which parts exist today.

4manifests compiled into merud: SearXNG, Obsidian, Google and Ollamainternal/connectors/manifests/, 29 Sep 2026
Node 24.21.0, uv 0.12.21the runtimes Meru downloads for itself, each checked against a pinned SHA-256internal/connectors/runtimes.go, 30 Sep 2026
1, 2, 4, 8 swait before each restart after a crash; it doubles, up to 60 sinternal/connectors/supervisor.go, 30 Sep 2026
5 in 10 mincrashes before a connector stops trying and says whyinternal/connectors/supervisor.go, 30 Sep 2026
10 minidle time before Obsidian or Google stopsidle_timeout in both manifests, 29 Sep 2026
15 show often Meru checks again while Google waits for you to sign ininternal/connectors/supervisor.go, 30 Sep 2026

The problem today

merud, Meru's background program, leans on four other programs. Ollama runs the models. SearXNG, a search engine you host on your own machine, backs the built-in web_search tool. An Obsidian server reads your notes, and a Google server reaches Gmail, Calendar and Drive. Those last two speak the Model Context Protocol (MCP), the standard way a program offers tools to a model.

Today you install each of these, start it, and restart it when it stops. merud reads the MCP servers from ~/.meru/config.toml, starts the ones it can, and tells you little when one fails. Three failures show what that costs.

Obsidian fails on every turn. A common setup starts the server through npx, the Node.js package runner:

[[mcp.servers]]
name    = "obsidian"
command = "npx"
args    = [
  "-y", "obsidian-mcp", "serve",
  "--vault", "notes=~/Notes/vault",
]

On a Mac, launchd, the service manager that starts merud at login, hands merud a short PATH, the list of folders a program searches for other programs, and that list holds no Node.js. Each start then fails with this error, and the server stays down:

exec: "npx": executable file not found in $PATH

The same entry works when you start merud from a terminal, whose PATH does hold Node.js, so the fault shows up only once Meru runs in the background.

Web search says "Connected" while SearXNG is down. Settings marks web search connected whenever [web] searxng_url holds a URL, because merud never asks SearXNG whether it answers. The model still gets web_search, and each call fails.

Google runs by hand. merud connects to the Google server at 127.0.0.1:8000 but never starts it. Older installers wrote a start script and a launchd job for it. When that job is missing, you start the server in a terminal and leave the terminal open.

merud can't repair any of this, because of how it holds its servers today. The MCP pool, the part of merud that keeps its server connections, connects to each server once at start, one after another, with 30 seconds for each. It has no restart and no timer. At the start of each turn that offers tools it tries a dead server once more, and it never sends a failed call a second time. SearXNG sits outside the pool. Until step 4, merud checked Ollama once, and if Ollama didn't answer, merud exited before it opened its socket, the file the clients talk to it through, so no client could show you why.

What a connector is

A connector is one of those programs that Meru installs, configures, starts, checks and restarts for you, at a version fixed in Meru's own release. Two files describe each one, and two different people write them.

The manifest belongs to Meru's developers. It is a TOML file, the same plain format as config.toml, at internal/connectors/manifests/<id>.toml, compiled into the merud binary. It names the package and its exact version, the command that starts it, the values to ask you for, a health check (a cheap request that proves the program works), and which of its tools the model may call. Obsidian's manifest, without its comments:

id = "obsidian"
name = "Obsidian"
kind = "stdio"
required = false
default_on = false
idle_timeout = "10m"

[install]
type = "npm"
package = "obsidian-mcp"
version = "2.0.1"

[launch]
command = "obsidian-mcp"
args = [
  "serve",
  "--vault", "{field.vault_name}={field.vault_path}",
]

[[field]]
id = "vault_path"
type = "folder"
label = "Vault folder"
help = "The folder that holds your Obsidian notes."
required = true

[[field]]
id = "vault_name"
type = "text"
label = "Vault name"
help = "A short name the tools use for the vault. Leave it empty and Meru makes one from the folder's name."
required = false
pattern = "^[a-z][a-z0-9_-]*$"

[health]
tool = "obsidian_list_vaults"
args = {}
expect = "nonempty"

[mcp]
allow = [
  "obsidian_list_vaults",
  "obsidian_search_vault",
  "obsidian_read_note",
]
confirm = []

kind = "stdio" means Meru starts the program and talks MCP over its standard input and output. command names a program the npm package installs; Meru finds it in the install folder and runs it with its own Node (see Where things live on disk). {field.vault_path} stands for the value you type into the Vault folder field. Every client will draw its form from the [[field]] tables, so the desktop app and meru chat ask the same questions. [mcp] works as in a hand-added server: the model sees only the three tools allow names.

Your config belongs to you. It holds whether the connector is on and the value of each field, in one table per connector in config.toml:

[connectors.obsidian]
enabled    = true
vault_path = "~/Notes/vault"

A secret never goes in that table. Google's OAuth client secret, for example, lives in ~/.meru/secrets.toml under the name connector_google_client_secret, the pattern connector_<id>_<field>, and merud refers to it as secret:connector_google_client_secret. config reads each table as a plain map, because every connector has its own fields:

// internal/config/config.go
type Connector map[string]any

func (c Connector) Enabled() (enabled, ok bool) {
	enabled, ok = c["enabled"].(bool)
	return enabled, ok
}

config.Load checks only the table's shape: lower-case keys, and enabled set to true or false. It can't check the fields against the manifest, because the desktop app and meru import config and must never reach the connector code. merud runs that check each time it starts or reloads its tools.

Adding your own MCP server stays the same. You add it to [[mcp.servers]] in config.toml, or with meru mcp add, and the supervisor leaves it alone. You can't edit a manifest on your machine: it sits inside the merud binary, so it changes only when Meru's developers ship a release. A new manifest is how a Meru release adds a managed connector.

The split has two effects. Nobody can point a working install at an untested version by editing a file on disk, because the pins live in the binary. And a Meru upgrade can move a pin without touching your settings, because your config holds only your values.

The manifest and your config both feed the supervisor, which fills the runtime folder Manifest written by Meru's developers · compiled into merud package obsidian-mcp 2.0.1 start obsidian-mcp, with Meru's own Node fields vault_path, vault_name health obsidian_list_vaults → nonempty tools allow 3, confirm 0 Your config ~/.meru/config.toml · you change it [connectors.obsidian] enabled, vault_path ~/.meru/secrets.toml connector_<id>_<field> Supervisor in merud BUILT FOR STDIO · step 3 ~/.meru/runtime/ the only place installs land; global npm, pip and Homebrew stay untouched node-24.21.0/pinned Node.js uv-0.12.21/pinned uv pkg/obsidian-2.0.1/the installed server state/obsidian.jsonlast tool list logs/obsidian.logerror output, planned
Figure 1. Each file has one owner. A Meru release changes the manifest; you change the config and secrets; only merud writes the runtime folder.

Where things live on disk built

Step 2 built this code, and the supervisor calls it since step 3.

Every install lands under one folder, ~/.meru/runtime/:

~/.meru/runtime/
  node-24.21.0/           pinned Node.js, for npm packages
  uv-0.12.21/             pinned uv, a Python package installer
  python/                 the Python 3.12 uv downloads
  cache/npm/, cache/uv/   download caches
  home/                   HOME for npm and uv
  npmrc                   an empty npm settings file
  pkg/obsidian-2.0.1/     obsidian-mcp and its npm packages
  pkg/google-1.30.0/      workspace-mcp and its Python environment
  state/obsidian.json     the tool list from the last health check
  logs/obsidian.log       the server's error output (planned)

Until logs/ lands, merud writes a connector's error output to merud.log at debug level, and keeps the last line for the status sentence.

merud downloads Node.js 24.21.0, the newest Long Term Support release, and uv 0.12.21, a Python package installer, the first time a connector needs one. Before it unpacks a download, it compares the file's SHA-256, a 64-character fingerprint of its contents, with the pin compiled into merud, and refuses a file that doesn't match. A changed or corrupt download never runs. Unpacking refuses any entry that would land outside the runtime's folder.

Each connector installs into its own folder, named for its ID and version. The install type in the manifest picks the command, and each program runs by its full path:

TypeWhat merud runs
npmthe pinned node running npm's own script: npm-cli.js install --prefix <dir> <package>@<version> --no-audit --no-fund --no-update-notifier --ignore-scripts
pipthe pinned uv venv <dir>/.venv --python 3.12, then uv pip install --python <dir>/.venv/bin/python <package>==<version>
binarydownload the file for this platform and check its SHA-256
containerdocker info, then docker pull <image>@sha256:<digest>

A folder is finished only when it holds a marker file, .meru-installed, which merud writes last. A folder without one is a leftover from an install that stopped part way, and merud deletes it rather than trust it. When a new Meru release moves a pin, the version in the manifest no longer matches the marker, so merud installs the new version beside the old one, and removes the old folder once the new one is complete.

Two rules keep your own tools out of it:

Every program runs from one Go file, internal/connectors/run.go, by absolute path, with no shell and a short environment; a policy test fails the build if another file in the package runs one. Meru never runs your global npm, pip or Homebrew, so a connector can't break another program's packages, and removing ~/.meru/runtime/ removes every install.

The supervisor and its states built

Step 3 built this for stdio connectors, in internal/connectors/supervisor.go, and step 5 for Google, the one http connector. SearXNG has its own loop, built in step 4.

The supervisor is the part of merud that runs each connector. It keeps one small state machine per connector: a record of which state the connector is in, and which events move it to the next one. It resembles launchd, which also starts and restarts programs. The likeness ends at two points: the supervisor installs the program first, and it gives up after five crashes in ten minutes and tells you why, where launchd would keep restarting.

StateWhat it means
offyou haven't turned it on
by_handan [[mcp.servers]] entry with the same name runs instead
needs_configa field is missing or wrong, or another program holds Google's port
sign_inGoogle runs and waits for you to sign in at its link; you see needs_config
installingdownloading the runtime or the package, then the first health check
readyinstalled and stopped; its tool list is known from the last health check
startingthe process is starting, and must pass its health check
okrunning and healthy
backoffthe process exited or failed to start; waiting out a backoff, a pause that grows after each crash, before the next start
failedstopped trying; the reason says why
The connector state machine off by_hand needs_config config fixed installing ready starting ok backoff failed(reason) installed, check ok first tool call check ok idle 10 min crash start fails wait 1, 2, 4, 8 s 5th crash in 10 min install or check fails config changes, or merud restarts You see: ok off by_hand needs_config starting failed(reason)
Figure 2. Nine states inside, six outside: the outline colour shows which of the six you see. A crash loops through backoff and starting with a growing wait, and only a config change or a restart of merud leaves failed.

You see six of those states, so a status line never has to explain the machine:

You seeStates inside it
okok (running) and ready (stopped, tools known)
offoff
by_handby_hand; clients show it as "set up by hand"
needs_configneeds_config
startinginstalling, starting and backoff
failed(reason)failed

These rules govern the machine.

Health checks run after an install, at each start and on Fix, and a container gets one every minute while it is on. The supervisor also outlives a reload of the MCP pool, which stops every hand-added server's process each time you change a tool's policy. The pool asks the supervisor for a connector's session and never starts or stops the program itself. A reload hands each supervisor its config again: one whose config didn't change keeps its program running, and one that failed gets a fresh try.

Turning on Obsidian, end to end built

Step 3 built this, with the form from step 6.

This walk-through follows one connector from off to a first answer, with the values from its manifest. The rest of the design follows the same path with a different install type.

  1. You fill in the fields. In Settings, under Connections, you pick your vault folder, ~/Notes/vault, on Obsidian's card with Choose…, and press Save and turn on. The app sends the socket op connector_set; merud checks the folder exists and writes [connectors.obsidian] with enabled = true and the folder. meru mcp set obsidian enabled=true vault_path=~/Notes/vault does the same in a terminal. You leave Vault name empty, so Meru makes one from the folder's name: vault. The fields pass, so the state moves from off to installing, and the card reads Starting.
  2. Node.js arrives. obsidian-mcp 2.0.1 needs Node.js 22 or later. merud downloads its pinned Node.js 24.21.0 into ~/.meru/runtime/node-24.21.0/, checks the SHA-256 and unpacks it.
  3. The package installs. With that Node.js, merud runs npm install --prefix ~/.meru/runtime/pkg/obsidian-2.0.1 obsidian-mcp@2.0.1 --no-audit --no-fund --no-update-notifier --ignore-scripts. The server's script lands at pkg/obsidian-2.0.1/node_modules/obsidian-mcp/dist/main.js.
  4. The first health check. merud starts the pinned node by its full path with that script and serve --vault vault=/Users/you/Notes/vault, and calls the tool obsidian_list_vaults with no arguments. The answer lists one vault, which meets expect = "nonempty". merud saves the server's tool list to state/obsidian.json, stops the process, and moves to ready. The card now reads "Obsidian is ready. It starts when a question needs it."
  5. The first question. You ask "what did I write about the garden plan?". The model sees obsidian.obsidian_search_vault from the saved list and calls it. Figure 3 traces that call.
  6. Ten quiet minutes. No further call comes, so the process stops and the state goes back to ready. The card reads "Obsidian is ready." again, and the next call starts the process again.
The first tool call starts the server model dispatch pool + supervisor obsidian-mcp obsidian_search_vault offered from state/obsidian.json checks the allow list, writes a tool_calls row session for obsidian? ready → starting spawn by full path, no shell obsidian_list_vaults nonempty → ok obsidian_search_vault matching notes result, logged 10 min, no call: stop the process → ready
Figure 3. The model gets the tool before any process runs. The first call pays for the start and one health check, and every later call within ten minutes goes straight through. dispatch, the one path every tool call takes, logs it the same way it logs any other call.

If the process crashes while it works on that search, the search fails and the model sees the error. The supervisor waits 1 second and starts the process again, so your next question finds it running.

The four connectors

Four manifests ship in step 1. The table shows what each one pins and how merud checks it. Each pin carries a comment in its manifest that says where it came from and on what date.

IDKindPinHealth checkYou give
searxngcontainerimage searxng/searxng by digestGET /search?q=&format=json, expects a JSON objectnothing
obsidianstdionpm obsidian-mcp 2.0.1obsidian_list_vaults, nonemptyvault folder, vault name
googlehttpPyPI workspace-mcp 1.30.0list_calendars, nonemptyaddress, client ID, client secret, sign-in
ollamadependencynone; Meru installs nothingGET /api/version, has versionnothing

SearXNG is the only connector on by default, and by default Meru only checks it. With [connectors.searxng] enabled = true, Meru runs it as a Docker container named meru-searxng, from an image pinned by digest, the hash of the image's contents:

[install]
type = "container"
image = "docker.io/searxng/searxng:2026.9.29-4e2c1ea7f@sha256:3284e8900e9b3e5df284ae8c48a26851ae2eff6f99b4b0b18ec3da5a4d9095c3"

A tag such as 2026.9.29-4e2c1ea7f can move to a new image; the digest can't, so the pin holds even if someone retags. Docker maps 127.0.0.1:8888 to the container's port 8080 and mounts ~/.meru/searxng as its settings folder, where Meru writes a settings.yml with JSON on before the first start. The container runs with --restart no and the label meru.connector=searxng: Meru alone restarts it, 1, 2, 4 and 8 seconds after it stops answering, and the label tells Meru's container apart from any other.

The health check runs at start and every minute: an empty search with format=json. SearXNG refuses it without asking any search engine, in JSON when JSON is on and as a web page when it's off, so the check sends nothing off the machine and also catches a SearXNG that web_search can't read. A test against the pinned image on 30 September 2026 showed why /healthz isn't enough: it answered OK with JSON off, while the empty search answered 403 and a web page.

The model gets web_search only while the check passes. Without Docker the status reads "Web search needs Docker or Podman, and neither is installed." or "Web search can't start: Docker or Podman isn't running.", and the next minute's check tries again.

Some people already run SearXNG, with Docker Compose for example, or have the container an older Mac installer started. If a healthy SearXNG that isn't Meru's container already answers at [web] searxng_url, Meru calls it external: the status reads "Web search uses the SearXNG already running at http://127.0.0.1:8888.", and Meru never starts, stops or pulls anything for it. A config from before connectors, with no [connectors.searxng] table, gets the check alone, so an upgrade starts no container.

Obsidian, for notes

The Obsidian connector uses the npm package obsidian-mcp, which reads the vault folder on disk, so the Obsidian app needn't be open. Meru's catalog, its list of starter servers, holds another Obsidian server, mcp-obsidian, which talks to a plugin inside the running app. It stays in the catalog for anyone who adds it by hand.

Google, for mail, calendar and files

built in step 5.

Google is an http connector: Meru starts workspace-mcp 1.30.0 and talks MCP to it at http://127.0.0.1:8000/mcp. You sign in with OAuth, the standard that lets a program act for your account without your password. Google sends the browser back to a callback address on port 8000, which is why the manifest fixes that port. Before each start, Meru looks at the port. If another program holds it, such as a Google server you started yourself, the connector reads "Google can't start: another program listens on 127.0.0.1:8000." and Meru looks again every 30 seconds. It never stops that program.

To check the server, Meru calls list_calendars, a read-only tool that reads the calendar list. Before you sign in, the server asks Google nothing and answers with an error that holds a sign-in link. The connector then keeps the server running, since the link calls back to it, and reads "Google needs you to sign in." with the link: a "Sign in to Google" button in Settings, and the link after "Sign in:" in /mcp and meru mcp status. Every 15 seconds Meru checks again, and once you have signed in the connector is ok. Each link works for ten minutes, so Meru shows the newest. The link holds a one-time value, so it never goes in merud.log: Meru cuts the query off every link in the server's output before it logs a line.

The four fields are your Google address, the ID of an OAuth client you create (it must end in .apps.googleusercontent.com), that client's secret, and the sign-in. The secret reaches the server as an environment variable and never as a command-line argument, because any user on the machine can read another's arguments in the process list; the manifest check refuses a secret in args. The server runs with your real home folder and saves its sign-in tokens there, so the tokens from a server you ran by hand keep working once Meru runs it. Mail attachments go to ~/meru-output/attachments, where Meru's read_file tool can read them. The model may call nine tools, and two of them, send_gmail_message and manage_event, ask you first.

Ollama, reported and never run

Ollama is a dependency: Meru never installs or starts it, and only checks GET /api/version at [ollama] base_url. merud opens its socket first, checks Ollama every 30 seconds, and at once when you ask something, until it answers with 0.40.5 or later, then warms the models and opens the rest. A question asked meanwhile gets "Ollama isn't running, so Meru can't answer yet.", and meru mcp status and the desktop app's status block show "Ollama isn't running at http://127.0.0.1:11434." or the version that is too old.

Status and Fix built

Step 3 built the status, and step 6 Fix and the forms.

A hand-added server knows two states, connected and not connected, and no view offers a way to repair it. Each connector gets one plain sentence and one Fix action, the same in every client.

The socket op connectors returns one status per connector: its ID, name, kind, state and sentence, whether Meru needs it, the field list with the values of the non-secret fields and whether each secret has a saved value, and the Fix, which names the fields to ask again. mcp_status and connections carry the same state and sentence for the connector's row, and link, Google's sign-in link while it waits for you. connector_adopt and connector_unadopt move a hand-added entry over and back (see Moving a working setup over). Two more ops make changes. connector_set checks new values, secrets and on or off against the manifest, writes config.toml and secrets.toml, then follows the connector as it installs, starts and checks, and sends each step to the client. It refuses a change that would leave the connector short of a field, and writes nothing then. connector_fix answers with the fields to ask when the connector lacks some, and otherwise runs the check again and follows it the same way.

You seeExample sentenceFix
okObsidian is ready. It starts when a question needs it.runs the check again
okObsidian is running.runs the check again
offObsidian is off.asks every field, then turns it on
by_handObsidian runs from your own setup, the obsidian entry in [[mcp.servers]]. There is nothing to do. Optional: meru mcp adopt obsidian lets Meru run and restart it.none; Adopt moves it over
needs_configObsidian needs your vault folder.asks for the vault folder
needs_configGoogle needs you to sign in.starts the server again for a new link; the Sign in button opens the link
needs_configGoogle can't start: another program listens on 127.0.0.1:8000. …looks at the port again; stop that program first
startingObsidian stopped (…) and starts again in 2 s.none needed
needs_configWeb search can't start: Docker or Podman isn't running.runs the check again
failed(reason)Obsidian keeps stopping: <last line of its error output>installs and checks it again
failed (Ollama)Ollama isn't running at http://127.0.0.1:11434.runs the check again

The Fix column follows one rule, rpc.AskFields: Fix asks for the fields it names, every field for a connector that is off, and otherwise runs the check again. Four places show these rows:

The about_meru tool adds the sentence too, so the model can tell you why a connector's tools are missing. Every client draws its form from the same field list, so a new connector in a later release needs no new screen in any client.

Pinned versions

A pin is one exact version, such as obsidian-mcp 2.0.1. "Latest" can mean one release today and another tomorrow, so an unpinned install can break a working Meru with no change on your side. With a pin, every Meru user runs the version Meru's developers tested for that release. This part exists today.

connectors.Load parses the four manifests and refuses the set if any one breaks a rule. It refuses latest, an empty version, a range such as ^2.0.0 or >=1.30, a bare major such as 2, a container image without @sha256: and its digest, and a download without an https URL and a SHA-256 for each platform. A policy test calls it:

// internal/policy/pins_test.go
func TestManifestsPinned(t *testing.T) {
	if _, err := connectors.Load(); err != nil {
		t.Fatalf("connector manifests: %v", err)
	}
}

A second test, TestNoUnpinnedVersions, reads more than the manifests. It scans the installer, the catalog, cmd/meru, scripts/, deploy/ and every code block in the Markdown under docs/. It fails on @latest, :latest, a version range, npx or uvx with no exact version, an image with no digest, and a file fetched from a branch such as main. Meru's own releases/latest link passes, because it fetches Meru and not a dependency.

Two places break the rule today and keep working, each listed in the test with a reason. Step 4 took three off: meru setup's SearXNG recipe and the two docs that repeated it. Step 5 took six: the Google start commands in the catalog, the installer, running.md, google-setup.md and the catalog's coding note, which now all run uvx workspace-mcp==1.30.0, the Google connector's own pin, and the catalog's install hint. Step 6 took the installer's searxng:latest: the installer hands web search to merud, which runs the pinned image. Dropping the local Grafana stack took one more. Two stay: an Ollama model tag and a made-up server name in an example. The list can only shrink, since an entry that no longer matches anything also fails the test.

A pin moves only in a Meru release. Its developers pick the new version, test it, and list it in the release notes under "Connector versions". Your installed Meru never picks up a new connector version by itself.

Moving a working setup over built

Built in step 5.

A setup that works today keeps working. An [[mcp.servers]] entry named google or obsidian runs as before, and its connector reads "set up by hand". Nothing moves until you run meru mcp adopt obsidian or meru mcp adopt google. The command asks merud what it would change, prints each change, and asks before merud makes any. Adopt:

  1. reads what the connector needs. For Obsidian it takes the vault from the entry's --vault name=path. For Google it reads your address, client ID and client secret from ~/.config/workspace-mcp/start.sh, the script the Google guide has you write; with no script, you give them as --email and --client-id, and the command asks for the secret without showing it;
  2. saves the client secret in secrets.toml as connector_google_client_secret, readable by you alone;
  3. stops the launchd job com.meru.workspace-mcp, if one runs the old Google server, and renames its file to .plist.disabled so it doesn't come back at login;
  4. comments the old entry out between two marker lines and writes [connectors.<id>] right after it, with enabled = true, the values, and your allow and confirm lists where they differ from the connector's own;
  5. reloads, and merud installs, checks and runs the connector, Google on the same port, so its sign-in callback and saved tokens still work.

Adopt refuses, with a reason, what the connector can't take over: the other Obsidian server, mcp-obsidian, which talks to the app's Local REST API plugin and has other tool names; an entry with no vault or with two; a Google entry at another address; and a Google server you started by hand that still holds port 8000. Meru never stops a program it didn't start, so it asks you to stop that one first. Run twice, Adopt says the entry is adopted already.

meru mcp unadopt <id> undoes it: it takes the table out, puts the entry back without the markers, reloads, and starts the launchd job again if Adopt stopped it. The file then matches the one before Adopt, byte for byte. The secret stays in secrets.toml. The IDs stay google and obsidian, so tool names such as google.search_gmail_messages read the same in the tool_calls log, the transcripts and the router, the part of Meru that picks how to handle each question.

What it doesn't do

Where the work stands

The plan lands in seven pull requests, each of which keeps main working.

StepWhat it addsState
1ARCHITECTURE.md rule change, the manifest types, the four manifests, their checks, [connectors.<id>] parsing and the pin testbuilt merged in PR #90
2Node.js and uv download and check; npm, pip, binary and container installs into ~/.meru/runtime; Node run by Meru; uv's folders under ~/.meru/runtimebuilt merged in PR #91
3the supervisor for Obsidian: lazy start, idle stop, backoff, health checks, the pool's hook, the connectors op and the new states in every status viewbuilt merged in PR #92
4SearXNG as a container with the external rule; web_search only while healthy; merud stays up without Ollamabuilt merged in PR #93
5Google over HTTP with sign-in, and Adopt for existing entriesbuilt merged in PR #95
6athe config flow and Fix in the clients: connector_set and connector_fix, the connector cards in Settings, the rail's dots, the connector rows in /mcp, meru mcp set and meru mcp fixbuilt PR #96
6bthe installer and meru setup hand connectors to merud: the installer's steps gather each connector's values, Start Meru sends them, and the installer runs no docker, uv or launchctl for a connectorbuilt this pull request
7docs, the install skill and the release notesplanned

Sources

Repository files, as of branch main (30 September 2026):

The plan and its review:

Upstream pages for the pins, checked 30 September 2026: